@backstage/frontend-plugin-api 0.11.0-next.0 → 0.11.0-next.2

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode, JSX as JSX$1, ComponentType, PropsWithChildren } from 'react';
+import { ReactNode, JSX as JSX$1, ComponentType } from 'react';
 import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
-import { ApiHolder, ConfigApi, ApiRef, ApiFactory, AnyApiFactory, IconComponent as IconComponent$2, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
+import { ApiHolder, ConfigApi, ApiRef, TypesToApiRefs, ApiFactory, AnyApiFactory, IconComponent as IconComponent$2, 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 { Expand, JsonObject } from '@backstage/types';
 import { z } from 'zod';
@@ -12,11 +12,11 @@ import { TranslationResource, TranslationMessages } from '@backstage/core-plugin
 export { TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, createTranslationMessages, createTranslationRef, createTranslationResource, useTranslationRef } from '@backstage/core-plugin-api/alpha';
 
 /**
- * Common analytics context attributes.
+ * Analytics context envelope.
  *
  * @public
  */
-type CommonAnalyticsContext = {
+interface AnalyticsContextValue {
     /**
      * The nearest known parent plugin where the event was captured.
      */
@@ -25,15 +25,8 @@ type CommonAnalyticsContext = {
      * The nearest known parent extension where the event was captured.
      */
     extensionId: string;
-};
-/**
- * Analytics context envelope.
- *
- * @public
- */
-type AnalyticsContextValue = CommonAnalyticsContext & {
-    [param in string]: string | boolean | number | undefined;
-};
+    [key: string]: string | boolean | number | undefined;
+}
 
 /**
  * Provides components in the child react tree an Analytics Context, ensuring
@@ -58,9 +51,11 @@ type ExtensionDataValue<TData, TId extends string> = {
     readonly value: TData;
 };
 /** @public */
-type ExtensionDataRef<TData, TId extends string = string, TConfig extends {
+type ExtensionDataRef<TData = unknown, TId extends string = string, TConfig extends {
     optional?: true;
-} = {}> = {
+} = {
+    optional?: true;
+}> = {
     readonly $$type: '@backstage/ExtensionDataRef';
     readonly id: TId;
     readonly T: TData;
@@ -68,10 +63,11 @@ type ExtensionDataRef<TData, TId extends string = string, TConfig extends {
 };
 /** @public */
 type ExtensionDataRefToValue<TDataRef extends AnyExtensionDataRef> = TDataRef extends ExtensionDataRef<infer IData, infer IId, any> ? ExtensionDataValue<IData, IId> : never;
-/** @public */
-type AnyExtensionDataRef = ExtensionDataRef<unknown, string, {
-    optional?: true;
-}>;
+/**
+ * @deprecated Use `ExtensionDataRef` without type parameters instead.
+ * @public
+ */
+type AnyExtensionDataRef = ExtensionDataRef;
 /** @public */
 interface ConfigurableExtensionDataRef<TData, TId extends string, TConfig extends {
     optional?: true;
@@ -120,7 +116,8 @@ declare function createRouteRef<TParams extends {
     [param in TParamKeys]: string;
 } | undefined = undefined, TParamKeys extends string = string>(config?: {
     /** A list of parameter names that the path that this route ref is bound to must contain */
-    readonly params: string extends TParamKeys ? (keyof TParams)[] : TParamKeys[];
+    readonly params?: string extends TParamKeys ? (keyof TParams)[] : TParamKeys[];
+    aliasFor?: string;
 }): RouteRef<keyof TParams extends never ? undefined : string extends TParamKeys ? TParams : {
     [param in TParamKeys]: string;
 }>;
@@ -163,14 +160,14 @@ declare function createExtensionInput<UExtensionData extends ExtensionDataRef<un
     optional: TConfig['optional'] extends true ? true : false;
 }>;
 
-/** @public */
-type ResolveInputValueOverrides<TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+/** @ignore */
+type ResolvedInputValueOverrides<TInputs extends {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
 } = {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
@@ -192,6 +189,115 @@ type ResolveInputValueOverrides<TInputs extends {
     }> ? ISingleton extends true ? Iterable<ExtensionDataRefToValue<IDataRefs>> : Array<Iterable<ExtensionDataRefToValue<IDataRefs>>> : never;
 }>;
 
+/** @public */
+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;
+}
+/**
+ * Creates a new module that can be installed in a Backstage app.
+ *
+ * @remarks
+ *
+ * Modules are used to add or override extensions for an existing plugin. If a
+ * module provides an extension with the same ID as one provided by the plugin,
+ * the extension provided by the module will always take precedence.
+ *
+ * Every module is created for a specific plugin by providing the
+ * unique ID of the plugin that the module should be installed for. If that
+ * plugin is not present in the app, the module will be ignored and have no
+ * effect.
+ *
+ * For more information on how modules work, see the
+ * {@link https://backstage.io/docs/frontend-system/architecture/extension-overrides#creating-a-frontend-module | documentation for modules}
+ * in the frontend system documentation.
+ *
+ * It is recommended to name the module variable of the form `<pluginId>Module<ModuleName>`.
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createFrontendModule } from '@backstage/frontend-plugin-api';
+ *
+ * export const exampleModuleCustomPage = createFrontendModule({
+ *   pluginId: 'example',
+ *   extensions: [
+ *     // Overrides the default page for the 'example' plugin
+ *     PageBlueprint.make({
+ *       path: '/example',
+ *       loader: () => import('./CustomPage').then(m => <m.CustomPage />),
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function createFrontendModule<TId extends string, TExtensions extends readonly ExtensionDefinition[] = []>(options: CreateFrontendModuleOptions<TId, TExtensions>): FrontendModule;
+
+/** @public */
+type PortableSchema<TOutput, TInput = TOutput> = {
+    parse: (input: TInput) => TOutput;
+    schema: JsonObject;
+};
+
+/** @public */
+interface Extension<TConfig, TConfigInput = TConfig> {
+    $$type: '@backstage/Extension';
+    readonly id: string;
+    readonly attachTo: ExtensionAttachToSpec;
+    readonly disabled: boolean;
+    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
+}
+/** @ignore */
+type ResolveExtensionId<TExtension extends ExtensionDefinition, TNamespace extends string> = TExtension extends ExtensionDefinition<{
+    kind: infer IKind extends string | undefined;
+    name: infer IName extends string | undefined;
+    params: any;
+}> ? [string] extends [IKind | IName] ? never : (undefined extends IName ? TNamespace : `${TNamespace}/${IName}`) extends infer INamePart extends string ? IKind extends string ? `${IKind}:${INamePart}` : INamePart : never : never;
+
+type CompareChars<A extends string, B extends string> = [A, B] extends [
+    `${infer IAHead}${infer IARest}`,
+    `${infer IBHead}${infer IBRest}`
+] ? IAHead extends IBHead ? IBRest extends '' ? IARest extends '' ? 'eq' : 'gt' : IARest extends '' ? 'lt' : CompareChars<IARest, IBRest> : `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz` extends `${string}${IAHead}${string}${IBHead}${string}` ? 'lt' : 'gt' : 'eq';
+type CompareStrings<A extends string | undefined, B extends string | undefined> = A extends B ? 'eq' : A extends undefined ? 'lt' : B extends undefined ? 'gt' : CompareChars<A & string, B & string>;
+type CompareExtensions<A extends ExtensionDefinition, B extends ExtensionDefinition> = CompareStrings<A['T']['kind'], B['T']['kind']> extends 'eq' ? CompareStrings<A['T']['name'], B['T']['name']> : CompareStrings<A['T']['kind'], B['T']['kind']>;
+type SortExtensionsInner<TPivot extends ExtensionDefinition, TRest extends readonly ExtensionDefinition[], TLow extends readonly ExtensionDefinition[], THigh extends readonly ExtensionDefinition[]> = TRest extends [
+    infer IHead extends ExtensionDefinition,
+    ...infer IRest extends readonly ExtensionDefinition[]
+] ? CompareExtensions<IHead, TPivot> extends 'lt' ? SortExtensionsInner<TPivot, IRest, [...TLow, IHead], THigh> : SortExtensionsInner<TPivot, IRest, TLow, [...THigh, IHead]> : [low: TLow, high: THigh];
+type SortExtensions<T extends readonly ExtensionDefinition[]> = T extends [
+    infer IPivot extends ExtensionDefinition,
+    ...infer IRest extends readonly ExtensionDefinition[]
+] ? SortExtensionsInner<IPivot, IRest, [], []> extends [
+    low: infer ILow extends readonly ExtensionDefinition[],
+    high: infer IHigh extends readonly ExtensionDefinition[]
+] ? [...SortExtensions<ILow>, IPivot, ...SortExtensions<IHigh>] : 'invalid SortExtensionsInner' : [];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PopUnion$1<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? [next: R, rest: Exclude<U, R>] : undefined;
+type UnionToArray<U, T = U, TResult extends T[] = []> = PopUnion$1<U> extends [
+    next: infer INext extends T,
+    rest: infer IRest extends T
+] ? UnionToArray<IRest, T, [INext, ...TResult]> : TResult;
+type ExtensionArrayToMap<T extends ExtensionDefinition[], TId extends string, TOut extends {
+    [KId in string]: ExtensionDefinition;
+} = {}> = T extends [
+    infer IHead extends ExtensionDefinition,
+    ...infer IRest extends ExtensionDefinition[]
+] ? ExtensionArrayToMap<IRest, TId, TOut & {
+    [K in ResolveExtensionId<IHead, TId>]: IHead;
+}> : TOut extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+/** @ignore */
+type MakeSortedExtensionsMap<UExtensions extends ExtensionDefinition, TId extends string> = ExtensionArrayToMap<SortExtensions<UnionToArray<UExtensions>>, TId>;
+
 /**
  * Descriptor of a route relative to an absolute {@link RouteRef}.
  *
@@ -319,77 +425,6 @@ declare function useRouteRef<TParams extends AnyRouteRefParams>(routeRef: RouteR
  */
 declare function useRouteRefParams<Params extends AnyRouteRefParams>(_routeRef: RouteRef<Params> | SubRouteRef<Params>): Params;
 
-/** @public */
-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;
-
-/** @public */
-type PortableSchema<TOutput, TInput = TOutput> = {
-    parse: (input: TInput) => TOutput;
-    schema: JsonObject;
-};
-
-/** @public */
-interface Extension<TConfig, TConfigInput = TConfig> {
-    $$type: '@backstage/Extension';
-    readonly id: string;
-    readonly attachTo: ExtensionAttachToSpec;
-    readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
-}
-/** @ignore */
-type ResolveExtensionId<TExtension extends ExtensionDefinition, TNamespace extends string> = TExtension extends ExtensionDefinition<{
-    kind: infer IKind extends string | undefined;
-    name: infer IName extends string | undefined;
-    params: any;
-}> ? [string] extends [IKind | IName] ? never : (undefined extends IName ? TNamespace : `${TNamespace}/${IName}`) extends infer INamePart extends string ? IKind extends string ? `${IKind}:${INamePart}` : INamePart : never : never;
-
-type CompareChars<A extends string, B extends string> = [A, B] extends [
-    `${infer IAHead}${infer IARest}`,
-    `${infer IBHead}${infer IBRest}`
-] ? IAHead extends IBHead ? IBRest extends '' ? IARest extends '' ? 'eq' : 'gt' : IARest extends '' ? 'lt' : CompareChars<IARest, IBRest> : `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz` extends `${string}${IAHead}${string}${IBHead}${string}` ? 'lt' : 'gt' : 'eq';
-type CompareStrings<A extends string | undefined, B extends string | undefined> = A extends B ? 'eq' : A extends undefined ? 'lt' : B extends undefined ? 'gt' : CompareChars<A & string, B & string>;
-type CompareExtensions<A extends ExtensionDefinition, B extends ExtensionDefinition> = CompareStrings<A['T']['kind'], B['T']['kind']> extends 'eq' ? CompareStrings<A['T']['name'], B['T']['name']> : CompareStrings<A['T']['kind'], B['T']['kind']>;
-type SortExtensionsInner<TPivot extends ExtensionDefinition, TRest extends readonly ExtensionDefinition[], TLow extends readonly ExtensionDefinition[], THigh extends readonly ExtensionDefinition[]> = TRest extends [
-    infer IHead extends ExtensionDefinition,
-    ...infer IRest extends readonly ExtensionDefinition[]
-] ? CompareExtensions<IHead, TPivot> extends 'lt' ? SortExtensionsInner<TPivot, IRest, [...TLow, IHead], THigh> : SortExtensionsInner<TPivot, IRest, TLow, [...THigh, IHead]> : [low: TLow, high: THigh];
-type SortExtensions<T extends readonly ExtensionDefinition[]> = T extends [
-    infer IPivot extends ExtensionDefinition,
-    ...infer IRest extends readonly ExtensionDefinition[]
-] ? SortExtensionsInner<IPivot, IRest, [], []> extends [
-    low: infer ILow extends readonly ExtensionDefinition[],
-    high: infer IHigh extends readonly ExtensionDefinition[]
-] ? [...SortExtensions<ILow>, IPivot, ...SortExtensions<IHigh>] : 'invalid SortExtensionsInner' : [];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type PopUnion$1<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? [next: R, rest: Exclude<U, R>] : undefined;
-type UnionToArray<U, T = U, TResult extends T[] = []> = PopUnion$1<U> extends [
-    next: infer INext extends T,
-    rest: infer IRest extends T
-] ? UnionToArray<IRest, T, [INext, ...TResult]> : TResult;
-type ExtensionArrayToMap<T extends ExtensionDefinition[], TId extends string, TOut extends {
-    [KId in string]: ExtensionDefinition;
-} = {}> = T extends [
-    infer IHead extends ExtensionDefinition,
-    ...infer IRest extends ExtensionDefinition[]
-] ? ExtensionArrayToMap<IRest, TId, TOut & {
-    [K in ResolveExtensionId<IHead, TId>]: IHead;
-}> : TOut extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-/** @ignore */
-type MakeSortedExtensionsMap<UExtensions extends ExtensionDefinition, TId extends string> = ExtensionArrayToMap<SortExtensions<UnionToArray<UExtensions>>, TId>;
-
 /**
  * Information about the plugin.
  *
@@ -450,7 +485,15 @@ type FrontendPluginInfoOptions = {
     manifest?: () => Promise<JsonObject>;
 };
 /** @public */
-interface FrontendPlugin<TRoutes extends AnyRoutes = AnyRoutes, TExternalRoutes extends AnyExternalRoutes = AnyExternalRoutes, TExtensionMap extends {
+interface FrontendPlugin<TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+} = {
+    [name in string]: RouteRef | SubRouteRef;
+}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+} = {
+    [name in string]: ExternalRouteRef;
+}, TExtensionMap extends {
     [id in string]: ExtensionDefinition;
 } = {
     [id in string]: ExtensionDefinition;
@@ -473,7 +516,11 @@ interface FrontendPlugin<TRoutes extends AnyRoutes = AnyRoutes, TExternalRoutes
     }): FrontendPlugin<TRoutes, TExternalRoutes, TExtensionMap>;
 }
 /** @public */
-interface PluginOptions<TId extends string, TRoutes extends AnyRoutes, TExternalRoutes extends AnyExternalRoutes, TExtensions extends readonly ExtensionDefinition[]> {
+interface PluginOptions<TId extends string, TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+}, TExtensions extends readonly ExtensionDefinition[]> {
     pluginId: TId;
     routes?: TRoutes;
     externalRoutes?: TExternalRoutes;
@@ -481,15 +528,41 @@ interface PluginOptions<TId extends string, TRoutes extends AnyRoutes, TExternal
     featureFlags?: FeatureFlagConfig[];
     info?: FrontendPluginInfoOptions;
 }
-/** @public */
-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, MakeSortedExtensionsMap<TExtensions[number], TId>>;
 /**
+ * Creates a new plugin that can be installed in a Backstage app.
+ *
+ * @remarks
+ *
+ * Every plugin is created with a unique ID and a set of extensions
+ * that are installed as part of the plugin.
+ *
+ * For more information on how plugins work, see the
+ * {@link https://backstage.io/docs/frontend-system/building-plugins/index | documentation for plugins}
+ * in the frontend system documentation.
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createFrontendPlugin } from '@backstage/frontend-plugin-api';
+ *
+ * export const examplePlugin = createFrontendPlugin({
+ *   pluginId: 'example',
+ *   extensions: [
+ *     PageBlueprint.make({
+ *       path: '/example',
+ *       loader: () => import('./ExamplePage').then(m => <m.ExamplePage />),
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
  * @public
- * @deprecated The `id` option is deprecated, use `pluginId` instead.
  */
-declare function createFrontendPlugin<TId extends string, TRoutes extends AnyRoutes = {}, TExternalRoutes extends AnyExternalRoutes = {}, TExtensions extends readonly ExtensionDefinition[] = []>(options: Omit<PluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>, 'pluginId'> & {
-    id: string;
-}): FrontendPlugin<TRoutes, TExternalRoutes, MakeSortedExtensionsMap<TExtensions[number], TId>>;
+declare function createFrontendPlugin<TId extends string, TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+} = {}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+} = {}, TExtensions extends readonly ExtensionDefinition[] = []>(options: PluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>): FrontendPlugin<TRoutes, TExternalRoutes, MakeSortedExtensionsMap<TExtensions[number], TId>>;
 
 /**
  * Feature flag configuration.
@@ -501,21 +574,13 @@ type FeatureFlagConfig = {
     name: string;
 };
 /** @public */
-type AnyRoutes = {
-    [name in string]: RouteRef | SubRouteRef;
-};
-/** @public */
-type AnyExternalRoutes = {
-    [name in string]: ExternalRouteRef;
-};
-/** @public */
-type ExtensionDataContainer<UExtensionData extends AnyExtensionDataRef> = Iterable<UExtensionData extends ExtensionDataRef<infer IData, infer IId, infer IConfig> ? IConfig['optional'] extends true ? never : ExtensionDataValue<IData, IId> : never> & {
+type ExtensionDataContainer<UExtensionData extends ExtensionDataRef> = Iterable<UExtensionData extends ExtensionDataRef<infer IData, infer IId, infer IConfig> ? IConfig['optional'] extends true ? never : ExtensionDataValue<IData, IId> : never> & {
     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 */
 type ExtensionFactoryMiddleware = (originalFactory: (contextOverrides?: {
     config?: JsonObject;
-}) => ExtensionDataContainer<AnyExtensionDataRef>, context: {
+}) => ExtensionDataContainer<ExtensionDataRef>, context: {
     node: AppNode;
     apis: ApiHolder;
     config?: JsonObject;
@@ -538,7 +603,7 @@ type FrontendFeature = FrontendPlugin | FrontendModule;
  *
  * @public
  */
-type ExtensionBlueprintParamsDefiner<TParams extends object = object, TInput = any> = (params: TInput) => ExtensionBlueprintParams<TParams>;
+type ExtensionBlueprintDefineParams<TParams extends object = object, TInput = any> = (params: TInput) => ExtensionBlueprintParams<TParams>;
 /**
  * An opaque type that represents a set of parameters to be passed to a blueprint.
  *
@@ -565,22 +630,21 @@ declare function createExtensionBlueprintParams<T extends object = object>(param
 /**
  * @public
  */
-type CreateExtensionBlueprintOptions<TKind extends string, TName extends string | undefined, TParams extends object | ExtensionBlueprintParamsDefiner, UOutput extends AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+type CreateExtensionBlueprintOptions<TKind extends string, TParams extends object | ExtensionBlueprintDefineParams, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
 }, TConfigSchema extends {
     [key in string]: (zImpl: typeof z) => z.ZodType;
 }, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
-    [name in string]: AnyExtensionDataRef;
+    [name in string]: ExtensionDataRef;
 }> = {
     kind: TKind;
     attachTo: ExtensionAttachToSpec;
     disabled?: boolean;
     inputs?: TInputs;
     output: Array<UOutput>;
-    name?: TName;
     config?: {
         schema: TConfigSchema;
     };
@@ -615,15 +679,15 @@ type CreateExtensionBlueprintOptions<TKind extends string, TName extends string
      * Usage of the above example blueprint:
      * ```ts
      * const example = ExampleBlueprint.make({
-     *   params: define => define({
+     *   params: defineParams => defineParams({
      *     component: ...,
      *     fetcher: ...,
      *   }),
      * });
      * ```
      */
-    defineParams?: TParams extends ExtensionBlueprintParamsDefiner ? TParams : 'The defineParams option must be a function if provided, see the docs for details';
-    factory(params: TParams extends ExtensionBlueprintParamsDefiner ? ReturnType<TParams>['T'] : TParams, context: {
+    defineParams?: TParams extends ExtensionBlueprintDefineParams ? TParams : 'The defineParams option must be a function if provided, see the docs for details';
+    factory(params: TParams extends ExtensionBlueprintDefineParams ? ReturnType<TParams>['T'] : TParams, context: {
         node: AppNode;
         apis: ApiHolder;
         config: {
@@ -636,47 +700,46 @@ type CreateExtensionBlueprintOptions<TKind extends string, TName extends string
 /** @public */
 type ExtensionBlueprintParameters = {
     kind: string;
-    name?: string;
-    params?: object | ExtensionBlueprintParamsDefiner;
+    params?: object | ExtensionBlueprintDefineParams;
     configInput?: {
         [K in string]: any;
     };
     config?: {
         [K in string]: any;
     };
-    output?: AnyExtensionDataRef;
+    output?: ExtensionDataRef;
     inputs?: {
-        [KName in string]: ExtensionInput<AnyExtensionDataRef, {
+        [KName in string]: ExtensionInput<ExtensionDataRef, {
             optional: boolean;
             singleton: boolean;
         }>;
     };
     dataRefs?: {
-        [name in string]: AnyExtensionDataRef;
+        [name in string]: ExtensionDataRef;
     };
 };
 /** @ignore */
-type ParamsFactory<TDefiner extends ExtensionBlueprintParamsDefiner> = (define: TDefiner) => ReturnType<TDefiner>;
+type ParamsFactory<TDefiner extends ExtensionBlueprintDefineParams> = (defineParams: TDefiner) => ReturnType<TDefiner>;
 /**
  * Represents any form of params input that can be passed to a blueprint.
  * This also includes the invalid form of passing a plain params object to a blueprint that uses a definition callback.
  *
  * @ignore
  */
-type AnyParamsInput$1<TParams extends object | ExtensionBlueprintParamsDefiner> = TParams extends ExtensionBlueprintParamsDefiner<infer IParams> ? IParams | ParamsFactory<TParams> : TParams | ParamsFactory<ExtensionBlueprintParamsDefiner<TParams, TParams>>;
+type AnyParamsInput$1<TParams extends object | ExtensionBlueprintDefineParams> = TParams extends ExtensionBlueprintDefineParams<infer IParams> ? IParams | ParamsFactory<TParams> : TParams | ParamsFactory<ExtensionBlueprintDefineParams<TParams, TParams>>;
 /**
  * @public
  */
 interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionBlueprintParameters> {
     dataRefs: T['dataRefs'];
-    make<TNewName extends string | undefined, TParamsInput extends AnyParamsInput$1<NonNullable<T['params']>>>(args: {
-        name?: TNewName;
+    make<TName extends string | undefined, TParamsInput extends AnyParamsInput$1<NonNullable<T['params']>>>(args: {
+        name?: TName;
         attachTo?: ExtensionAttachToSpec;
         disabled?: boolean;
-        params: TParamsInput extends ExtensionBlueprintParamsDefiner ? TParamsInput : T['params'] extends ExtensionBlueprintParamsDefiner ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `<blueprint>.make({ params: define => define(<params>) })`' : TParamsInput;
+        params: TParamsInput extends ExtensionBlueprintDefineParams ? TParamsInput : T['params'] extends ExtensionBlueprintDefineParams ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `<blueprint>.make({ params: defineParams => defineParams(<params>) })`' : T['params'];
     }): ExtensionDefinition<{
         kind: T['kind'];
-        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        name: string | undefined extends TName ? undefined : TName;
         config: T['config'];
         configInput: T['configInput'];
         output: T['output'];
@@ -689,15 +752,15 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
      * You must either pass `params` directly, or define a `factory` that can
      * optionally call the original factory with the same params.
      */
-    makeWithOverrides<TNewName extends string | undefined, TExtensionConfigSchema extends {
+    makeWithOverrides<TName 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, {
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, TExtraInputs extends {
+        [inputName in string]: ExtensionInput<ExtensionDataRef, {
             optional: boolean;
             singleton: boolean;
         }>;
     }>(args: {
-        name?: TNewName;
+        name?: TName;
         attachTo?: ExtensionAttachToSpec;
         disabled?: boolean;
         inputs?: TExtraInputs & {
@@ -709,9 +772,9 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
                 [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
             };
         };
-        factory(originalFactory: <TParamsInput extends AnyParamsInput$1<NonNullable<T['params']>>>(params: TParamsInput extends ExtensionBlueprintParamsDefiner ? TParamsInput : T['params'] extends ExtensionBlueprintParamsDefiner ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(define => define(<params>))`' : TParamsInput, context?: {
+        factory(originalFactory: <TParamsInput extends AnyParamsInput$1<NonNullable<T['params']>>>(params: TParamsInput extends ExtensionBlueprintDefineParams ? TParamsInput : T['params'] extends ExtensionBlueprintDefineParams ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(defineParams => defineParams(<params>))`' : T['params'], context?: {
             config?: T['config'];
-            inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
+            inputs?: ResolvedInputValueOverrides<NonNullable<T['inputs']>>;
         }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
             node: AppNode;
             apis: ApiHolder;
@@ -719,7 +782,7 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
                 [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>;
+        }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>;
     }): ExtensionDefinition<{
         config: (string extends keyof TExtensionConfigSchema ? {} : {
             [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
@@ -727,33 +790,75 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
         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;
+        output: ExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
         inputs: T['inputs'] & TExtraInputs;
         kind: T['kind'];
-        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        name: string | undefined extends TName ? undefined : TName;
         params: T['params'];
     }>;
 }
 /**
- * A simpler replacement for wrapping up `createExtension` inside a kind or type. This allows for a cleaner API for creating
- * types and instances of those types.
+ * Creates a new extension blueprint that encapsulates the creation of
+ * extensions of particular kinds.
+ *
+ * @remarks
  *
+ * For details on how blueprints work, see the
+ * {@link https://backstage.io/docs/frontend-system/architecture/extension-blueprints | documentation for extension blueprints}
+ * in the frontend system documentation.
+ *
+ * Extension blueprints make it much easier for users to create new extensions
+ * for your plugin. Rather than letting them use {@link createExtension}
+ * directly, you can define a set of parameters and default factory for your
+ * blueprint, removing a lot of the boilerplate and complexity that is otherwise
+ * needed to create an extension.
+ *
+ * Each blueprint has its own `kind` that helps identify and group the
+ * extensions that have been created with it. For example the
+ * {@link PageBlueprint} has the kind `'page'`, and extensions created with it
+ * will be given the ID `'page:<plugin-id>[/<name>]'`. Blueprints should always
+ * be exported as `<PascalCaseKind>Blueprint`.
+ *
+ * When creating a blueprint the type of the parameters are inferred from the
+ * `factory` function that you provide. The exception to that is when you need
+ * your blueprint to include inferred type parameters, in which case you need to
+ * use the `defineParams` option. See the documentation for the `defineParams`
+ * option for more details on how that works.
+ *
+ * @example
+ * ```tsx
+ * // In your plugin library
+ * export const GreetingBlueprint = createExtensionBlueprint({
+ *   kind: 'greeting',
+ *   attachTo: { id: 'example', input: 'greetings' },
+ *   output: [coreExtensionData.reactElement],
+ *   factory(params: { greeting: string }) {
+ *     return [coreExtensionData.reactElement(<h1>{params.greeting}</h1>)];
+ *   },
+ * });
+ *
+ * // Someone using your blueprint in their plugin
+ * const exampleGreeting = GreetingBlueprint.make({
+ *   params: {
+ *     greeting: 'Hello, world!',
+ *   },
+ * });
+ * ```
  * @public
  */
-declare function createExtensionBlueprint<TParams extends object | ExtensionBlueprintParamsDefiner, UOutput extends AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+declare function createExtensionBlueprint<TParams extends object | ExtensionBlueprintDefineParams, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
 }, TConfigSchema extends {
     [key in string]: (zImpl: typeof z) => z.ZodType;
-}, UFactoryOutput extends ExtensionDataValue<any, any>, TKind extends string, TName extends string | undefined = undefined, TDataRefs extends {
-    [name in string]: AnyExtensionDataRef;
-} = never>(options: CreateExtensionBlueprintOptions<TKind, TName, TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<{
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TKind extends string, TDataRefs extends {
+    [name in string]: ExtensionDataRef;
+} = never>(options: CreateExtensionBlueprintOptions<TKind, TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<{
     kind: TKind;
-    name: TName;
     params: TParams;
-    output: UOutput;
+    output: UOutput extends ExtensionDataRef<infer IData, infer IId, infer IConfig> ? ExtensionDataRef<IData, IId, IConfig> : never;
     inputs: string extends keyof TInputs ? {} : TInputs;
     config: string extends keyof TConfigSchema ? {} : {
         [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
@@ -768,7 +873,7 @@ declare function createExtensionBlueprint<TParams extends object | ExtensionBlue
  * Convert a single extension input into a matching resolved input.
  * @public
  */
-type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<AnyExtensionDataRef> ? {
+type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<ExtensionDataRef> ? {
     node: AppNode;
 } & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : never;
 /**
@@ -785,7 +890,7 @@ type PopUnion<U> = ToIntersection<U extends any ? () => U : never> extends () =>
 /** @ignore */
 type JoinStringUnion<U, TDiv extends string = ', ', TResult extends string = ''> = PopUnion<U> extends [infer IRest extends string, infer INext extends string] ? TResult extends '' ? JoinStringUnion<IRest, TDiv, INext> : JoinStringUnion<IRest, TDiv, `${TResult}${TDiv}${INext}`> : TResult;
 /** @ignore */
-type VerifyExtensionFactoryOutput<UDeclaredOutput extends AnyExtensionDataRef, UFactoryOutput extends ExtensionDataValue<any, any>> = (UDeclaredOutput extends any ? UDeclaredOutput['config']['optional'] extends true ? never : UDeclaredOutput['id'] : never) extends infer IRequiredOutputIds ? [IRequiredOutputIds] extends [UFactoryOutput['id']] ? [UFactoryOutput['id']] extends [UDeclaredOutput['id']] ? {} : `Error: The extension factory has undeclared output(s): ${JoinStringUnion<Exclude<UFactoryOutput['id'], UDeclaredOutput['id']>>}` : `Error: The extension factory is missing the following output(s): ${JoinStringUnion<Exclude<IRequiredOutputIds, UFactoryOutput['id']>>}` : never;
+type VerifyExtensionFactoryOutput<UDeclaredOutput extends ExtensionDataRef, UFactoryOutput extends ExtensionDataValue<any, any>> = (UDeclaredOutput extends any ? UDeclaredOutput['config']['optional'] extends true ? never : UDeclaredOutput['id'] : never) extends infer IRequiredOutputIds ? [IRequiredOutputIds] extends [UFactoryOutput['id']] ? [UFactoryOutput['id']] extends [UDeclaredOutput['id']] ? {} : `Error: The extension factory has undeclared output(s): ${JoinStringUnion<Exclude<UFactoryOutput['id'], UDeclaredOutput['id']>>}` : `Error: The extension factory is missing the following output(s): ${JoinStringUnion<Exclude<IRequiredOutputIds, UFactoryOutput['id']>>}` : never;
 /** @public */
 type ExtensionAttachToSpec = {
     id: string;
@@ -795,8 +900,8 @@ type ExtensionAttachToSpec = {
     input: string;
 }>;
 /** @public */
-type CreateExtensionOptions<TKind extends string | undefined, TName extends string | undefined, UOutput extends AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+type CreateExtensionOptions<TKind extends string | undefined, TName extends string | undefined, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
@@ -831,29 +936,29 @@ type ExtensionDefinitionParameters = {
     config?: {
         [K in string]: any;
     };
-    output?: AnyExtensionDataRef;
+    output?: ExtensionDataRef;
     inputs?: {
-        [KName in string]: ExtensionInput<AnyExtensionDataRef, {
+        [KName in string]: ExtensionInput<ExtensionDataRef, {
             optional: boolean;
             singleton: boolean;
         }>;
     };
-    params?: object | ExtensionBlueprintParamsDefiner;
+    params?: object | ExtensionBlueprintDefineParams;
 };
 /**
  * Same as the one in `createExtensionBlueprint`, but with `ParamsFactory` inlined.
  * It can't be exported because it breaks API reports.
  * @ignore
  */
-type AnyParamsInput<TParams extends object | ExtensionBlueprintParamsDefiner> = TParams extends ExtensionBlueprintParamsDefiner<infer IParams> ? IParams | ((define: TParams) => ReturnType<TParams>) : TParams | ((define: ExtensionBlueprintParamsDefiner<TParams, TParams>) => ReturnType<ExtensionBlueprintParamsDefiner<TParams, TParams>>);
+type AnyParamsInput<TParams extends object | ExtensionBlueprintDefineParams> = TParams extends ExtensionBlueprintDefineParams<infer IParams> ? IParams | ((define: TParams) => ReturnType<TParams>) : TParams | ((define: ExtensionBlueprintDefineParams<TParams, TParams>) => ReturnType<ExtensionBlueprintDefineParams<TParams, TParams>>);
 /** @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 {
-        [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, TExtraInputs extends {
+        [inputName in string]: ExtensionInput<ExtensionDataRef, {
             optional: boolean;
             singleton: boolean;
         }>;
@@ -871,9 +976,9 @@ type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefi
         };
         factory?(originalFactory: <TFactoryParamsReturn extends AnyParamsInput<NonNullable<T['params']>>>(context?: Expand<{
             config?: T['config'];
-            inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
+            inputs?: ResolvedInputValueOverrides<NonNullable<T['inputs']>>;
         } & ([T['params']] extends [never] ? {} : {
-            params?: TFactoryParamsReturn extends ExtensionBlueprintParamsDefiner ? TFactoryParamsReturn : T['params'] extends ExtensionBlueprintParamsDefiner ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(define => define(<params>))`' : Partial<T['params']>;
+            params?: TFactoryParamsReturn extends ExtensionBlueprintDefineParams ? TFactoryParamsReturn : T['params'] extends ExtensionBlueprintDefineParams ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(defineParams => defineParams(<params>))`' : Partial<T['params']>;
         })>) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
             node: AppNode;
             apis: ApiHolder;
@@ -883,11 +988,11 @@ type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefi
             inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
         }): Iterable<UFactoryOutput>;
     } & ([T['params']] extends [never] ? {} : {
-        params?: TParamsInput extends ExtensionBlueprintParamsDefiner ? TParamsInput : T['params'] extends ExtensionBlueprintParamsDefiner ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(define => define(<params>))`' : Partial<T['params']>;
-    })> & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>): ExtensionDefinition<{
+        params?: TParamsInput extends ExtensionBlueprintDefineParams ? TParamsInput : T['params'] extends ExtensionBlueprintDefineParams ? 'Error: This blueprint uses advanced parameter types and requires you to pass parameters as using the following callback syntax: `originalFactory(defineParams => defineParams(<params>))`' : Partial<T['params']>;
+    })> & VerifyExtensionFactoryOutput<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>): ExtensionDefinition<{
         kind: T['kind'];
         name: T['name'];
-        output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        output: ExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
         inputs: T['inputs'] & TExtraInputs;
         config: T['config'] & {
             [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
@@ -897,9 +1002,43 @@ type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefi
         }>>;
     }>;
 };
-/** @public */
-declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
-    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+/**
+ * Creates a new extension definition for installation in a Backstage app.
+ *
+ * @remarks
+ *
+ * This is a low-level function for creation of extensions with arbitrary inputs
+ * and outputs and is typically only intended to be used for advanced overrides
+ * or framework-level extensions. For most extension creation needs, it is
+ * recommended to use existing {@link ExtensionBlueprint}s instead. You can find
+ * blueprints both in the `@backstage/frontend-plugin-api` package as well as
+ * other plugin libraries. There is also a list of
+ * {@link https://backstage.io/docs/frontend-system/building-plugins/common-extension-blueprints | commonly used blueprints}
+ * in the frontend system documentation.
+ *
+ * Extension definitions that are created with this function can be installed in
+ * a Backstage app via a {@link FrontendPlugin} or {@link FrontendModule}.
+ *
+ * For more details on how extensions work, see the
+ * {@link https://backstage.io/docs/frontend-system/architecture/extensions | documentation for extensions}.
+ *
+ * @example
+ *
+ * ```ts
+ * const myExtension = createExtension({
+ *   name: 'example',
+ *   attachTo: { id: 'app', input: 'root' },
+ *   output: [coreExtensionData.reactElement],
+ *   factory() {
+ *     return [coreExtensionData.reactElement(<h1>Hello, world!</h1>)];
+ *   },
+ * });
+ * ```
+ *
+ * @public
+ */
+declare function createExtension<UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<ExtensionDataRef, {
         optional: boolean;
         singleton: boolean;
     }>;
@@ -912,7 +1051,7 @@ declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs ex
     configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
         [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
     }>>;
-    output: UOutput;
+    output: UOutput extends ExtensionDataRef<infer IData, infer IId, infer IConfig> ? ExtensionDataRef<IData, IId, IConfig> : never;
     inputs: TInputs;
     params: never;
     kind: string | undefined extends TKind ? undefined : TKind;
@@ -953,11 +1092,7 @@ interface AppNodeSpec {
     readonly extension: Extension<unknown, unknown>;
     readonly disabled: boolean;
     readonly config?: unknown;
-    readonly plugin?: FrontendPlugin;
-    /**
-     * @deprecated Use {@link AppNodeSpec.plugin} instead.
-     */
-    readonly source?: FrontendPlugin;
+    readonly plugin: FrontendPlugin;
 }
 /**
  * The connections from this {@link AppNode} to other nodes.
@@ -1032,7 +1167,7 @@ interface AppTreeApi {
     /**
      * Get all nodes in the app that are mounted at a given route path.
      */
-    getNodesByRoutePath(sourcePath: string): {
+    getNodesByRoutePath(routePath: string): {
         nodes: AppNode[];
     };
 }
@@ -1046,12 +1181,6 @@ declare const appTreeApiRef: _backstage_core_plugin_api.ApiRef<AppTreeApi>;
 /** @public */
 interface ExtensionBoundaryProps {
     node: AppNode;
-    /**
-     * This explicitly marks the extension as routable for the purpose of
-     * capturing analytics events. If not provided, the extension boundary will be
-     * marked as routable if it outputs a routePath.
-     */
-    routable?: boolean;
     children: ReactNode;
 }
 /** @public */
@@ -1063,33 +1192,30 @@ declare namespace ExtensionBoundary {
 }
 
 /** @public */
-type ComponentRef<T extends {} = {}> = {
+type SwappableComponentRef<TInnerComponentProps extends {} = {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
     id: string;
-    T: T;
+    TProps: TInnerComponentProps;
+    TExternalProps: TExternalComponentProps;
+    $$type: '@backstage/SwappableComponentRef';
 };
-/** @public */
-declare function createComponentRef<T extends {} = {}>(options: {
+/**
+ * Options for creating an SwappableComponent.
+ *
+ * @public
+ */
+type CreateSwappableComponentOptions<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
     id: string;
-}): ComponentRef<T>;
-
-/** @public */
-type CoreProgressProps = {};
-/** @public */
-type CoreNotFoundErrorPageProps = {
-    children?: ReactNode;
-};
-/** @public */
-type CoreErrorBoundaryFallbackProps = {
-    plugin?: FrontendPlugin;
-    error: Error;
-    resetError: () => void;
+    loader?: (() => (props: TInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: TInnerComponentProps) => JSX.Element | null>);
+    transformProps?: (props: TExternalComponentProps) => TInnerComponentProps;
 };
-
-/** @public */
-declare const coreComponentRefs: {
-    progress: ComponentRef<CoreProgressProps>;
-    notFoundErrorPage: ComponentRef<CoreNotFoundErrorPageProps>;
-    errorBoundaryFallback: ComponentRef<CoreErrorBoundaryFallbackProps>;
+/**
+ * Creates a SwappableComponent that can be used to render the component, optionally overridden by the app.
+ *
+ * @public
+ */
+declare function createSwappableComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(options: CreateSwappableComponentOptions<TInnerComponentProps, TExternalComponentProps>): {
+    (props: TExternalComponentProps): JSX.Element | null;
+    ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>;
 };
 
 /**
@@ -1107,25 +1233,55 @@ declare const coreComponentRefs: {
  */
 declare function useAppNode(): AppNode | undefined;
 
+/** @public */
+type ProgressProps = {};
+/** @public */
+type NotFoundErrorPageProps = {
+    children?: ReactNode;
+};
+/** @public */
+type ErrorDisplayProps = {
+    plugin?: FrontendPlugin;
+    error: Error;
+    resetError: () => void;
+};
+
 /**
- * API for looking up components based on component refs.
- *
  * @public
  */
-interface ComponentsApi {
-    getComponent<T extends {}>(ref: ComponentRef<T>): ComponentType<T>;
-}
+declare const Progress: {
+    (props: ProgressProps): JSX.Element | null;
+    ref: SwappableComponentRef<ProgressProps, ProgressProps>;
+};
+/**
+ * @public
+ */
+declare const NotFoundErrorPage: {
+    (props: NotFoundErrorPageProps): JSX.Element | null;
+    ref: SwappableComponentRef<NotFoundErrorPageProps, NotFoundErrorPageProps>;
+};
 /**
- * The `ApiRef` of {@link ComponentsApi}.
+ * @public
+ */
+declare const ErrorDisplay: {
+    (props: ErrorDisplayProps): JSX.Element | null;
+    ref: SwappableComponentRef<ErrorDisplayProps, ErrorDisplayProps>;
+};
+
+/**
+ * API for looking up components based on component refs.
  *
  * @public
  */
-declare const componentsApiRef: _backstage_core_plugin_api.ApiRef<ComponentsApi>;
+interface SwappableComponentsApi {
+    getComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>): (props: TInnerComponentProps) => JSX.Element | null;
+}
 /**
+ * The `ApiRef` of {@link SwappableComponentsApi}.
+ *
  * @public
- * Returns the component associated with the given ref.
  */
-declare function useComponentRef<T extends {}>(ref: ComponentRef<T>): ComponentType<T>;
+declare const swappableComponentsApiRef: _backstage_core_plugin_api.ApiRef<SwappableComponentsApi>;
 
 /**
  * IconComponent is the common icon type used throughout Backstage when
@@ -1172,7 +1328,7 @@ declare const iconsApiRef: _backstage_core_plugin_api.ApiRef<IconsApi>;
  *
  * @public
  */
-interface DialogApiDialog<TResult = unknown> {
+interface DialogApiDialog<TResult = void> {
     /**
      * Closes the dialog with that provided result.
      *
@@ -1249,7 +1405,7 @@ interface DialogApi {
      * @param elementOrComponent - The element or component to render in the dialog. If a component is provided, it will be provided with a `dialog` prop that contains the dialog handle.
      * @public
      */
-    show<TResult = {}>(elementOrComponent: JSX.Element | ((props: {
+    show<TResult = void>(elementOrComponent: JSX.Element | ((props: {
         dialog: DialogApiDialog<TResult | undefined>;
     }) => JSX.Element)): DialogApiDialog<TResult | undefined>;
     /**
@@ -1296,7 +1452,7 @@ interface DialogApi {
      * @param elementOrComponent - The element or component to render in the dialog. If a component is provided, it will be provided with a `dialog` prop that contains the dialog handle.
      * @public
      */
-    showModal<TResult = {}>(elementOrComponent: JSX.Element | ((props: {
+    showModal<TResult = void>(elementOrComponent: JSX.Element | ((props: {
         dialog: DialogApiDialog<TResult>;
     }) => JSX.Element)): DialogApiDialog<TResult>;
 }
@@ -1321,21 +1477,17 @@ declare const dialogApiRef: _backstage_core_plugin_api.ApiRef<DialogApi>;
  * @public
  */
 type RouteFunc<TParams extends AnyRouteRefParams> = (...[params]: TParams extends undefined ? readonly [] : readonly [params: TParams]) => string;
-/**
- * @public
- */
-type RouteResolutionApiResolveOptions = {
-    /**
-     * An absolute path to use as a starting point when resolving the route.
-     * If no path is provided the route will be resolved from the root of the app.
-     */
-    sourcePath?: string;
-};
 /**
  * @public
  */
 interface RouteResolutionApi {
-    resolve<TParams extends AnyRouteRefParams>(anyRouteRef: RouteRef<TParams> | SubRouteRef<TParams> | ExternalRouteRef<TParams>, options?: RouteResolutionApiResolveOptions): RouteFunc<TParams> | undefined;
+    resolve<TParams extends AnyRouteRefParams>(anyRouteRef: RouteRef<TParams> | SubRouteRef<TParams> | ExternalRouteRef<TParams>, options?: {
+        /**
+         * An absolute path to use as a starting point when resolving the route.
+         * If no path is provided the route will be resolved from the root of the app.
+         */
+        sourcePath?: string;
+    }): RouteFunc<TParams> | undefined;
 }
 /**
  * The `ApiRef` of {@link RouteResolutionApi}.
@@ -1418,6 +1570,25 @@ type AnalyticsTracker = {
         attributes?: AnalyticsEventAttributes;
     }) => void;
 };
+/**
+ * Analytics implementations are used to track user behavior in a Backstage
+ * instance.
+ *
+ * @remarks
+ *
+ * To instrument your App or Plugin, retrieve an analytics tracker using the
+ * `useAnalytics()` hook. This will return a pre-configured `AnalyticsTracker`
+ * with relevant methods for instrumentation.
+ *
+ * @public
+ */
+type AnalyticsImplementation = {
+    /**
+     * Primary event handler responsible for compiling and forwarding events to
+     * an analytics system.
+     */
+    captureEvent(event: AnalyticsEvent): void;
+};
 /**
  * The Analytics API is used to track user behavior in a Backstage instance.
  *
@@ -1439,6 +1610,11 @@ type AnalyticsApi = {
 /**
  * The API reference of {@link AnalyticsApi}.
  *
+ * @remarks
+ *
+ * To define a concrete Analytics Implementation, use
+ * {@link AnalyticsImplementationBlueprint} instead.
+ *
  * @public
  */
 declare const analyticsApiRef: ApiRef<AnalyticsApi>;
@@ -1450,6 +1626,30 @@ declare const analyticsApiRef: ApiRef<AnalyticsApi>;
  */
 declare function useAnalytics(): AnalyticsTracker;
 
+/** @public */
+type AnalyticsImplementationFactory<Deps extends {
+    [name in string]: unknown;
+} = {}> = {
+    deps: TypesToApiRefs<Deps>;
+    factory(deps: Deps): AnalyticsImplementation;
+};
+/**
+ * Creates analytics implementations.
+ *
+ * @public
+ */
+declare const AnalyticsImplementationBlueprint: ExtensionBlueprint<{
+    kind: "analytics";
+    params: <TDeps extends { [name in string]: unknown; }>(params: AnalyticsImplementationFactory<TDeps>) => ExtensionBlueprintParams<AnalyticsImplementationFactory<{}>>;
+    output: ExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        factory: ConfigurableExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
+    };
+}>;
+
 /**
  * Creates utility API extensions.
  *
@@ -1457,9 +1657,8 @@ declare function useAnalytics(): AnalyticsTracker;
  */
 declare const ApiBlueprint: ExtensionBlueprint<{
     kind: "api";
-    name: undefined;
     params: <TApi, TImpl extends TApi, TDeps extends { [name in string]: unknown; }>(params: ApiFactory<TApi, TImpl, TDeps>) => ExtensionBlueprintParams<AnyApiFactory>;
-    output: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+    output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1476,11 +1675,10 @@ declare const ApiBlueprint: ExtensionBlueprint<{
  */
 declare const AppRootElementBlueprint: ExtensionBlueprint<{
     kind: "app-root-element";
-    name: undefined;
     params: {
-        element: JSX.Element | (() => JSX.Element);
+        element: JSX.Element;
     };
-    output: ConfigurableExtensionDataRef<react.JSX.Element, "core.reactElement", {}>;
+    output: ExtensionDataRef<react.JSX.Element, "core.reactElement", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1496,31 +1694,33 @@ declare const AppRootElementBlueprint: ExtensionBlueprint<{
  */
 declare const AppRootWrapperBlueprint: ExtensionBlueprint<{
     kind: "app-root-wrapper";
-    name: undefined;
     params: {
-        Component: ComponentType<PropsWithChildren<{}>>;
+        /** @deprecated use the `component` parameter instead */
+        Component?: [error: "Use the `component` parameter instead"];
+        component: (props: {
+            children: ReactNode;
+        }) => JSX.Element | null;
     };
-    output: ConfigurableExtensionDataRef<ComponentType<{
-        children?: react.ReactNode | undefined;
-    }>, "app.root.wrapper", {}>;
+    output: ExtensionDataRef<(props: {
+        children: ReactNode;
+    }) => JSX.Element | null, "app.root.wrapper", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<ComponentType<{
-            children?: react.ReactNode | undefined;
-        }>, "app.root.wrapper", {}>;
+        component: ConfigurableExtensionDataRef<(props: {
+            children: ReactNode;
+        }) => JSX.Element | null, "app.root.wrapper", {}>;
     };
 }>;
 
 /** @public */
 declare const IconBundleBlueprint: ExtensionBlueprint<{
     kind: "icon-bundle";
-    name: undefined;
     params: {
         icons: { [key in string]: IconComponent; };
     };
-    output: ConfigurableExtensionDataRef<{
+    output: ExtensionDataRef<{
         [x: string]: IconComponent;
     }, "core.icons", {}>;
     inputs: {};
@@ -1568,11 +1768,10 @@ type NavContentComponent = (props: NavContentComponentProps) => JSX.Element | nu
  */
 declare const NavContentBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "nav-content";
-    name: undefined;
     params: {
         component: NavContentComponent;
     };
-    output: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<NavContentComponent, "core.nav-content.component", {}>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<NavContentComponent, "core.nav-content.component", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1588,13 +1787,12 @@ declare const NavContentBlueprint: _backstage_frontend_plugin_api.ExtensionBluep
  */
 declare const NavItemBlueprint: ExtensionBlueprint<{
     kind: "nav-item";
-    name: undefined;
     params: {
         title: string;
         icon: IconComponent$2;
         routeRef: RouteRef<undefined>;
     };
-    output: ConfigurableExtensionDataRef<{
+    output: ExtensionDataRef<{
         title: string;
         icon: IconComponent$2;
         routeRef: RouteRef<undefined>;
@@ -1618,13 +1816,16 @@ declare const NavItemBlueprint: ExtensionBlueprint<{
  */
 declare const PageBlueprint: ExtensionBlueprint<{
     kind: "page";
-    name: undefined;
     params: {
-        defaultPath: string;
+        /**
+         * @deprecated Use the `path` param instead.
+         */
+        defaultPath?: [Error: `Use the 'path' param instead`];
+        path: string;
         loader: () => Promise<JSX.Element>;
         routeRef?: RouteRef;
     };
-    output: ConfigurableExtensionDataRef<react.JSX.Element, "core.reactElement", {}> | ConfigurableExtensionDataRef<string, "core.routing.path", {}> | ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {
+    output: ExtensionDataRef<string, "core.routing.path", {}> | ExtensionDataRef<react.JSX.Element, "core.reactElement", {}> | ExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {
         optional: true;
     }>;
     inputs: {};
@@ -1640,20 +1841,23 @@ declare const PageBlueprint: ExtensionBlueprint<{
 /** @public */
 declare const RouterBlueprint: ExtensionBlueprint<{
     kind: "app-router-component";
-    name: undefined;
     params: {
-        Component: ComponentType<PropsWithChildren<{}>>;
+        /** @deprecated use the `component` parameter instead */
+        Component?: [error: "Use the `component` parameter instead"];
+        component: (props: {
+            children: ReactNode;
+        }) => JSX.Element | null;
     };
-    output: ConfigurableExtensionDataRef<ComponentType<{
-        children?: react.ReactNode | undefined;
-    }>, "app.router.wrapper", {}>;
+    output: ExtensionDataRef<(props: {
+        children: ReactNode;
+    }) => JSX.Element | null, "app.router.wrapper", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<ComponentType<{
-            children?: react.ReactNode | undefined;
-        }>, "app.router.wrapper", {}>;
+        component: ConfigurableExtensionDataRef<(props: {
+            children: ReactNode;
+        }) => JSX.Element | null, "app.router.wrapper", {}>;
     };
 }>;
 
@@ -1664,11 +1868,10 @@ declare const RouterBlueprint: ExtensionBlueprint<{
  */
 declare const SignInPageBlueprint: ExtensionBlueprint<{
     kind: "sign-in-page";
-    name: undefined;
     params: {
         loader: () => Promise<ComponentType<SignInPageProps>>;
     };
-    output: ConfigurableExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+    output: ExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1684,11 +1887,10 @@ declare const SignInPageBlueprint: ExtensionBlueprint<{
  */
 declare const ThemeBlueprint: ExtensionBlueprint<{
     kind: "theme";
-    name: undefined;
     params: {
         theme: AppTheme;
     };
-    output: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+    output: ExtensionDataRef<AppTheme, "core.theme.theme", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1704,11 +1906,10 @@ declare const ThemeBlueprint: ExtensionBlueprint<{
  */
 declare const TranslationBlueprint: ExtensionBlueprint<{
     kind: "translation";
-    name: undefined;
     params: {
         resource: TranslationResource | TranslationMessages;
     };
-    output: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
+    output: ExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
         [x: string]: string;
     }, boolean>, "core.translation.translation", {}>;
     inputs: {};
@@ -1721,39 +1922,37 @@ declare const TranslationBlueprint: ExtensionBlueprint<{
     };
 }>;
 
-/** @public */
-declare function createComponentExtension<TProps extends {}>(options: {
-    ref: ComponentRef<TProps>;
-    name?: string;
-    disabled?: boolean;
-    loader: {
-        lazy: () => Promise<ComponentType<TProps>>;
-    } | {
-        sync: () => ComponentType<TProps>;
-    };
-}): ExtensionDefinition<{
+/**
+ * Blueprint for creating swappable components from a SwappableComponentRef and a loader
+ *
+ * @public
+ */
+declare const SwappableComponentBlueprint: ExtensionBlueprint<{
+    kind: "component";
+    params: <Ref extends SwappableComponentRef<any>>(params: {
+        component: Ref extends SwappableComponentRef<any, infer IExternalComponentProps> ? {
+            ref: Ref;
+        } & ((props: IExternalComponentProps) => JSX.Element | null) : never;
+        loader: Ref extends SwappableComponentRef<infer IInnerComponentProps, any> ? (() => (props: IInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: IInnerComponentProps) => JSX.Element | null>) : never;
+    }) => ExtensionBlueprintParams<{
+        component: Ref extends SwappableComponentRef<any, infer IExternalComponentProps> ? {
+            ref: Ref;
+        } & ((props: IExternalComponentProps) => JSX.Element | null) : never;
+        loader: Ref extends SwappableComponentRef<infer IInnerComponentProps, any> ? (() => (props: IInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: IInnerComponentProps) => JSX.Element | null>) : never;
+    }>;
+    output: ExtensionDataRef<{
+        ref: SwappableComponentRef;
+        loader: (() => (props: {}) => JSX.Element | null) | (() => Promise<(props: {}) => JSX.Element | null>);
+    }, "core.swappableComponent", {}>;
+    inputs: {};
     config: {};
     configInput: {};
-    output: ConfigurableExtensionDataRef<{
-        ref: ComponentRef;
-        impl: ComponentType;
-    }, "core.component.component", {}>;
-    inputs: {
-        [x: string]: ExtensionInput<AnyExtensionDataRef, {
-            optional: boolean;
-            singleton: boolean;
-        }>;
+    dataRefs: {
+        component: ConfigurableExtensionDataRef<{
+            ref: SwappableComponentRef;
+            loader: (() => (props: {}) => JSX.Element | null) | (() => Promise<(props: {}) => JSX.Element | null>);
+        }, "core.swappableComponent", {}>;
     };
-    params: never;
-    kind: "component";
-    name: string;
 }>;
-/** @public */
-declare namespace createComponentExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<{
-        ref: ComponentRef;
-        impl: ComponentType;
-    }, "core.component.component", {}>;
-}
 
-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 CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type CreateFrontendFeatureLoaderOptions, type CreateFrontendModuleOptions, type DialogApi, type DialogApiDialog, type Extension, type ExtensionAttachToSpec, type ExtensionBlueprint, type ExtensionBlueprintParameters, type ExtensionBlueprintParams, type ExtensionBlueprintParamsDefiner, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDefinition, type ExtensionDefinitionParameters, type ExtensionFactoryMiddleware, type ExtensionInput, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, type FrontendFeatureLoader, type FrontendModule, type FrontendPlugin, type FrontendPluginInfo, type FrontendPluginInfoOptions, IconBundleBlueprint, type IconComponent, type IconsApi, NavContentBlueprint, type NavContentComponent, type NavContentComponentProps, NavItemBlueprint, 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, createExtensionBlueprintParams, createExtensionDataRef, createExtensionInput, createExternalRouteRef, createFrontendFeatureLoader, createFrontendModule, createFrontendPlugin, createRouteRef, createSubRouteRef, dialogApiRef, iconsApiRef, routeResolutionApiRef, useAnalytics, useAppNode, useComponentRef, useRouteRef, useRouteRefParams };
+export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsImplementation, AnalyticsImplementationBlueprint, type AnalyticsImplementationFactory, type AnalyticsTracker, type AnyExtensionDataRef, type AnyRouteRefParams, ApiBlueprint, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, AppRootElementBlueprint, AppRootWrapperBlueprint, type AppTree, type AppTreeApi, type ConfigurableExtensionDataRef, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type CreateFrontendFeatureLoaderOptions, type CreateFrontendModuleOptions, type CreateSwappableComponentOptions, type DialogApi, type DialogApiDialog, ErrorDisplay, type ErrorDisplayProps, type Extension, type ExtensionAttachToSpec, type ExtensionBlueprint, type ExtensionBlueprintDefineParams, type ExtensionBlueprintParameters, type ExtensionBlueprintParams, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDefinition, type ExtensionDefinitionParameters, type ExtensionFactoryMiddleware, type ExtensionInput, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, type FrontendFeatureLoader, type FrontendModule, type FrontendPlugin, type FrontendPluginInfo, type FrontendPluginInfoOptions, IconBundleBlueprint, type IconComponent, type IconsApi, NavContentBlueprint, type NavContentComponent, type NavContentComponentProps, NavItemBlueprint, NotFoundErrorPage, type NotFoundErrorPageProps, PageBlueprint, type PluginOptions, type PortableSchema, Progress, type ProgressProps, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, RouterBlueprint, SignInPageBlueprint, type SubRouteRef, SwappableComponentBlueprint, type SwappableComponentRef, type SwappableComponentsApi, ThemeBlueprint, TranslationBlueprint, analyticsApiRef, appTreeApiRef, coreExtensionData, createExtension, createExtensionBlueprint, createExtensionBlueprintParams, createExtensionDataRef, createExtensionInput, createExternalRouteRef, createFrontendFeatureLoader, createFrontendModule, createFrontendPlugin, createRouteRef, createSubRouteRef, createSwappableComponent, dialogApiRef, iconsApiRef, routeResolutionApiRef, swappableComponentsApiRef, useAnalytics, useAppNode, useRouteRef, useRouteRefParams };