@backstage/frontend-plugin-api 0.14.2-next.0 → 0.15.0

package/dist/index.d.ts

@@ -2,9 +2,12 @@ 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_frontend_plugin_api from '@backstage/frontend-plugin-api';
-import { Expand, JsonObject, Observable, JsonValue, ExpandRecursive } from '@backstage/types';
-import { z } from 'zod';
+import { I as IconElement, R as RouteRef, A as AnyRouteRefParams, S as SubRouteRef, E as ExternalRouteRef, F as FrontendFeature, a as IconComponent, b as AppNode, c as FrontendPlugin, d as ApiRef, e as ApiHolder, T as TypesToApiRefs, f as ApiFactory, g as AnyApiFactory } from './types/alpha.d-DzeiOzxk.js';
+export { n as AnyApiRef, i as AppNodeEdges, j as AppNodeInstance, k as AppNodeSpec, l as AppTree, m as AppTreeApi, J as ConfigurableExtensionDataRef, a1 as CreateExtensionBlueprintOptions, C as CreateExtensionOptions, X as CreateFrontendModuleOptions, L as CreateFrontendPluginOptions, Y as Extension, Z as ExtensionAttachTo, a2 as ExtensionBlueprint, a5 as ExtensionBlueprintDefineParams, a3 as ExtensionBlueprintParameters, a4 as ExtensionBlueprintParams, _ as ExtensionDataContainer, G as ExtensionDataRef, H as ExtensionDataValue, w as ExtensionDefinition, x as ExtensionDefinitionAttachTo, y as ExtensionDefinitionParameters, a0 as ExtensionFactoryMiddleware, B as ExtensionInput, $ as FeatureFlagConfig, W as FrontendModule, Q as FrontendPluginInfo, U as FrontendPluginInfoOptions, O as OverridableExtensionDefinition, M as OverridableFrontendPlugin, N as PluginOptions, P as PluginWrapperApi, o as PluginWrapperBlueprint, q as PluginWrapperDefinition, u as PortableSchema, h as appTreeApiRef, v as createExtension, a6 as createExtensionBlueprint, a7 as createExtensionBlueprintParams, D as createExtensionDataRef, z as createExtensionInput, t as createExternalRouteRef, V as createFrontendModule, K as createFrontendPlugin, r as createRouteRef, s as createSubRouteRef, p as pluginWrapperApiRef } from './types/alpha.d-DzeiOzxk.js';
+import { Observable, JsonValue, Expand, ExpandRecursive } from '@backstage/types';
 import { Config } from '@backstage/config';
+import '@backstage/filter-predicates';
+import 'zod/v3';
 
 /**
  * Analytics context envelope.
@@ -39,1433 +42,54 @@ declare const AnalyticsContext: (options: {
     children: ReactNode;
 }) => react_jsx_runtime.JSX.Element;
 
-/**
- * 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
- *
- * Icons should be exactly 24x24 pixels in size.
- *
- * @public
- */
-type IconElement = JSX$1.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 */
-declare const coreExtensionData: {
-    title: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<string, "core.title", {}>;
-    /** An icon element for the extension. Should be exactly 24x24 pixels. */
-    icon: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<IconElement, "core.icon", {}>;
-    reactElement: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<JSX$1.Element, "core.reactElement", {}>;
-    routePath: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<string, "core.routing.path", {}>;
-    routeRef: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<RouteRef<_backstage_frontend_plugin_api.AnyRouteRefParams>, "core.routing.ref", {}>;
-};
-
-/** @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;
-};
-/** @public */
-type ExtensionDataRefToValue<TDataRef extends AnyExtensionDataRef> = TDataRef extends ExtensionDataRef<infer IData, infer IId, any> ? ExtensionDataValue<IData, IId> : never;
-/**
- * @deprecated Use `ExtensionDataRef` without type parameters instead.
- * @public
- */
-type AnyExtensionDataRef = ExtensionDataRef;
-/** @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[];
-}
-/** @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;
-} | Array<{
-    id: string;
-    input: string;
-}>;
-/**
- * @deprecated Use {@link ExtensionAttachTo} instead.
- * @public
- */
-type ExtensionAttachToSpec = ExtensionAttachTo;
-/** @public */
-interface Extension<TConfig, TConfigInput = TConfig> {
-    $$type: '@backstage/Extension';
-    readonly id: string;
-    readonly attachTo: ExtensionAttachToSpec;
-    readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
-}
-/** @ignore */
-type ResolveExtensionId<TExtension extends ExtensionDefinition, TNamespace extends string> = TExtension extends ExtensionDefinition<{
-    kind: infer IKind extends string | undefined;
-    name: infer IName extends string | undefined;
-    params: any;
-}> ? [string] extends [IKind | IName] ? never : (undefined extends IName ? TNamespace : `${TNamespace}/${IName}`) extends infer INamePart extends string ? IKind extends string ? `${IKind}:${INamePart}` : INamePart : never : never;
-
-type CompareChars<A extends string, B extends string> = [A, B] extends [
-    `${infer IAHead}${infer IARest}`,
-    `${infer IBHead}${infer IBRest}`
-] ? IAHead extends IBHead ? IBRest extends '' ? IARest extends '' ? 'eq' : 'gt' : IARest extends '' ? 'lt' : CompareChars<IARest, IBRest> : `0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz` extends `${string}${IAHead}${string}${IBHead}${string}` ? 'lt' : 'gt' : 'eq';
-type CompareStrings<A extends string | undefined, B extends string | undefined> = A extends B ? 'eq' : A extends undefined ? 'lt' : B extends undefined ? 'gt' : CompareChars<A & string, B & string>;
-type CompareExtensions<A extends ExtensionDefinition, B extends ExtensionDefinition> = CompareStrings<A['T']['kind'], B['T']['kind']> extends 'eq' ? CompareStrings<A['T']['name'], B['T']['name']> : CompareStrings<A['T']['kind'], B['T']['kind']>;
-type SortExtensionsInner<TPivot extends ExtensionDefinition, TRest extends readonly ExtensionDefinition[], TLow extends readonly ExtensionDefinition[], THigh extends readonly ExtensionDefinition[]> = TRest extends [
-    infer IHead extends ExtensionDefinition,
-    ...infer IRest extends readonly ExtensionDefinition[]
-] ? CompareExtensions<IHead, TPivot> extends 'lt' ? SortExtensionsInner<TPivot, IRest, [...TLow, IHead], THigh> : SortExtensionsInner<TPivot, IRest, TLow, [...THigh, IHead]> : [low: TLow, high: THigh];
-type SortExtensions<T extends readonly ExtensionDefinition[]> = T extends [
-    infer IPivot extends ExtensionDefinition,
-    ...infer IRest extends readonly ExtensionDefinition[]
-] ? SortExtensionsInner<IPivot, IRest, [], []> extends [
-    low: infer ILow extends readonly ExtensionDefinition[],
-    high: infer IHigh extends readonly ExtensionDefinition[]
-] ? [...SortExtensions<ILow>, IPivot, ...SortExtensions<IHigh>] : 'invalid SortExtensionsInner' : [];
-type UnionToIntersection$1<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type PopUnion$1<U> = UnionToIntersection$1<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;
-}>;
-
-/**
- * React hook for constructing URLs to routes.
- *
- * @remarks
- *
- * See {@link https://backstage.io/docs/plugins/composability#routing-system}
- *
- * @param routeRef - The ref to route that should be converted to URL.
- * @returns A function that will in turn return the concrete URL of the `routeRef`, or `undefined` if the route is not available.
- * @public
- */
-declare function useRouteRef<TParams extends AnyRouteRefParams>(routeRef: RouteRef<TParams> | SubRouteRef<TParams> | ExternalRouteRef<TParams>): RouteFunc<TParams> | undefined;
-
-/**
- * React hook for retrieving dynamic params from the current URL.
- * @param _routeRef - Ref of the current route.
- * @public
- */
-declare function useRouteRefParams<Params extends AnyRouteRefParams>(_routeRef: RouteRef<Params> | SubRouteRef<Params>): Params;
-
-/**
- * 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 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>;
-}
-/** @public */
-interface PluginOptions<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[];
-    info?: FrontendPluginInfoOptions;
-}
-/**
- * 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: PluginOptions<TId, TRoutes, TExternalRoutes, TExtensions>): OverridableFrontendPlugin<TRoutes, TExternalRoutes, MakeSortedExtensionsMap<TExtensions[number], TId>>;
-
-/**
- * Feature flag configuration.
- *
- * @public
- */
-type FeatureFlagConfig = {
-    /** Feature flag name */
-    name: 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 */
-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;
-    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;
-        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;
-        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;
-}>;
-
-/**
- * Convert a single extension input into a matching resolved input.
- * @public
- */
-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.
- * @public
- */
-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;
-    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;
-        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;
-}>;
-
-/** @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}.
- *
- * @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 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>;
-
-/**
- * API reference.
- *
- * @public
- */
-type ApiRef<T> = {
-    id: string;
-    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;
-}>;
-
-/**
- * React hook for retrieving {@link ApiHolder}, an API catalog.
- *
- * @public
- */
-declare function useApiHolder(): ApiHolder;
-/**
- * React hook for retrieving APIs.
- *
- * @param apiRef - Reference of the API to use.
- * @public
- */
-declare function useApi<T>(apiRef: ApiRef<T>): T;
-/**
- * Wrapper for giving component an API context.
- *
- * @param apis - APIs for the context.
- * @public
- */
-declare function withApis<T extends {}>(apis: TypesToApiRefs<T>): <TProps extends T>(WrappedComponent: ComponentType<TProps>) => {
-    (props: PropsWithChildren<Omit<TProps, keyof T>>): react_jsx_runtime.JSX.Element;
-    displayName: string;
+/** @public */
+declare const coreExtensionData: {
+    title: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<string, "core.title", {}>;
+    /** An icon element for the extension. Should be exactly 24x24 pixels. */
+    icon: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<IconElement, "core.icon", {}>;
+    reactElement: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<JSX$1.Element, "core.reactElement", {}>;
+    routePath: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<string, "core.routing.path", {}>;
+    routeRef: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<RouteRef<_backstage_frontend_plugin_api.AnyRouteRefParams>, "core.routing.ref", {}>;
 };
 
 /**
- * API reference configuration - holds an ID of the referenced API.
- *
- * @public
- */
-type ApiRefConfig = {
-    id: string;
-};
-/**
- * Creates a reference to an API. The provided `id` is a stable identifier for
- * the API implementation.
+ * React hook for constructing URLs to routes.
  *
  * @remarks
  *
- * The frontend system infers the owning plugin for an API from the `id`. The
- * recommended pattern is `plugin.<plugin-id>.*` (for example,
- * `plugin.catalog.entity-presentation`). This ensures that other plugins can't
- * mistakenly override your API implementation.
+ * See {@link https://backstage.io/docs/plugins/composability#routing-system}
  *
- * @param config - The descriptor of the API to reference.
- * @returns An API reference.
+ * @param routeRef - The ref to route that should be converted to URL.
+ * @returns A function that will in turn return the concrete URL of the `routeRef`, or `undefined` if the route is not available.
  * @public
  */
-declare function createApiRef<T>(config: ApiRefConfig): ApiRef<T>;
+declare function useRouteRef<TParams extends AnyRouteRefParams>(routeRef: RouteRef<TParams> | SubRouteRef<TParams> | ExternalRouteRef<TParams>): RouteFunc<TParams> | undefined;
 
 /**
- * Used to infer types for a standalone {@link ApiFactory} that isn't immediately passed
- * to another function.
- *
- * @remarks
- *
- * This function doesn't actually do anything, it's only used to infer types.
- *
- * @public
- */
-declare function createApiFactory<Api, Impl extends Api, Deps extends {
-    [name in string]: unknown;
-}>(factory: ApiFactory<Api, Impl, Deps>): ApiFactory<Api, Impl, Deps>;
-/**
- * Used to infer types for a standalone {@link ApiFactory} that isn't immediately passed
- * to another function.
- *
- * @param api - Ref of the API that will be produced by the factory.
- * @param instance - Implementation of the API to use.
+ * React hook for retrieving dynamic params from the current URL.
+ * @param _routeRef - Ref of the current route.
  * @public
  */
-declare function createApiFactory<Api, Impl extends Api>(api: ApiRef<Api>, instance: Impl): ApiFactory<Api, Impl, {}>;
+declare function useRouteRefParams<Params extends AnyRouteRefParams>(_routeRef: RouteRef<Params> | SubRouteRef<Params>): Params;
+
+/** @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;
 
 /**
  * This file contains declarations for common interfaces of auth-related APIs.
@@ -1475,7 +99,10 @@ declare function createApiFactory<Api, Impl extends Api>(api: ApiRef<Api>, insta
  * For example, a Google OAuth provider that supports OAuth 2 and OpenID Connect,
  * would be declared as follows:
  *
- * const googleAuthApiRef = createApiRef<OAuthApi & OpenIDConnectApi>({ ... })
+ * const googleAuthApiRef = createApiRef<OAuthApi & OpenIDConnectApi>().with({
+ *   id: 'core.auth.google',
+ *   pluginId: 'app',
+ * })
  */
 /**
  * Information about the auth provider.
@@ -1498,8 +125,13 @@ type AuthProviderInfo = {
     title: string;
     /**
      * Icon for the auth provider.
+     *
+     * @remarks
+     *
+     * Accepts either an `IconElement` (e.g. `<MyIcon />`) or an `IconComponent`
+     * (e.g. `MyIcon`). Prefer passing `IconElement`.
      */
-    icon: IconComponent;
+    icon: IconComponent | IconElement;
     /**
      * Optional user friendly messaage to display for the auth provider.
      */
@@ -1743,7 +375,9 @@ type SessionApi = {
  * Note that the ID token payload is only guaranteed to contain the user's numerical Google ID,
  * email and expiration information. Do not rely on any other fields, as they might not be present.
  */
-declare const googleAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const googleAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.google"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards GitHub APIs.
  *
@@ -1753,7 +387,9 @@ declare const googleAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfo
  * See {@link https://developer.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/}
  * for a full list of supported scopes.
  */
-declare const githubAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const githubAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.github"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards Okta APIs.
  *
@@ -1763,7 +399,9 @@ declare const githubAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIden
  * See {@link https://developer.okta.com/docs/guides/implement-oauth-for-okta/scopes/}
  * for a full list of supported scopes.
  */
-declare const oktaAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const oktaAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.okta"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards GitLab APIs.
  *
@@ -1773,7 +411,9 @@ declare const oktaAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoAp
  * See {@link https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#limiting-scopes-of-a-personal-access-token}
  * for a full list of supported scopes.
  */
-declare const gitlabAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const gitlabAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.gitlab"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards Microsoft APIs and identities.
  *
@@ -1784,13 +424,17 @@ declare const gitlabAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfo
  * - {@link https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-permissions-and-consent}
  * - {@link https://docs.microsoft.com/en-us/graph/permissions-reference}
  */
-declare const microsoftAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const microsoftAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.microsoft"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards OneLogin APIs.
  *
  * @public
  */
-declare const oneloginAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const oneloginAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.onelogin"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards Bitbucket APIs.
  *
@@ -1800,7 +444,9 @@ declare const oneloginAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileIn
  * See {@link https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/}
  * for a full list of supported scopes.
  */
-declare const bitbucketAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const bitbucketAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.bitbucket"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards Bitbucket Server APIs.
  *
@@ -1810,7 +456,9 @@ declare const bitbucketAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageI
  * See {@link https://confluence.atlassian.com/bitbucketserver/bitbucket-oauth-2-0-provider-api-1108483661.html#BitbucketOAuth2.0providerAPI-scopes}
  * for a full list of supported scopes.
  */
-declare const bitbucketServerAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const bitbucketServerAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.bitbucket-server"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards Atlassian APIs.
  *
@@ -1820,7 +468,9 @@ declare const bitbucketServerAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & Back
  * See {@link https://developer.atlassian.com/cloud/jira/platform/scopes-for-connect-and-oauth-2-3LO-apps/}
  * for a full list of supported scopes.
  */
-declare const atlassianAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const atlassianAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.atlassian"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards VMware Cloud APIs and identities.
  *
@@ -1830,7 +480,9 @@ declare const atlassianAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageI
  * For more info about VMware Cloud identity and access management:
  * - {@link https://docs.vmware.com/en/VMware-Cloud-services/services/Using-VMware-Cloud-Services/GUID-53D39337-D93A-4B84-BD18-DDF43C21479A.html}
  */
-declare const vmwareCloudAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const vmwareCloudAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.vmware-cloud"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 /**
  * Provides authentication towards OpenShift APIs and identities.
  *
@@ -1842,12 +494,22 @@ declare const vmwareCloudAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & Profil
  * {@link https://docs.redhat.com/en/documentation/openshift_container_platform/latest/html-single/authentication_and_authorization/index#tokens-scoping-about_configuring-internal-oauth}
  * for available scopes.
  */
-declare const openshiftAuthApiRef: ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+declare const openshiftAuthApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthApi & ProfileInfoApi & BackstageIdentityApi & SessionApi, "core.auth.openshift"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Message handled by the {@link AlertApi}.
  *
  * @public
+ * @deprecated Use {@link ToastApiMessage} from {@link ToastApi} instead. AlertApi will be removed in a future release.
+ *
+ * Migration guide:
+ * - `message` becomes `title`
+ * - `severity: 'error'` becomes `status: 'danger'`
+ * - `severity: 'success' | 'info' | 'warning'` becomes `status: 'success' | 'info' | 'warning'`
+ * - `display: 'transient'` becomes `timeout: 5000` (or custom milliseconds)
+ * - `display: 'permanent'` means omitting `timeout`
  */
 type AlertMessage = {
     message: string;
@@ -1858,6 +520,23 @@ type AlertMessage = {
  * The alert API is used to report alerts to the app, and display them to the user.
  *
  * @public
+ * @deprecated Use {@link ToastApi} instead. AlertApi will be removed in a future release.
+ *
+ * ToastApi provides richer notification features including:
+ * - Title and optional description
+ * - Action links
+ * - Custom icons
+ * - Per-toast timeout control
+ * - Programmatic dismiss via returned key
+ *
+ * @example
+ * ```typescript
+ * // Before (AlertApi)
+ * alertApi.post({ message: 'Saved!', severity: 'success', display: 'transient' });
+ *
+ * // After (ToastApi)
+ * toastApi.post({ title: 'Saved!', status: 'success', timeout: 5000 });
+ * ```
  */
 type AlertApi = {
     /**
@@ -1873,8 +552,11 @@ type AlertApi = {
  * The {@link ApiRef} of {@link AlertApi}.
  *
  * @public
+ * @deprecated Use {@link toastApiRef} instead. AlertApi will be removed in a future release.
  */
-declare const alertApiRef: ApiRef<AlertApi>;
+declare const alertApiRef: _backstage_frontend_plugin_api.ApiRef<AlertApi, "core.alert"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /** @public */
 type AppLanguageApi = {
@@ -1892,7 +574,9 @@ type AppLanguageApi = {
 /**
  * @public
  */
-declare const appLanguageApiRef: ApiRef<AppLanguageApi>;
+declare const appLanguageApiRef: _backstage_frontend_plugin_api.ApiRef<AppLanguageApi, "core.applanguage"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Describes a theme provided by the app.
@@ -1951,7 +635,9 @@ type AppThemeApi = {
  *
  * @public
  */
-declare const appThemeApiRef: ApiRef<AppThemeApi>;
+declare const appThemeApiRef: _backstage_frontend_plugin_api.ApiRef<AppThemeApi, "core.apptheme"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /** @public */
 interface ExtensionBoundaryProps {
@@ -2048,12 +734,17 @@ declare const ErrorDisplay: {
  * Tab configuration for page navigation
  * @public
  */
-interface PageTab {
+interface PageLayoutTab {
     id: string;
     label: string;
     icon?: IconElement;
     href: string;
 }
+/**
+ * @deprecated Use {@link PageLayoutTab} instead
+ * @public
+ */
+type PageTab = PageLayoutTab;
 /**
  * Props for the PageLayout component
  * @public
@@ -2063,7 +754,7 @@ interface PageLayoutProps {
     icon?: IconElement;
     noHeader?: boolean;
     headerActions?: Array<JSX.Element | null>;
-    tabs?: PageTab[];
+    tabs?: PageLayoutTab[];
     children?: ReactNode;
 }
 /**
@@ -2091,7 +782,9 @@ interface SwappableComponentsApi {
  *
  * @public
  */
-declare const swappableComponentsApiRef: _backstage_frontend_plugin_api.ApiRef<SwappableComponentsApi>;
+declare const swappableComponentsApiRef: _backstage_frontend_plugin_api.ApiRef<SwappableComponentsApi, "core.swappable-components"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * The Config API is used to provide a mechanism to access the
@@ -2105,7 +798,9 @@ type ConfigApi = Config;
  *
  * @public
  */
-declare const configApiRef: ApiRef<ConfigApi>;
+declare const configApiRef: _backstage_frontend_plugin_api.ApiRef<Config, "core.config"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * The discovery API is used to provide a mechanism for plugins to
@@ -2141,7 +836,9 @@ type DiscoveryApi = {
  *
  * @public
  */
-declare const discoveryApiRef: ApiRef<DiscoveryApi>;
+declare const discoveryApiRef: _backstage_frontend_plugin_api.ApiRef<DiscoveryApi, "core.discovery"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Mirrors the JavaScript Error class, for the purpose of
@@ -2208,7 +905,9 @@ type ErrorApi = {
  *
  * @public
  */
-declare const errorApiRef: ApiRef<ErrorApi>;
+declare const errorApiRef: _backstage_frontend_plugin_api.ApiRef<ErrorApi, "core.error"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Feature flag descriptor.
@@ -2302,7 +1001,9 @@ interface FeatureFlagsApi {
  *
  * @public
  */
-declare const featureFlagsApiRef: ApiRef<FeatureFlagsApi>;
+declare const featureFlagsApiRef: _backstage_frontend_plugin_api.ApiRef<FeatureFlagsApi, "core.featureflags"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * A wrapper for the fetch API, that has additional behaviors such as the
@@ -2333,7 +1034,9 @@ type FetchApi = {
  *
  * @public
  */
-declare const fetchApiRef: ApiRef<FetchApi>;
+declare const fetchApiRef: _backstage_frontend_plugin_api.ApiRef<FetchApi, "core.fetch"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * API for accessing app icons.
@@ -2356,7 +1059,9 @@ interface IconsApi {
  *
  * @public
  */
-declare const iconsApiRef: _backstage_frontend_plugin_api.ApiRef<IconsApi>;
+declare const iconsApiRef: _backstage_frontend_plugin_api.ApiRef<IconsApi, "core.icons"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * The Identity API used to identify and get information about the signed in user.
@@ -2391,7 +1096,9 @@ type IdentityApi = {
  *
  * @public
  */
-declare const identityApiRef: ApiRef<IdentityApi>;
+declare const identityApiRef: _backstage_frontend_plugin_api.ApiRef<IdentityApi, "core.identity"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * A handle for an open dialog that can be used to interact with it.
@@ -2414,7 +1121,7 @@ interface DialogApiDialog<TResult = void> {
     /**
      * Replaces the content of the dialog with the provided element or component, causing it to be rerenedered.
      */
-    update(elementOrComponent: React.JSX.Element | ((props: {
+    update(elementOrComponent: JSX.Element | ((props: {
         dialog: DialogApiDialog<TResult>;
     }) => JSX.Element)): void;
     /**
@@ -2535,7 +1242,9 @@ interface DialogApi {
  *
  * @public
  */
-declare const dialogApiRef: _backstage_frontend_plugin_api.ApiRef<DialogApi>;
+declare const dialogApiRef: _backstage_frontend_plugin_api.ApiRef<DialogApi, "core.dialog"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Describes how to handle auth requests. Both how to show them to the user, and what to do when
@@ -2633,7 +1342,9 @@ type OAuthRequestApi = {
  *
  * @public
  */
-declare const oauthRequestApiRef: ApiRef<OAuthRequestApi>;
+declare const oauthRequestApiRef: _backstage_frontend_plugin_api.ApiRef<OAuthRequestApi, "core.oauthrequest"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * TS magic for handling route parameters.
@@ -2666,7 +1377,9 @@ interface RouteResolutionApi {
  *
  * @public
  */
-declare const routeResolutionApiRef: _backstage_frontend_plugin_api.ApiRef<RouteResolutionApi>;
+declare const routeResolutionApiRef: _backstage_frontend_plugin_api.ApiRef<RouteResolutionApi, "core.route-resolution"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * A snapshot in time of the current known value of a storage key.
@@ -2746,7 +1459,9 @@ interface StorageApi {
  *
  * @public
  */
-declare const storageApiRef: ApiRef<StorageApi>;
+declare const storageApiRef: _backstage_frontend_plugin_api.ApiRef<StorageApi, "core.storage"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Represents an event worth tracking in an analytics system that could inform
@@ -2869,7 +1584,207 @@ type AnalyticsApi = {
  *
  * @public
  */
-declare const analyticsApiRef: ApiRef<AnalyticsApi>;
+declare const analyticsApiRef: _backstage_frontend_plugin_api.ApiRef<AnalyticsApi, "core.analytics"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
+
+/**
+ * React hook for retrieving {@link ApiHolder}, an API catalog.
+ *
+ * @public
+ */
+declare function useApiHolder(): ApiHolder;
+/**
+ * React hook for retrieving APIs.
+ *
+ * @param apiRef - Reference of the API to use.
+ * @public
+ */
+declare function useApi<T>(apiRef: ApiRef<T>): T;
+/**
+ * Wrapper for giving component an API context.
+ *
+ * @param apis - APIs for the context.
+ * @deprecated Use `withApis` from `@backstage/core-compat-api` instead.
+ * @public
+ */
+declare function withApis<T extends {}>(apis: TypesToApiRefs<T>): <TProps extends T>(WrappedComponent: ComponentType<TProps>) => {
+    (props: PropsWithChildren<Omit<TProps, keyof T>>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * API reference configuration - holds an ID of the referenced API.
+ *
+ * @public
+ */
+type ApiRefConfig = {
+    id: string;
+};
+/**
+ * Creates a reference to an API.
+ *
+ * @remarks
+ *
+ * The `id` is a stable identifier for the API implementation. The frontend
+ * system infers the owning plugin for an API from the `id`. When using the
+ * builder form, you can instead provide a `pluginId` explicitly. The
+ * recommended pattern is `plugin.<plugin-id>.*` (for example,
+ * `plugin.catalog.entity-presentation`). This ensures that other plugins can't
+ * mistakenly override your API implementation.
+ *
+ * The recommended way to create an API reference is:
+ *
+ * ```ts
+ * const myApiRef = createApiRef<MyApi>().with({
+ *   id: 'my-api',
+ *   pluginId: 'my-plugin',
+ * });
+ * ```
+ *
+ * The legacy way to create an API reference is:
+ *
+ * ```ts
+ * const myApiRef = createApiRef<MyApi>({ id: 'plugin.my.api' });
+ * ```
+ *
+ * @public
+ */
+/**
+ * Creates a reference to an API.
+ *
+ * @deprecated Use `createApiRef<T>().with(...)` instead.
+ * @public
+ */
+declare function createApiRef<T>(config: ApiRefConfig): ApiRef<T> & {
+    readonly $$type: '@backstage/ApiRef';
+};
+/**
+ * Creates a reference to an API.
+ *
+ * @remarks
+ *
+ * Returns a builder with a `.with()` method for providing the API reference
+ * configuration.
+ *
+ * @public
+ */
+declare function createApiRef<T>(): {
+    with<const TId extends string>(config: ApiRefConfig & {
+        id: TId;
+        pluginId?: string;
+    }): ApiRef<T, TId> & {
+        readonly $$type: '@backstage/ApiRef';
+    };
+};
+
+/**
+ * Used to infer types for a standalone {@link ApiFactory} that isn't immediately passed
+ * to another function.
+ *
+ * @remarks
+ *
+ * This function doesn't actually do anything, it's only used to infer types.
+ *
+ * @public
+ */
+declare function createApiFactory<Api, Impl extends Api, Deps extends {
+    [name in string]: unknown;
+}>(factory: ApiFactory<Api, Impl, Deps>): ApiFactory<Api, Impl, Deps>;
+/**
+ * Used to infer types for a standalone {@link ApiFactory} that isn't immediately passed
+ * to another function.
+ *
+ * @param api - Ref of the API that will be produced by the factory.
+ * @param instance - Implementation of the API to use.
+ * @public
+ */
+declare function createApiFactory<Api, Impl extends Api>(api: ApiRef<Api>, instance: Impl): ApiFactory<Api, Impl, {}>;
+
+/**
+ * Link item for toast notifications.
+ *
+ * @public
+ */
+type ToastApiMessageLink = {
+    /** Display text for the link */
+    label: string;
+    /** URL the link points to */
+    href: string;
+};
+/**
+ * Message handled by the {@link ToastApi}.
+ *
+ * @public
+ */
+type ToastApiMessage = {
+    /** Title of the toast (required) */
+    title: ReactNode;
+    /** Optional description text */
+    description?: ReactNode;
+    /** Status variant of the toast - defaults to 'success' */
+    status?: 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+    /** Optional array of links to display */
+    links?: ToastApiMessageLink[];
+    /** Timeout in milliseconds before auto-dismiss. If not set, toast is permanent. */
+    timeout?: number;
+};
+/**
+ * Handle returned by {@link ToastApi.post} that allows programmatic control
+ * of the posted toast.
+ *
+ * @public
+ */
+type ToastApiPostResult = {
+    /** Dismiss the toast. */
+    close(): void;
+};
+/**
+ * The toast API is used to display toast notifications to the user.
+ *
+ * @remarks
+ * This API provides richer notification capabilities than the AlertApi,
+ * including title/description, links, and per-toast timeout control.
+ *
+ * @example
+ * ```tsx
+ * const toastApi = useApi(toastApiRef);
+ *
+ * // Full-featured toast
+ * toastApi.post({
+ *   title: 'Entity saved',
+ *   description: 'Your changes have been saved successfully.',
+ *   status: 'success',
+ *   timeout: 5000,
+ *   links: [{ label: 'View entity', href: '/catalog/default/component/my-service' }],
+ * });
+ *
+ * // Simple toast
+ * toastApi.post({ title: 'Processing...', status: 'info' });
+ *
+ * // Programmatic dismiss
+ * const { close } = toastApi.post({ title: 'Uploading...', status: 'info' });
+ * // Later...
+ * close();
+ * ```
+ *
+ * @public
+ */
+type ToastApi = {
+    /**
+     * Post a toast notification for display to the user.
+     *
+     * @param toast - The toast message to display
+     * @returns A handle with a `close()` method to programmatically dismiss the toast
+     */
+    post(toast: ToastApiMessage): ToastApiPostResult;
+};
+/**
+ * The {@link ApiRef} of {@link ToastApi}.
+ *
+ * @public
+ */
+declare const toastApiRef: ApiRef<ToastApi>;
 
 /** @public */
 interface TranslationRef<TId extends string = string, TMessages extends {
@@ -3248,7 +2163,9 @@ type TranslationApi = {
 /**
  * @public
  */
-declare const translationApiRef: ApiRef<TranslationApi>;
+declare const translationApiRef: _backstage_frontend_plugin_api.ApiRef<TranslationApi, "core.translation"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * API for retrieving plugin-scoped header actions.
@@ -3272,7 +2189,9 @@ type PluginHeaderActionsApi = {
  *
  * @public
  */
-declare const pluginHeaderActionsApiRef: _backstage_frontend_plugin_api.ApiRef<PluginHeaderActionsApi>;
+declare const pluginHeaderActionsApiRef: _backstage_frontend_plugin_api.ApiRef<PluginHeaderActionsApi, "core.plugin-header-actions"> & {
+    readonly $$type: "@backstage/ApiRef";
+};
 
 /**
  * Gets a pre-configured analytics tracker.
@@ -3281,7 +2200,10 @@ declare const pluginHeaderActionsApiRef: _backstage_frontend_plugin_api.ApiRef<P
  */
 declare function useAnalytics(): AnalyticsTracker;
 
-/** @public */
+/**
+ * @public
+ * @deprecated Use `AnalyticsImplementationFactory` from `@backstage/plugin-app-react` instead.
+ */
 type AnalyticsImplementationFactory<Deps extends {
     [name in string]: unknown;
 } = {}> = {
@@ -3292,6 +2214,7 @@ type AnalyticsImplementationFactory<Deps extends {
  * Creates analytics implementations.
  *
  * @public
+ * @deprecated Use `AnalyticsImplementationBlueprint` from `@backstage/plugin-app-react` instead.
  */
 declare const AnalyticsImplementationBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "analytics";
@@ -3344,6 +2267,10 @@ declare const AppRootElementBlueprint: _backstage_frontend_plugin_api.ExtensionB
  * Creates extensions that make up the items of the nav bar.
  *
  * @public
+ * @deprecated Nav items are now automatically inferred from `PageBlueprint`
+ * extensions based on their `title` and `icon` params. You can remove your
+ * `NavItemBlueprint` usage and instead pass `title` and `icon` directly to
+ * the `PageBlueprint`.
  */
 declare const NavItemBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "nav-item";
@@ -3377,10 +2304,6 @@ declare const NavItemBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprin
 declare const PageBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "page";
     params: {
-        /**
-         * @deprecated Use the `path` param instead.
-         */
-        defaultPath?: [Error: `Use the 'path' param instead`];
         path: string;
         title?: string;
         icon?: IconElement;
@@ -3511,5 +2434,5 @@ declare const PluginHeaderActionBlueprint: _backstage_frontend_plugin_api.Extens
     dataRefs: never;
 }>;
 
-export { AnalyticsContext, AnalyticsImplementationBlueprint, ApiBlueprint, AppRootElementBlueprint, ErrorDisplay, ExtensionBoundary, FeatureFlagState, NavItemBlueprint, NotFoundErrorPage, PageBlueprint, PageLayout, PluginHeaderActionBlueprint, Progress, SessionState, SubPageBlueprint, alertApiRef, analyticsApiRef, appLanguageApiRef, appThemeApiRef, appTreeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, coreExtensionData, createApiFactory, createApiRef, createExtension, createExtensionBlueprint, createExtensionBlueprintParams, createExtensionDataRef, createExtensionInput, createExternalRouteRef, createFrontendFeatureLoader, createFrontendModule, createFrontendPlugin, createRouteRef, createSubRouteRef, createSwappableComponent, createTranslationMessages, createTranslationRef, createTranslationResource, dialogApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, iconsApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, openshiftAuthApiRef, pluginHeaderActionsApiRef, routeResolutionApiRef, storageApiRef, swappableComponentsApiRef, translationApiRef, useAnalytics, useApi, useApiHolder, useAppNode, useRouteRef, useRouteRefParams, useTranslationRef, vmwareCloudAuthApiRef, withApis };
-export type { AlertApi, AlertMessage, AnalyticsApi, AnalyticsContextValue, AnalyticsEvent, AnalyticsEventAttributes, AnalyticsImplementation, AnalyticsImplementationFactory, AnalyticsTracker, AnyApiFactory, AnyApiRef, AnyExtensionDataRef, AnyRouteRefParams, ApiFactory, ApiHolder, ApiRef, ApiRefConfig, AppLanguageApi, AppNode, AppNodeEdges, AppNodeInstance, AppNodeSpec, AppTheme, AppThemeApi, AppTree, AppTreeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, ConfigurableExtensionDataRef, CreateExtensionBlueprintOptions, CreateExtensionOptions, CreateFrontendFeatureLoaderOptions, CreateFrontendModuleOptions, CreateSwappableComponentOptions, DialogApi, DialogApiDialog, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, ErrorDisplayProps, Extension, ExtensionAttachTo, ExtensionAttachToSpec, ExtensionBlueprint, ExtensionBlueprintDefineParams, ExtensionBlueprintParameters, ExtensionBlueprintParams, ExtensionBoundaryProps, ExtensionDataContainer, ExtensionDataRef, ExtensionDataRefToValue, ExtensionDataValue, ExtensionDefinition, ExtensionDefinitionAttachTo, ExtensionDefinitionParameters, ExtensionFactoryMiddleware, ExtensionInput, ExternalRouteRef, FeatureFlag, FeatureFlagConfig, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, FrontendFeature, FrontendFeatureLoader, FrontendModule, FrontendPlugin, FrontendPluginInfo, FrontendPluginInfoOptions, IconComponent, IconElement, IconsApi, IdentityApi, NotFoundErrorPageProps, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, OverridableExtensionDefinition, OverridableFrontendPlugin, PageLayoutProps, PageTab, PendingOAuthRequest, PluginHeaderActionsApi, PluginOptions, PortableSchema, ProfileInfo, ProfileInfoApi, ProgressProps, ResolvedExtensionInput, ResolvedExtensionInputs, RouteFunc, RouteRef, RouteResolutionApi, SessionApi, StorageApi, StorageValueSnapshot, SubRouteRef, SwappableComponentRef, SwappableComponentsApi, TranslationApi, TranslationFunction, TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, TranslationSnapshot, TypesToApiRefs };
+export { AnalyticsContext, AnalyticsImplementationBlueprint, AnyApiFactory, AnyRouteRefParams, ApiBlueprint, ApiFactory, ApiHolder, ApiRef, AppNode, AppRootElementBlueprint, ErrorDisplay, ExtensionBoundary, ExternalRouteRef, FeatureFlagState, FrontendFeature, FrontendPlugin, IconComponent, IconElement, NavItemBlueprint, NotFoundErrorPage, PageBlueprint, PageLayout, PluginHeaderActionBlueprint, Progress, RouteRef, SessionState, SubPageBlueprint, SubRouteRef, TypesToApiRefs, alertApiRef, analyticsApiRef, appLanguageApiRef, appThemeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, coreExtensionData, createApiFactory, createApiRef, createFrontendFeatureLoader, createSwappableComponent, createTranslationMessages, createTranslationRef, createTranslationResource, dialogApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, iconsApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, openshiftAuthApiRef, pluginHeaderActionsApiRef, routeResolutionApiRef, storageApiRef, swappableComponentsApiRef, toastApiRef, translationApiRef, useAnalytics, useApi, useApiHolder, useAppNode, useRouteRef, useRouteRefParams, useTranslationRef, vmwareCloudAuthApiRef, withApis };
+export type { AlertApi, AlertMessage, AnalyticsApi, AnalyticsContextValue, AnalyticsEvent, AnalyticsEventAttributes, AnalyticsImplementation, AnalyticsImplementationFactory, AnalyticsTracker, ApiRefConfig, AppLanguageApi, AppTheme, AppThemeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, CreateFrontendFeatureLoaderOptions, CreateSwappableComponentOptions, DialogApi, DialogApiDialog, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, ErrorDisplayProps, ExtensionBoundaryProps, FeatureFlag, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, FrontendFeatureLoader, IconsApi, IdentityApi, NotFoundErrorPageProps, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, PageLayoutProps, PageLayoutTab, PageTab, PendingOAuthRequest, PluginHeaderActionsApi, ProfileInfo, ProfileInfoApi, ProgressProps, RouteFunc, RouteResolutionApi, SessionApi, StorageApi, StorageValueSnapshot, SwappableComponentRef, SwappableComponentsApi, ToastApi, ToastApiMessage, ToastApiMessageLink, ToastApiPostResult, TranslationApi, TranslationFunction, TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, TranslationSnapshot };