@backstage/frontend-plugin-api 0.15.0-next.1 → 0.15.1

package/dist/types/alpha.d-DzeiOzxk.d.ts

@@ -0,0 +1,1425 @@
+import * as _backstage_frontend_plugin_api from '@backstage/frontend-plugin-api';
+import { JSX, ComponentType, ReactNode } from 'react';
+import { Expand, JsonObject } from '@backstage/types';
+import { FilterPredicate } from '@backstage/filter-predicates';
+import { z } from 'zod/v3';
+
+/**
+ * IconComponent is the common icon type used throughout Backstage when
+ * working with and rendering generic icons, including the app system icons.
+ *
+ * @remarks
+ *
+ * The type is based on SvgIcon from Material UI, but we do not want the plugin-api
+ * package to have a dependency on Material UI, nor do we want the props to be as broad
+ * as the SvgIconProps interface.
+ *
+ * If you have the need to forward additional props from SvgIconProps, you can
+ * open an issue or submit a PR to the main Backstage repo. When doing so please
+ * also describe your use-case and reasoning of the addition.
+ *
+ * @public
+ * @deprecated Use {@link IconElement} instead, passing `<MyIcon />` rather than `MyIcon`.
+ */
+type IconComponent = ComponentType<{
+    fontSize?: 'medium' | 'large' | 'small' | 'inherit';
+}>;
+/**
+ * The type used for icon elements throughout Backstage.
+ *
+ * @remarks
+ *
+ * Icon elements should behave like rendering a plain icon directly, for example
+ * from `@remixicon/react`, and are expected to be sized by the surrounding UI.
+ * Icons should be exactly 24x24 pixels in size by default.
+ *
+ * Using icons from `@remixicon/react` is preferred. Using icons from
+ * `@material-ui/icons` or `AppIcon` and its variants from
+ * `@backstage/core-components` is supported while migrating, but deprecated.
+ * When using those icons, you must set `fontSize="inherit"` on the element.
+ *
+ * @public
+ */
+type IconElement = JSX.Element | null;
+
+/**
+ * Catch-all type for route params.
+ *
+ * @public
+ */
+type AnyRouteRefParams = {
+    [param in string]: string;
+} | undefined;
+
+/**
+ * Absolute route reference.
+ *
+ * @remarks
+ *
+ * See {@link https://backstage.io/docs/plugins/composability#routing-system}.
+ *
+ * @public
+ */
+interface RouteRef<TParams extends AnyRouteRefParams = AnyRouteRefParams> {
+    readonly $$type: '@backstage/RouteRef';
+    readonly T: TParams;
+}
+/**
+ * Create a {@link RouteRef} from a route descriptor.
+ *
+ * @param config - Description of the route reference to be created.
+ * @public
+ */
+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[];
+    aliasFor?: string;
+}): RouteRef<keyof TParams extends never ? undefined : string extends TParamKeys ? TParams : {
+    [param in TParamKeys]: string;
+}>;
+
+/** @public */
+type ExtensionDataValue<TData, TId extends string> = {
+    readonly $$type: '@backstage/ExtensionDataValue';
+    readonly id: TId;
+    readonly value: TData;
+};
+/** @public */
+type ExtensionDataRef<TData = unknown, TId extends string = string, TConfig extends {
+    optional?: true;
+} = {
+    optional?: true;
+}> = {
+    readonly $$type: '@backstage/ExtensionDataRef';
+    readonly id: TId;
+    readonly T: TData;
+    readonly config: TConfig;
+};
+/** @ignore */
+type ExtensionDataRefToValue<TDataRef extends ExtensionDataRef> = TDataRef extends ExtensionDataRef<infer IData, infer IId, any> ? ExtensionDataValue<IData, IId> : never;
+/** @public */
+interface ConfigurableExtensionDataRef<TData, TId extends string, TConfig extends {
+    optional?: true;
+} = {}> extends ExtensionDataRef<TData, TId, TConfig> {
+    optional(): ConfigurableExtensionDataRef<TData, TId, TConfig & {
+        optional: true;
+    }>;
+    (t: TData): ExtensionDataValue<TData, TId>;
+}
+/** @public */
+declare function createExtensionDataRef<TData>(): {
+    with<TId extends string>(options: {
+        id: TId;
+    }): ConfigurableExtensionDataRef<TData, TId>;
+};
+
+/** @public */
+interface ExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}> = ExtensionDataRef, TConfig extends {
+    singleton: boolean;
+    optional: boolean;
+    internal?: boolean;
+} = {
+    singleton: boolean;
+    optional: boolean;
+    internal?: boolean;
+}> {
+    readonly $$type: '@backstage/ExtensionInput';
+    readonly extensionData: Array<UExtensionData>;
+    readonly config: TConfig;
+    readonly replaces?: Array<{
+        id: string;
+        input: string;
+    }>;
+}
+/**
+ * Creates a new extension input to be passed to the input map of an extension.
+ *
+ * @remarks
+ *
+ * Extension inputs created with this function can be passed to any `inputs` map
+ * as part of creating or overriding an extension.
+ *
+ * The array of extension data references defines the data this input expects.
+ * If the required data is not provided by the attached extension, the
+ * attachment will fail.
+ *
+ * The `config` object can be used to restrict the behavior and shape of the
+ * input. By default an input will accept zero or more extensions from any
+ * plugin. The following options are available:
+ *
+ * - `singleton`: If set to `true`, only one extension can be attached to the
+ *   input at a time. Additional extensions will trigger an app error and be
+ *   ignored.
+ * - `optional`: If set to `true`, the input is optional and can be omitted,
+ *   this only has an effect if the `singleton` is set to `true`.
+ * - `internal`: If set to `true`, only extensions from the same plugin will be
+ *   allowed to attach to this input. Other extensions will trigger an app error
+ *   and be ignored.
+ *
+ * @param extensionData - The array of extension data references that this input
+ * expects.
+ * @param config - The configuration object for the input.
+ * @returns An extension input declaration.
+ * @example
+ * ```ts
+ * const extension = createExtension({
+ *   attachTo: { id: 'example-parent', input: 'example-input' },
+ *   inputs: {
+ *     content: createExtensionInput([coreExtensionData.reactElement], {
+ *       singleton: true,
+ *     }),
+ *   },
+ *   output: [coreExtensionData.reactElement],
+ *   *factory({ inputs }) {
+ *     const content = inputs.content?.get(coreExtensionData.reactElement);
+ *     yield coreExtensionData.reactElement(<ContentWrapper>{content}</ContentWrapper>);
+ *   },
+ * });
+ * ```
+ * @public
+ */
+declare function createExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>, TConfig extends {
+    singleton?: boolean;
+    optional?: boolean;
+    internal?: boolean;
+}>(extensionData: Array<UExtensionData>, config?: TConfig & {
+    replaces?: Array<{
+        id: string;
+        input: string;
+    }>;
+}): ExtensionInput<UExtensionData, {
+    singleton: TConfig['singleton'] extends true ? true : false;
+    optional: TConfig['optional'] extends true ? true : false;
+    internal: TConfig['internal'] extends true ? true : false;
+}>;
+
+/** @ignore */
+type ResolvedInputValueOverrides<TInputs extends {
+    [inputName in string]: ExtensionInput;
+} = {
+    [inputName in string]: ExtensionInput;
+}> = Expand<{
+    [KName in keyof TInputs as TInputs[KName] extends ExtensionInput<any, {
+        optional: infer IOptional extends boolean;
+        singleton: boolean;
+        internal?: boolean;
+    }> ? IOptional extends true ? never : KName : never]: TInputs[KName] extends ExtensionInput<infer IDataRefs, {
+        optional: boolean;
+        singleton: infer ISingleton extends boolean;
+        internal?: boolean;
+    }> ? ISingleton extends true ? Iterable<ExtensionDataRefToValue<IDataRefs>> : Array<Iterable<ExtensionDataRefToValue<IDataRefs>>> : never;
+} & {
+    [KName in keyof TInputs as TInputs[KName] extends ExtensionInput<any, {
+        optional: infer IOptional extends boolean;
+        singleton: boolean;
+        internal?: boolean;
+    }> ? IOptional extends true ? KName : never : never]?: TInputs[KName] extends ExtensionInput<infer IDataRefs, {
+        optional: boolean;
+        singleton: infer ISingleton extends boolean;
+        internal?: boolean;
+    }> ? 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[];
+    if?: FilterPredicate;
+}
+/** @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 */
+type ExtensionAttachTo = {
+    id: string;
+    input: string;
+};
+/** @public */
+interface Extension<TConfig, TConfigInput = TConfig> {
+    $$type: '@backstage/Extension';
+    readonly id: string;
+    readonly attachTo: ExtensionAttachTo;
+    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}.
+ *
+ * @remarks
+ *
+ * See {@link https://backstage.io/docs/plugins/composability#routing-system}.
+ *
+ * @public
+ */
+interface SubRouteRef<TParams extends AnyRouteRefParams = AnyRouteRefParams> {
+    readonly $$type: '@backstage/SubRouteRef';
+    readonly T: TParams;
+    readonly path: string;
+}
+/**
+ * Used in {@link PathParams} type declaration.
+ * @ignore
+ */
+type ParamPart<S extends string> = S extends `:${infer Param}` ? Param : never;
+/**
+ * Used in {@link PathParams} type declaration.
+ * @ignore
+ */
+type ParamNames<S extends string> = S extends `${infer Part}/${infer Rest}` ? ParamPart<Part> | ParamNames<Rest> : ParamPart<S>;
+/**
+ * This utility type helps us infer a Param object type from a string path
+ * For example, `/foo/:bar/:baz` inferred to `{ bar: string, baz: string }`
+ * @ignore
+ */
+type PathParams<S extends string> = {
+    [name in ParamNames<S>]: string;
+};
+/**
+ * Merges a param object type with an optional params type into a params object.
+ * @ignore
+ */
+type MergeParams<P1 extends {
+    [param in string]: string;
+}, P2 extends AnyRouteRefParams> = (P1[keyof P1] extends never ? {} : P1) & (P2 extends undefined ? {} : P2);
+/**
+ * Convert empty params to undefined.
+ * @ignore
+ */
+type TrimEmptyParams<Params extends {
+    [param in string]: string;
+}> = keyof Params extends never ? undefined : Params;
+/**
+ * Creates a SubRouteRef type given the desired parameters and parent route parameters.
+ * The parameters types are merged together while ensuring that there is no overlap between the two.
+ *
+ * @ignore
+ */
+type MakeSubRouteRef<Params extends {
+    [param in string]: string;
+}, ParentParams extends AnyRouteRefParams> = keyof Params & keyof ParentParams extends never ? SubRouteRef<TrimEmptyParams<MergeParams<Params, ParentParams>>> : never;
+/**
+ * Create a {@link SubRouteRef} from a route descriptor.
+ *
+ * @param config - Description of the route reference to be created.
+ * @public
+ */
+declare function createSubRouteRef<Path extends string, ParentParams extends AnyRouteRefParams = never>(config: {
+    path: Path;
+    parent: RouteRef<ParentParams>;
+}): MakeSubRouteRef<PathParams<Path>, ParentParams>;
+
+/**
+ * Route descriptor, to be later bound to a concrete route by the app. Used to implement cross-plugin route references.
+ *
+ * @remarks
+ *
+ * See {@link https://backstage.io/docs/plugins/composability#routing-system}.
+ *
+ * @public
+ */
+interface ExternalRouteRef<TParams extends AnyRouteRefParams = AnyRouteRefParams> {
+    readonly $$type: '@backstage/ExternalRouteRef';
+    readonly T: TParams;
+}
+/**
+ * Creates a route descriptor, to be later bound to a concrete route by the app. Used to implement cross-plugin route references.
+ *
+ * @remarks
+ *
+ * See {@link https://backstage.io/docs/plugins/composability#routing-system}.
+ *
+ * @param options - Description of the route reference to be created.
+ * @public
+ */
+declare function createExternalRouteRef<TParams extends {
+    [param in TParamKeys]: string;
+} | undefined = undefined, TParamKeys extends string = string>(config?: {
+    /**
+     * The parameters that will be provided to the external route reference.
+     */
+    readonly params?: string extends TParamKeys ? (keyof TParams)[] : TParamKeys[];
+    /**
+     * The route (typically in another plugin) that this should map to by default.
+     *
+     * The string is expected to be on the standard `<plugin id>.<route id>` form,
+     * for example `techdocs.docRoot`.
+     */
+    defaultTarget?: string;
+}): ExternalRouteRef<keyof TParams extends never ? undefined : string extends TParamKeys ? TParams : {
+    [param in TParamKeys]: string;
+}>;
+
+/**
+ * Information about the plugin.
+ *
+ * @public
+ * @remarks
+ *
+ * This interface is intended to be extended via [module
+ * augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation)
+ * in order to add fields that are specific to each project.
+ *
+ * For example, one might add a `slackChannel` field that is read from the
+ * opaque manifest file.
+ *
+ * See the options for `createApp` for more information about how to
+ * customize the parsing of manifest files.
+ */
+interface FrontendPluginInfo {
+    /**
+     * The name of the package that implements the plugin.
+     */
+    packageName?: string;
+    /**
+     * The version of the plugin, typically the version of the package.json file.
+     */
+    version?: string;
+    /**
+     * As short description of the plugin, typically the description field in
+     * package.json.
+     */
+    description?: string;
+    /**
+     * The owner entity references of the plugin.
+     */
+    ownerEntityRefs?: string[];
+    /**
+     * Links related to the plugin.
+     */
+    links?: Array<{
+        title: string;
+        url: string;
+    }>;
+}
+/**
+ * Options for providing information for a plugin.
+ *
+ * @public
+ */
+type FrontendPluginInfoOptions = {
+    /**
+     * A loader function for the package.json file for the plugin.
+     */
+    packageJson?: () => Promise<{
+        name: string;
+    } & JsonObject>;
+    /**
+     * A loader function for an opaque manifest file for the plugin.
+     */
+    manifest?: () => Promise<JsonObject>;
+};
+/**
+ * A variant of the {@link FrontendPlugin} interface that can also be used to install overrides for the plugin.
+ *
+ * @public
+ */
+interface OverridableFrontendPlugin<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;
+}> extends FrontendPlugin<TRoutes, TExternalRoutes> {
+    getExtension<TId extends keyof TExtensionMap>(id: TId): OverridableExtensionDefinition<TExtensionMap[TId]['T']>;
+    withOverrides(options: {
+        extensions?: Array<ExtensionDefinition>;
+        /**
+         * Overrides the shared condition that applies to all extensions in the plugin.
+         */
+        if?: FilterPredicate;
+        /**
+         * Overrides the display title of the plugin.
+         */
+        title?: string;
+        /**
+         * Overrides the display icon of the plugin.
+         */
+        icon?: IconElement;
+        /**
+         * Overrides the original info loaders of the plugin one by one.
+         */
+        info?: FrontendPluginInfoOptions;
+    }): OverridableFrontendPlugin<TRoutes, TExternalRoutes, TExtensionMap>;
+}
+/** @public */
+interface FrontendPlugin<TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+} = {
+    [name in string]: RouteRef | SubRouteRef;
+}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+} = {
+    [name in string]: ExternalRouteRef;
+}> {
+    readonly $$type: '@backstage/FrontendPlugin';
+    /**
+     * The plugin ID.
+     */
+    readonly pluginId: string;
+    /**
+     * Deprecated alias for `pluginId`.
+     *
+     * @deprecated Use `pluginId` instead.
+     */
+    readonly id: string;
+    /**
+     * The display title of the plugin, used in page headers and navigation.
+     * Falls back to the plugin ID if not provided.
+     */
+    readonly title?: string;
+    /**
+     * The display icon of the plugin, used in page headers and navigation.
+     */
+    readonly icon?: IconElement;
+    readonly routes: TRoutes;
+    readonly externalRoutes: TExternalRoutes;
+    /**
+     * Loads the plugin info.
+     */
+    info(): Promise<FrontendPluginInfo>;
+}
+/**
+ * Options for {@link createFrontendPlugin}.
+ *
+ * @public
+ */
+interface CreateFrontendPluginOptions<TId extends string, TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+}, TExtensions extends readonly ExtensionDefinition[]> {
+    pluginId: TId;
+    /**
+     * The display title of the plugin, used in page headers and navigation.
+     * Falls back to the plugin ID if not provided.
+     */
+    title?: string;
+    /**
+     * The display icon of the plugin, used in page headers and navigation.
+     */
+    icon?: IconElement;
+    routes?: TRoutes;
+    externalRoutes?: TExternalRoutes;
+    extensions?: TExtensions;
+    featureFlags?: FeatureFlagConfig[];
+    if?: FilterPredicate;
+    info?: FrontendPluginInfoOptions;
+}
+/**
+ * @deprecated Use {@link CreateFrontendPluginOptions} instead.
+ * @public
+ */
+type PluginOptions<TId extends string, TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+}, TExtensions extends readonly ExtensionDefinition[]> = CreateFrontendPluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>;
+/**
+ * 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
+ */
+declare function createFrontendPlugin<TId extends string, TExtensions extends readonly ExtensionDefinition[], TRoutes extends {
+    [name in string]: RouteRef | SubRouteRef;
+} = {}, TExternalRoutes extends {
+    [name in string]: ExternalRouteRef;
+} = {}>(options: CreateFrontendPluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>): OverridableFrontendPlugin<TRoutes, TExternalRoutes, MakeSortedExtensionsMap<TExtensions[number], TId>>;
+
+/**
+ * Feature flag configuration.
+ *
+ * @public
+ */
+type FeatureFlagConfig = {
+    /** Feature flag name */
+    name: string;
+    /** Feature flag description */
+    description?: string;
+};
+/** @public */
+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
+ * @deprecated Moved to {@link @backstage/frontend-app-api#ExtensionFactoryMiddleware}
+ */
+type ExtensionFactoryMiddleware = (originalFactory: (contextOverrides?: {
+    config?: JsonObject;
+}) => ExtensionDataContainer<ExtensionDataRef>, context: {
+    node: AppNode;
+    apis: ApiHolder;
+    config?: JsonObject;
+}) => Iterable<ExtensionDataValue<any, any>>;
+/** @public  */
+type FrontendFeature = (Omit<FrontendPlugin, 'pluginId'> & {
+    pluginId?: string;
+}) | FrontendModule;
+
+/**
+ * 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 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.
+ *
+ * @remarks
+ *
+ * Created with {@link createExtensionBlueprintParams}.
+ *
+ * @public
+ */
+type ExtensionBlueprintParams<T extends object = object> = {
+    $$type: '@backstage/BlueprintParams';
+    T: T;
+};
+/**
+ * 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, TParams extends object | ExtensionBlueprintDefineParams, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput;
+}, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: ExtensionDataRef;
+}, UParentInputs extends ExtensionDataRef> = {
+    kind: TKind;
+    attachTo: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<UOutput, UParentInputs>;
+    disabled?: boolean;
+    if?: FilterPredicate;
+    inputs?: TInputs;
+    output: Array<UOutput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    /**
+     * 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: defineParams => defineParams({
+     *     component: ...,
+     *     fetcher: ...,
+     *   }),
+     * });
+     * ```
+     */
+    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: {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        };
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    }): Iterable<UFactoryOutput>;
+    dataRefs?: TDataRefs;
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
+/** @public */
+type ExtensionBlueprintParameters = {
+    kind: string;
+    params?: object | ExtensionBlueprintDefineParams;
+    configInput?: {
+        [K in string]: any;
+    };
+    config?: {
+        [K in string]: any;
+    };
+    output?: ExtensionDataRef;
+    inputs?: {
+        [KName in string]: ExtensionInput;
+    };
+    dataRefs?: {
+        [name in string]: ExtensionDataRef;
+    };
+};
+/** @ignore */
+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 | 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<TName extends string | undefined, TParamsInput extends AnyParamsInput$1<NonNullable<T['params']>>, UParentInputs extends ExtensionDataRef>(args: {
+        name?: TName;
+        attachTo?: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<NonNullable<T['output']>, UParentInputs>;
+        disabled?: boolean;
+        if?: FilterPredicate;
+        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'];
+    }): OverridableExtensionDefinition<{
+        kind: T['kind'];
+        name: string | undefined extends TName ? undefined : TName;
+        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<TName extends string | undefined, TExtensionConfigSchema extends {
+        [key in string]: (zImpl: typeof z) => z.ZodType;
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, UParentInputs extends ExtensionDataRef, TExtraInputs extends {
+        [inputName in string]: ExtensionInput;
+    } = {}>(args: {
+        name?: TName;
+        attachTo?: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UParentInputs>;
+        disabled?: boolean;
+        if?: FilterPredicate;
+        inputs?: TExtraInputs & {
+            [KName in keyof T['inputs']]?: `Error: Input '${KName & string}' is already defined in parent definition`;
+        };
+        output?: Array<UNewOutput>;
+        config?: {
+            schema: TExtensionConfigSchema & {
+                [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+            };
+        };
+        factory(originalFactory: <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?: ResolvedInputValueOverrides<NonNullable<T['inputs']>>;
+        }) => ExtensionDataContainer<NonNullable<T['output']>>, context: {
+            node: AppNode;
+            apis: ApiHolder;
+            config: T['config'] & {
+                [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+            };
+            inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
+        }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>;
+    }): OverridableExtensionDefinition<{
+        config: Expand<(string extends keyof TExtensionConfigSchema ? {} : {
+            [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+        }) & T['config']>;
+        configInput: Expand<(string extends keyof TExtensionConfigSchema ? {} : z.input<z.ZodObject<{
+            [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+        }>>) & T['configInput']>;
+        output: ExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        inputs: Expand<T['inputs'] & TExtraInputs>;
+        kind: T['kind'];
+        name: string | undefined extends TName ? undefined : TName;
+        params: T['params'];
+    }>;
+}
+/**
+ * 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 | ExtensionBlueprintDefineParams, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput;
+}, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TKind extends string, UParentInputs extends ExtensionDataRef, TDataRefs extends {
+    [name in string]: ExtensionDataRef;
+} = never>(options: CreateExtensionBlueprintOptions<TKind, TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs, UParentInputs>): ExtensionBlueprint<{
+    kind: TKind;
+    params: TParams;
+    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]>>;
+    };
+    configInput: string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+        [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+    }>>;
+    dataRefs: TDataRefs;
+}>;
+
+/** @ignore */
+type ResolvedExtensionInput<TExtensionInput extends ExtensionInput> = TExtensionInput['extensionData'] extends Array<ExtensionDataRef> ? {
+    node: AppNode;
+} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : never;
+/**
+ * Converts an extension input map into a matching collection of resolved inputs.
+ *
+ * @ignore
+ */
+type ResolvedExtensionInputs<TInputs extends {
+    [name in string]: ExtensionInput;
+}> = {
+    [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 RequiredExtensionIds<UExtensionData extends ExtensionDataRef> = UExtensionData extends any ? UExtensionData['config']['optional'] extends true ? never : UExtensionData['id'] : never;
+/** @ignore */
+type VerifyExtensionFactoryOutput<UDeclaredOutput extends ExtensionDataRef, UFactoryOutput extends ExtensionDataValue<any, any>> = [RequiredExtensionIds<UDeclaredOutput>] 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<RequiredExtensionIds<UDeclaredOutput>, UFactoryOutput['id']>>}`;
+/** @ignore */
+type VerifyExtensionAttachTo<UOutput extends ExtensionDataRef, UParentInput extends ExtensionDataRef> = ExtensionDataRef extends UParentInput ? {} : [RequiredExtensionIds<UParentInput>] extends [RequiredExtensionIds<UOutput>] ? {} : `Error: This parent extension input requires the following extension data, but it is not declared as guaranteed output of this extension: ${JoinStringUnion<Exclude<RequiredExtensionIds<UParentInput>, RequiredExtensionIds<UOutput>>>}`;
+/**
+ * Specifies where an extension should attach in the extension tree.
+ *
+ * @remarks
+ *
+ * A standard attachment point declaration will specify the ID of the parent extension, as well as the name of the input to attach to.
+ *
+ * There are two more advanced forms that are available for more complex use-cases:
+ *
+ * 1. Relative attachment points: using the `relative` property instead of `id`, the attachment point is resolved relative to the current plugin.
+ * 2. Extension input references: using a reference in code to another extension's input in the same plugin. These references are always relative.
+ *
+ * @example
+ * ```ts
+ * // Attach to a specific extension by full ID
+ * { id: 'app/routes', input: 'routes' }
+ *
+ * // Attach to an extension in the same plugin by kind
+ * { relative: { kind: 'page' }, input: 'actions' }
+ *
+ * // Attach to a specific input of another extension
+ * const page = ParentBlueprint.make({ ... });
+ * const child = ChildBlueprint.make({ attachTo: page.inputs.children });
+ * ```
+ *
+ * @public
+ */
+type ExtensionDefinitionAttachTo<UParentInputs extends ExtensionDataRef = ExtensionDataRef> = {
+    id: string;
+    input: string;
+    relative?: never;
+} | {
+    relative: {
+        kind?: string;
+        name?: string;
+    };
+    input: string;
+    id?: never;
+} | ExtensionInput<UParentInputs>;
+/** @public */
+type CreateExtensionOptions<TKind extends string | undefined, TName extends string | undefined, UOutput extends ExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput;
+}, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, UParentInputs extends ExtensionDataRef> = {
+    kind?: TKind;
+    name?: TName;
+    attachTo: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<UOutput, UParentInputs>;
+    disabled?: boolean;
+    if?: FilterPredicate;
+    inputs?: TInputs;
+    output: Array<UOutput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    factory(context: {
+        node: AppNode;
+        apis: ApiHolder;
+        config: {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        };
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    }): Iterable<UFactoryOutput>;
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
+/** @public */
+type ExtensionDefinitionParameters = {
+    kind?: string;
+    name?: string;
+    configInput?: {
+        [K in string]: any;
+    };
+    config?: {
+        [K in string]: any;
+    };
+    output?: ExtensionDataRef;
+    inputs?: {
+        [KName in string]: ExtensionInput;
+    };
+    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 | ExtensionBlueprintDefineParams> = TParams extends ExtensionBlueprintDefineParams<infer IParams> ? IParams | ((define: TParams) => ReturnType<TParams>) : TParams | ((define: ExtensionBlueprintDefineParams<TParams, TParams>) => ReturnType<ExtensionBlueprintDefineParams<TParams, TParams>>);
+/** @public */
+interface ExtensionDefinition<TParams extends ExtensionDefinitionParameters = ExtensionDefinitionParameters> {
+    $$type: '@backstage/ExtensionDefinition';
+    readonly T: TParams;
+}
+/** @public */
+interface OverridableExtensionDefinition<T extends ExtensionDefinitionParameters = ExtensionDefinitionParameters> extends ExtensionDefinition<T> {
+    /**
+     * References to the inputs of this extension, which can be used to attach child extensions.
+     */
+    readonly inputs: {
+        [K in keyof T['inputs']]: ExtensionInput<T['inputs'][K] extends ExtensionInput<infer IData> ? IData : never>;
+    };
+    override<TExtensionConfigSchema extends {
+        [key in string]: (zImpl: typeof z) => z.ZodType;
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, TExtraInputs extends {
+        [inputName in string]: ExtensionInput;
+    }, TParamsInput extends AnyParamsInput<NonNullable<T['params']>>, UParentInputs extends ExtensionDataRef>(args: Expand<{
+        attachTo?: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UParentInputs>;
+        disabled?: boolean;
+        if?: FilterPredicate;
+        inputs?: TExtraInputs & {
+            [KName in keyof T['inputs']]?: `Error: Input '${KName & string}' is already defined in parent definition`;
+        };
+        output?: Array<UNewOutput>;
+        config?: {
+            schema: TExtensionConfigSchema & {
+                [KName in keyof T['config']]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+            };
+        };
+        factory?(originalFactory: <TFactoryParamsReturn extends AnyParamsInput<NonNullable<T['params']>>>(context?: Expand<{
+            config?: T['config'];
+            inputs?: ResolvedInputValueOverrides<NonNullable<T['inputs']>>;
+        } & ([T['params']] extends [never] ? {} : {
+            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;
+            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?: 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>): OverridableExtensionDefinition<{
+        kind: T['kind'];
+        name: T['name'];
+        output: ExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
+        inputs: T['inputs'] & TExtraInputs;
+        config: T['config'] & {
+            [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+        };
+        configInput: T['configInput'] & z.input<z.ZodObject<{
+            [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+        }>>;
+    }>;
+}
+/**
+ * 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;
+}, 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, UParentInputs extends ExtensionDataRef = ExtensionDataRef>(options: CreateExtensionOptions<TKind, TName, UOutput, TInputs, TConfigSchema, UFactoryOutput, UParentInputs>): OverridableExtensionDefinition<{
+    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 extends ExtensionDataRef<infer IData, infer IId, infer IConfig> ? ExtensionDataRef<IData, IId, IConfig> : never;
+    inputs: TInputs;
+    params: never;
+    kind: string | undefined extends TKind ? undefined : TKind;
+    name: string | undefined extends TName ? undefined : TName;
+}>;
+
+/**
+ * The specification for this {@link AppNode} in the {@link AppTree}.
+ *
+ * @public
+ * @remarks
+ *
+ * The specifications for a collection of app nodes is all the information needed
+ * to build the tree and instantiate the nodes.
+ */
+interface AppNodeSpec {
+    readonly id: string;
+    readonly attachTo: ExtensionAttachTo;
+    readonly extension: Extension<unknown, unknown>;
+    readonly disabled: boolean;
+    readonly if?: FilterPredicate;
+    readonly config?: unknown;
+    readonly plugin: FrontendPlugin;
+}
+/**
+ * The connections from this {@link AppNode} to other nodes.
+ *
+ * @public
+ * @remarks
+ *
+ * The app node edges are resolved based on the app node specs, regardless of whether
+ * adjacent nodes are disabled or not. If no parent attachment is present or
+ */
+interface AppNodeEdges {
+    readonly attachedTo?: {
+        node: AppNode;
+        input: string;
+    };
+    readonly attachments: ReadonlyMap<string, AppNode[]>;
+}
+/**
+ * The instance of this {@link AppNode} in the {@link AppTree}.
+ *
+ * @public
+ * @remarks
+ *
+ * The app node instance is created when the `factory` function of an extension is called.
+ * Instances will only be present for nodes in the app that are connected to the root
+ * node and not disabled
+ */
+interface AppNodeInstance {
+    /** Returns a sequence of all extension data refs that were output by this instance */
+    getDataRefs(): Iterable<ExtensionDataRef<unknown>>;
+    /** Get the output data for a single extension data ref */
+    getData<T>(ref: ExtensionDataRef<T>): T | undefined;
+}
+/**
+ * A node in the {@link AppTree}.
+ *
+ * @public
+ */
+interface AppNode {
+    /** The specification for how this node should be instantiated */
+    readonly spec: AppNodeSpec;
+    /** The edges from this node to other nodes in the app tree */
+    readonly edges: AppNodeEdges;
+    /** The instance of this node, if it was instantiated */
+    readonly instance?: AppNodeInstance;
+}
+/**
+ * The app tree containing all {@link AppNode}s of the app.
+ *
+ * @public
+ */
+interface AppTree {
+    /** The root node of the app */
+    readonly root: AppNode;
+    /** A map of all nodes in the app by ID, including orphaned or disabled nodes */
+    readonly nodes: ReadonlyMap<string, AppNode>;
+    /** A sequence of all nodes with a parent that is not reachable from the app root node */
+    readonly orphans: Iterable<AppNode>;
+}
+/**
+ * The API for interacting with the {@link AppTree}.
+ *
+ * @public
+ */
+interface AppTreeApi {
+    /**
+     * Get the {@link AppTree} for the app.
+     */
+    getTree(): {
+        tree: AppTree;
+    };
+    /**
+     * Get all nodes in the app that are mounted at a given route path.
+     */
+    getNodesByRoutePath(routePath: string): {
+        nodes: AppNode[];
+    };
+}
+/**
+ * The `ApiRef` of {@link AppTreeApi}.
+ *
+ * @public
+ */
+declare const appTreeApiRef: _backstage_frontend_plugin_api.ApiRef<AppTreeApi, "core.app-tree"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
+
+/**
+ * API reference.
+ *
+ * @public
+ */
+type ApiRef<T, TId extends string = string> = {
+    readonly $$type?: '@backstage/ApiRef';
+    readonly id: TId;
+    readonly T: T;
+};
+/**
+ * Catch-all {@link ApiRef} type.
+ *
+ * @public
+ */
+type AnyApiRef = ApiRef<unknown>;
+/**
+ * Wraps a type with API properties into a type holding their respective {@link ApiRef}s.
+ *
+ * @public
+ */
+type TypesToApiRefs<T> = {
+    [key in keyof T]: ApiRef<T[key]>;
+};
+/**
+ * Provides lookup of APIs through their {@link ApiRef}s.
+ *
+ * @public
+ */
+type ApiHolder = {
+    get<T>(api: ApiRef<T>): T | undefined;
+};
+/**
+ * Describes type returning API implementations.
+ *
+ * @public
+ */
+type ApiFactory<Api, Impl extends Api, Deps extends {
+    [name in string]: unknown;
+}> = {
+    api: ApiRef<Api>;
+    deps: TypesToApiRefs<Deps>;
+    factory(deps: Deps): Impl;
+};
+/**
+ * Catch-all {@link ApiFactory} type.
+ *
+ * @public
+ */
+type AnyApiFactory = ApiFactory<unknown, unknown, {
+    [key in string]: unknown;
+}>;
+
+/**
+ * The Plugin Wrapper API allows plugins to wrap their extensions with
+ * providers. This API is only intended for internal use by the Backstage
+ * frontend system. To provide contexts to plugin components, use
+ * `ExtensionBoundary` instead.
+ *
+ * @public
+ */
+type PluginWrapperApi = {
+    /**
+     * Returns the root wrapper that manages the global plugin state across
+     * plugin wrapper instances.
+     */
+    getRootWrapper(): ComponentType<{
+        children: ReactNode;
+    }>;
+    /**
+     * Returns a wrapper component for a specific plugin, or undefined if no
+     * wrappers exist. Do not use this API directly, instead use
+     * `ExtensionBoundary` to wrap your plugin components if needed.
+     */
+    getPluginWrapper(pluginId: string): ComponentType<{
+        children: ReactNode;
+    }> | undefined;
+};
+/**
+ * The API reference of {@link PluginWrapperApi}.
+ *
+ * @public
+ */
+declare const pluginWrapperApiRef: _backstage_frontend_plugin_api.ApiRef<PluginWrapperApi, "core.plugin-wrapper"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
+
+/**
+ * Defines the structure of a plugin wrapper, optionally including a shared
+ * hook value.
+ *
+ * @remarks
+ *
+ * When `useWrapperValue` is provided, the hook is called in a single location
+ * in the app and the resulting value is forwarded as the `value` prop to the
+ * component. The hook obeys the rules of React hooks and is not called until a
+ * component from the plugin is rendered.
+ *
+ * @public
+ */
+type PluginWrapperDefinition<TValue = unknown | never> = {
+    /**
+     * Creates a shared value that is forwarded as the `value` prop to the
+     * component.
+     *
+     * @remarks
+     *
+     * This function obeys the rules of React hooks and is only invoked in a
+     * single location in the app. Note that the hook will not be called until a
+     * component from the plugin is rendered.
+     */
+    useWrapperValue?: () => TValue;
+    component: ComponentType<{
+        children: ReactNode;
+        value: TValue;
+    }>;
+};
+/**
+ * Creates extensions that wrap plugin extensions with providers.
+ *
+ * @public
+ */
+declare const PluginWrapperBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
+    kind: "plugin-wrapper";
+    params: <TValue = never>(params: {
+        loader: () => Promise<PluginWrapperDefinition<TValue>>;
+    }) => _backstage_frontend_plugin_api.ExtensionBlueprintParams<{
+        loader: () => Promise<PluginWrapperDefinition>;
+    }>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<() => Promise<PluginWrapperDefinition>, "core.plugin-wrapper.loader", {}>;
+    inputs: {};
+    config: {};
+    configInput: {};
+    dataRefs: {
+        wrapper: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<() => Promise<PluginWrapperDefinition>, "core.plugin-wrapper.loader", {}>;
+    };
+}>;
+
+export { createExtensionDataRef as D, createFrontendPlugin as K, createFrontendModule as V, createExtensionBlueprint as a6, createExtensionBlueprintParams as a7, appTreeApiRef as h, PluginWrapperBlueprint as o, pluginWrapperApiRef as p, createRouteRef as r, createSubRouteRef as s, createExternalRouteRef as t, createExtension as v, createExtensionInput as z };
+export type { FeatureFlagConfig as $, AnyRouteRefParams as A, ExtensionInput as B, CreateExtensionOptions as C, ExternalRouteRef as E, FrontendFeature as F, ExtensionDataRef as G, ExtensionDataValue as H, IconElement as I, ConfigurableExtensionDataRef as J, CreateFrontendPluginOptions as L, OverridableFrontendPlugin as M, PluginOptions as N, OverridableExtensionDefinition as O, PluginWrapperApi as P, FrontendPluginInfo as Q, RouteRef as R, SubRouteRef as S, TypesToApiRefs as T, FrontendPluginInfoOptions as U, FrontendModule as W, CreateFrontendModuleOptions as X, Extension as Y, ExtensionAttachTo as Z, ExtensionDataContainer as _, IconComponent as a, ExtensionFactoryMiddleware as a0, CreateExtensionBlueprintOptions as a1, ExtensionBlueprint as a2, ExtensionBlueprintParameters as a3, ExtensionBlueprintParams as a4, ExtensionBlueprintDefineParams as a5, AppNode as b, FrontendPlugin as c, ApiRef as d, ApiHolder as e, ApiFactory as f, AnyApiFactory as g, AppNodeEdges as i, AppNodeInstance as j, AppNodeSpec as k, AppTree as l, AppTreeApi as m, AnyApiRef as n, PluginWrapperDefinition as q, PortableSchema as u, ExtensionDefinition as w, ExtensionDefinitionAttachTo as x, ExtensionDefinitionParameters as y };