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

package/dist/index.d.ts

@@ -2,13 +2,14 @@ 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 * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
-import { ApiHolder, ConfigApi, ApiRef, AnyApiFactory, IconComponent as IconComponent$1, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
+import { ApiHolder, ConfigApi, ApiRef, 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';
+import * as _backstage_frontend_plugin_api from '@backstage/frontend-plugin-api';
+import { IconComponent as IconComponent$1, RouteRef as RouteRef$1 } from '@backstage/frontend-plugin-api';
 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';
-import * as _backstage_frontend_plugin_api from '@backstage/frontend-plugin-api';
 
 /**
  * Common analytics context attributes.
@@ -350,6 +351,7 @@ interface Extension<TConfig, TConfigInput = TConfig> {
 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 [
@@ -522,54 +524,106 @@ type ExtensionFactoryMiddleware = (originalFactory: (contextOverrides?: {
 type FrontendFeature = FrontendPlugin | FrontendModule;
 
 /**
- * Convert a single extension input into a matching resolved input.
+ * A function used to define a parameter mapping function in order to facilitate
+ * advanced parameter typing for extension blueprints.
+ *
+ * @remarks
+ *
+ * This function is primarily intended to enable the use of inferred type
+ * parameters for blueprint params, but it can also be used to transoform the
+ * params before they are handed ot the blueprint.
+ *
+ * The function must return an object created with
+ * {@link createExtensionBlueprintParams}.
+ *
  * @public
  */
-type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<AnyExtensionDataRef> ? {
-    node: AppNode;
-} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : never;
+type ExtensionBlueprintParamsDefiner<TParams extends object = object, TInput = any> = (params: TInput) => ExtensionBlueprintParams<TParams>;
 /**
- * Converts an extension input map into a matching collection of resolved inputs.
+ * An opaque type that represents a set of parameters to be passed to a blueprint.
+ *
+ * @remarks
+ *
+ * Created with {@link createExtensionBlueprintParams}.
+ *
  * @public
  */
-type ResolvedExtensionInputs<TInputs extends {
-    [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>;
+type ExtensionBlueprintParams<T extends object = object> = {
+    $$type: '@backstage/BlueprintParams';
+    T: T;
 };
-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 */
-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;
-/** @public */
-type ExtensionAttachToSpec = {
-    id: string;
-    input: string;
-} | Array<{
-    id: string;
-    input: string;
-}>;
-/** @public */
-type CreateExtensionOptions<TKind extends string | undefined, TName extends string | undefined, UOutput extends AnyExtensionDataRef, TInputs extends {
+/**
+ * Wraps a plain blueprint parameter object in an opaque {@link ExtensionBlueprintParams} object.
+ *
+ * This is used in the definition of the `defineParams` option of {@link ExtensionBlueprint}.
+ *
+ * @public
+ * @param params - The plain blueprint parameter object to wrap.
+ * @returns The wrapped blueprint parameter object.
+ */
+declare function createExtensionBlueprintParams<T extends object = object>(params: T): ExtensionBlueprintParams<T>;
+/**
+ * @public
+ */
+type CreateExtensionBlueprintOptions<TKind extends string, TName extends string | undefined, TParams extends object | ExtensionBlueprintParamsDefiner, 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>> = {
-    kind?: TKind;
-    name?: TName;
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+}> = {
+    kind: TKind;
     attachTo: ExtensionAttachToSpec;
     disabled?: boolean;
     inputs?: TInputs;
     output: Array<UOutput>;
+    name?: TName;
     config?: {
         schema: TConfigSchema;
     };
-    factory(context: {
+    /**
+     * This option is used to further refine the blueprint params. When this
+     * option is used, the blueprint will require params to be passed in callback
+     * form. This function can both transform the params before they are handed to
+     * the blueprint factory, but importantly it also allows you to define
+     * inferred type parameters for your blueprint params.
+     *
+     * @example
+     * Blueprint definition with inferred type parameters:
+     * ```ts
+     * const ExampleBlueprint = createExtensionBlueprint({
+     *   kind: 'example',
+     *   attachTo: { id: 'example', input: 'example' },
+     *   output: [exampleComponentDataRef, exampleFetcherDataRef],
+     *   defineParams<T>(params: {
+     *     component(props: ExampleProps<T>): JSX.Element | null
+     *     fetcher(options: FetchOptions): Promise<FetchResult<T>>
+     *   }) {
+     *     return createExtensionBlueprintParams(params);
+     *   },
+     *   *factory(params) {
+     *     yield exampleComponentDataRef(params.component)
+     *     yield exampleFetcherDataRef(params.fetcher)
+     *   },
+     * });
+     * ```
+     *
+     * @example
+     * Usage of the above example blueprint:
+     * ```ts
+     * const example = ExampleBlueprint.make({
+     *   params: define => define({
+     *     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: {
         node: AppNode;
         apis: ApiHolder;
         config: {
@@ -577,11 +631,13 @@ type CreateExtensionOptions<TKind extends string | undefined, TName extends stri
         };
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     }): Iterable<UFactoryOutput>;
+    dataRefs?: TDataRefs;
 } & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /** @public */
-type ExtensionDefinitionParameters = {
-    kind?: string;
+type ExtensionBlueprintParameters = {
+    kind: string;
     name?: string;
+    params?: object | ExtensionBlueprintParamsDefiner;
     configInput?: {
         [K in string]: any;
     };
@@ -595,20 +651,53 @@ type ExtensionDefinitionParameters = {
             singleton: boolean;
         }>;
     };
-    params?: object;
+    dataRefs?: {
+        [name in string]: AnyExtensionDataRef;
+    };
 };
-/** @public */
-type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefinitionParameters> = {
-    $$type: '@backstage/ExtensionDefinition';
-    readonly T: T;
-    override<TExtensionConfigSchema extends {
+/** @ignore */
+type ParamsFactory<TDefiner extends ExtensionBlueprintParamsDefiner> = (define: 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>>;
+/**
+ * @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;
+        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;
+    }): ExtensionDefinition<{
+        kind: T['kind'];
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        config: T['config'];
+        configInput: T['configInput'];
+        output: T['output'];
+        inputs: T['inputs'];
+        params: T['params'];
+    }>;
+    /**
+     * Creates a new extension from the blueprint.
+     *
+     * 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 {
         [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: Expand<{
+    }>(args: {
+        name?: TNewName;
         attachTo?: ExtensionAttachToSpec;
         disabled?: boolean;
         inputs?: TExtraInputs & {
@@ -620,98 +709,110 @@ type ExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefi
                 [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
             };
         };
-        factory?(originalFactory: (context?: Expand<{
+        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?: {
             config?: T['config'];
             inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
-        } & ([T['params']] extends [never] ? {} : {
-            params?: Partial<T['params']>;
-        })>) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
+        }) => 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>;
-    } & ([T['params']] extends [never] ? {} : {
-        params?: Partial<T['params']>;
-    })> & VerifyExtensionFactoryOutput<AnyExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>): ExtensionDefinition<{
-        kind: T['kind'];
-        name: T['name'];
-        output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
-        inputs: T['inputs'] & TExtraInputs;
-        config: T['config'] & {
+        }): 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]>>;
-        };
-        configInput: T['configInput'] & z.input<z.ZodObject<{
+        }) & 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'];
+        name: string | undefined extends TNewName ? T['name'] : TNewName;
+        params: T['params'];
     }>;
-};
-/** @public */
-declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
+}
+/**
+ * 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.
+ *
+ * @public
+ */
+declare function createExtensionBlueprint<TParams extends object | ExtensionBlueprintParamsDefiner, 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 TName extends string | undefined = undefined>(options: CreateExtensionOptions<TKind, TName, UOutput, TInputs, TConfigSchema, UFactoryOutput>): ExtensionDefinition<{
+    [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<{
+    kind: TKind;
+    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]>;
     }>>;
-    output: UOutput;
-    inputs: TInputs;
-    params: never;
-    kind: string | undefined extends TKind ? undefined : TKind;
-    name: string | undefined extends TName ? undefined : TName;
+    dataRefs: TDataRefs;
 }>;
 
-/** @public */
-interface CreateFrontendFeatureLoaderOptions {
-    loader(deps: {
-        config: ConfigApi;
-    }): Iterable<FrontendFeature | FrontendFeatureLoader | Promise<{
-        default: FrontendFeature | FrontendFeatureLoader;
-    }>> | Promise<Iterable<FrontendFeature | FrontendFeatureLoader | Promise<{
-        default: FrontendFeature | FrontendFeatureLoader;
-    }>>> | AsyncIterable<FrontendFeature | FrontendFeatureLoader | {
-        default: FrontendFeature | FrontendFeatureLoader;
-    }>;
-}
-/** @public */
-interface FrontendFeatureLoader {
-    readonly $$type: '@backstage/FrontendFeatureLoader';
-}
-/** @public */
-declare function createFrontendFeatureLoader(options: CreateFrontendFeatureLoaderOptions): FrontendFeatureLoader;
-
 /**
+ * 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]> : never;
+/**
+ * Converts an extension input map into a matching collection of resolved inputs.
  * @public
  */
-type CreateExtensionBlueprintOptions<TKind extends string, TName extends string | undefined, TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+type ResolvedExtensionInputs<TInputs extends {
+    [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>;
+};
+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 */
+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;
+/** @public */
+type ExtensionAttachToSpec = {
+    id: string;
+    input: string;
+} | Array<{
+    id: string;
+    input: string;
+}>;
+/** @public */
+type CreateExtensionOptions<TKind extends string | undefined, TName extends string | undefined, 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>, TDataRefs extends {
-    [name in string]: AnyExtensionDataRef;
-}> = {
-    kind: TKind;
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>> = {
+    kind?: TKind;
+    name?: TName;
     attachTo: ExtensionAttachToSpec;
     disabled?: boolean;
     inputs?: TInputs;
     output: Array<UOutput>;
-    name?: TName;
     config?: {
         schema: TConfigSchema;
     };
-    factory(params: TParams, context: {
+    factory(context: {
         node: AppNode;
         apis: ApiHolder;
         config: {
@@ -719,13 +820,11 @@ type CreateExtensionBlueprintOptions<TKind extends string, TName extends string
         };
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     }): Iterable<UFactoryOutput>;
-    dataRefs?: TDataRefs;
 } & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /** @public */
-type ExtensionBlueprintParameters = {
-    kind: string;
+type ExtensionDefinitionParameters = {
+    kind?: string;
     name?: string;
-    params?: object;
     configInput?: {
         [K in string]: any;
     };
@@ -739,44 +838,26 @@ type ExtensionBlueprintParameters = {
             singleton: boolean;
         }>;
     };
-    dataRefs?: {
-        [name in string]: AnyExtensionDataRef;
-    };
+    params?: object | ExtensionBlueprintParamsDefiner;
 };
 /**
- * @public
+ * Same as the one in `createExtensionBlueprint`, but with `ParamsFactory` inlined.
+ * It can't be exported because it breaks API reports.
+ * @ignore
  */
-interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionBlueprintParameters> {
-    dataRefs: T['dataRefs'];
-    make<TNewName extends string | undefined>(args: {
-        name?: TNewName;
-        attachTo?: ExtensionAttachToSpec;
-        disabled?: boolean;
-        params: T['params'];
-    }): ExtensionDefinition<{
-        kind: T['kind'];
-        name: string | undefined extends TNewName ? T['name'] : TNewName;
-        config: T['config'];
-        configInput: T['configInput'];
-        output: T['output'];
-        inputs: T['inputs'];
-        params: T['params'];
-    }>;
-    /**
-     * Creates a new extension from the blueprint.
-     *
-     * 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 {
+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>>);
+/** @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, {
             optional: boolean;
             singleton: boolean;
         }>;
-    }>(args: {
-        name?: TNewName;
+    }, TParamsInput extends AnyParamsInput<NonNullable<T['params']>>>(args: Expand<{
         attachTo?: ExtensionAttachToSpec;
         disabled?: boolean;
         inputs?: TExtraInputs & {
@@ -788,61 +869,75 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
                 [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
             };
         };
-        factory(originalFactory: (params: T['params'], context?: {
+        factory?(originalFactory: <TFactoryParamsReturn extends AnyParamsInput<NonNullable<T['params']>>>(context?: Expand<{
             config?: T['config'];
             inputs?: ResolveInputValueOverrides<NonNullable<T['inputs']>>;
-        }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
+        } & ([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']>;
+        })>) => 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'];
+        }): 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<{
+        kind: T['kind'];
+        name: T['name'];
         output: AnyExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
         inputs: T['inputs'] & TExtraInputs;
-        kind: T['kind'];
-        name: string | undefined extends TNewName ? T['name'] : TNewName;
-        params: T['params'];
+        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]>;
+        }>>;
     }>;
-}
-/**
- * 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.
- *
- * @public
- */
-declare function createExtensionBlueprint<TParams extends object, UOutput extends AnyExtensionDataRef, TInputs extends {
+};
+/** @public */
+declare function createExtension<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, TName extends string | undefined = undefined, TDataRefs extends {
-    [name in string]: AnyExtensionDataRef;
-} = never>(options: CreateExtensionBlueprintOptions<TKind, TName, TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<{
-    kind: TKind;
-    name: TName;
-    params: TParams;
-    output: UOutput;
-    inputs: string extends keyof TInputs ? {} : TInputs;
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, const TKind extends string | undefined = undefined, const TName extends string | undefined = undefined>(options: CreateExtensionOptions<TKind, 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]>;
     }>>;
-    dataRefs: TDataRefs;
+    output: UOutput;
+    inputs: TInputs;
+    params: never;
+    kind: string | undefined extends TKind ? undefined : TKind;
+    name: string | undefined extends TName ? undefined : TName;
 }>;
 
+/** @public */
+interface CreateFrontendFeatureLoaderOptions {
+    loader(deps: {
+        config: ConfigApi;
+    }): Iterable<FrontendFeature | FrontendFeatureLoader | Promise<{
+        default: FrontendFeature | FrontendFeatureLoader;
+    }>> | Promise<Iterable<FrontendFeature | FrontendFeatureLoader | Promise<{
+        default: FrontendFeature | FrontendFeatureLoader;
+    }>>> | AsyncIterable<FrontendFeature | FrontendFeatureLoader | {
+        default: FrontendFeature | FrontendFeatureLoader;
+    }>;
+}
+/** @public */
+interface FrontendFeatureLoader {
+    readonly $$type: '@backstage/FrontendFeatureLoader';
+}
+/** @public */
+declare function createFrontendFeatureLoader(options: CreateFrontendFeatureLoaderOptions): FrontendFeatureLoader;
+
 /**
  * The specification for this {@link AppNode} in the {@link AppTree}.
  *
@@ -1363,9 +1458,7 @@ declare function useAnalytics(): AnalyticsTracker;
 declare const ApiBlueprint: ExtensionBlueprint<{
     kind: "api";
     name: undefined;
-    params: {
-        factory: AnyApiFactory;
-    };
+    params: <TApi, TImpl extends TApi, TDeps extends { [name in string]: unknown; }>(params: ApiFactory<TApi, TImpl, TDeps>) => ExtensionBlueprintParams<AnyApiFactory>;
     output: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
     inputs: {};
     config: {};
@@ -1441,59 +1534,80 @@ declare const IconBundleBlueprint: ExtensionBlueprint<{
 }>;
 
 /**
- * Creates extensions that make up the items of the nav bar.
+ * The props for the {@link NavContentComponent}.
  *
  * @public
  */
-declare const NavItemBlueprint: ExtensionBlueprint<{
-    kind: "nav-item";
+interface NavContentComponentProps {
+    /**
+     * The nav items available to the component. These are all the items created
+     * with the {@link NavItemBlueprint} in the app.
+     *
+     * In addition to the original properties from the nav items, these also
+     * include a resolved route path as `to`, and duplicated `title` as `text` to
+     * simplify rendering.
+     */
+    items: Array<{
+        icon: IconComponent$1;
+        title: string;
+        routeRef: RouteRef$1<undefined>;
+        to: string;
+        text: string;
+    }>;
+}
+/**
+ * A component that renders the nav bar content, to be passed to the {@link NavContentBlueprint}.
+ *
+ * @public
+ */
+type NavContentComponent = (props: NavContentComponentProps) => JSX.Element | null;
+/**
+ * Creates an extension that replaces the entire nav bar with your own component.
+ *
+ * @public
+ */
+declare const NavContentBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
+    kind: "nav-content";
     name: undefined;
     params: {
-        title: string;
-        icon: IconComponent$1;
-        routeRef: RouteRef<undefined>;
+        component: NavContentComponent;
     };
-    output: ConfigurableExtensionDataRef<{
-        title: string;
-        icon: IconComponent$1;
-        routeRef: RouteRef<undefined>;
-    }, "core.nav-item.target", {}>;
+    output: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<NavContentComponent, "core.nav-content.component", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        target: ConfigurableExtensionDataRef<{
-            title: string;
-            icon: IconComponent$1;
-            routeRef: RouteRef<undefined>;
-        }, "core.nav-item.target", {}>;
+        component: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<NavContentComponent, "core.nav-content.component", {}>;
     };
 }>;
 
 /**
- * Creates an extension that replaces the logo in the nav bar with your own.
+ * Creates extensions that make up the items of the nav bar.
  *
  * @public
  */
-declare const NavLogoBlueprint: ExtensionBlueprint<{
-    kind: "nav-logo";
+declare const NavItemBlueprint: ExtensionBlueprint<{
+    kind: "nav-item";
     name: undefined;
     params: {
-        logoIcon: JSX.Element;
-        logoFull: JSX.Element;
+        title: string;
+        icon: IconComponent$2;
+        routeRef: RouteRef<undefined>;
     };
     output: ConfigurableExtensionDataRef<{
-        logoIcon?: JSX.Element;
-        logoFull?: JSX.Element;
-    }, "core.nav-logo.logo-elements", {}>;
+        title: string;
+        icon: IconComponent$2;
+        routeRef: RouteRef<undefined>;
+    }, "core.nav-item.target", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        logoElements: ConfigurableExtensionDataRef<{
-            logoIcon?: JSX.Element;
-            logoFull?: JSX.Element;
-        }, "core.nav-logo.logo-elements", {}>;
+        target: ConfigurableExtensionDataRef<{
+            title: string;
+            icon: IconComponent$2;
+            routeRef: RouteRef<undefined>;
+        }, "core.nav-item.target", {}>;
     };
 }>;
 
@@ -1642,4 +1756,4 @@ declare namespace createComponentExtension {
     }, "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, 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, 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, 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 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 };