Variable defaultConst

default: OverridableFrontendPlugin<
    {},
    {},
    {
        "api:app/alert": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "alert";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/analytics": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    implementations: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            AnalyticsImplementationFactory<{}>,
                            "core.analytics.factory",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: "api";
                name: "analytics";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/app-language": OverridableExtensionDefinition<
            {
                config: {
                    availableLanguages: string[]
                    | undefined;
                    defaultLanguage: string | undefined;
                };
                configInput: { availableLanguages?: string[]; defaultLanguage?: string };
                inputs: {};
                kind: "api";
                name: "app-language";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/app-theme": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    themes: ExtensionInput<
                        ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>,
                        { optional: false; singleton: false },
                    >;
                };
                kind: "api";
                name: "app-theme";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/atlassian-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "atlassian-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/bitbucket-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "bitbucket-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/bitbucket-server-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "bitbucket-server-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/components": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "components";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/dialog": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "dialog";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/discovery": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "discovery";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/error": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "error";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/feature-flags": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "feature-flags";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/fetch": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "fetch";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/github-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "github-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/gitlab-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "gitlab-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/google-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "google-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/icons": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    icons: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            { [key: string]: IconComponent },
                            "core.icons",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: "api";
                name: "icons";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/microsoft-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "microsoft-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/oauth-request": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "oauth-request";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/okta-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "okta-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/onelogin-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "onelogin-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/openshift-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "openshift-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/permission": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "permission";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/scm-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "scm-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/scm-integrations": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "scm-integrations";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/storage": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "storage";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/swappable-components": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    components: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            {
                                loader: (() => (props: ...) => ...)
                                | (() => Promise<(...)>);
                                ref: SwappableComponentRef;
                            },
                            "core.swappableComponent",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: "api";
                name: "swappable-components";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/translations": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    translations: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            | TranslationResource<string>
                            | TranslationMessages<string, { [key: string]: string }, boolean>,
                            "core.translation.translation",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: "api";
                name: "translations";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        "api:app/vmware-cloud-auth": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "api";
                name: "vmware-cloud-auth";
                output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
                params: <TApi, TImpl, TDeps extends { [key: string]: unknown }>(
                    params: ApiFactory<TApi, TImpl, TDeps>,
                ) => ExtensionBlueprintParams<AnyApiFactory>;
            },
        >;
        app: OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    root: ExtensionInput<
                        ConfigurableExtensionDataRef<Element, "core.reactElement", {}>,
                        { optional: false; singleton: true },
                    >;
                };
                kind: undefined;
                name: undefined;
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: never;
            },
        >;
        "app-root-element:app/alert-display": OverridableExtensionDefinition<
            {
                config: {
                    anchorOrigin: {
                        horizontal: "left"
                        | "center"
                        | "right";
                        vertical: "top" | "bottom";
                    };
                    transientTimeoutMs: number;
                };
                configInput: {
                    anchorOrigin?: {
                        horizontal?: "left"
                        | "center"
                        | "right";
                        vertical?: "top" | "bottom";
                    };
                    transientTimeoutMs?: number;
                };
                inputs: {};
                kind: "app-root-element";
                name: "alert-display";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: { element: Element };
            },
        >;
        "app-root-element:app/dialog-display": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "app-root-element";
                name: "dialog-display";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: { element: Element };
            },
        >;
        "app-root-element:app/oauth-request-dialog": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "app-root-element";
                name: "oauth-request-dialog";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: { element: Element };
            },
        >;
        "app/layout": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    content: ExtensionInput<
                        ConfigurableExtensionDataRef<Element, "core.reactElement", {}>,
                        { optional: false; singleton: true },
                    >;
                    nav: ExtensionInput<
                        ConfigurableExtensionDataRef<Element, "core.reactElement", {}>,
                        { optional: false; singleton: true },
                    >;
                };
                kind: undefined;
                name: "layout";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: never;
            },
        >;
        "app/nav": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    content: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            NavContentComponent,
                            "core.nav-content.component",
                            {},
                        >,
                        { optional: true; singleton: true },
                    >;
                    items: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            {
                                icon: IconComponent;
                                routeRef: RouteRef<undefined>;
                                title: string;
                            },
                            "core.nav-item.target",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: undefined;
                name: "nav";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: never;
            },
        >;
        "app/root": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    children: ExtensionInput<
                        ConfigurableExtensionDataRef<Element, "core.reactElement", {}>,
                        { optional: false; singleton: true },
                    >;
                    elements: ExtensionInput<
                        ConfigurableExtensionDataRef<Element, "core.reactElement", {}>,
                        { optional: false; singleton: false },
                    >;
                    router: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            (props: { children: ReactNode }) => Element | null,
                            "app.router.wrapper",
                            {},
                        >,
                        { optional: true; singleton: true },
                    >;
                    signInPage: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            ComponentType<SignInPageProps>,
                            "core.sign-in-page.component",
                            {},
                        >,
                        { optional: true; singleton: true },
                    >;
                    wrappers: ExtensionInput<
                        ConfigurableExtensionDataRef<
                            (props: { children: ReactNode }) => Element | null,
                            "app.root.wrapper",
                            {},
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: undefined;
                name: "root";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: never;
            },
        >;
        "app/routes": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {
                    routes: ExtensionInput<
                        | ConfigurableExtensionDataRef<Element, "core.reactElement", {}>
                        | ConfigurableExtensionDataRef<string, "core.routing.path", {}>
                        | ConfigurableExtensionDataRef<
                            RouteRef<AnyRouteRefParams>,
                            "core.routing.ref",
                            { optional: true },
                        >,
                        { optional: false; singleton: false },
                    >;
                };
                kind: undefined;
                name: "routes";
                output: ExtensionDataRef<Element, "core.reactElement", {}>;
                params: never;
            },
        >;
        "component:app/core-error-display": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "component";
                name: "core-error-display";
                output: ExtensionDataRef<
                    {
                        loader: | (() => (props: {}) => Element | null)
                        | (() => Promise<(props: {}) => (...) | (...)>);
                        ref: SwappableComponentRef;
                    },
                    "core.swappableComponent",
                    {},
                >;
                params: <Ref extends SwappableComponentRef<any>>(
                    params: {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<Ref> } & (
                                props: IExternalComponentProps,
                            ) => Element | null
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ?
                                | (() => (props: IInnerComponentProps) => (...) | (...))
                                | (() => Promise<(props: ...) => ...>)
                            : never;
                    },
                ) => ExtensionBlueprintParams<
                    {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<(...)> } & (
                                props: IExternalComponentProps,
                            ) => (...) | (...)
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ? (() => (props: ...) => ...) | (() => Promise<(...)>)
                            : never;
                    },
                >;
            },
        >;
        "component:app/core-not-found-error-page": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "component";
                name: "core-not-found-error-page";
                output: ExtensionDataRef<
                    {
                        loader: | (() => (props: {}) => Element | null)
                        | (() => Promise<(props: {}) => (...) | (...)>);
                        ref: SwappableComponentRef;
                    },
                    "core.swappableComponent",
                    {},
                >;
                params: <Ref extends SwappableComponentRef<any>>(
                    params: {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<Ref> } & (
                                props: IExternalComponentProps,
                            ) => Element | null
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ?
                                | (() => (props: IInnerComponentProps) => (...) | (...))
                                | (() => Promise<(props: ...) => ...>)
                            : never;
                    },
                ) => ExtensionBlueprintParams<
                    {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<(...)> } & (
                                props: IExternalComponentProps,
                            ) => (...) | (...)
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ? (() => (props: ...) => ...) | (() => Promise<(...)>)
                            : never;
                    },
                >;
            },
        >;
        "component:app/core-progress": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "component";
                name: "core-progress";
                output: ExtensionDataRef<
                    {
                        loader: | (() => (props: {}) => Element | null)
                        | (() => Promise<(props: {}) => (...) | (...)>);
                        ref: SwappableComponentRef;
                    },
                    "core.swappableComponent",
                    {},
                >;
                params: <Ref extends SwappableComponentRef<any>>(
                    params: {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<Ref> } & (
                                props: IExternalComponentProps,
                            ) => Element | null
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ?
                                | (() => (props: IInnerComponentProps) => (...) | (...))
                                | (() => Promise<(props: ...) => ...>)
                            : never;
                    },
                ) => ExtensionBlueprintParams<
                    {
                        component: Ref extends SwappableComponentRef<
                            any,
                            IExternalComponentProps,
                        >
                            ? { ref: Ref<(...)> } & (
                                props: IExternalComponentProps,
                            ) => (...) | (...)
                            : never;
                        loader: Ref extends SwappableComponentRef<IInnerComponentProps, any>
                            ? (() => (props: ...) => ...) | (() => Promise<(...)>)
                            : never;
                    },
                >;
            },
        >;
        "sign-in-page:app": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "sign-in-page";
                name: undefined;
                output: ExtensionDataRef<
                    ComponentType<SignInPageProps>,
                    "core.sign-in-page.component",
                    {},
                >;
                params: { loader: () => Promise<ComponentType<SignInPageProps>> };
            },
        >;
        "theme:app/dark": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "theme";
                name: "dark";
                output: ExtensionDataRef<AppTheme, "core.theme.theme", {}>;
                params: { theme: AppTheme };
            },
        >;
        "theme:app/light": OverridableExtensionDefinition<
            {
                config: {};
                configInput: {};
                inputs: {};
                kind: "theme";
                name: "light";
                output: ExtensionDataRef<AppTheme, "core.theme.theme", {}>;
                params: { theme: AppTheme };
            },
        >;
    },
> = ...