@backstage/frontend-plugin-api 0.7.0 → 0.8.0-next.1

package/dist/index.d.ts

@@ -2,9 +2,9 @@
 import * as React from 'react';
 import React__default, { ReactNode, JSX as JSX$1, ComponentType, PropsWithChildren } from 'react';
 import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
-import { ApiRef, AnyApiFactory, IconComponent as IconComponent$1, SignInPageProps, AppTheme, AnyApiRef } from '@backstage/core-plugin-api';
+import { ApiHolder, ApiRef, AnyApiFactory, IconComponent as IconComponent$1, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
 export { AlertApi, AlertMessage, AnyApiFactory, AnyApiRef, ApiFactory, ApiHolder, ApiRef, ApiRefConfig, AppTheme, AppThemeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, FeatureFlag, FeatureFlagState, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, IdentityApi, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, PendingOAuthRequest, ProfileInfo, ProfileInfoApi, SessionApi, SessionState, StorageApi, StorageValueSnapshot, TypesToApiRefs, alertApiRef, appThemeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, createApiFactory, createApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, storageApiRef, useApi, useApiHolder, vmwareCloudAuthApiRef, withApis } from '@backstage/core-plugin-api';
-import { z, ZodSchema, ZodTypeDef } from 'zod';
+import { z } from 'zod';
 import { JsonObject } from '@backstage/types';
 import { TranslationResource, TranslationMessages } from '@backstage/core-plugin-api/alpha';
 export { TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, createTranslationMessages, createTranslationRef, createTranslationResource, useTranslationRef } from '@backstage/core-plugin-api/alpha';
@@ -262,18 +262,6 @@ declare const coreExtensionData: {
     routeRef: ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {}>;
 };
 
-/** @public */
-type PortableSchema<TOutput, TInput = TOutput> = {
-    parse: (input: TInput) => TOutput;
-    schema: JsonObject;
-};
-
-/**
- * @public
- * @deprecated Use the `config.schema` option of `createExtension` instead, or use `createExtensionBlueprint`.
- */
-declare function createSchemaFromZod<TOutput, TInput>(schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>): PortableSchema<TOutput, TInput>;
-
 /**
  * Utility type to expand type aliases into their equivalent type.
  * @ignore
@@ -295,46 +283,32 @@ type CoreErrorBoundaryFallbackProps = {
 };
 
 /** @public */
-interface ExtensionInput<TExtensionData extends ExtensionDataRef<unknown, string, {
+interface ExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
     optional?: true;
 }>, TConfig extends {
     singleton: boolean;
     optional: boolean;
 }> {
     $$type: '@backstage/ExtensionInput';
-    extensionData: Array<TExtensionData>;
-    config: TConfig;
-}
-/**
- * @public
- * @deprecated This type will be removed. Use `ExtensionInput` instead.
- */
-interface LegacyExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
-    singleton: boolean;
-    optional: boolean;
-}> {
-    $$type: '@backstage/ExtensionInput';
-    extensionData: TExtensionDataMap;
+    extensionData: Array<UExtensionData>;
     config: TConfig;
+    replaces?: Array<{
+        id: string;
+        input: string;
+    }>;
 }
-/**
- * @public
- * @deprecated Use the following form instead: `createExtensionInput([dataRef1, dataRef2])`
- */
-declare function createExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
-    singleton?: boolean;
-    optional?: boolean;
-}>(extensionData: TExtensionDataMap, config?: TConfig): LegacyExtensionInput<TExtensionDataMap, {
-    singleton: TConfig['singleton'] extends true ? true : false;
-    optional: TConfig['optional'] extends true ? true : false;
-}>;
 /** @public */
 declare function createExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
     optional?: true;
 }>, TConfig extends {
     singleton?: boolean;
     optional?: boolean;
-}>(extensionData: Array<UExtensionData>, config?: TConfig): ExtensionInput<UExtensionData, {
+}>(extensionData: Array<UExtensionData>, config?: TConfig & {
+    replaces?: Array<{
+        id: string;
+        input: string;
+    }>;
+}): ExtensionInput<UExtensionData, {
     singleton: TConfig['singleton'] extends true ? true : false;
     optional: TConfig['optional'] extends true ? true : false;
 }>;
@@ -373,78 +347,22 @@ type ExtensionDataContainer<UExtensionData extends AnyExtensionDataRef> = Iterab
     get<TId extends UExtensionData['id']>(ref: ExtensionDataRef<any, TId, any>): UExtensionData extends ExtensionDataRef<infer IData, TId, infer IConfig> ? IConfig['optional'] extends true ? IData | undefined : IData : never;
 };
 
-/**
- * @public
- * @deprecated Extension data maps will be removed.
- */
-type AnyExtensionDataMap = {
-    [name in string]: AnyExtensionDataRef;
-};
-/**
- * @public
- * @deprecated This type will be removed.
- */
-type AnyExtensionInputMap = {
-    [inputName in string]: LegacyExtensionInput<AnyExtensionDataMap, {
-        optional: boolean;
-        singleton: boolean;
-    }>;
-};
-/**
- * Converts an extension data map into the matching concrete data values type.
- * @public
- * @deprecated Extension data maps will be removed.
- */
-type ExtensionDataValues<TExtensionData extends AnyExtensionDataMap> = {
-    [DataName in keyof TExtensionData as TExtensionData[DataName]['config'] extends {
-        optional: true;
-    } ? never : DataName]: TExtensionData[DataName]['T'];
-} & {
-    [DataName in keyof TExtensionData as TExtensionData[DataName]['config'] extends {
-        optional: true;
-    } ? DataName : never]?: TExtensionData[DataName]['T'];
-};
 /**
  * Convert a single extension input into a matching resolved input.
  * @public
  */
 type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<AnyExtensionDataRef> ? {
     node: AppNode;
-} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : TExtensionInput['extensionData'] extends AnyExtensionDataMap ? {
-    node: AppNode;
-    output: ExtensionDataValues<TExtensionInput['extensionData']>;
-} : never;
+} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : never;
 /**
  * Converts an extension input map into a matching collection of resolved inputs.
  * @public
  */
 type ResolvedExtensionInputs<TInputs extends {
-    [name in string]: ExtensionInput<any, any> | LegacyExtensionInput<any, any>;
+    [name in string]: ExtensionInput<any, any>;
 }> = {
     [InputName in keyof TInputs]: false extends TInputs[InputName]['config']['singleton'] ? Array<Expand<ResolvedExtensionInput<TInputs[InputName]>>> : false extends TInputs[InputName]['config']['optional'] ? Expand<ResolvedExtensionInput<TInputs[InputName]>> : Expand<ResolvedExtensionInput<TInputs[InputName]> | undefined>;
 };
-/**
- * @public
- * @deprecated This way of structuring the options is deprecated, this type will be removed in the future
- */
-interface LegacyCreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput> {
-    kind?: string;
-    namespace?: string;
-    name?: string;
-    attachTo: {
-        id: string;
-        input: string;
-    };
-    disabled?: boolean;
-    inputs?: TInputs;
-    output: TOutput;
-    configSchema?: PortableSchema<TConfig, TConfigInput>;
-    factory(context: {
-        node: AppNode;
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    }): Expand<ExtensionDataValues<TOutput>>;
-}
 type ToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 type PopUnion<U> = ToIntersection<U extends any ? () => U : never> extends () => infer R ? [rest: Exclude<U, R>, next: R] : undefined;
 /** @ignore */
@@ -475,6 +393,7 @@ type CreateExtensionOptions<TKind extends string | undefined, TNamespace extends
     };
     factory(context: {
         node: AppNode;
+        apis: ApiHolder;
         config: {
             [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
         };
@@ -482,30 +401,28 @@ type CreateExtensionOptions<TKind extends string | undefined, TNamespace extends
     }): Iterable<UFactoryOutput>;
 } & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /** @public */
-interface ExtensionDefinition<TConfig, TConfigInput = TConfig, UOutput extends AnyExtensionDataRef = AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
-        optional: boolean;
-        singleton: boolean;
-    }>;
-} = {}, TIdParts extends {
-    kind?: string;
-    namespace?: string;
-    name?: string;
-} = {
+type ExtensionDefinitionParameters = {
     kind?: string;
     namespace?: string;
     name?: string;
-}> {
-    $$type: '@backstage/ExtensionDefinition';
-    readonly kind?: TIdParts['kind'];
-    readonly namespace?: TIdParts['namespace'];
-    readonly name?: TIdParts['name'];
-    readonly attachTo: {
-        id: string;
-        input: string;
+    configInput?: {
+        [K in string]: any;
     };
-    readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
+    config?: {
+        [K in string]: any;
+    };
+    output?: AnyExtensionDataRef;
+    inputs?: {
+        [KName in string]: ExtensionInput<AnyExtensionDataRef, {
+            optional: boolean;
+            singleton: boolean;
+        }>;
+    };
+};
+/** @public */
+type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefinitionParameters> = {
+    $$type: '@backstage/ExtensionDefinition';
+    readonly T: T;
     override<TExtensionConfigSchema extends {
         [key in string]: (zImpl: typeof z) => z.ZodType;
     }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends AnyExtensionDataRef, TExtraInputs extends {
@@ -520,30 +437,39 @@ interface ExtensionDefinition<TConfig, TConfigInput = TConfig, UOutput extends A
         };
         disabled?: boolean;
         inputs?: TExtraInputs & {
-            [KName in keyof TInputs]?: `Error: Input '${KName & string}' is already defined in parent definition`;
+            [KName in keyof T['inputs']]?: `Error: Input '${KName & string}' is already defined in parent definition`;
         };
         output?: Array<UNewOutput>;
         config?: {
             schema: TExtensionConfigSchema & {
-                [KName in keyof TConfig]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+                [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
             };
         };
         factory(originalFactory: (context?: {
-            config?: TConfig;
-            inputs?: ResolveInputValueOverrides<TInputs>;
-        }) => ExtensionDataContainer<UOutput>, context: {
+            config?: T['config'];
+            inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
+        }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
             node: AppNode;
-            config: TConfig & {
+            apis: ApiHolder;
+            config: T['config'] & {
                 [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
             };
-            inputs: Expand<ResolvedExtensionInputs<TInputs & TExtraInputs>>;
+            inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
         }): Iterable<UFactoryOutput>;
-    } & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? UOutput : UNewOutput, UFactoryOutput>): ExtensionDefinition<{
-        [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
-    } & TConfig, z.input<z.ZodObject<{
-        [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
-    }>> & TConfigInput, AnyExtensionDataRef extends UNewOutput ? UOutput : UNewOutput, TInputs & TExtraInputs, TIdParts>;
-}
+    } & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>): ExtensionDefinition<{
+        kind: T['kind'];
+        namespace: T['namespace'];
+        name: T['name'];
+        output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        inputs: T['inputs'] & TExtraInputs;
+        config: T['config'] & {
+            [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+        };
+        configInput: T['configInput'] & z.input<z.ZodObject<{
+            [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+        }>>;
+    }>;
+};
 /** @public */
 declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
     [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
@@ -552,20 +478,49 @@ declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs ex
     }>;
 }, TConfigSchema extends {
     [key: string]: (zImpl: typeof z) => z.ZodType;
-}, UFactoryOutput extends ExtensionDataValue<any, any>, const TKind extends string | undefined = undefined, const TNamespace extends string | undefined = undefined, const TName extends string | undefined = undefined>(options: CreateExtensionOptions<TKind, TNamespace, TName, UOutput, TInputs, TConfigSchema, UFactoryOutput>): ExtensionDefinition<{
-    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
-}, z.input<z.ZodObject<{
-    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
-}>>, UOutput, TInputs, {
+}, UFactoryOutput extends ExtensionDataValue<any, any>, const TKind extends string | undefined = undefined, const TNamespace extends string | undefined = undefined, const TName extends string | undefined = undefined>(options: CreateExtensionOptions<TKind, undefined, TName, UOutput, TInputs, TConfigSchema, UFactoryOutput>): ExtensionDefinition<{
+    config: string extends keyof TConfigSchema ? {} : {
+        [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+    };
+    configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+        [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+    }>>;
+    output: UOutput;
+    inputs: TInputs;
     kind: string | undefined extends TKind ? undefined : TKind;
     namespace: string | undefined extends TNamespace ? undefined : TNamespace;
     name: string | undefined extends TName ? undefined : TName;
 }>;
 /**
  * @public
- * @deprecated - use the array format of `output` instead, see TODO-doc-link
+ * @deprecated namespace is no longer required, you can safely remove this option and it will default to the `pluginId`. It will be removed in a future release.
  */
-declare function createExtension<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput>(options: LegacyCreateExtensionOptions<TOutput, TInputs, TConfig, TConfigInput>): ExtensionDefinition<TConfig, TConfigInput, never, never>;
+declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, const TKind extends string | undefined = undefined, const TNamespace extends string | undefined = undefined, const TName extends string | undefined = undefined>(options: CreateExtensionOptions<TKind, TNamespace, TName, UOutput, TInputs, TConfigSchema, UFactoryOutput>): ExtensionDefinition<{
+    config: string extends keyof TConfigSchema ? {} : {
+        [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+    };
+    configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+        [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+    }>>;
+    output: UOutput;
+    inputs: TInputs;
+    kind: string | undefined extends TKind ? undefined : TKind;
+    namespace: string | undefined extends TNamespace ? undefined : TNamespace;
+    name: string | undefined extends TName ? undefined : TName;
+}>;
+
+/** @public */
+type PortableSchema<TOutput, TInput = TOutput> = {
+    parse: (input: TInput) => TOutput;
+    schema: JsonObject;
+};
 
 /** @public */
 interface Extension<TConfig, TConfigInput = TConfig> {
@@ -579,7 +534,7 @@ interface Extension<TConfig, TConfigInput = TConfig> {
     readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
 }
 /** @ignore */
-type ResolveExtensionId<TExtension extends ExtensionDefinition<any>, TDefaultNamespace extends string | undefined> = TExtension extends ExtensionDefinition<any, any, any, any, {
+type ResolveExtensionId<TExtension extends ExtensionDefinition, TDefaultNamespace extends string | undefined> = TExtension extends ExtensionDefinition<{
     kind: infer IKind extends string | undefined;
     namespace: infer INamespace extends string | undefined;
     name: infer IName extends string | undefined;
@@ -603,27 +558,37 @@ type AnyExternalRoutes = {
     [name in string]: ExternalRouteRef;
 };
 /** @public */
-interface BackstagePlugin<TRoutes extends AnyRoutes = AnyRoutes, TExternalRoutes extends AnyExternalRoutes = AnyExternalRoutes, TExtensionMap extends {
-    [id in string]: ExtensionDefinition<any, any>;
+interface ExtensionOverrides {
+    readonly $$type: '@backstage/ExtensionOverrides';
+}
+/**
+ * @public
+ * @deprecated import from {@link @backstage/frontend-app-api#FrontendFeature} instead
+ */
+type FrontendFeature = FrontendPlugin | ExtensionOverrides;
+
+/** @public */
+interface FrontendPlugin<TRoutes extends AnyRoutes = AnyRoutes, TExternalRoutes extends AnyExternalRoutes = AnyExternalRoutes, TExtensionMap extends {
+    [id in string]: ExtensionDefinition;
 } = {}> {
-    readonly $$type: '@backstage/BackstagePlugin';
+    readonly $$type: '@backstage/FrontendPlugin';
     readonly id: string;
     readonly routes: TRoutes;
     readonly externalRoutes: TExternalRoutes;
     getExtension<TId extends keyof TExtensionMap>(id: TId): TExtensionMap[TId];
     withOverrides(options: {
-        extensions: Array<ExtensionDefinition<any, any>>;
-    }): BackstagePlugin<TRoutes, TExternalRoutes, TExtensionMap>;
-}
-/** @public */
-interface ExtensionOverrides {
-    readonly $$type: '@backstage/ExtensionOverrides';
+        extensions: Array<ExtensionDefinition>;
+    }): FrontendPlugin<TRoutes, TExternalRoutes, TExtensionMap>;
 }
+/**
+ * @public
+ * @deprecated Use {@link FrontendPlugin} instead.
+ */
+type BackstagePlugin<TRoutes extends AnyRoutes = AnyRoutes, TExternalRoutes extends AnyExternalRoutes = AnyExternalRoutes, TExtensionMap extends {
+    [id in string]: ExtensionDefinition;
+} = {}> = FrontendPlugin<TRoutes, TExternalRoutes, TExtensionMap>;
 /** @public */
-type FrontendFeature = BackstagePlugin | ExtensionOverrides;
-
-/** @public */
-interface PluginOptions<TId extends string, TRoutes extends AnyRoutes, TExternalRoutes extends AnyExternalRoutes, TExtensions extends readonly ExtensionDefinition<any, any>[]> {
+interface PluginOptions<TId extends string, TRoutes extends AnyRoutes, TExternalRoutes extends AnyExternalRoutes, TExtensions extends readonly ExtensionDefinition[]> {
     id: TId;
     routes?: TRoutes;
     externalRoutes?: TExternalRoutes;
@@ -631,7 +596,7 @@ interface PluginOptions<TId extends string, TRoutes extends AnyRoutes, TExternal
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
-declare function createFrontendPlugin<TId extends string, TRoutes extends AnyRoutes = {}, TExternalRoutes extends AnyExternalRoutes = {}, TExtensions extends readonly ExtensionDefinition<any, any>[] = []>(options: PluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>): BackstagePlugin<TRoutes, TExternalRoutes, {
+declare function createFrontendPlugin<TId extends string, TRoutes extends AnyRoutes = {}, TExternalRoutes extends AnyExternalRoutes = {}, TExtensions extends readonly ExtensionDefinition[] = []>(options: PluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>): FrontendPlugin<TRoutes, TExternalRoutes, {
     [KExtension in TExtensions[number] as ResolveExtensionId<KExtension, TId>]: KExtension;
 }>;
 /**
@@ -641,11 +606,31 @@ declare function createFrontendPlugin<TId extends string, TRoutes extends AnyRou
 declare const createPlugin: typeof createFrontendPlugin;
 
 /** @public */
-interface ExtensionOverridesOptions {
-    extensions: ExtensionDefinition<any, any>[];
+interface CreateFrontendModuleOptions<TPluginId extends string, TExtensions extends readonly ExtensionDefinition[]> {
+    pluginId: TPluginId;
+    extensions?: TExtensions;
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
+interface FrontendModule {
+    readonly $$type: '@backstage/FrontendModule';
+    readonly pluginId: string;
+}
+/** @public */
+declare function createFrontendModule<TId extends string, TExtensions extends readonly ExtensionDefinition[] = []>(options: CreateFrontendModuleOptions<TId, TExtensions>): FrontendModule;
+
+/**
+ * @deprecated Use {@link createFrontendModule} instead.
+ * @public
+ */
+interface ExtensionOverridesOptions {
+    extensions: ExtensionDefinition[];
+    featureFlags?: FeatureFlagConfig[];
+}
+/**
+ * @deprecated Use {@link createFrontendModule} instead.
+ * @public
+ */
 declare function createExtensionOverrides(options: ExtensionOverridesOptions): ExtensionOverrides;
 
 /**
@@ -676,6 +661,7 @@ type CreateExtensionBlueprintOptions<TKind extends string, TNamespace extends st
     };
     factory(params: TParams, context: {
         node: AppNode;
+        apis: ApiHolder;
         config: {
             [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
         };
@@ -683,26 +669,53 @@ type CreateExtensionBlueprintOptions<TKind extends string, TNamespace extends st
     }): Iterable<UFactoryOutput>;
     dataRefs?: TDataRefs;
 } & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
-/**
- * @public
- */
-interface ExtensionBlueprint<TIdParts extends {
+/** @public */
+type ExtensionBlueprintParameters = {
     kind: string;
     namespace?: string;
     name?: string;
-}, TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
-        optional: boolean;
-        singleton: boolean;
+    params?: object;
+    configInput?: {
+        [K in string]: any;
+    };
+    config?: {
+        [K in string]: any;
+    };
+    output?: AnyExtensionDataRef;
+    inputs?: {
+        [KName in string]: ExtensionInput<AnyExtensionDataRef, {
+            optional: boolean;
+            singleton: boolean;
+        }>;
+    };
+    dataRefs?: {
+        [name in string]: AnyExtensionDataRef;
+    };
+};
+/**
+ * @public
+ */
+interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionBlueprintParameters> {
+    dataRefs: T['dataRefs'];
+    make<TNewNamespace extends string | undefined, TNewName extends string | undefined>(args: {
+        namespace?: undefined;
+        name?: TNewName;
+        attachTo?: {
+            id: string;
+            input: string;
+        };
+        disabled?: boolean;
+        params: T['params'];
+    }): ExtensionDefinition<{
+        kind: T['kind'];
+        namespace: undefined;
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        config: T['config'];
+        configInput: T['configInput'];
+        output: T['output'];
+        inputs: T['inputs'];
     }>;
-}, TConfig extends {
-    [key in string]: unknown;
-}, TConfigInput extends {
-    [key in string]: unknown;
-}, TDataRefs extends {
-    [name in string]: AnyExtensionDataRef;
-}> {
-    dataRefs: TDataRefs;
+    /** @deprecated namespace is no longer required, you can safely remove this option and it will default to the `pluginId`. It will be removed in a future release. */
     make<TNewNamespace extends string | undefined, TNewName extends string | undefined>(args: {
         namespace?: TNewNamespace;
         name?: TNewName;
@@ -711,11 +724,15 @@ interface ExtensionBlueprint<TIdParts extends {
             input: string;
         };
         disabled?: boolean;
-        params: TParams;
-    }): ExtensionDefinition<TConfig, TConfigInput, UOutput, TInputs, {
-        kind: TIdParts['kind'];
-        namespace: string | undefined extends TNewNamespace ? TIdParts['namespace'] : TNewNamespace;
-        name: string | undefined extends TNewName ? TIdParts['name'] : TNewName;
+        params: T['params'];
+    }): ExtensionDefinition<{
+        kind: T['kind'];
+        namespace: string | undefined extends TNewNamespace ? T['namespace'] : TNewNamespace;
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        config: T['config'];
+        configInput: T['configInput'];
+        output: T['output'];
+        inputs: T['inputs'];
     }>;
     /**
      * Creates a new extension from the blueprint.
@@ -731,7 +748,56 @@ interface ExtensionBlueprint<TIdParts extends {
             singleton: boolean;
         }>;
     }>(args: {
-        namespace?: TNewNamespace;
+        namespace?: undefined;
+        name?: TNewName;
+        attachTo?: {
+            id: string;
+            input: string;
+        };
+        disabled?: boolean;
+        inputs?: TExtraInputs & {
+            [KName in keyof T['inputs']]?: `Error: Input '${KName & string}' is already defined in parent definition`;
+        };
+        output?: Array<UNewOutput>;
+        config?: {
+            schema: TExtensionConfigSchema & {
+                [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+            };
+        };
+        factory(originalFactory: (params: T['params'], context?: {
+            config?: T['config'];
+            inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
+        }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
+            node: AppNode;
+            apis: ApiHolder;
+            config: T['config'] & {
+                [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+            };
+            inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
+        }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>;
+    }): ExtensionDefinition<{
+        config: (string extends keyof TExtensionConfigSchema ? {} : {
+            [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+        }) & T['config'];
+        configInput: (string extends keyof TExtensionConfigSchema ? {} : z.input<z.ZodObject<{
+            [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+        }>>) & T['configInput'];
+        output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        inputs: T['inputs'] & TExtraInputs;
+        kind: T['kind'];
+        namespace: undefined;
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
+    }>;
+    /** @deprecated namespace is no longer required, you can safely remove this option and it will default to the `pluginId`. It will be removed in a future release. */
+    makeWithOverrides<TNewNamespace extends string | undefined, TNewName extends string | undefined, TExtensionConfigSchema extends {
+        [key in string]: (zImpl: typeof z) => z.ZodType;
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends AnyExtensionDataRef, TExtraInputs extends {
+        [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+            optional: boolean;
+            singleton: boolean;
+        }>;
+    }>(args: {
+        namespace: TNewNamespace;
         name?: TNewName;
         attachTo?: {
             id: string;
@@ -739,32 +805,37 @@ interface ExtensionBlueprint<TIdParts extends {
         };
         disabled?: boolean;
         inputs?: TExtraInputs & {
-            [KName in keyof TInputs]?: `Error: Input '${KName & string}' is already defined in parent definition`;
+            [KName in keyof T['inputs']]?: `Error: Input '${KName & string}' is already defined in parent definition`;
         };
         output?: Array<UNewOutput>;
         config?: {
             schema: TExtensionConfigSchema & {
-                [KName in keyof TConfig]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+                [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
             };
         };
-        factory(originalFactory: (params: TParams, context?: {
-            config?: TConfig;
-            inputs?: ResolveInputValueOverrides<TInputs>;
-        }) => ExtensionDataContainer<UOutput>, context: {
+        factory(originalFactory: (params: T['params'], context?: {
+            config?: T['config'];
+            inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
+        }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
             node: AppNode;
-            config: TConfig & {
+            apis: ApiHolder;
+            config: T['config'] & {
                 [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
             };
-            inputs: Expand<ResolvedExtensionInputs<TInputs & TExtraInputs>>;
-        }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? UOutput : UNewOutput, UFactoryOutput>;
+            inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
+        }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>;
     }): ExtensionDefinition<{
-        [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
-    } & TConfig, z.input<z.ZodObject<{
-        [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
-    }>> & TConfigInput, AnyExtensionDataRef extends UNewOutput ? UOutput : UNewOutput, TInputs & TExtraInputs, {
-        kind: TIdParts['kind'];
-        namespace: string | undefined extends TNewNamespace ? TIdParts['namespace'] : TNewNamespace;
-        name: string | undefined extends TNewName ? TIdParts['name'] : TNewName;
+        config: (string extends keyof TExtensionConfigSchema ? {} : {
+            [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+        }) & T['config'];
+        configInput: (string extends keyof TExtensionConfigSchema ? {} : z.input<z.ZodObject<{
+            [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+        }>>) & T['configInput'];
+        output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        inputs: T['inputs'] & TExtraInputs;
+        kind: T['kind'];
+        namespace: string | undefined extends TNewNamespace ? T['namespace'] : TNewNamespace;
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
     }>;
 }
 /**
@@ -773,7 +844,35 @@ interface ExtensionBlueprint<TIdParts extends {
  *
  * @public
  */
-declare function createExtensionBlueprint<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+declare function createExtensionBlueprint<TParams extends object, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TKind extends string, TNamespace extends undefined = undefined, TName extends string | undefined = undefined, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+} = never>(options: CreateExtensionBlueprintOptions<TKind, undefined, TName, TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<{
+    kind: TKind;
+    namespace: undefined;
+    name: TName;
+    params: TParams;
+    output: UOutput;
+    inputs: string extends keyof TInputs ? {} : TInputs;
+    config: string extends keyof TConfigSchema ? {} : {
+        [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+    };
+    configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+        [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+    }>>;
+    dataRefs: TDataRefs;
+}>;
+/**
+ * @public
+ * @deprecated the namespace is no longer required, you can safely remove this option and it will default to the `pluginId`. It will be removed in a future release.
+ */
+declare function createExtensionBlueprint<TParams extends object, UOutput extends AnyExtensionDataRef, TInputs extends {
     [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
@@ -786,11 +885,17 @@ declare function createExtensionBlueprint<TParams, UOutput extends AnyExtensionD
     kind: TKind;
     namespace: TNamespace;
     name: TName;
-}, TParams, UOutput, string extends keyof TInputs ? {} : TInputs, string extends keyof TConfigSchema ? {} : {
-    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
-}, string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
-    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
-}>>, TDataRefs>;
+    params: TParams;
+    output: UOutput;
+    inputs: string extends keyof TInputs ? {} : TInputs;
+    config: string extends keyof TConfigSchema ? {} : {
+        [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+    };
+    configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+        [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+    }>>;
+    dataRefs: TDataRefs;
+}>;
 
 /**
  * The specification for this {@link AppNode} in the {@link AppTree}.
@@ -1135,10 +1240,16 @@ declare const ApiBlueprint: ExtensionBlueprint<{
     kind: "api";
     namespace: undefined;
     name: undefined;
-}, {
-    factory: AnyApiFactory;
-}, ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>, {}, {}, {}, {
-    factory: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+    params: {
+        factory: AnyApiFactory;
+    };
+    output: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        factory: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+    };
 }>;
 
 /**
@@ -1151,9 +1262,15 @@ declare const AppRootElementBlueprint: ExtensionBlueprint<{
     kind: "app-root-element";
     namespace: undefined;
     name: undefined;
-}, {
-    element: JSX.Element | (() => JSX.Element);
-}, ConfigurableExtensionDataRef<React.JSX.Element, "core.reactElement", {}>, {}, {}, {}, never>;
+    params: {
+        element: JSX.Element | (() => JSX.Element);
+    };
+    output: ConfigurableExtensionDataRef<React.JSX.Element, "core.reactElement", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: never;
+}>;
 
 /**
  * Creates a extensions that render a React wrapper at the app root, enclosing
@@ -1166,37 +1283,49 @@ declare const AppRootWrapperBlueprint: ExtensionBlueprint<{
     kind: "app-root-wrapper";
     namespace: undefined;
     name: undefined;
-}, {
-    Component: ComponentType<PropsWithChildren<{}>>;
-}, ConfigurableExtensionDataRef<React__default.ComponentType<{
-    children?: React__default.ReactNode;
-}>, "app.root.wrapper", {}>, {}, {}, {}, {
-    component: ConfigurableExtensionDataRef<React__default.ComponentType<{
+    params: {
+        Component: ComponentType<PropsWithChildren<{}>>;
+    };
+    output: ConfigurableExtensionDataRef<React__default.ComponentType<{
         children?: React__default.ReactNode;
     }>, "app.root.wrapper", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        component: ConfigurableExtensionDataRef<React__default.ComponentType<{
+            children?: React__default.ReactNode;
+        }>, "app.root.wrapper", {}>;
+    };
 }>;
 
 /** @public */
 declare const IconBundleBlueprint: ExtensionBlueprint<{
     kind: "icon-bundle";
-    namespace: "app";
+    namespace: undefined;
     name: undefined;
-}, {
-    icons: {
-        [x: string]: IconComponent;
+    params: {
+        icons: {
+            [x: string]: IconComponent;
+        };
     };
-}, ConfigurableExtensionDataRef<{
-    [x: string]: IconComponent;
-}, "core.icons", {}>, {}, {
-    icons: string;
-    test: string;
-}, {
-    test: string;
-    icons?: string | undefined;
-}, {
-    icons: ConfigurableExtensionDataRef<{
+    output: ConfigurableExtensionDataRef<{
         [x: string]: IconComponent;
     }, "core.icons", {}>;
+    inputs: {};
+    config: {
+        icons: string;
+        test: string;
+    };
+    configInput: {
+        test: string;
+        icons?: string | undefined;
+    };
+    dataRefs: {
+        icons: ConfigurableExtensionDataRef<{
+            [x: string]: IconComponent;
+        }, "core.icons", {}>;
+    };
 }>;
 
 /**
@@ -1208,20 +1337,26 @@ declare const NavItemBlueprint: ExtensionBlueprint<{
     kind: "nav-item";
     namespace: undefined;
     name: undefined;
-}, {
-    title: string;
-    icon: IconComponent$1;
-    routeRef: RouteRef<undefined>;
-}, ConfigurableExtensionDataRef<{
-    title: string;
-    icon: IconComponent$1;
-    routeRef: RouteRef<undefined>;
-}, "core.nav-item.target", {}>, {}, {}, {}, {
-    target: ConfigurableExtensionDataRef<{
+    params: {
+        title: string;
+        icon: IconComponent$1;
+        routeRef: RouteRef<undefined>;
+    };
+    output: ConfigurableExtensionDataRef<{
         title: string;
         icon: IconComponent$1;
         routeRef: RouteRef<undefined>;
     }, "core.nav-item.target", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        target: ConfigurableExtensionDataRef<{
+            title: string;
+            icon: IconComponent$1;
+            routeRef: RouteRef<undefined>;
+        }, "core.nav-item.target", {}>;
+    };
 }>;
 
 /**
@@ -1233,17 +1368,23 @@ declare const NavLogoBlueprint: ExtensionBlueprint<{
     kind: "nav-logo";
     namespace: undefined;
     name: undefined;
-}, {
-    logoIcon: JSX.Element;
-    logoFull: JSX.Element;
-}, ConfigurableExtensionDataRef<{
-    logoIcon?: JSX.Element | undefined;
-    logoFull?: JSX.Element | undefined;
-}, "core.nav-logo.logo-elements", {}>, {}, {}, {}, {
-    logoElements: ConfigurableExtensionDataRef<{
+    params: {
+        logoIcon: JSX.Element;
+        logoFull: JSX.Element;
+    };
+    output: ConfigurableExtensionDataRef<{
         logoIcon?: JSX.Element | undefined;
         logoFull?: JSX.Element | undefined;
     }, "core.nav-logo.logo-elements", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        logoElements: ConfigurableExtensionDataRef<{
+            logoIcon?: JSX.Element | undefined;
+            logoFull?: JSX.Element | undefined;
+        }, "core.nav-logo.logo-elements", {}>;
+    };
 }>;
 
 /**
@@ -1255,31 +1396,43 @@ declare const PageBlueprint: ExtensionBlueprint<{
     kind: "page";
     namespace: undefined;
     name: undefined;
-}, {
-    defaultPath: string;
-    loader: () => Promise<JSX.Element>;
-    routeRef?: RouteRef<AnyRouteRefParams> | undefined;
-}, ConfigurableExtensionDataRef<React.JSX.Element, "core.reactElement", {}> | ConfigurableExtensionDataRef<string, "core.routing.path", {}> | ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {
-    optional: true;
-}>, {}, {
-    path: string | undefined;
-}, {
-    path?: string | undefined;
-}, never>;
+    params: {
+        defaultPath: string;
+        loader: () => Promise<JSX.Element>;
+        routeRef?: RouteRef<AnyRouteRefParams> | undefined;
+    };
+    output: ConfigurableExtensionDataRef<React.JSX.Element, "core.reactElement", {}> | ConfigurableExtensionDataRef<string, "core.routing.path", {}> | ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {
+        optional: true;
+    }>;
+    inputs: {};
+    config: {
+        path: string | undefined;
+    };
+    configInput: {
+        path?: string | undefined;
+    };
+    dataRefs: never;
+}>;
 
 /** @public */
 declare const RouterBlueprint: ExtensionBlueprint<{
     kind: "app-router-component";
     namespace: undefined;
     name: undefined;
-}, {
-    Component: ComponentType<PropsWithChildren<{}>>;
-}, ConfigurableExtensionDataRef<ComponentType<{
-    children?: React.ReactNode;
-}>, "app.router.wrapper", {}>, {}, {}, {}, {
-    component: ConfigurableExtensionDataRef<ComponentType<{
+    params: {
+        Component: ComponentType<PropsWithChildren<{}>>;
+    };
+    output: ConfigurableExtensionDataRef<ComponentType<{
         children?: React.ReactNode;
     }>, "app.router.wrapper", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        component: ConfigurableExtensionDataRef<ComponentType<{
+            children?: React.ReactNode;
+        }>, "app.router.wrapper", {}>;
+    };
 }>;
 
 /**
@@ -1291,10 +1444,16 @@ declare const SignInPageBlueprint: ExtensionBlueprint<{
     kind: "sign-in-page";
     namespace: undefined;
     name: undefined;
-}, {
-    loader: () => Promise<ComponentType<SignInPageProps>>;
-}, ConfigurableExtensionDataRef<React__default.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>, {}, {}, {}, {
-    component: ConfigurableExtensionDataRef<React__default.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+    params: {
+        loader: () => Promise<ComponentType<SignInPageProps>>;
+    };
+    output: ConfigurableExtensionDataRef<React__default.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        component: ConfigurableExtensionDataRef<React__default.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+    };
 }>;
 
 /**
@@ -1304,12 +1463,18 @@ declare const SignInPageBlueprint: ExtensionBlueprint<{
  */
 declare const ThemeBlueprint: ExtensionBlueprint<{
     kind: "theme";
-    namespace: "app";
+    namespace: undefined;
     name: undefined;
-}, {
-    theme: AppTheme;
-}, ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>, {}, {}, {}, {
-    theme: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+    params: {
+        theme: AppTheme;
+    };
+    output: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        theme: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+    };
 }>;
 
 /**
@@ -1321,308 +1486,48 @@ declare const TranslationBlueprint: ExtensionBlueprint<{
     kind: "translation";
     namespace: undefined;
     name: undefined;
-}, {
-    resource: TranslationResource | TranslationMessages;
-}, ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
-    [x: string]: string;
-}, boolean>, "core.translation.translation", {}>, {}, {}, {}, {
-    translation: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
+    params: {
+        resource: TranslationResource | TranslationMessages;
+    };
+    output: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
         [x: string]: string;
     }, boolean>, "core.translation.translation", {}>;
-}>;
-
-/**
- * @public
- * @deprecated Use {@link ApiBlueprint} instead.
- */
-declare function createApiExtension<TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: ({
-    api: AnyApiRef;
-    factory: (options: {
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    }) => AnyApiFactory;
-} | {
-    factory: AnyApiFactory;
-}) & {
-    configSchema?: PortableSchema<TConfig>;
-    inputs?: TInputs;
-}): ExtensionDefinition<TConfig, TConfig, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
-}>;
-/**
- * @public
- * @deprecated Use {@link ApiBlueprint} instead.
- */
-declare namespace createApiExtension {
-    /**
-     * @deprecated Use {@link ApiBlueprint} instead.
-     */
-    const factoryDataRef: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
-}
-
-/**
- * Creates an extension that renders a React element at the app root, outside of
- * the app layout. This is useful for example for shared popups and similar.
- *
- * @public
- * @deprecated Use {@link AppRootElementBlueprint} instead.
- */
-declare function createAppRootElementExtension<TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-        id: string;
-        input: string;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        translation: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
+            [x: string]: string;
+        }, boolean>, "core.translation.translation", {}>;
     };
-    configSchema?: PortableSchema<TConfig>;
-    disabled?: boolean;
-    inputs?: TInputs;
-    element: JSX$1.Element | ((options: {
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        config: TConfig;
-    }) => JSX$1.Element);
-}): ExtensionDefinition<TConfig>;
-
-/**
- * Creates an extension that renders a React wrapper at the app root, enclosing
- * the app layout. This is useful for example for adding global React contexts
- * and similar.
- *
- * @public
- * @deprecated Use {@link AppRootWrapperBlueprint} instead.
- */
-declare function createAppRootWrapperExtension<TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-        id: string;
-        input: string;
-    };
-    configSchema?: PortableSchema<TConfig>;
-    disabled?: boolean;
-    inputs?: TInputs;
-    Component: ComponentType<PropsWithChildren<{
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        config: TConfig;
-    }>>;
-}): ExtensionDefinition<TConfig>;
-/**
- * @public
- * @deprecated Use {@link AppRootWrapperBlueprint} instead.
- */
-declare namespace createAppRootWrapperExtension {
-    /**
-     * @deprecated Use {@link AppRootWrapperBlueprint} instead.
-     */
-    const componentDataRef: ConfigurableExtensionDataRef<React__default.ComponentType<{
-        children?: React__default.ReactNode;
-    }>, "app.root.wrapper", {}>;
-}
-
-/**
- * Creates an extension that replaces the router implementation at the app root.
- * This is useful to be able to for example replace the BrowserRouter with a
- * MemoryRouter in tests, or to add additional props to a BrowserRouter.
- *
- * @public
- * @deprecated Use {@link RouterBlueprint} instead.
- */
-declare function createRouterExtension<TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-        id: string;
-        input: string;
-    };
-    configSchema?: PortableSchema<TConfig>;
-    disabled?: boolean;
-    inputs?: TInputs;
-    Component: ComponentType<PropsWithChildren<{
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        config: TConfig;
-    }>>;
-}): ExtensionDefinition<TConfig>;
-/**
- * @public
- * @deprecated Use {@link RouterBlueprint} instead.
- */
-declare namespace createRouterExtension {
-    /**
-     * @deprecated Use {@link RouterBlueprint} instead.
-     */
-    const componentDataRef: ConfigurableExtensionDataRef<React__default.ComponentType<{
-        children?: React__default.ReactNode;
-    }>, "app.router.wrapper", {}>;
-}
-
-/**
- * Helper for creating extensions for a routable React page component.
- *
- * @public
- * @deprecated Use {@link PageBlueprint} instead.
- */
-declare function createPageExtension<TConfig extends {
-    path: string;
-}, TInputs extends AnyExtensionInputMap>(options: ({
-    defaultPath: string;
-} | {
-    configSchema: PortableSchema<TConfig>;
-}) & {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-        id: string;
-        input: string;
-    };
-    disabled?: boolean;
-    inputs?: TInputs;
-    routeRef?: RouteRef;
-    loader: (options: {
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    }) => Promise<JSX.Element>;
-}): ExtensionDefinition<TConfig>;
-
-/**
- * Helper for creating extensions for a nav item.
- *
- * @public
- * @deprecated Use {@link NavItemBlueprint} instead.
- */
-declare function createNavItemExtension(options: {
-    namespace?: string;
-    name?: string;
-    routeRef: RouteRef<undefined>;
-    title: string;
-    icon: IconComponent$1;
-}): ExtensionDefinition<{
-    title: string;
-}, {
-    title?: string | undefined;
-}, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
 }>;
-/**
- * @public
- * @deprecated Use {@link NavItemBlueprint} instead.
- */
-declare namespace createNavItemExtension {
-    /**
-     * @deprecated Use {@link NavItemBlueprint} instead.
-     */
-    const targetDataRef: ConfigurableExtensionDataRef<{
-        title: string;
-        icon: IconComponent$1;
-        routeRef: RouteRef<undefined>;
-    }, "core.nav-item.target", {}>;
-}
-
-/**
- * Helper for creating extensions for a nav logos.
- *
- * @public
- * @deprecated Use {@link NavLogoBlueprint} instead.
- */
-declare function createNavLogoExtension(options: {
-    name?: string;
-    namespace?: string;
-    logoIcon: JSX.Element;
-    logoFull: JSX.Element;
-}): ExtensionDefinition<unknown, unknown, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
-}>;
-/**
- * @public
- * @deprecated Use {@link NavLogoBlueprint} instead.
- */
-declare namespace createNavLogoExtension {
-    /**
-     * @deprecated Use {@link NavLogoBlueprint} instead.
-     */
-    const logoElementsDataRef: ConfigurableExtensionDataRef<{
-        logoIcon?: JSX.Element | undefined;
-        logoFull?: JSX.Element | undefined;
-    }, "core.nav-logo.logo-elements", {}>;
-}
-
-/**
- *
- * @public
- * @deprecated Use {@link SignInPageBlueprint} instead.
- */
-declare function createSignInPageExtension<TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-        id: string;
-        input: string;
-    };
-    configSchema?: PortableSchema<TConfig>;
-    disabled?: boolean;
-    inputs?: TInputs;
-    loader: (options: {
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    }) => Promise<ComponentType<SignInPageProps>>;
-}): ExtensionDefinition<TConfig>;
-/**
- * @public
- * @deprecated Use {@link SignInPageBlueprint} instead.
- */
-declare namespace createSignInPageExtension {
-    /**
-     * @deprecated Use {@link SignInPageBlueprint} instead.
-     */
-    const componentDataRef: ConfigurableExtensionDataRef<React__default.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
-}
-
-/**
- * @public
- * @deprecated Use {@link ThemeBlueprint} instead.
- */
-declare function createThemeExtension(theme: AppTheme): ExtensionDefinition<unknown, unknown, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
-}>;
-/**
- * @public
- * @deprecated Use {@link ThemeBlueprint} instead.
- */
-declare namespace createThemeExtension {
-    const themeDataRef: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
-}
 
 /** @public */
-declare function createComponentExtension<TProps extends {}, TConfig extends {}, TInputs extends AnyExtensionInputMap>(options: {
+declare function createComponentExtension<TProps extends {}>(options: {
     ref: ComponentRef<TProps>;
     name?: string;
     disabled?: boolean;
-    /** @deprecated these will be removed in the future */
-    inputs?: TInputs;
-    /** @deprecated these will be removed in the future */
-    configSchema?: PortableSchema<TConfig>;
     loader: {
-        lazy: (values: {
-            config: TConfig;
-            inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        }) => Promise<ComponentType<TProps>>;
+        lazy: () => Promise<ComponentType<TProps>>;
     } | {
-        sync: (values: {
-            config: TConfig;
-            inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        }) => ComponentType<TProps>;
+        sync: () => ComponentType<TProps>;
+    };
+}): ExtensionDefinition<{
+    config: {};
+    configInput: {};
+    output: ConfigurableExtensionDataRef<{
+        ref: ComponentRef;
+        impl: ComponentType;
+    }, "core.component.component", {}>;
+    inputs: {
+        [x: string]: ExtensionInput<AnyExtensionDataRef, {
+            optional: boolean;
+            singleton: boolean;
+        }>;
     };
-}): ExtensionDefinition<TConfig, TConfig, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
+    kind: "component";
+    namespace: undefined;
+    name: string;
 }>;
 /** @public */
 declare namespace createComponentExtension {
@@ -1632,26 +1537,4 @@ declare namespace createComponentExtension {
     }, "core.component.component", {}>;
 }
 
-/**
- * @public
- * @deprecated Use {@link TranslationBlueprint} instead.
- */
-declare function createTranslationExtension(options: {
-    name?: string;
-    resource: TranslationResource | TranslationMessages;
-}): ExtensionDefinition<unknown, unknown, never, never, {
-    kind?: string | undefined;
-    namespace?: string | undefined;
-    name?: string | undefined;
-}>;
-/**
- * @public
- * @deprecated Use {@link TranslationBlueprint} instead.
- */
-declare namespace createTranslationExtension {
-    const translationDataRef: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
-        [x: string]: string;
-    }, boolean>, "core.translation.translation", {}>;
-}
-
-export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataMap, type AnyExtensionDataRef, type AnyExtensionInputMap, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, ApiBlueprint, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, AppRootElementBlueprint, AppRootWrapperBlueprint, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type Extension, type ExtensionBlueprint, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDataValues, type ExtensionDefinition, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, IconBundleBlueprint, type IconComponent, type IconsApi, type LegacyCreateExtensionOptions, type LegacyExtensionInput, NavItemBlueprint, NavLogoBlueprint, PageBlueprint, type PluginOptions, type PortableSchema, type ResolveInputValueOverrides, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, RouterBlueprint, SignInPageBlueprint, type SubRouteRef, ThemeBlueprint, TranslationBlueprint, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createApiExtension, createAppRootElementExtension, createAppRootWrapperExtension, createComponentExtension, createComponentRef, createExtension, createExtensionBlueprint, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createFrontendPlugin, createNavItemExtension, createNavLogoExtension, createPageExtension, createPlugin, createRouteRef, createRouterExtension, createSchemaFromZod, createSignInPageExtension, createSubRouteRef, createThemeExtension, createTranslationExtension, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };
+export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataRef, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, ApiBlueprint, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, AppRootElementBlueprint, AppRootWrapperBlueprint, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type CreateFrontendModuleOptions, type Extension, type ExtensionBlueprint, type ExtensionBlueprintParameters, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDefinition, type ExtensionDefinitionParameters, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, type FrontendModule, type FrontendPlugin, IconBundleBlueprint, type IconComponent, type IconsApi, NavItemBlueprint, NavLogoBlueprint, PageBlueprint, type PluginOptions, type PortableSchema, type ResolveInputValueOverrides, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, RouterBlueprint, SignInPageBlueprint, type SubRouteRef, ThemeBlueprint, TranslationBlueprint, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createComponentExtension, createComponentRef, createExtension, createExtensionBlueprint, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createFrontendModule, createFrontendPlugin, createPlugin, createRouteRef, createSubRouteRef, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };