@backstage/frontend-plugin-api 0.13.1 → 0.13.2-next.1

package/dist/index.d.ts

@@ -1,15 +1,11 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode, JSX as JSX$1, ComponentType } from 'react';
-import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
-import { ApiHolder, ConfigApi, ApiRef, TypesToApiRefs, ApiFactory, AnyApiFactory, IconComponent as IconComponent$2, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
-export { AlertApi, AlertMessage, AnyApiFactory, AnyApiRef, ApiFactory, ApiHolder, ApiRef, ApiRefConfig, AppTheme, AppThemeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, FeatureFlag, FeatureFlagState, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, IdentityApi, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, PendingOAuthRequest, ProfileInfo, ProfileInfoApi, SessionApi, SessionState, StorageApi, StorageValueSnapshot, TypesToApiRefs, alertApiRef, appThemeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, createApiFactory, createApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, openshiftAuthApiRef, storageApiRef, useApi, useApiHolder, vmwareCloudAuthApiRef, withApis } from '@backstage/core-plugin-api';
-import { Expand, JsonObject } from '@backstage/types';
-import { z } from 'zod';
+import { ReactNode, JSX as JSX$1, ComponentType, PropsWithChildren } from 'react';
 import * as _backstage_frontend_plugin_api from '@backstage/frontend-plugin-api';
 import { IconComponent as IconComponent$1, RouteRef as RouteRef$1 } from '@backstage/frontend-plugin-api';
-import { TranslationResource, TranslationMessages } from '@backstage/core-plugin-api/alpha';
-export { TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, createTranslationMessages, createTranslationRef, createTranslationResource, useTranslationRef } from '@backstage/core-plugin-api/alpha';
+import { Expand, JsonObject, Observable, JsonValue, ExpandRecursive } from '@backstage/types';
+import { z } from 'zod';
+import { Config } from '@backstage/config';
 
 /**
  * Analytics context envelope.
@@ -44,46 +40,6 @@ declare const AnalyticsContext: (options: {
     children: ReactNode;
 }) => react_jsx_runtime.JSX.Element;
 
-/** @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>;
-};
-
 /**
  * Catch-all type for route params.
  *
@@ -124,10 +80,50 @@ declare function createRouteRef<TParams extends {
 
 /** @public */
 declare const coreExtensionData: {
-    title: ConfigurableExtensionDataRef<string, "core.title", {}>;
-    reactElement: ConfigurableExtensionDataRef<JSX$1.Element, "core.reactElement", {}>;
-    routePath: ConfigurableExtensionDataRef<string, "core.routing.path", {}>;
-    routeRef: ConfigurableExtensionDataRef<RouteRef<_backstage_frontend_plugin_api.AnyRouteRefParams>, "core.routing.ref", {}>;
+    title: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<string, "core.title", {}>;
+    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 */
@@ -290,8 +286,8 @@ type SortExtensions<T extends readonly ExtensionDefinition[]> = T extends [
     low: infer ILow extends readonly ExtensionDefinition[],
     high: infer IHigh extends readonly ExtensionDefinition[]
 ] ? [...SortExtensions<ILow>, IPivot, ...SortExtensions<IHigh>] : 'invalid SortExtensionsInner' : [];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type PopUnion$1<U> = UnionToIntersection<U extends any ? () => U : never> extends () => infer R ? [next: R, rest: Exclude<U, R>] : undefined;
+type 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
@@ -774,9 +770,9 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
      */
     makeWithOverrides<TName extends string | undefined, TExtensionConfigSchema extends {
         [key in string]: (zImpl: typeof z) => z.ZodType;
-    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, TExtraInputs extends {
+    }, UFactoryOutput extends ExtensionDataValue<any, any>, UNewOutput extends ExtensionDataRef, UParentInputs extends ExtensionDataRef, TExtraInputs extends {
         [inputName in string]: ExtensionInput;
-    }, UParentInputs extends ExtensionDataRef>(args: {
+    } = {}>(args: {
         name?: TName;
         attachTo?: ExtensionDefinitionAttachTo<UParentInputs> & VerifyExtensionAttachTo<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UParentInputs>;
         disabled?: boolean;
@@ -801,14 +797,14 @@ interface ExtensionBlueprint<T extends ExtensionBlueprintParameters = ExtensionB
             inputs: Expand<ResolvedExtensionInputs<T['inputs'] & TExtraInputs>>;
         }): Iterable<UFactoryOutput> & VerifyExtensionFactoryOutput<ExtensionDataRef extends UNewOutput ? NonNullable<T['output']> : UNewOutput, UFactoryOutput>;
     }): OverridableExtensionDefinition<{
-        config: (string extends keyof TExtensionConfigSchema ? {} : {
+        config: Expand<(string extends keyof TExtensionConfigSchema ? {} : {
             [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
-        }) & T['config'];
-        configInput: (string extends keyof TExtensionConfigSchema ? {} : z.input<z.ZodObject<{
+        }) & T['config']>;
+        configInput: Expand<(string extends keyof TExtensionConfigSchema ? {} : z.input<z.ZodObject<{
             [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
-        }>>) & T['configInput'];
+        }>>) & T['configInput']>;
         output: ExtensionDataRef extends UNewOutput ? T['output'] : UNewOutput;
-        inputs: T['inputs'] & TExtraInputs;
+        inputs: Expand<T['inputs'] & TExtraInputs>;
         kind: T['kind'];
         name: string | undefined extends TName ? undefined : TName;
         params: T['params'];
@@ -1240,112 +1236,123 @@ interface AppTreeApi {
  *
  * @public
  */
-declare const appTreeApiRef: _backstage_core_plugin_api.ApiRef<AppTreeApi>;
-
-/** @public */
-interface ExtensionBoundaryProps {
-    node: AppNode;
-    children: ReactNode;
-}
-/** @public */
-declare function ExtensionBoundary(props: ExtensionBoundaryProps): react_jsx_runtime.JSX.Element;
-/** @public */
-declare namespace ExtensionBoundary {
-    function lazy(appNode: AppNode, loader: () => Promise<JSX.Element>): JSX.Element;
-    function lazyComponent<TProps extends {}>(appNode: AppNode, loader: () => Promise<(props: TProps) => JSX.Element>): (props: TProps) => JSX.Element;
-}
+declare const appTreeApiRef: _backstage_frontend_plugin_api.ApiRef<AppTreeApi>;
 
-/** @public */
-type SwappableComponentRef<TInnerComponentProps extends {} = {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
-    id: string;
-    TProps: TInnerComponentProps;
-    TExternalProps: TExternalComponentProps;
-    $$type: '@backstage/SwappableComponentRef';
-};
 /**
- * Options for creating an SwappableComponent.
+ * API reference.
  *
  * @public
  */
-type CreateSwappableComponentOptions<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
+type ApiRef<T> = {
     id: string;
-    loader?: (() => (props: TInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: TInnerComponentProps) => JSX.Element | null>);
-    transformProps?: (props: TExternalComponentProps) => TInnerComponentProps;
+    T: T;
 };
 /**
- * Creates a SwappableComponent that can be used to render the component, optionally overridden by the app.
+ * Catch-all {@link ApiRef} type.
  *
  * @public
  */
-declare function createSwappableComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(options: CreateSwappableComponentOptions<TInnerComponentProps, TExternalComponentProps>): {
-    (props: TExternalComponentProps): JSX.Element | null;
-    ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>;
-};
-
+type AnyApiRef = ApiRef<unknown>;
 /**
- * React hook providing access to the current {@link AppNode}.
+ * Wraps a type with API properties into a type holding their respective {@link ApiRef}s.
  *
  * @public
- * @remarks
- *
- * This hook will return the {@link AppNode} for the closest extension. This
- * relies on the extension using the {@link (ExtensionBoundary:function)} component in its
- * implementation, which is included by default for all common blueprints.
+ */
+type TypesToApiRefs<T> = {
+    [key in keyof T]: ApiRef<T[key]>;
+};
+/**
+ * Provides lookup of APIs through their {@link ApiRef}s.
  *
- * If the current component is not inside an {@link (ExtensionBoundary:function)}, it will
- * return `undefined`.
+ * @public
  */
-declare function useAppNode(): AppNode | undefined;
-
-/** @public */
-type ProgressProps = {};
-/** @public */
-type NotFoundErrorPageProps = {
-    children?: ReactNode;
+type ApiHolder = {
+    get<T>(api: ApiRef<T>): T | undefined;
 };
-/** @public */
-type ErrorDisplayProps = {
-    plugin?: FrontendPlugin;
-    error: Error;
-    resetError: () => void;
+/**
+ * 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 const Progress: {
-    (props: ProgressProps): JSX.Element | null;
-    ref: SwappableComponentRef<ProgressProps, ProgressProps>;
-};
+declare function useApiHolder(): ApiHolder;
 /**
+ * React hook for retrieving APIs.
+ *
+ * @param apiRef - Reference of the API to use.
  * @public
  */
-declare const NotFoundErrorPage: {
-    (props: NotFoundErrorPageProps): JSX.Element | null;
-    ref: SwappableComponentRef<NotFoundErrorPageProps, NotFoundErrorPageProps>;
+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;
 };
+
 /**
+ * API reference configuration - holds an ID of the referenced API.
+ *
  * @public
  */
-declare const ErrorDisplay: {
-    (props: ErrorDisplayProps): JSX.Element | null;
-    ref: SwappableComponentRef<ErrorDisplayProps, ErrorDisplayProps>;
+type ApiRefConfig = {
+    id: string;
 };
+/**
+ * Creates a reference to an API.
+ *
+ * @param config - The descriptor of the API to reference.
+ * @returns An API reference.
+ * @public
+ */
+declare function createApiRef<T>(config: ApiRefConfig): ApiRef<T>;
 
 /**
- * API for looking up components based on component refs.
+ * 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
  */
-interface SwappableComponentsApi {
-    getComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>): (props: TInnerComponentProps) => JSX.Element | null;
-}
+declare function createApiFactory<Api, Impl extends Api, Deps extends {
+    [name in string]: unknown;
+}>(factory: ApiFactory<Api, Impl, Deps>): ApiFactory<Api, Impl, Deps>;
 /**
- * The `ApiRef` of {@link SwappableComponentsApi}.
+ * 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 const swappableComponentsApiRef: _backstage_core_plugin_api.ApiRef<SwappableComponentsApi>;
+declare function createApiFactory<Api, Impl extends Api>(api: ApiRef<Api>, instance: Impl): ApiFactory<Api, Impl, {}>;
 
 /**
  * IconComponent is the common icon type used throughout Backstage when
@@ -1368,87 +1375,956 @@ type IconComponent = ComponentType<{
 }>;
 
 /**
- * API for accessing app icons.
+ * This file contains declarations for common interfaces of auth-related APIs.
+ * The declarations should be used to signal which type of authentication and
+ * authorization methods each separate auth provider supports.
  *
- * @public
+ * For example, a Google OAuth provider that supports OAuth 2 and OpenID Connect,
+ * would be declared as follows:
+ *
+ * const googleAuthApiRef = createApiRef<OAuthApi & OpenIDConnectApi>({ ... })
  */
-interface IconsApi {
-    getIcon(key: string): IconComponent | undefined;
-    listIconKeys(): string[];
-}
 /**
- * The `ApiRef` of {@link IconsApi}.
+ * Information about the auth provider.
+ *
+ * @remarks
+ *
+ * This information is used both to connect the correct auth provider in the backend, as
+ * well as displaying the provider to the user.
  *
  * @public
  */
-declare const iconsApiRef: _backstage_core_plugin_api.ApiRef<IconsApi>;
-
+type AuthProviderInfo = {
+    /**
+     * The ID of the auth provider. This should match with ID of the provider in the `@backstage/auth-backend`.
+     */
+    id: string;
+    /**
+     * Title for the auth provider, for example "GitHub"
+     */
+    title: string;
+    /**
+     * Icon for the auth provider.
+     */
+    icon: IconComponent;
+    /**
+     * Optional user friendly messaage to display for the auth provider.
+     */
+    message?: string;
+};
 /**
- * A handle for an open dialog that can be used to interact with it.
+ * An array of scopes, or a scope string formatted according to the
+ * auth provider, which is typically a space separated list.
  *
  * @remarks
  *
- * Dialogs can be opened using either {@link DialogApi.show} or {@link DialogApi.showModal}.
+ * See the documentation for each auth provider for the list of scopes
+ * supported by each provider.
  *
  * @public
  */
-interface DialogApiDialog<TResult = void> {
+type OAuthScope = string | string[];
+/**
+ * Configuration of an authentication request.
+ *
+ * @public
+ */
+type AuthRequestOptions = {
     /**
-     * Closes the dialog with that provided result.
+     * If this is set to true, the user will not be prompted to log in,
+     * and an empty response will be returned if there is no existing session.
      *
-     * @remarks
+     * This can be used to perform a check whether the user is logged in, or if you don't
+     * want to force a user to be logged in, but provide functionality if they already are.
      *
-     * If the dialog is a modal dialog a result must always be provided. If it's a regular dialog then passing a result is optional.
-     */
-    close(...args: undefined extends TResult ? [result?: TResult] : [result: TResult]): void;
-    /**
-     * Replaces the content of the dialog with the provided element or component, causing it to be rerenedered.
+     * @defaultValue false
      */
-    update(elementOrComponent: React.JSX.Element | ((props: {
-        dialog: DialogApiDialog<TResult>;
-    }) => JSX.Element)): void;
+    optional?: boolean;
     /**
-     * Wait until the dialog is closed and return the result.
+     * If this is set to true, the request will bypass the regular oauth login modal
+     * and open the login popup directly.
      *
-     * @remarks
+     * The method must be called synchronously from a user action for this to work in all browsers.
      *
-     * If the dialog is a modal dialog a result will always be returned. If it's a regular dialog then the result may be `undefined`.
+     * @defaultValue false
      */
-    result(): Promise<TResult>;
-}
+    instantPopup?: boolean;
+};
 /**
- * A Utility API for showing dialogs that render in the React tree and return a result.
+ * This API provides access to OAuth 2 credentials. It lets you request access tokens,
+ * which can be used to act on behalf of the user when talking to APIs.
  *
  * @public
  */
-interface DialogApi {
+type OAuthApi = {
     /**
-     * Opens a modal dialog and returns a handle to it.
+     * Requests an OAuth 2 Access Token, optionally with a set of scopes. The access token allows
+     * you to make requests on behalf of the user, and the copes may grant you broader access, depending
+     * on the auth provider.
      *
-     * @remarks
+     * Each auth provider has separate handling of scope, so you need to look at the documentation
+     * for each one to know what scope you need to request.
      *
-     * This dialog can be closed by calling the `close` method on the returned handle, optionally providing a result.
-     * The dialog can also be closed by the user by clicking the backdrop or pressing the escape key.
+     * This method is cheap and should be called each time an access token is used. Do not for example
+     * store the access token in React component state, as that could cause the token to expire. Instead
+     * fetch a new access token for each request.
      *
-     * If the dialog is closed without a result, the result will be `undefined`.
+     * Be sure to include all required scopes when requesting an access token. When testing your implementation
+     * it is best to log out the Backstage session and then visit your plugin page directly, as
+     * you might already have some required scopes in your existing session. Not requesting the correct
+     * scopes can lead to 403 or other authorization errors, which can be tricky to debug.
      *
-     * @example
+     * If the user has not yet granted access to the provider and the set of requested scopes, the user
+     * will be prompted to log in. The returned promise will not resolve until the user has
+     * successfully logged in. The returned promise can be rejected, but only if the user rejects the login request.
+     */
+    getAccessToken(scope?: OAuthScope, options?: AuthRequestOptions): Promise<string>;
+};
+/**
+ * This API provides access to OpenID Connect credentials. It lets you request ID tokens,
+ * which can be passed to backend services to prove the user's identity.
+ *
+ * @public
+ */
+type OpenIdConnectApi = {
+    /**
+     * Requests an OpenID Connect ID Token.
      *
-     * ### Example with inline dialog content
-     * ```tsx
-     * const dialog = dialogApi.show<boolean>(
-     *   <DialogContent>
-     *     <DialogTitle>Are you sure?</DialogTitle>
-     *     <DialogActions>
-     *       <Button onClick={() => dialog.close(true)}>Yes</Button>
-     *       <Button onClick={() => dialog.close(false)}>No</Button>
-     *     </DialogActions>
-     *   </DialogContent>
-     * );
-     * const result = await dialog.result();
-     * ```
+     * This method is cheap and should be called each time an ID token is used. Do not for example
+     * store the id token in React component state, as that could cause the token to expire. Instead
+     * fetch a new id token for each request.
      *
-     * @example
+     * If the user has not yet logged in to Google inside Backstage, the user will be prompted
+     * to log in. The returned promise will not resolve until the user has successfully logged in.
+     * The returned promise can be rejected, but only if the user rejects the login request.
+     */
+    getIdToken(options?: AuthRequestOptions): Promise<string>;
+};
+/**
+ * This API provides access to profile information of the user from an auth provider.
+ *
+ * @public
+ */
+type ProfileInfoApi = {
+    /**
+     * Get profile information for the user as supplied by this auth provider.
+     *
+     * If the optional flag is not set, a session is guaranteed to be returned, while if
+     * the optional flag is set, the session may be undefined. See {@link AuthRequestOptions} for more details.
+     */
+    getProfile(options?: AuthRequestOptions): Promise<ProfileInfo | undefined>;
+};
+/**
+ * This API provides access to the user's identity within Backstage.
+ *
+ * @remarks
+ *
+ * An auth provider that implements this interface can be used to sign-in to backstage. It is
+ * not intended to be used directly from a plugin, but instead serves as a connection between
+ * this authentication method and the app's {@link IdentityApi}
+ *
+ * @public
+ */
+type BackstageIdentityApi = {
+    /**
+     * Get the user's identity within Backstage. This should normally not be called directly,
+     * use the {@link IdentityApi} instead.
+     *
+     * If the optional flag is not set, a session is guaranteed to be returned, while if
+     * the optional flag is set, the session may be undefined. See {@link AuthRequestOptions} for more details.
+     */
+    getBackstageIdentity(options?: AuthRequestOptions): Promise<BackstageIdentityResponse | undefined>;
+};
+/**
+ * User identity information within Backstage.
+ *
+ * @public
+ */
+type BackstageUserIdentity = {
+    /**
+     * The type of identity that this structure represents. In the frontend app
+     * this will currently always be 'user'.
+     */
+    type: 'user';
+    /**
+     * The entityRef of the user in the catalog.
+     * For example User:default/sandra
+     */
+    userEntityRef: string;
+    /**
+     * The user and group entities that the user claims ownership through
+     */
+    ownershipEntityRefs: string[];
+};
+/**
+ * Token and Identity response, with the users claims in the Identity.
+ *
+ * @public
+ */
+type BackstageIdentityResponse = {
+    /**
+     * The token used to authenticate the user within Backstage.
+     */
+    token: string;
+    /**
+     * The time at which the token expires. If not set, it can be assumed that the token does not expire.
+     */
+    expiresAt?: Date;
+    /**
+     * Identity information derived from the token.
+     */
+    identity: BackstageUserIdentity;
+};
+/**
+ * Profile information of the user.
+ *
+ * @public
+ */
+type ProfileInfo = {
+    /**
+     * Email ID.
+     */
+    email?: string;
+    /**
+     * Display name that can be presented to the user.
+     */
+    displayName?: string;
+    /**
+     * URL to an avatar image of the user.
+     */
+    picture?: string;
+};
+/**
+ * Session state values passed to subscribers of the SessionApi.
+ *
+ * @public
+ */
+declare const SessionState: {
+    /**
+     * User signed in.
+     */
+    readonly SignedIn: "SignedIn";
+    /**
+     * User not signed in.
+     */
+    readonly SignedOut: "SignedOut";
+};
+/**
+ * @public
+ */
+type SessionState = (typeof SessionState)[keyof typeof SessionState];
+/**
+ * @public
+ */
+declare namespace SessionState {
+    type SignedIn = typeof SessionState.SignedIn;
+    type SignedOut = typeof SessionState.SignedOut;
+}
+/**
+ * The SessionApi provides basic controls for any auth provider that is tied to a persistent session.
+ *
+ * @public
+ */
+type SessionApi = {
+    /**
+     * Sign in with a minimum set of permissions.
+     */
+    signIn(): Promise<void>;
+    /**
+     * Sign out from the current session. This will reload the page.
+     */
+    signOut(): Promise<void>;
+    /**
+     * Observe the current state of the auth session. Emits the current state on subscription.
+     */
+    sessionState$(): Observable<SessionState>;
+};
+/**
+ * Provides authentication towards Google APIs and identities.
+ *
+ * @public
+ * @remarks
+ *
+ * See {@link https://developers.google.com/identity/protocols/googlescopes} for a full list of supported scopes.
+ *
+ * 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>;
+/**
+ * Provides authentication towards GitHub APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards Okta APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards GitLab APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards Microsoft APIs and identities.
+ *
+ * @public
+ * @remarks
+ *
+ * For more info and a full list of supported scopes, see:
+ * - {@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>;
+/**
+ * Provides authentication towards OneLogin APIs.
+ *
+ * @public
+ */
+declare const oneloginAuthApiRef: ApiRef<OAuthApi & OpenIdConnectApi & ProfileInfoApi & BackstageIdentityApi & SessionApi>;
+/**
+ * Provides authentication towards Bitbucket APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards Bitbucket Server APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards Atlassian APIs.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards VMware Cloud APIs and identities.
+ *
+ * @public
+ * @remarks
+ *
+ * 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>;
+/**
+ * Provides authentication towards OpenShift APIs and identities.
+ *
+ * @public
+ * @remarks
+ *
+ * See {@link https://docs.redhat.com/en/documentation/openshift_container_platform/latest/html/authentication_and_authorization/configuring-oauth-clients}
+ * on how to configure the OAuth clients and
+ * {@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>;
+
+/**
+ * Message handled by the {@link AlertApi}.
+ *
+ * @public
+ */
+type AlertMessage = {
+    message: string;
+    severity?: 'success' | 'info' | 'warning' | 'error';
+    display?: 'permanent' | 'transient';
+};
+/**
+ * The alert API is used to report alerts to the app, and display them to the user.
+ *
+ * @public
+ */
+type AlertApi = {
+    /**
+     * Post an alert for handling by the application.
+     */
+    post(alert: AlertMessage): void;
+    /**
+     * Observe alerts posted by other parts of the application.
+     */
+    alert$(): Observable<AlertMessage>;
+};
+/**
+ * The {@link ApiRef} of {@link AlertApi}.
+ *
+ * @public
+ */
+declare const alertApiRef: ApiRef<AlertApi>;
+
+/** @public */
+type AppLanguageApi = {
+    getAvailableLanguages(): {
+        languages: string[];
+    };
+    setLanguage(language?: string): void;
+    getLanguage(): {
+        language: string;
+    };
+    language$(): Observable<{
+        language: string;
+    }>;
+};
+/**
+ * @public
+ */
+declare const appLanguageApiRef: ApiRef<AppLanguageApi>;
+
+/**
+ * Describes a theme provided by the app.
+ *
+ * @public
+ */
+type AppTheme = {
+    /**
+     * ID used to remember theme selections.
+     */
+    id: string;
+    /**
+     * Title of the theme
+     */
+    title: string;
+    /**
+     * Theme variant
+     */
+    variant: 'light' | 'dark';
+    /**
+     * An Icon for the theme mode setting.
+     */
+    icon?: React.ReactElement;
+    Provider(props: {
+        children: ReactNode;
+    }): JSX.Element | null;
+};
+/**
+ * The AppThemeApi gives access to the current app theme, and allows switching
+ * to other options that have been registered as a part of the App.
+ *
+ * @public
+ */
+type AppThemeApi = {
+    /**
+     * Get a list of available themes.
+     */
+    getInstalledThemes(): AppTheme[];
+    /**
+     * Observe the currently selected theme. A value of undefined means no specific theme has been selected.
+     */
+    activeThemeId$(): Observable<string | undefined>;
+    /**
+     * Get the current theme ID. Returns undefined if no specific theme is selected.
+     */
+    getActiveThemeId(): string | undefined;
+    /**
+     * Set a specific theme to use in the app, overriding the default theme selection.
+     *
+     * Clear the selection by passing in undefined.
+     */
+    setActiveThemeId(themeId?: string): void;
+};
+/**
+ * The {@link ApiRef} of {@link AppThemeApi}.
+ *
+ * @public
+ */
+declare const appThemeApiRef: ApiRef<AppThemeApi>;
+
+/** @public */
+interface ExtensionBoundaryProps {
+    errorPresentation?: 'error-api' | 'error-display';
+    node: AppNode;
+    children: ReactNode;
+}
+/** @public */
+declare function ExtensionBoundary(props: ExtensionBoundaryProps): react_jsx_runtime.JSX.Element;
+/** @public */
+declare namespace ExtensionBoundary {
+    function lazy(appNode: AppNode, loader: () => Promise<JSX.Element>): JSX.Element;
+    function lazyComponent<TProps extends {}>(appNode: AppNode, loader: () => Promise<(props: TProps) => JSX.Element>): (props: TProps) => JSX.Element;
+}
+
+/** @public */
+type SwappableComponentRef<TInnerComponentProps extends {} = {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
+    id: string;
+    TProps: TInnerComponentProps;
+    TExternalProps: TExternalComponentProps;
+    $$type: '@backstage/SwappableComponentRef';
+};
+/**
+ * Options for creating an SwappableComponent.
+ *
+ * @public
+ */
+type CreateSwappableComponentOptions<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps> = {
+    id: string;
+    loader?: (() => (props: TInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: TInnerComponentProps) => JSX.Element | null>);
+    transformProps?: (props: TExternalComponentProps) => TInnerComponentProps;
+};
+/**
+ * Creates a SwappableComponent that can be used to render the component, optionally overridden by the app.
+ *
+ * @public
+ */
+declare function createSwappableComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(options: CreateSwappableComponentOptions<TInnerComponentProps, TExternalComponentProps>): {
+    (props: TExternalComponentProps): JSX.Element | null;
+    ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>;
+};
+
+/**
+ * React hook providing access to the current {@link AppNode}.
+ *
+ * @public
+ * @remarks
+ *
+ * This hook will return the {@link AppNode} for the closest extension. This
+ * relies on the extension using the {@link (ExtensionBoundary:function)} component in its
+ * implementation, which is included by default for all common blueprints.
+ *
+ * If the current component is not inside an {@link (ExtensionBoundary:function)}, it will
+ * return `undefined`.
+ */
+declare function useAppNode(): AppNode | undefined;
+
+/** @public */
+type ProgressProps = {};
+/** @public */
+type NotFoundErrorPageProps = {
+    children?: ReactNode;
+};
+/** @public */
+type ErrorDisplayProps = {
+    plugin?: FrontendPlugin;
+    error: Error;
+    resetError: () => void;
+};
+
+/**
+ * @public
+ */
+declare const Progress: {
+    (props: ProgressProps): JSX.Element | null;
+    ref: _backstage_frontend_plugin_api.SwappableComponentRef<ProgressProps, ProgressProps>;
+};
+/**
+ * @public
+ */
+declare const NotFoundErrorPage: {
+    (props: NotFoundErrorPageProps): JSX.Element | null;
+    ref: _backstage_frontend_plugin_api.SwappableComponentRef<NotFoundErrorPageProps, NotFoundErrorPageProps>;
+};
+/**
+ * @public
+ */
+declare const ErrorDisplay: {
+    (props: ErrorDisplayProps): JSX.Element | null;
+    ref: _backstage_frontend_plugin_api.SwappableComponentRef<ErrorDisplayProps, ErrorDisplayProps>;
+};
+
+/**
+ * API for looking up components based on component refs.
+ *
+ * @public
+ */
+interface SwappableComponentsApi {
+    getComponent<TInnerComponentProps extends {}, TExternalComponentProps extends {} = TInnerComponentProps>(ref: SwappableComponentRef<TInnerComponentProps, TExternalComponentProps>): (props: TInnerComponentProps) => JSX.Element | null;
+}
+/**
+ * The `ApiRef` of {@link SwappableComponentsApi}.
+ *
+ * @public
+ */
+declare const swappableComponentsApiRef: _backstage_frontend_plugin_api.ApiRef<SwappableComponentsApi>;
+
+/**
+ * The Config API is used to provide a mechanism to access the
+ * runtime configuration of the system.
+ *
+ * @public
+ */
+type ConfigApi = Config;
+/**
+ * The {@link ApiRef} of {@link ConfigApi}.
+ *
+ * @public
+ */
+declare const configApiRef: ApiRef<ConfigApi>;
+
+/**
+ * The discovery API is used to provide a mechanism for plugins to
+ * discover the endpoint to use to talk to their backend counterpart.
+ *
+ * @remarks
+ *
+ * The purpose of the discovery API is to allow for many different deployment
+ * setups and routing methods through a central configuration, instead
+ * of letting each individual plugin manage that configuration.
+ *
+ * Implementations of the discovery API can be a simple as a URL pattern
+ * using the pluginId, but could also have overrides for individual plugins,
+ * or query a separate discovery service.
+ *
+ * @public
+ */
+type DiscoveryApi = {
+    /**
+     * Returns the HTTP base backend URL for a given plugin, without a trailing slash.
+     *
+     * This method must always be called just before making a request, as opposed to
+     * fetching the URL when constructing an API client. That is to ensure that more
+     * flexible routing patterns can be supported.
+     *
+     * For example, asking for the URL for `auth` may return something
+     * like `https://backstage.example.com/api/auth`
+     */
+    getBaseUrl(pluginId: string): Promise<string>;
+};
+/**
+ * The {@link ApiRef} of {@link DiscoveryApi}.
+ *
+ * @public
+ */
+declare const discoveryApiRef: ApiRef<DiscoveryApi>;
+
+/**
+ * Mirrors the JavaScript Error class, for the purpose of
+ * providing documentation and optional fields.
+ *
+ * @public
+ */
+type ErrorApiError = {
+    name: string;
+    message: string;
+    stack?: string;
+};
+/**
+ * Provides additional information about an error that was posted to the application.
+ *
+ * @public
+ */
+type ErrorApiErrorContext = {
+    /**
+     * If set to true, this error should not be displayed to the user.
+     *
+     * Hidden errors are typically not displayed in the UI, but the ErrorApi
+     * implementation may still report them to error tracking services
+     * or other utilities that care about all errors.
+     *
+     * @defaultValue false
+     */
+    hidden?: boolean;
+};
+/**
+ * The error API is used to report errors to the app, and display them to the user.
+ *
+ * @remarks
+ *
+ * Plugins can use this API as a method of displaying errors to the user, but also
+ * to report errors for collection by error reporting services.
+ *
+ * If an error can be displayed inline, e.g. as feedback in a form, that should be
+ * preferred over relying on this API to display the error. The main use of this API
+ * for displaying errors should be for asynchronous errors, such as a failing background process.
+ *
+ * Even if an error is displayed inline, it should still be reported through this API
+ * if it would be useful to collect or log it for debugging purposes, but with
+ * the hidden flag set. For example, an error arising from form field validation
+ * should probably not be reported, while a failed REST call would be useful to report.
+ *
+ * @public
+ */
+type ErrorApi = {
+    /**
+     * Post an error for handling by the application.
+     */
+    post(error: ErrorApiError, context?: ErrorApiErrorContext): void;
+    /**
+     * Observe errors posted by other parts of the application.
+     */
+    error$(): Observable<{
+        error: ErrorApiError;
+        context?: ErrorApiErrorContext;
+    }>;
+};
+/**
+ * The {@link ApiRef} of {@link ErrorApi}.
+ *
+ * @public
+ */
+declare const errorApiRef: ApiRef<ErrorApi>;
+
+/**
+ * Feature flag descriptor.
+ *
+ * @public
+ */
+type FeatureFlag = {
+    name: string;
+    pluginId: string;
+    description?: string;
+};
+/**
+ * Enum representing the state of a feature flag (inactive/active).
+ *
+ * @public
+ */
+declare const FeatureFlagState: {
+    /**
+     * Feature flag inactive (disabled).
+     */
+    readonly None: 0;
+    /**
+     * Feature flag active (enabled).
+     */
+    readonly Active: 1;
+};
+/**
+ * @public
+ */
+type FeatureFlagState = (typeof FeatureFlagState)[keyof typeof FeatureFlagState];
+/**
+ * @public
+ */
+declare namespace FeatureFlagState {
+    type None = typeof FeatureFlagState.None;
+    type Active = typeof FeatureFlagState.Active;
+}
+/**
+ * Options to use when saving feature flags.
+ *
+ * @public
+ */
+type FeatureFlagsSaveOptions = {
+    /**
+     * The new feature flag states to save.
+     */
+    states: Record<string, FeatureFlagState>;
+    /**
+     * Whether the saves states should be merged into the existing ones, or replace them.
+     *
+     * Defaults to false.
+     */
+    merge?: boolean;
+};
+/**
+ * The feature flags API is used to toggle functionality to users across plugins and Backstage.
+ *
+ * @remarks
+ *
+ * Plugins can use this API to register feature flags that they have available
+ * for users to enable/disable, and this API will centralize the current user's
+ * state of which feature flags they would like to enable.
+ *
+ * This is ideal for Backstage plugins, as well as your own App, to trial incomplete
+ * or unstable upcoming features. Although there will be a common interface for users
+ * to enable and disable feature flags, this API acts as another way to enable/disable.
+ *
+ * @public
+ */
+interface FeatureFlagsApi {
+    /**
+     * Registers a new feature flag. Once a feature flag has been registered it
+     * can be toggled by users, and read back to enable or disable features.
+     */
+    registerFlag(flag: FeatureFlag): void;
+    /**
+     * Get a list of all registered flags.
+     */
+    getRegisteredFlags(): FeatureFlag[];
+    /**
+     * Whether the feature flag with the given name is currently activated for the user.
+     */
+    isActive(name: string): boolean;
+    /**
+     * Save the user's choice of feature flag states.
+     */
+    save(options: FeatureFlagsSaveOptions): void;
+}
+/**
+ * The {@link ApiRef} of {@link FeatureFlagsApi}.
+ *
+ * @public
+ */
+declare const featureFlagsApiRef: ApiRef<FeatureFlagsApi>;
+
+/**
+ * A wrapper for the fetch API, that has additional behaviors such as the
+ * ability to automatically inject auth information where necessary.
+ *
+ * @public
+ */
+type FetchApi = {
+    /**
+     * The `fetch` implementation.
+     */
+    fetch: typeof fetch;
+};
+/**
+ * The {@link ApiRef} of {@link FetchApi}.
+ *
+ * @remarks
+ *
+ * This is a wrapper for the fetch API, that has additional behaviors such as
+ * the ability to automatically inject auth information where necessary.
+ *
+ * Note that the default behavior of this API (unless overridden by your org),
+ * is to require that the user is already signed in so that it has auth
+ * information to inject. Therefore, using the default implementation of this
+ * utility API e.g. on the `SignInPage` or similar, would cause issues. In
+ * special circumstances like those, you can use the regular system `fetch`
+ * instead.
+ *
+ * @public
+ */
+declare const fetchApiRef: ApiRef<FetchApi>;
+
+/**
+ * API for accessing app icons.
+ *
+ * @public
+ */
+interface IconsApi {
+    getIcon(key: string): IconComponent | undefined;
+    listIconKeys(): string[];
+}
+/**
+ * The `ApiRef` of {@link IconsApi}.
+ *
+ * @public
+ */
+declare const iconsApiRef: _backstage_frontend_plugin_api.ApiRef<IconsApi>;
+
+/**
+ * The Identity API used to identify and get information about the signed in user.
+ *
+ * @public
+ */
+type IdentityApi = {
+    /**
+     * The profile of the signed in user.
+     */
+    getProfileInfo(): Promise<ProfileInfo>;
+    /**
+     * User identity information within Backstage.
+     */
+    getBackstageIdentity(): Promise<BackstageUserIdentity>;
+    /**
+     * Provides credentials in the form of a token which proves the identity of the signed in user.
+     *
+     * The token will be undefined if the signed in user does not have a verified
+     * identity, such as a demo user or mocked user for e2e tests.
+     */
+    getCredentials(): Promise<{
+        token?: string;
+    }>;
+    /**
+     * Sign out the current user
+     */
+    signOut(): Promise<void>;
+};
+/**
+ * The {@link ApiRef} of {@link IdentityApi}.
+ *
+ * @public
+ */
+declare const identityApiRef: ApiRef<IdentityApi>;
+
+/**
+ * A handle for an open dialog that can be used to interact with it.
+ *
+ * @remarks
+ *
+ * Dialogs can be opened using either {@link DialogApi.show} or {@link DialogApi.showModal}.
+ *
+ * @public
+ */
+interface DialogApiDialog<TResult = void> {
+    /**
+     * Closes the dialog with that provided result.
+     *
+     * @remarks
+     *
+     * If the dialog is a modal dialog a result must always be provided. If it's a regular dialog then passing a result is optional.
+     */
+    close(...args: undefined extends TResult ? [result?: TResult] : [result: 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: {
+        dialog: DialogApiDialog<TResult>;
+    }) => JSX.Element)): void;
+    /**
+     * Wait until the dialog is closed and return the result.
+     *
+     * @remarks
+     *
+     * If the dialog is a modal dialog a result will always be returned. If it's a regular dialog then the result may be `undefined`.
+     */
+    result(): Promise<TResult>;
+}
+/**
+ * A Utility API for showing dialogs that render in the React tree and return a result.
+ *
+ * @public
+ */
+interface DialogApi {
+    /**
+     * Opens a modal dialog and returns a handle to it.
+     *
+     * @remarks
+     *
+     * This dialog can be closed by calling the `close` method on the returned handle, optionally providing a result.
+     * The dialog can also be closed by the user by clicking the backdrop or pressing the escape key.
+     *
+     * If the dialog is closed without a result, the result will be `undefined`.
+     *
+     * @example
+     *
+     * ### Example with inline dialog content
+     * ```tsx
+     * const dialog = dialogApi.show<boolean>(
+     *   <DialogContent>
+     *     <DialogTitle>Are you sure?</DialogTitle>
+     *     <DialogActions>
+     *       <Button onClick={() => dialog.close(true)}>Yes</Button>
+     *       <Button onClick={() => dialog.close(false)}>No</Button>
+     *     </DialogActions>
+     *   </DialogContent>
+     * );
+     * const result = await dialog.result();
+     * ```
+     *
+     * @example
      *
      * ### Example with separate dialog component
      * ```tsx
@@ -1495,37 +2371,135 @@ interface DialogApi {
      * const result = await dialog.result();
      * ```
      *
-     * @example
+     * @example
+     *
+     * ### Example with separate dialog component
+     * ```tsx
+     * function CustomDialog({ dialog }: { dialog: DialogApiDialog<boolean> }) {
+     *   return (
+     *     <DialogContent>
+     *       <DialogTitle>Are you sure?</DialogTitle>
+     *       <DialogActions>
+     *         <Button onClick={() => dialog.close(true)}>Yes</Button>
+     *         <Button onClick={() => dialog.close(false)}>No</Button>
+     *       </DialogActions>
+     *     </DialogContent>
+     *   )
+     * }
+     * const result = await dialogApi.showModal(CustomDialog).result();
+     * ```
+     *
+     * @param elementOrComponent - The element or component to render in the dialog. If a component is provided, it will be provided with a `dialog` prop that contains the dialog handle.
+     * @public
+     */
+    showModal<TResult = void>(elementOrComponent: JSX.Element | ((props: {
+        dialog: DialogApiDialog<TResult>;
+    }) => JSX.Element)): DialogApiDialog<TResult>;
+}
+/**
+ * The `ApiRef` of {@link DialogApi}.
+ *
+ * @public
+ */
+declare const dialogApiRef: _backstage_frontend_plugin_api.ApiRef<DialogApi>;
+
+/**
+ * Describes how to handle auth requests. Both how to show them to the user, and what to do when
+ * the user accesses the auth request.
+ *
+ * @public
+ */
+type OAuthRequesterOptions<TOAuthResponse> = {
+    /**
+     * Information about the auth provider, which will be forwarded to auth requests.
+     */
+    provider: AuthProviderInfo;
+    /**
+     * Implementation of the auth flow, which will be called synchronously when
+     * trigger() is called on an auth requests.
+     */
+    onAuthRequest(scopes: Set<string>): Promise<TOAuthResponse>;
+};
+/**
+ * Function used to trigger new auth requests for a set of scopes.
+ *
+ * @remarks
+ *
+ * The returned promise will resolve to the same value returned by the onAuthRequest in the
+ * {@link OAuthRequesterOptions}. Or rejected, if the request is rejected.
+ *
+ * This function can be called multiple times before the promise resolves. All calls
+ * will be merged into one request, and the scopes forwarded to the onAuthRequest will be the
+ * union of all requested scopes.
+ *
+ * @public
+ */
+type OAuthRequester<TAuthResponse> = (scopes: Set<string>) => Promise<TAuthResponse>;
+/**
+ * An pending auth request for a single auth provider. The request will remain in this pending
+ * state until either reject() or trigger() is called.
+ *
+ * @remarks
+ *
+ * Any new requests for the same provider are merged into the existing pending request, meaning
+ * there will only ever be a single pending request for a given provider.
+ *
+ * @public
+ */
+type PendingOAuthRequest = {
+    /**
+     * Information about the auth provider, as given in the AuthRequesterOptions
+     */
+    provider: AuthProviderInfo;
+    /**
+     * Rejects the request, causing all pending AuthRequester calls to fail with "RejectedError".
+     */
+    reject(): void;
+    /**
+     * Trigger the auth request to continue the auth flow, by for example showing a popup.
+     *
+     * Synchronously calls onAuthRequest with all scope currently in the request.
+     */
+    trigger(): Promise<void>;
+};
+/**
+ * Provides helpers for implemented OAuth login flows within Backstage.
+ *
+ * @public
+ */
+type OAuthRequestApi = {
+    /**
+     * A utility for showing login popups or similar things, and merging together multiple requests for
+     * different scopes into one request that includes all scopes.
+     *
+     * The passed in options provide information about the login provider, and how to handle auth requests.
+     *
+     * The returned AuthRequester function is used to request login with new scopes. These requests
+     * are merged together and forwarded to the auth handler, as soon as a consumer of auth requests
+     * triggers an auth flow.
+     *
+     * See AuthRequesterOptions, AuthRequester, and handleAuthRequests for more info.
+     */
+    createAuthRequester<OAuthResponse>(options: OAuthRequesterOptions<OAuthResponse>): OAuthRequester<OAuthResponse>;
+    /**
+     * Observers pending auth requests. The returned observable will emit all
+     * current active auth request, at most one for each created auth requester.
      *
-     * ### Example with separate dialog component
-     * ```tsx
-     * function CustomDialog({ dialog }: { dialog: DialogApiDialog<boolean> }) {
-     *   return (
-     *     <DialogContent>
-     *       <DialogTitle>Are you sure?</DialogTitle>
-     *       <DialogActions>
-     *         <Button onClick={() => dialog.close(true)}>Yes</Button>
-     *         <Button onClick={() => dialog.close(false)}>No</Button>
-     *       </DialogActions>
-     *     </DialogContent>
-     *   )
-     * }
-     * const result = await dialogApi.showModal(CustomDialog).result();
-     * ```
+     * Each request has its own info about the login provider, forwarded from the auth requester options.
      *
-     * @param elementOrComponent - The element or component to render in the dialog. If a component is provided, it will be provided with a `dialog` prop that contains the dialog handle.
-     * @public
+     * Depending on user interaction, the request should either be rejected, or used to trigger the auth handler.
+     * If the request is rejected, all pending AuthRequester calls will fail with a "RejectedError".
+     * If a auth is triggered, and the auth handler resolves successfully, then all currently pending
+     * AuthRequester calls will resolve to the value returned by the onAuthRequest call.
      */
-    showModal<TResult = void>(elementOrComponent: JSX.Element | ((props: {
-        dialog: DialogApiDialog<TResult>;
-    }) => JSX.Element)): DialogApiDialog<TResult>;
-}
+    authRequest$(): Observable<PendingOAuthRequest[]>;
+};
 /**
- * The `ApiRef` of {@link DialogApi}.
+ * The {@link ApiRef} of {@link OAuthRequestApi}.
  *
  * @public
  */
-declare const dialogApiRef: _backstage_core_plugin_api.ApiRef<DialogApi>;
+declare const oauthRequestApiRef: ApiRef<OAuthRequestApi>;
 
 /**
  * TS magic for handling route parameters.
@@ -1558,7 +2532,87 @@ interface RouteResolutionApi {
  *
  * @public
  */
-declare const routeResolutionApiRef: _backstage_core_plugin_api.ApiRef<RouteResolutionApi>;
+declare const routeResolutionApiRef: _backstage_frontend_plugin_api.ApiRef<RouteResolutionApi>;
+
+/**
+ * A snapshot in time of the current known value of a storage key.
+ *
+ * @public
+ */
+type StorageValueSnapshot<TValue extends JsonValue> = {
+    key: string;
+    presence: 'unknown' | 'absent';
+    value?: undefined;
+} | {
+    key: string;
+    presence: 'present';
+    value: TValue;
+};
+/**
+ * Provides a key-value persistence API.
+ *
+ * @public
+ */
+interface StorageApi {
+    /**
+     * Create a bucket to store data in.
+     *
+     * @param name - Namespace for the storage to be stored under,
+     *               will inherit previous namespaces too
+     */
+    forBucket(name: string): StorageApi;
+    /**
+     * Remove persistent data.
+     *
+     * @param key - Unique key associated with the data.
+     */
+    remove(key: string): Promise<void>;
+    /**
+     * Save persistent data, and emit messages to anyone that is using
+     * {@link StorageApi.observe$} for this key.
+     *
+     * @param key - Unique key associated with the data.
+     * @param data - The data to be stored under the key.
+     */
+    set<T extends JsonValue>(key: string, data: T): Promise<void>;
+    /**
+     * Observe the value over time for a particular key in the current bucket.
+     *
+     * @remarks
+     *
+     * The observable will only emit values when the value changes in the underlying
+     * storage, although multiple values with the same shape may be emitted in a row.
+     *
+     * If a {@link StorageApi.snapshot} of a key is retrieved and the presence is
+     * `'unknown'`, then you are guaranteed to receive a snapshot with a known
+     * presence, as long as you observe the key within the same tick.
+     *
+     * Since the emitted values are shared across all subscribers, it is important
+     * not to mutate the returned values. The values may be frozen as a precaution.
+     *
+     * @param key - Unique key associated with the data
+     */
+    observe$<T extends JsonValue>(key: string): Observable<StorageValueSnapshot<T>>;
+    /**
+     * Returns an immediate snapshot value for the given key, if possible.
+     *
+     * @remarks
+     *
+     * Combine with {@link StorageApi.observe$} to get notified of value changes.
+     *
+     * Note that this method is synchronous, and some underlying storages may be
+     * unable to retrieve a value using this method - the result may or may not
+     * consistently have a presence of 'unknown'. Use {@link StorageApi.observe$}
+     * to be sure to receive an actual value eventually.
+     */
+    snapshot<T extends JsonValue>(key: string): StorageValueSnapshot<T>;
+}
+/**
+ * The {@link ApiRef} of {@link StorageApi}.
+ *
+ * @public
+ */
+declare const storageApiRef: ApiRef<StorageApi>;
 
 /**
  * Represents an event worth tracking in an analytics system that could inform
@@ -1683,6 +2737,385 @@ type AnalyticsApi = {
  */
 declare const analyticsApiRef: ApiRef<AnalyticsApi>;
 
+/** @public */
+interface TranslationRef<TId extends string = string, TMessages extends {
+    [key in string]: string;
+} = {
+    [key in string]: string;
+}> {
+    $$type: '@backstage/TranslationRef';
+    id: TId;
+    T: TMessages;
+}
+/** @ignore */
+type AnyNestedMessages = {
+    [key in string]: AnyNestedMessages | string;
+};
+/**
+ * Flattens a nested message declaration into a flat object with dot-separated keys.
+ *
+ * @ignore
+ */
+type FlattenedMessages<TMessages extends AnyNestedMessages> = {
+    [TKey in keyof TMessages]: (_: TMessages[TKey] extends infer TValue ? TValue extends AnyNestedMessages ? FlattenedMessages<TValue> extends infer TNested ? {
+        [TNestedKey in keyof TNested as `${TKey & string}.${TNestedKey & string}`]: TNested[TNestedKey];
+    } : never : {
+        [_ in TKey]: TValue;
+    } : never) => void;
+}[keyof TMessages] extends (_: infer TIntersection) => void ? {
+    readonly [TExpandKey in keyof TIntersection]: TIntersection[TExpandKey];
+} : never;
+/** @public */
+interface TranslationRefOptions<TId extends string, TNestedMessages extends AnyNestedMessages, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: {
+            [key in keyof FlattenedMessages<TNestedMessages>]: string | null;
+        };
+    }>;
+}> {
+    id: TId;
+    messages: TNestedMessages;
+    translations?: TTranslations;
+}
+/** @public */
+declare function createTranslationRef<TId extends string, const TNestedMessages extends AnyNestedMessages, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: {
+            [key in keyof FlattenedMessages<TNestedMessages>]: string | null;
+        };
+    }>;
+}>(config: TranslationRefOptions<TId, TNestedMessages, TTranslations>): TranslationRef<TId, FlattenedMessages<TNestedMessages>>;
+
+/**
+ * Represents a collection of messages to be provided for a given translation ref.
+ *
+ * @public
+ * @remarks
+ *
+ * This collection of messages can either be used directly as an override for the
+ * default messages, or it can be used to provide translations for a language by
+ * by being referenced by a {@link TranslationResource}.
+ */
+interface TranslationMessages<TId extends string = string, TMessages extends {
+    [key in string]: string;
+} = {
+    [key in string]: string;
+}, TFull extends boolean = boolean> {
+    $$type: '@backstage/TranslationMessages';
+    /** The ID of the translation ref that these messages are for */
+    id: TId;
+    /** Whether or not these messages override all known messages */
+    full: TFull;
+    /** The messages provided for the given translation ref */
+    messages: TMessages;
+}
+/**
+ * Options for {@link createTranslationMessages}.
+ *
+ * @public
+ */
+interface TranslationMessagesOptions<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TFull extends boolean> {
+    ref: TranslationRef<TId, TMessages>;
+    full?: TFull;
+    messages: false extends TFull ? {
+        [key in keyof TMessages]?: string | null;
+    } : {
+        [key in keyof TMessages]: string | null;
+    };
+}
+/**
+ * Creates a collection of messages for a given translation ref.
+ *
+ * @public
+ */
+declare function createTranslationMessages<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TFull extends boolean>(options: TranslationMessagesOptions<TId, TMessages, TFull>): TranslationMessages<TId, TMessages, TFull>;
+
+/** @public */
+interface TranslationResource<TId extends string = string> {
+    $$type: '@backstage/TranslationResource';
+    id: TId;
+}
+/** @public */
+interface TranslationResourceOptions<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: TranslationMessages<TId> | {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}> {
+    ref: TranslationRef<TId, TMessages>;
+    translations: TTranslations;
+}
+/** @public */
+declare function createTranslationResource<TId extends string, TMessages extends {
+    [key in string]: string;
+}, TTranslations extends {
+    [language in string]: () => Promise<{
+        default: TranslationMessages<TId> | {
+            [key in keyof TMessages]: string | null;
+        };
+    }>;
+}>(options: TranslationResourceOptions<TId, TMessages, TTranslations>): TranslationResource<TId>;
+
+/** @public */
+declare const useTranslationRef: <TMessages extends { [key in string]: string; }>(translationRef: TranslationRef<string, TMessages>) => {
+    t: TranslationFunction<TMessages>;
+};
+
+/**
+ * Base translation options.
+ *
+ * @alpha
+ */
+interface BaseOptions {
+    interpolation?: {
+        /** Whether to HTML escape provided values, defaults to false  */
+        escapeValue?: boolean;
+    };
+}
+/**
+ * All pluralization suffixes supported by i18next
+ *
+ * @ignore
+ */
+type TranslationPlural = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+/**
+ * A mapping of i18n formatting types to their corresponding types and options.
+ * @ignore
+ */
+type I18nextFormatMap = {
+    number: {
+        type: number;
+        options: Intl.NumberFormatOptions;
+    };
+    currency: {
+        type: number;
+        options: Intl.NumberFormatOptions;
+    };
+    datetime: {
+        type: Date;
+        options: Intl.DateTimeFormatOptions;
+    };
+    relativetime: {
+        type: number;
+        options: {
+            range?: Intl.RelativeTimeFormatUnit;
+        } & Intl.RelativeTimeFormatOptions;
+    };
+    list: {
+        type: string[];
+        options: Intl.ListFormatOptions;
+    };
+};
+/**
+ * Extracts all pluralized keys from the message map.
+ *
+ * @example
+ * ```
+ * { foo: 'foo', bar_one: 'bar', bar_other: 'bars' } -> 'bar'
+ * ```
+ *
+ * @ignore
+ */
+type PluralKeys<TMessages extends {
+    [key in string]: string;
+}> = {
+    [Key in keyof TMessages]: Key extends `${infer K}_${TranslationPlural}` ? K : never;
+}[keyof TMessages];
+/**
+ * Collapses a message map into normalized keys with union values.
+ *
+ * @example
+ * ```
+ * { foo_one: 'foo', foo_other: 'foos' } -> { foo: 'foo' | 'foos' }
+ * ```
+ *
+ * @ignore
+ */
+type CollapsedMessages<TMessages extends {
+    [key in string]: string;
+}> = {
+    [key in keyof TMessages as key extends `${infer K}_${TranslationPlural}` ? K : key]: TMessages[key];
+};
+/**
+ * Trim away whitespace
+ *
+ * @ignore
+ */
+type Trim<T> = T extends ` ${infer U}` ? Trim<U> : T extends `${infer U} ` ? Trim<U> : T;
+/**
+ * Extracts the key and format from a replacement string.
+ *
+ * @example
+ * ```
+ * 'foo, number' -> { foo: number }, 'foo' -> { foo: undefined }
+ * ```
+ */
+type ExtractFormat<Replacement extends string> = Replacement extends `${infer Key},${infer FullFormat}` ? {
+    [key in Trim<Key>]: Lowercase<Trim<FullFormat extends `${infer Format}(${string})${string}` ? Format : FullFormat>>;
+} : {
+    [key in Trim<Replacement>]: undefined;
+};
+/**
+ * Expand the keys in a flat map to nested objects.
+ *
+ * @example
+ * ```
+ * { 'a.b': 'foo', 'a.c': 'bar' } -> { a: { b: 'foo', c: 'bar' }
+ * ```
+ *
+ * @ignore
+ */
+type ExpandKeys<TMap extends {}> = {
+    [Key in keyof TMap as Key extends `${infer Prefix}.${string}` ? Prefix : Key]: Key extends `${string}.${infer Rest}` ? ExpandKeys<{
+        [key in Rest]: TMap[Key];
+    }> : TMap[Key];
+};
+/**
+ * Extracts all option keys and their format from a message string.
+ *
+ * @example
+ * ```
+ * 'foo {{bar}} {{baz, number}}' -> { 'bar': undefined, 'baz': 'number' }
+ * ```
+ *
+ * @ignore
+ */
+type ReplaceFormatsFromMessage<TMessage> = TMessage extends `${string}{{${infer Replacement}}}${infer Tail}` ? ExpandKeys<ExtractFormat<Replacement>> & ReplaceFormatsFromMessage<Tail> : {};
+/**
+ * Generates the replace options structure
+ *
+ * @ignore
+ */
+type ReplaceOptionsFromFormats<TFormats extends {}, TValueType> = {
+    [Key in keyof TFormats]: TFormats[Key] extends keyof I18nextFormatMap ? I18nextFormatMap[TFormats[Key]]['type'] : TFormats[Key] extends {} ? Expand<ReplaceOptionsFromFormats<TFormats[Key], TValueType>> : TValueType;
+};
+/**
+ * Generates the formatParams options structure
+ *
+ * @ignore
+ */
+type ReplaceFormatParamsFromFormats<TFormats extends {}> = {
+    [Key in keyof TFormats]?: TFormats[Key] extends keyof I18nextFormatMap ? I18nextFormatMap[TFormats[Key]]['options'] : TFormats[Key] extends {} ? Expand<ReplaceFormatParamsFromFormats<TFormats[Key]>> : undefined;
+};
+/**
+ * Extracts all nesting keys from a message string.
+ *
+ * @example
+ * ```
+ * 'foo $t(bar) $t(baz)' -> 'bar' | 'baz'
+ * ```
+ *
+ * @ignore
+ */
+type NestingKeysFromMessage<TMessage extends string> = TMessage extends `${string}$t(${infer Key})${infer Tail}` ? Trim<Key> | NestingKeysFromMessage<Tail> : never;
+/**
+ * Find all referenced keys, given a starting key and the full set of messages.
+ *
+ * This will only discover keys up to 3 levels deep.
+ *
+ * @example
+ * ```
+ * <'x', { x: '$t(y) $t(z)', y: 'y', z: '$t(w)', w: 'w', foo: 'foo' }> -> 'x' | 'y' | 'z' | 'w'
+ * ```
+ *
+ * @ignore
+ */
+type NestedMessageKeys<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestedMessageKeys2<NestingKeysFromMessage<TMessages[TKey]>, TMessages>;
+type NestedMessageKeys2<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestedMessageKeys3<NestingKeysFromMessage<TMessages[TKey]>, TMessages>;
+type NestedMessageKeys3<TKey extends keyof TMessages, TMessages extends {
+    [key in string]: string;
+}> = TKey | NestingKeysFromMessage<TMessages[TKey]>;
+/**
+ * Converts a union type to an intersection type.
+ *
+ * @example
+ * ```
+ * { foo: 'foo' } | { bar: 'bar' } -> { foo: 'foo' } & { bar: 'bar' }
+ * ```
+ *
+ * @ignore
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Collects different types of options into a single object
+ *
+ * @ignore
+ */
+type CollectOptions<TCount extends {
+    count?: number;
+}, TFormats extends {}, TValueType> = TCount & (keyof Omit<TFormats, 'count'> extends never ? {} : (Expand<Omit<ReplaceOptionsFromFormats<TFormats, TValueType>, 'count'>> | {
+    replace: Expand<Omit<ReplaceOptionsFromFormats<TFormats, TValueType>, 'count'>>;
+}) & {
+    formatParams?: Expand<ReplaceFormatParamsFromFormats<TFormats>>;
+});
+/**
+ * Helper type to only require options argument if needed
+ *
+ * @ignore
+ */
+type OptionArgs<TOptions extends {}> = keyof TOptions extends never ? [options?: Expand<BaseOptions>] : [options: Expand<BaseOptions & TOptions>];
+/**
+ * @ignore
+ */
+type TranslationFunctionOptions<TKeys extends keyof TMessages, // All normalized message keys to be considered, i.e. included nested ones
+TPluralKeys extends keyof TMessages, // All keys in the message map that are pluralized
+TMessages extends {
+    [key in string]: string;
+}, // Collapsed message map with normalized keys and union values
+TValueType> = OptionArgs<Expand<CollectOptions<TKeys & TPluralKeys extends never ? {} : {
+    count: number;
+}, ExpandRecursive<UnionToIntersection<ReplaceFormatsFromMessage<TMessages[TKeys]>>>, TValueType>>>;
+/** @public */
+type TranslationFunction<TMessages extends {
+    [key in string]: string;
+}> = CollapsedMessages<TMessages> extends infer IMessages extends {
+    [key in string]: string;
+} ? {
+    /**
+     * A translation function that returns a string.
+     */
+    <TKey extends keyof IMessages>(key: TKey, ...[args]: TranslationFunctionOptions<NestedMessageKeys<TKey, IMessages>, PluralKeys<TMessages>, IMessages, string>): IMessages[TKey];
+    /**
+     * A translation function where at least one JSX.Element has been
+     * provided as an interpolation value, and will therefore return a
+     * JSX.Element.
+     */
+    <TKey extends keyof IMessages>(key: TKey, ...[args]: TranslationFunctionOptions<NestedMessageKeys<TKey, IMessages>, PluralKeys<TMessages>, IMessages, string | JSX$1.Element>): JSX$1.Element;
+} : never;
+/** @public */
+type TranslationSnapshot<TMessages extends {
+    [key in string]: string;
+}> = {
+    ready: false;
+} | {
+    ready: true;
+    t: TranslationFunction<TMessages>;
+};
+/** @public */
+type TranslationApi = {
+    getTranslation<TMessages extends {
+        [key in string]: string;
+    }>(translationRef: TranslationRef<string, TMessages>): TranslationSnapshot<TMessages>;
+    translation$<TMessages extends {
+        [key in string]: string;
+    }>(translationRef: TranslationRef<string, TMessages>): Observable<TranslationSnapshot<TMessages>>;
+};
+/**
+ * @public
+ */
+declare const translationApiRef: ApiRef<TranslationApi>;
+
 /**
  * Gets a pre-configured analytics tracker.
  *
@@ -1702,15 +3135,15 @@ type AnalyticsImplementationFactory<Deps extends {
  *
  * @public
  */
-declare const AnalyticsImplementationBlueprint: ExtensionBlueprint<{
+declare const AnalyticsImplementationBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "analytics";
-    params: <TDeps extends { [name in string]: unknown; }>(params: AnalyticsImplementationFactory<TDeps>) => ExtensionBlueprintParams<AnalyticsImplementationFactory<{}>>;
-    output: ExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
+    params: <TDeps extends { [name in string]: unknown; }>(params: AnalyticsImplementationFactory<TDeps>) => _backstage_frontend_plugin_api.ExtensionBlueprintParams<AnalyticsImplementationFactory<{}>>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        factory: ConfigurableExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
+        factory: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<AnalyticsImplementationFactory<{}>, "core.analytics.factory", {}>;
     };
 }>;
 
@@ -1719,15 +3152,15 @@ declare const AnalyticsImplementationBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const ApiBlueprint: ExtensionBlueprint<{
+declare const ApiBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "api";
-    params: <TApi, TImpl extends TApi, TDeps extends { [name in string]: unknown; }>(params: ApiFactory<TApi, TImpl, TDeps>) => ExtensionBlueprintParams<AnyApiFactory>;
-    output: ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+    params: <TApi, TImpl extends TApi, TDeps extends { [name in string]: unknown; }>(params: ApiFactory<TApi, TImpl, TDeps>) => _backstage_frontend_plugin_api.ExtensionBlueprintParams<AnyApiFactory>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        factory: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
+        factory: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
     };
 }>;
 
@@ -1737,12 +3170,12 @@ declare const ApiBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const AppRootElementBlueprint: ExtensionBlueprint<{
+declare const AppRootElementBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "app-root-element";
     params: {
         element: JSX.Element;
     };
-    output: ExtensionDataRef<react.JSX.Element, "core.reactElement", {}>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<react.JSX.Element, "core.reactElement", {}>;
     inputs: {};
     config: {};
     configInput: {};
@@ -1756,7 +3189,7 @@ declare const AppRootElementBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const AppRootWrapperBlueprint: ExtensionBlueprint<{
+declare const AppRootWrapperBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "app-root-wrapper";
     params: {
         /** @deprecated use the `component` parameter instead */
@@ -1765,33 +3198,33 @@ declare const AppRootWrapperBlueprint: ExtensionBlueprint<{
             children: ReactNode;
         }) => JSX.Element | null;
     };
-    output: ExtensionDataRef<(props: {
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<(props: {
         children: ReactNode;
     }) => JSX.Element | null, "app.root.wrapper", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<(props: {
+        component: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<(props: {
             children: ReactNode;
         }) => JSX.Element | null, "app.root.wrapper", {}>;
     };
 }>;
 
 /** @public */
-declare const IconBundleBlueprint: ExtensionBlueprint<{
+declare const IconBundleBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "icon-bundle";
     params: {
         icons: { [key in string]: IconComponent; };
     };
-    output: ExtensionDataRef<{
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<{
         [x: string]: IconComponent;
     }, "core.icons", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        icons: ConfigurableExtensionDataRef<{
+        icons: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<{
             [x: string]: IconComponent;
         }, "core.icons", {}>;
     };
@@ -1849,25 +3282,25 @@ declare const NavContentBlueprint: _backstage_frontend_plugin_api.ExtensionBluep
  *
  * @public
  */
-declare const NavItemBlueprint: ExtensionBlueprint<{
+declare const NavItemBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "nav-item";
     params: {
         title: string;
-        icon: IconComponent$2;
+        icon: IconComponent;
         routeRef: RouteRef<undefined>;
     };
-    output: ExtensionDataRef<{
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<{
         title: string;
-        icon: IconComponent$2;
+        icon: IconComponent;
         routeRef: RouteRef<undefined>;
     }, "core.nav-item.target", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        target: ConfigurableExtensionDataRef<{
+        target: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<{
             title: string;
-            icon: IconComponent$2;
+            icon: IconComponent;
             routeRef: RouteRef<undefined>;
         }, "core.nav-item.target", {}>;
     };
@@ -1878,7 +3311,7 @@ declare const NavItemBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const PageBlueprint: ExtensionBlueprint<{
+declare const PageBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "page";
     params: {
         /**
@@ -1889,7 +3322,7 @@ declare const PageBlueprint: ExtensionBlueprint<{
         loader: () => Promise<JSX.Element>;
         routeRef?: RouteRef;
     };
-    output: ExtensionDataRef<string, "core.routing.path", {}> | ExtensionDataRef<react.JSX.Element, "core.reactElement", {}> | ExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<string, "core.routing.path", {}> | _backstage_frontend_plugin_api.ExtensionDataRef<react.JSX.Element, "core.reactElement", {}> | _backstage_frontend_plugin_api.ExtensionDataRef<RouteRef<_backstage_frontend_plugin_api.AnyRouteRefParams>, "core.routing.ref", {
         optional: true;
     }>;
     inputs: {};
@@ -1903,7 +3336,7 @@ declare const PageBlueprint: ExtensionBlueprint<{
 }>;
 
 /** @public */
-declare const RouterBlueprint: ExtensionBlueprint<{
+declare const RouterBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "app-router-component";
     params: {
         /** @deprecated use the `component` parameter instead */
@@ -1912,35 +3345,50 @@ declare const RouterBlueprint: ExtensionBlueprint<{
             children: ReactNode;
         }) => JSX.Element | null;
     };
-    output: ExtensionDataRef<(props: {
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<(props: {
         children: ReactNode;
     }) => JSX.Element | null, "app.router.wrapper", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<(props: {
+        component: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<(props: {
             children: ReactNode;
         }) => JSX.Element | null, "app.router.wrapper", {}>;
     };
 }>;
 
+/**
+ * Props for the `SignInPage` component.
+ *
+ * @public
+ */
+type SignInPageProps = {
+    /**
+     * Set the IdentityApi on successful sign-in. This should only be called once.
+     */
+    onSignInSuccess(identityApi: IdentityApi): void;
+    /**
+     * The children to render.
+     */
+    children?: ReactNode;
+};
 /**
  * Creates an extension that replaces the sign in page.
  *
  * @public
  */
-declare const SignInPageBlueprint: ExtensionBlueprint<{
+declare const SignInPageBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "sign-in-page";
     params: {
         loader: () => Promise<ComponentType<SignInPageProps>>;
     };
-    output: ExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
+        component: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
     };
 }>;
 
@@ -1949,17 +3397,17 @@ declare const SignInPageBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const ThemeBlueprint: ExtensionBlueprint<{
+declare const ThemeBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "theme";
     params: {
         theme: AppTheme;
     };
-    output: ExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<AppTheme, "core.theme.theme", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        theme: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
+        theme: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
     };
 }>;
 
@@ -1968,19 +3416,19 @@ declare const ThemeBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const TranslationBlueprint: ExtensionBlueprint<{
+declare const TranslationBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "translation";
     params: {
         resource: TranslationResource | TranslationMessages;
     };
-    output: ExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
         [x: string]: string;
     }, boolean>, "core.translation.translation", {}>;
     inputs: {};
     config: {};
     configInput: {};
     dataRefs: {
-        translation: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
+        translation: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
             [x: string]: string;
         }, boolean>, "core.translation.translation", {}>;
     };
@@ -1991,20 +3439,20 @@ declare const TranslationBlueprint: ExtensionBlueprint<{
  *
  * @public
  */
-declare const SwappableComponentBlueprint: ExtensionBlueprint<{
+declare const SwappableComponentBlueprint: _backstage_frontend_plugin_api.ExtensionBlueprint<{
     kind: "component";
     params: <Ref extends SwappableComponentRef<any>>(params: {
         component: Ref extends SwappableComponentRef<any, infer IExternalComponentProps> ? {
             ref: Ref;
         } & ((props: IExternalComponentProps) => JSX.Element | null) : never;
         loader: Ref extends SwappableComponentRef<infer IInnerComponentProps, any> ? (() => (props: IInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: IInnerComponentProps) => JSX.Element | null>) : never;
-    }) => ExtensionBlueprintParams<{
+    }) => _backstage_frontend_plugin_api.ExtensionBlueprintParams<{
         component: Ref extends SwappableComponentRef<any, infer IExternalComponentProps> ? {
             ref: Ref;
         } & ((props: IExternalComponentProps) => JSX.Element | null) : never;
         loader: Ref extends SwappableComponentRef<infer IInnerComponentProps, any> ? (() => (props: IInnerComponentProps) => JSX.Element | null) | (() => Promise<(props: IInnerComponentProps) => JSX.Element | null>) : never;
     }>;
-    output: ExtensionDataRef<{
+    output: _backstage_frontend_plugin_api.ExtensionDataRef<{
         ref: SwappableComponentRef;
         loader: (() => (props: {}) => JSX.Element | null) | (() => Promise<(props: {}) => JSX.Element | null>);
     }, "core.swappableComponent", {}>;
@@ -2012,11 +3460,12 @@ declare const SwappableComponentBlueprint: ExtensionBlueprint<{
     config: {};
     configInput: {};
     dataRefs: {
-        component: ConfigurableExtensionDataRef<{
+        component: _backstage_frontend_plugin_api.ConfigurableExtensionDataRef<{
             ref: SwappableComponentRef;
             loader: (() => (props: {}) => JSX.Element | null) | (() => Promise<(props: {}) => JSX.Element | null>);
         }, "core.swappableComponent", {}>;
     };
 }>;
 
-export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsImplementation, AnalyticsImplementationBlueprint, type AnalyticsImplementationFactory, type AnalyticsTracker, type AnyExtensionDataRef, type AnyRouteRefParams, ApiBlueprint, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, AppRootElementBlueprint, AppRootWrapperBlueprint, type AppTree, type AppTreeApi, type ConfigurableExtensionDataRef, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type CreateFrontendFeatureLoaderOptions, type CreateFrontendModuleOptions, type CreateSwappableComponentOptions, type DialogApi, type DialogApiDialog, ErrorDisplay, type ErrorDisplayProps, type Extension, type ExtensionAttachTo, type ExtensionAttachToSpec, type ExtensionBlueprint, type ExtensionBlueprintDefineParams, type ExtensionBlueprintParameters, type ExtensionBlueprintParams, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDefinition, type ExtensionDefinitionAttachTo, type ExtensionDefinitionParameters, type ExtensionFactoryMiddleware, type ExtensionInput, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, type FrontendFeatureLoader, type FrontendModule, type FrontendPlugin, type FrontendPluginInfo, type FrontendPluginInfoOptions, IconBundleBlueprint, type IconComponent, type IconsApi, NavContentBlueprint, type NavContentComponent, type NavContentComponentProps, NavItemBlueprint, NotFoundErrorPage, type NotFoundErrorPageProps, type OverridableExtensionDefinition, type OverridableFrontendPlugin, PageBlueprint, type PluginOptions, type PortableSchema, Progress, type ProgressProps, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, RouterBlueprint, SignInPageBlueprint, type SubRouteRef, SwappableComponentBlueprint, type SwappableComponentRef, type SwappableComponentsApi, ThemeBlueprint, TranslationBlueprint, analyticsApiRef, appTreeApiRef, coreExtensionData, createExtension, createExtensionBlueprint, createExtensionBlueprintParams, createExtensionDataRef, createExtensionInput, createExternalRouteRef, createFrontendFeatureLoader, createFrontendModule, createFrontendPlugin, createRouteRef, createSubRouteRef, createSwappableComponent, dialogApiRef, iconsApiRef, routeResolutionApiRef, swappableComponentsApiRef, useAnalytics, useAppNode, useRouteRef, useRouteRefParams };
+export { AnalyticsContext, AnalyticsImplementationBlueprint, ApiBlueprint, AppRootElementBlueprint, AppRootWrapperBlueprint, ErrorDisplay, ExtensionBoundary, FeatureFlagState, IconBundleBlueprint, NavContentBlueprint, NavItemBlueprint, NotFoundErrorPage, PageBlueprint, Progress, RouterBlueprint, SessionState, SignInPageBlueprint, SwappableComponentBlueprint, ThemeBlueprint, TranslationBlueprint, 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, 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, IconsApi, IdentityApi, NavContentComponent, NavContentComponentProps, NotFoundErrorPageProps, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, OverridableExtensionDefinition, OverridableFrontendPlugin, PendingOAuthRequest, PluginOptions, PortableSchema, ProfileInfo, ProfileInfoApi, ProgressProps, ResolvedExtensionInput, ResolvedExtensionInputs, RouteFunc, RouteRef, RouteResolutionApi, SessionApi, SignInPageProps, StorageApi, StorageValueSnapshot, SubRouteRef, SwappableComponentRef, SwappableComponentsApi, TranslationApi, TranslationFunction, TranslationMessages, TranslationMessagesOptions, TranslationRef, TranslationRefOptions, TranslationResource, TranslationResourceOptions, TranslationSnapshot, TypesToApiRefs };