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

package/dist/index.d.ts

@@ -4,9 +4,9 @@ import * as _backstage_core_plugin_api from '@backstage/core-plugin-api';
 import { ApiRef, AnyApiRef, AnyApiFactory, IconComponent as IconComponent$1, SignInPageProps, AppTheme } from '@backstage/core-plugin-api';
 export { AlertApi, AlertMessage, AnyApiFactory, AnyApiRef, ApiFactory, ApiHolder, ApiRef, ApiRefConfig, AppTheme, AppThemeApi, AuthProviderInfo, AuthRequestOptions, BackstageIdentityApi, BackstageIdentityResponse, BackstageUserIdentity, ConfigApi, DiscoveryApi, ErrorApi, ErrorApiError, ErrorApiErrorContext, FeatureFlag, FeatureFlagState, FeatureFlagsApi, FeatureFlagsSaveOptions, FetchApi, IdentityApi, OAuthApi, OAuthRequestApi, OAuthRequester, OAuthRequesterOptions, OAuthScope, OpenIdConnectApi, PendingOAuthRequest, ProfileInfo, ProfileInfoApi, SessionApi, SessionState, StorageApi, StorageValueSnapshot, TypesToApiRefs, alertApiRef, appThemeApiRef, atlassianAuthApiRef, bitbucketAuthApiRef, bitbucketServerAuthApiRef, configApiRef, createApiFactory, createApiRef, discoveryApiRef, errorApiRef, featureFlagsApiRef, fetchApiRef, githubAuthApiRef, gitlabAuthApiRef, googleAuthApiRef, identityApiRef, microsoftAuthApiRef, oauthRequestApiRef, oktaAuthApiRef, oneloginAuthApiRef, storageApiRef, useApi, useApiHolder, vmwareCloudAuthApiRef, withApis } from '@backstage/core-plugin-api';
 import { JsonObject } from '@backstage/types';
+import { z, ZodSchema, ZodTypeDef } from 'zod';
 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 { z, ZodSchema, ZodTypeDef } from 'zod';
 
 /**
  * Common analytics context attributes.
@@ -232,50 +232,66 @@ declare function useRouteRef<TParams extends AnyRouteRefParams>(routeRef: RouteR
  */
 declare function useRouteRefParams<Params extends AnyRouteRefParams>(_routeRef: RouteRef<Params> | SubRouteRef<Params>): Params;
 
+/** @public */
+type ExtensionDataValue<TData, TId extends string> = {
+    readonly $$type: '@backstage/ExtensionDataValue';
+    readonly id: TId;
+    readonly value: TData;
+};
 /** @public */
 type ExtensionDataRef<TData, TId extends string = string, TConfig extends {
     optional?: true;
 } = {}> = {
-    id: TId;
-    T: TData;
-    config: TConfig;
-    $$type: '@backstage/ExtensionDataRef';
+    readonly $$type: '@backstage/ExtensionDataRef';
+    readonly id: TId;
+    readonly T: TData;
+    readonly config: TConfig;
 };
 /** @public */
-interface ConfigurableExtensionDataRef<TId extends string, TData, TConfig extends {
+type ExtensionDataRefToValue<TDataRef extends AnyExtensionDataRef> = TDataRef extends ExtensionDataRef<infer IData, infer IId, any> ? ExtensionDataValue<IData, IId> : never;
+/** @public */
+type AnyExtensionDataRef = ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>;
+/** @public */
+interface ConfigurableExtensionDataRef<TData, TId extends string, TConfig extends {
     optional?: true;
 } = {}> extends ExtensionDataRef<TData, TId, TConfig> {
-    optional(): ConfigurableExtensionDataRef<TId, TData, TData & {
+    optional(): ConfigurableExtensionDataRef<TData, TId, TData & {
         optional: true;
     }>;
+    (t: TData): ExtensionDataValue<TData, TId>;
 }
 /**
  * @public
  * @deprecated Use the following form instead: `createExtensionDataRef<Type>().with({ id: 'core.foo' })`
  */
-declare function createExtensionDataRef<TData>(id: string): ConfigurableExtensionDataRef<string, TData>;
+declare function createExtensionDataRef<TData>(id: string): ConfigurableExtensionDataRef<TData, string>;
 /** @public */
 declare function createExtensionDataRef<TData>(): {
     with<TId extends string>(options: {
         id: TId;
-    }): ConfigurableExtensionDataRef<TId, TData>;
+    }): ConfigurableExtensionDataRef<TData, TId>;
 };
 
 /** @public */
 declare const coreExtensionData: {
-    reactElement: ConfigurableExtensionDataRef<"core.reactElement", JSX$1.Element, {}>;
-    routePath: ConfigurableExtensionDataRef<"core.routing.path", string, {}>;
-    routeRef: ConfigurableExtensionDataRef<"core.routing.ref", RouteRef<AnyRouteRefParams>, {}>;
+    reactElement: ConfigurableExtensionDataRef<JSX$1.Element, "core.reactElement", {}>;
+    routePath: ConfigurableExtensionDataRef<string, "core.routing.path", {}>;
+    routeRef: ConfigurableExtensionDataRef<RouteRef<AnyRouteRefParams>, "core.routing.ref", {}>;
 };
 
 /** @public */
-type PortableSchema<TOutput> = {
-    parse: (input: unknown) => TOutput;
+type PortableSchema<TOutput, TInput = TOutput> = {
+    parse: (input: TInput) => TOutput;
     schema: JsonObject;
 };
 
-/** @public */
-declare function createSchemaFromZod<TOutput, TInput>(schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>): PortableSchema<TOutput>;
+/**
+ * @public
+ * @deprecated Use the `config.schema` option of `createExtension` instead, or use `createExtensionBlueprint`.
+ */
+declare function createSchemaFromZod<TOutput, TInput>(schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>): PortableSchema<TOutput, TInput>;
 
 /**
  * Utility type to expand type aliases into their equivalent type.
@@ -298,32 +314,63 @@ type CoreErrorBoundaryFallbackProps = {
 };
 
 /** @public */
-interface ExtensionInput<TExtensionData extends AnyExtensionDataMap, TConfig extends {
+interface ExtensionInput<TExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>, TConfig extends {
     singleton: boolean;
     optional: boolean;
 }> {
     $$type: '@backstage/ExtensionInput';
-    extensionData: TExtensionData;
+    extensionData: Array<TExtensionData>;
     config: TConfig;
 }
+/**
+ * @public
+ * @deprecated This type will be removed. Use `ExtensionInput` instead.
+ */
+interface LegacyExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
+    singleton: boolean;
+    optional: boolean;
+}> {
+    $$type: '@backstage/ExtensionInput';
+    extensionData: TExtensionDataMap;
+    config: TConfig;
+}
+/**
+ * @public
+ * @deprecated Use the following form instead: `createExtensionInput([dataRef1, dataRef2])`
+ */
+declare function createExtensionInput<TExtensionDataMap extends AnyExtensionDataMap, TConfig extends {
+    singleton?: boolean;
+    optional?: boolean;
+}>(extensionData: TExtensionDataMap, config?: TConfig): LegacyExtensionInput<TExtensionDataMap, {
+    singleton: TConfig['singleton'] extends true ? true : false;
+    optional: TConfig['optional'] extends true ? true : false;
+}>;
 /** @public */
-declare function createExtensionInput<TExtensionData extends AnyExtensionDataMap, TConfig extends {
+declare function createExtensionInput<UExtensionData extends ExtensionDataRef<unknown, string, {
+    optional?: true;
+}>, TConfig extends {
     singleton?: boolean;
     optional?: boolean;
-}>(extensionData: TExtensionData, config?: TConfig): ExtensionInput<TExtensionData, {
+}>(extensionData: Array<UExtensionData>, config?: TConfig): ExtensionInput<UExtensionData, {
     singleton: TConfig['singleton'] extends true ? true : false;
     optional: TConfig['optional'] extends true ? true : false;
 }>;
 
-/** @public */
+/**
+ * @public
+ * @deprecated Extension data maps will be removed.
+ */
 type AnyExtensionDataMap = {
-    [name in string]: ExtensionDataRef<unknown, string, {
-        optional?: true;
-    }>;
+    [name in string]: AnyExtensionDataRef;
 };
-/** @public */
+/**
+ * @public
+ * @deprecated This type will be removed.
+ */
 type AnyExtensionInputMap = {
-    [inputName in string]: ExtensionInput<AnyExtensionDataMap, {
+    [inputName in string]: LegacyExtensionInput<AnyExtensionDataMap, {
         optional: boolean;
         singleton: boolean;
     }>;
@@ -331,6 +378,7 @@ type AnyExtensionInputMap = {
 /**
  * Converts an extension data map into the matching concrete data values type.
  * @public
+ * @deprecated Extension data maps will be removed.
  */
 type ExtensionDataValues<TExtensionData extends AnyExtensionDataMap> = {
     [DataName in keyof TExtensionData as TExtensionData[DataName]['config'] extends {
@@ -341,25 +389,36 @@ type ExtensionDataValues<TExtensionData extends AnyExtensionDataMap> = {
         optional: true;
     } ? DataName : never]?: TExtensionData[DataName]['T'];
 };
+/** @public */
+type ExtensionDataContainer<UExtensionData extends AnyExtensionDataRef> = {
+    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;
+};
 /**
  * Convert a single extension input into a matching resolved input.
  * @public
  */
-type ResolvedExtensionInput<TExtensionData extends AnyExtensionDataMap> = {
+type ResolvedExtensionInput<TExtensionInput extends ExtensionInput<any, any>> = TExtensionInput['extensionData'] extends Array<AnyExtensionDataRef> ? {
     node: AppNode;
-    output: ExtensionDataValues<TExtensionData>;
-};
+} & ExtensionDataContainer<TExtensionInput['extensionData'][number]> : TExtensionInput['extensionData'] extends AnyExtensionDataMap ? {
+    node: AppNode;
+    output: ExtensionDataValues<TExtensionInput['extensionData']>;
+} : never;
 /**
  * Converts an extension input map into a matching collection of resolved inputs.
  * @public
  */
 type ResolvedExtensionInputs<TInputs extends {
-    [name in string]: ExtensionInput<any, any>;
+    [name in string]: ExtensionInput<any, any> | LegacyExtensionInput<any, any>;
 }> = {
-    [InputName in keyof TInputs]: false extends TInputs[InputName]['config']['singleton'] ? Array<Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']>>> : false extends TInputs[InputName]['config']['optional'] ? Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']>> : Expand<ResolvedExtensionInput<TInputs[InputName]['extensionData']> | undefined>;
+    [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>;
 };
-/** @public */
-interface CreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig> {
+/**
+ * @public
+ * @deprecated This way of structuring the options is deprecated, this type will be removed in the future
+ */
+interface LegacyCreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}> {
     kind?: string;
     namespace?: string;
     name?: string;
@@ -370,15 +429,57 @@ interface CreateExtensionOptions<TOutput extends AnyExtensionDataMap, TInputs ex
     disabled?: boolean;
     inputs?: TInputs;
     output: TOutput;
-    configSchema?: PortableSchema<TConfig>;
+    /** @deprecated - use `config.schema` instead */
+    configSchema?: PortableSchema<TConfig, TConfigInput>;
+    config?: {
+        schema: TConfigSchema;
+    };
     factory(context: {
         node: AppNode;
-        config: TConfig;
+        config: TConfig & (string extends keyof TConfigSchema ? {} : {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        });
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     }): Expand<ExtensionDataValues<TOutput>>;
 }
+/** @ignore */
+type VerifyExtensionFactoryOutput<UDeclaredOutput extends AnyExtensionDataRef, UFactoryOutput extends ExtensionDataValue<any, any>> = (UDeclaredOutput extends any ? UDeclaredOutput['config']['optional'] extends true ? never : UDeclaredOutput['id'] : never) extends infer IRequiredOutputIds ? [IRequiredOutputIds] extends [UFactoryOutput['id']] ? {} : {
+    'Error: The extension factory is missing the following outputs': Exclude<IRequiredOutputIds, UFactoryOutput['id']>;
+} : never;
+/** @public */
+type CreateExtensionOptions<UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>> = {
+    kind?: string;
+    namespace?: string;
+    name?: string;
+    attachTo: {
+        id: string;
+        input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output: Array<UOutput>;
+    /** @deprecated - use `config.schema` instead */
+    configSchema?: PortableSchema<TConfig, TConfigInput>;
+    config?: {
+        schema: TConfigSchema;
+    };
+    factory(context: {
+        node: AppNode;
+        config: TConfig & (string extends keyof TConfigSchema ? {} : {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        });
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    }): Iterable<UFactoryOutput>;
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /** @public */
-interface ExtensionDefinition<TConfig> {
+interface ExtensionDefinition<TConfig, TConfigInput = TConfig> {
     $$type: '@backstage/ExtensionDefinition';
     readonly kind?: string;
     readonly namespace?: string;
@@ -388,13 +489,35 @@ interface ExtensionDefinition<TConfig> {
         input: string;
     };
     readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig>;
+    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
 }
 /** @public */
-declare function createExtension<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig = never>(options: CreateExtensionOptions<TOutput, TInputs, TConfig>): ExtensionDefinition<TConfig>;
+declare function createExtension<UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>>(options: CreateExtensionOptions<UOutput, TInputs, TConfig, TConfigInput, TConfigSchema, UFactoryOutput>): ExtensionDefinition<TConfig & (string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}), TConfigInput & (string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>)>;
+/**
+ * @public
+ * @deprecated - use the array format of `output` instead, see TODO-doc-link
+ */
+declare function createExtension<TOutput extends AnyExtensionDataMap, TInputs extends AnyExtensionInputMap, TConfig, TConfigInput, TConfigSchema extends {
+    [key: string]: (zImpl: typeof z) => z.ZodType;
+}>(options: LegacyCreateExtensionOptions<TOutput, TInputs, TConfig, TConfigInput, TConfigSchema>): ExtensionDefinition<TConfig & (string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}), TConfigInput & (string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>)>;
 
 /** @public */
-interface Extension<TConfig> {
+interface Extension<TConfig, TConfigInput = TConfig> {
     $$type: '@backstage/Extension';
     readonly id: string;
     readonly attachTo: {
@@ -402,7 +525,7 @@ interface Extension<TConfig> {
         input: string;
     };
     readonly disabled: boolean;
-    readonly configSchema?: PortableSchema<TConfig>;
+    readonly configSchema?: PortableSchema<TConfig, TConfigInput>;
 }
 
 /**
@@ -441,7 +564,7 @@ interface PluginOptions<Routes extends AnyRoutes, ExternalRoutes extends AnyExte
     id: string;
     routes?: Routes;
     externalRoutes?: ExternalRoutes;
-    extensions?: ExtensionDefinition<unknown>[];
+    extensions?: ExtensionDefinition<any, any>[];
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
@@ -449,7 +572,7 @@ declare function createPlugin<Routes extends AnyRoutes = {}, ExternalRoutes exte
 
 /** @public */
 interface ExtensionOverridesOptions {
-    extensions: ExtensionDefinition<unknown>[];
+    extensions: ExtensionDefinition<any, any>[];
     featureFlags?: FeatureFlagConfig[];
 }
 /** @public */
@@ -458,7 +581,16 @@ declare function createExtensionOverrides(options: ExtensionOverridesOptions): E
 /**
  * @public
  */
-interface CreateExtensionBlueprintOptions<TParams, TInputs extends AnyExtensionInputMap, TOutput extends AnyExtensionDataMap, TConfig, TDataRefs extends AnyExtensionDataMap> {
+type CreateExtensionBlueprintOptions<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+}> = {
     kind: string;
     namespace?: string;
     attachTo: {
@@ -467,19 +599,34 @@ interface CreateExtensionBlueprintOptions<TParams, TInputs extends AnyExtensionI
     };
     disabled?: boolean;
     inputs?: TInputs;
-    output: TOutput;
-    configSchema?: PortableSchema<TConfig>;
+    output: Array<UOutput>;
+    config?: {
+        schema: TConfigSchema;
+    };
     factory(params: TParams, context: {
         node: AppNode;
-        config: TConfig;
+        config: {
+            [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+        };
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    }): Expand<ExtensionDataValues<TOutput>>;
+    }): Iterable<UFactoryOutput>;
     dataRefs?: TDataRefs;
-}
+} & VerifyExtensionFactoryOutput<UOutput, UFactoryOutput>;
 /**
  * @public
  */
-interface ExtensionBlueprint<TParams, TInputs extends AnyExtensionInputMap, TOutput extends AnyExtensionDataMap, TConfig, TDataRefs extends AnyExtensionDataMap> {
+interface ExtensionBlueprint<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, UExtraOutput extends AnyExtensionDataRef, TConfig extends {
+    [key in string]: unknown;
+}, TConfigInput extends {
+    [key in string]: unknown;
+}, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+}> {
     dataRefs: TDataRefs;
     /**
      * Creates a new extension from the blueprint.
@@ -487,7 +634,9 @@ interface ExtensionBlueprint<TParams, TInputs extends AnyExtensionInputMap, TOut
      * You must either pass `params` directly, or define a `factory` that can
      * optionally call the original factory with the same params.
      */
-    make(args: {
+    make<TExtensionConfigSchema extends {
+        [key in string]: (zImpl: typeof z) => z.ZodType;
+    }, UFactoryOutput extends ExtensionDataValue<any, any>>(args: {
         namespace?: string;
         name?: string;
         attachTo?: {
@@ -496,20 +645,30 @@ interface ExtensionBlueprint<TParams, TInputs extends AnyExtensionInputMap, TOut
         };
         disabled?: boolean;
         inputs?: TInputs;
-        output?: TOutput;
-        configSchema?: PortableSchema<TConfig>;
-    } & ({
+        output?: Array<UExtraOutput>;
+        config?: {
+            schema: TExtensionConfigSchema & {
+                [KName in keyof TConfig]?: `Error: Config key '${KName & string}' is already defined in parent schema`;
+            };
+        };
+    } & (({
         factory(originalFactory: (params: TParams, context?: {
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-        }) => Expand<ExtensionDataValues<TOutput>>, context: {
+        }) => Iterable<ExtensionDataRefToValue<UOutput>>, context: {
             node: AppNode;
-            config: TConfig;
+            config: TConfig & {
+                [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+            };
             inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        }): Expand<ExtensionDataValues<TOutput>>;
-    } | {
+        }): Iterable<UFactoryOutput>;
+    } & VerifyExtensionFactoryOutput<UOutput & UExtraOutput, UFactoryOutput>) | {
         params: TParams;
-    })): ExtensionDefinition<TConfig>;
+    })): ExtensionDefinition<{
+        [key in keyof TExtensionConfigSchema]: z.infer<ReturnType<TExtensionConfigSchema[key]>>;
+    } & TConfig, z.input<z.ZodObject<{
+        [key in keyof TExtensionConfigSchema]: ReturnType<TExtensionConfigSchema[key]>;
+    }>> & TConfigInput>;
 }
 /**
  * A simpler replacement for wrapping up `createExtension` inside a kind or type. This allows for a cleaner API for creating
@@ -517,7 +676,20 @@ interface ExtensionBlueprint<TParams, TInputs extends AnyExtensionInputMap, TOut
  *
  * @public
  */
-declare function createExtensionBlueprint<TParams, TInputs extends AnyExtensionInputMap, TOutput extends AnyExtensionDataMap, TConfig, TDataRefs extends AnyExtensionDataMap = never>(options: CreateExtensionBlueprintOptions<TParams, TInputs, TOutput, TConfig, TDataRefs>): ExtensionBlueprint<TParams, TInputs, TOutput, TConfig, TDataRefs>;
+declare function createExtensionBlueprint<TParams, UOutput extends AnyExtensionDataRef, TInputs extends {
+    [inputName in string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, UExtraOutput extends AnyExtensionDataRef, TConfigSchema extends {
+    [key in string]: (zImpl: typeof z) => z.ZodType;
+}, UFactoryOutput extends ExtensionDataValue<any, any>, TDataRefs extends {
+    [name in string]: AnyExtensionDataRef;
+} = never>(options: CreateExtensionBlueprintOptions<TParams, UOutput, TInputs, TConfigSchema, UFactoryOutput, TDataRefs>): ExtensionBlueprint<TParams, UOutput, TInputs, UExtraOutput, string extends keyof TConfigSchema ? {} : {
+    [key in keyof TConfigSchema]: z.infer<ReturnType<TConfigSchema[key]>>;
+}, string extends keyof TConfigSchema ? {} : z.input<z.ZodObject<{
+    [key in keyof TConfigSchema]: ReturnType<TConfigSchema[key]>;
+}>>, TDataRefs>;
 
 /**
  * The specification for this {@link AppNode} in the {@link AppTree}.
@@ -534,7 +706,7 @@ interface AppNodeSpec {
         id: string;
         input: string;
     };
-    readonly extension: Extension<unknown>;
+    readonly extension: Extension<unknown, unknown>;
     readonly disabled: boolean;
     readonly config?: unknown;
     readonly source?: BackstagePlugin;
@@ -861,10 +1033,10 @@ declare function createApiExtension<TConfig extends {}, TInputs extends AnyExten
 }) & {
     configSchema?: PortableSchema<TConfig>;
     inputs?: TInputs;
-}): ExtensionDefinition<TConfig>;
+}): ExtensionDefinition<TConfig & {}, TConfig & {}>;
 /** @public */
 declare namespace createApiExtension {
-    const factoryDataRef: ConfigurableExtensionDataRef<"core.api.factory", AnyApiFactory, {}>;
+    const factoryDataRef: ConfigurableExtensionDataRef<AnyApiFactory, "core.api.factory", {}>;
 }
 
 /**
@@ -913,9 +1085,9 @@ declare function createAppRootWrapperExtension<TConfig extends {}, TInputs exten
 }): ExtensionDefinition<TConfig>;
 /** @public */
 declare namespace createAppRootWrapperExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<"app.root.wrapper", React.ComponentType<{
+    const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<{
         children?: React.ReactNode;
-    }>, {}>;
+    }>, "app.root.wrapper", {}>;
 }
 
 /**
@@ -942,9 +1114,9 @@ declare function createRouterExtension<TConfig extends {}, TInputs extends AnyEx
 }): ExtensionDefinition<TConfig>;
 /** @public */
 declare namespace createRouterExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<"app.router.wrapper", React.ComponentType<{
+    const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<{
         children?: React.ReactNode;
-    }>, {}>;
+    }>, "app.router.wrapper", {}>;
 }
 
 /**
@@ -986,14 +1158,16 @@ declare function createNavItemExtension(options: {
     icon: IconComponent$1;
 }): ExtensionDefinition<{
     title: string;
+}, {
+    title?: string | undefined;
 }>;
 /** @public */
 declare namespace createNavItemExtension {
-    const targetDataRef: ConfigurableExtensionDataRef<"core.nav-item.target", {
+    const targetDataRef: ConfigurableExtensionDataRef<{
         title: string;
         icon: IconComponent$1;
         routeRef: RouteRef<undefined>;
-    }, {}>;
+    }, "core.nav-item.target", {}>;
 }
 
 /**
@@ -1005,13 +1179,13 @@ declare function createNavLogoExtension(options: {
     namespace?: string;
     logoIcon: JSX.Element;
     logoFull: JSX.Element;
-}): ExtensionDefinition<never>;
+}): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createNavLogoExtension {
-    const logoElementsDataRef: ConfigurableExtensionDataRef<"core.nav-logo.logo-elements", {
+    const logoElementsDataRef: ConfigurableExtensionDataRef<{
         logoIcon?: JSX.Element | undefined;
         logoFull?: JSX.Element | undefined;
-    }, {}>;
+    }, "core.nav-logo.logo-elements", {}>;
 }
 
 /**
@@ -1035,14 +1209,14 @@ declare function createSignInPageExtension<TConfig extends {}, TInputs extends A
 }): ExtensionDefinition<TConfig>;
 /** @public */
 declare namespace createSignInPageExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<"core.sign-in-page.component", React.ComponentType<SignInPageProps>, {}>;
+    const componentDataRef: ConfigurableExtensionDataRef<React.ComponentType<SignInPageProps>, "core.sign-in-page.component", {}>;
 }
 
 /** @public */
-declare function createThemeExtension(theme: AppTheme): ExtensionDefinition<never>;
+declare function createThemeExtension(theme: AppTheme): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createThemeExtension {
-    const themeDataRef: ConfigurableExtensionDataRef<"core.theme.theme", AppTheme, {}>;
+    const themeDataRef: ConfigurableExtensionDataRef<AppTheme, "core.theme.theme", {}>;
 }
 
 /** @public */
@@ -1063,25 +1237,25 @@ declare function createComponentExtension<TProps extends {}, TConfig extends {},
             inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         }) => ComponentType<TProps>;
     };
-}): ExtensionDefinition<TConfig>;
+}): ExtensionDefinition<TConfig & {}, TConfig & {}>;
 /** @public */
 declare namespace createComponentExtension {
-    const componentDataRef: ConfigurableExtensionDataRef<"core.component.component", {
+    const componentDataRef: ConfigurableExtensionDataRef<{
         ref: ComponentRef;
         impl: ComponentType;
-    }, {}>;
+    }, "core.component.component", {}>;
 }
 
 /** @public */
 declare function createTranslationExtension(options: {
     name?: string;
     resource: TranslationResource | TranslationMessages;
-}): ExtensionDefinition<never>;
+}): ExtensionDefinition<{}, {}>;
 /** @public */
 declare namespace createTranslationExtension {
-    const translationDataRef: ConfigurableExtensionDataRef<"core.translation.translation", TranslationResource<string> | TranslationMessages<string, {
+    const translationDataRef: ConfigurableExtensionDataRef<TranslationResource<string> | TranslationMessages<string, {
         [x: string]: string;
-    }, boolean>, {}>;
+    }, boolean>, "core.translation.translation", {}>;
 }
 
 /** @public */
@@ -1089,14 +1263,23 @@ declare const IconBundleBlueprint: ExtensionBlueprint<{
     icons: {
         [x: string]: IconComponent;
     };
-}, AnyExtensionInputMap, {
-    icons: ConfigurableExtensionDataRef<"core.icons", {
-        [x: string]: IconComponent;
-    }, {}>;
-}, unknown, {
-    icons: ConfigurableExtensionDataRef<"core.icons", {
+}, ConfigurableExtensionDataRef<{
+    [x: string]: IconComponent;
+}, "core.icons", {}>, {
+    [x: string]: ExtensionInput<AnyExtensionDataRef, {
+        optional: boolean;
+        singleton: boolean;
+    }>;
+}, AnyExtensionDataRef, {
+    icons: string;
+    test: string;
+}, {
+    test: string;
+    icons?: string | undefined;
+}, {
+    icons: ConfigurableExtensionDataRef<{
         [x: string]: IconComponent;
-    }, {}>;
+    }, "core.icons", {}>;
 }>;
 
-export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataMap, type AnyExtensionInputMap, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type Extension, type ExtensionBlueprint, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataRef, type ExtensionDataValues, type ExtensionDefinition, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, IconBundleBlueprint, type IconComponent, type IconsApi, type PluginOptions, type PortableSchema, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, type SubRouteRef, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createApiExtension, createAppRootElementExtension, createAppRootWrapperExtension, createComponentExtension, createComponentRef, createExtension, createExtensionBlueprint, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createNavItemExtension, createNavLogoExtension, createPageExtension, createPlugin, createRouteRef, createRouterExtension, createSchemaFromZod, createSignInPageExtension, createSubRouteRef, createThemeExtension, createTranslationExtension, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };
+export { type AnalyticsApi, AnalyticsContext, type AnalyticsContextValue, type AnalyticsEvent, type AnalyticsEventAttributes, type AnalyticsTracker, type AnyExtensionDataMap, type AnyExtensionDataRef, type AnyExtensionInputMap, type AnyExternalRoutes, type AnyRouteRefParams, type AnyRoutes, type AppNode, type AppNodeEdges, type AppNodeInstance, type AppNodeSpec, type AppTree, type AppTreeApi, type BackstagePlugin, type CommonAnalyticsContext, type ComponentRef, type ComponentsApi, type ConfigurableExtensionDataRef, type CoreErrorBoundaryFallbackProps, type CoreNotFoundErrorPageProps, type CoreProgressProps, type CreateExtensionBlueprintOptions, type CreateExtensionOptions, type Extension, type ExtensionBlueprint, ExtensionBoundary, type ExtensionBoundaryProps, type ExtensionDataContainer, type ExtensionDataRef, type ExtensionDataRefToValue, type ExtensionDataValue, type ExtensionDataValues, type ExtensionDefinition, type ExtensionInput, type ExtensionOverrides, type ExtensionOverridesOptions, type ExternalRouteRef, type FeatureFlagConfig, type FrontendFeature, IconBundleBlueprint, type IconComponent, type IconsApi, type LegacyCreateExtensionOptions, type LegacyExtensionInput, type PluginOptions, type PortableSchema, type ResolvedExtensionInput, type ResolvedExtensionInputs, type RouteFunc, type RouteRef, type RouteResolutionApi, type RouteResolutionApiResolveOptions, type SubRouteRef, analyticsApiRef, appTreeApiRef, componentsApiRef, coreComponentRefs, coreExtensionData, createApiExtension, createAppRootElementExtension, createAppRootWrapperExtension, createComponentExtension, createComponentRef, createExtension, createExtensionBlueprint, createExtensionDataRef, createExtensionInput, createExtensionOverrides, createExternalRouteRef, createNavItemExtension, createNavLogoExtension, createPageExtension, createPlugin, createRouteRef, createRouterExtension, createSchemaFromZod, createSignInPageExtension, createSubRouteRef, createThemeExtension, createTranslationExtension, iconsApiRef, routeResolutionApiRef, useAnalytics, useComponentRef, useRouteRef, useRouteRefParams };

package/dist/schema/createSchemaFromZod.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"createSchemaFromZod.esm.js","sources":["../../src/schema/createSchemaFromZod.ts"],"sourcesContent":["/*\n * Copyright 2023 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { JsonObject } from '@backstage/types';\nimport { z, ZodSchema, ZodTypeDef } from 'zod';\nimport zodToJsonSchema from 'zod-to-json-schema';\nimport { PortableSchema } from './types';\n\n/** @public */\nexport function createSchemaFromZod<TOutput, TInput>(\n  schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>,\n): PortableSchema<TOutput> {\n  const schema = schemaCreator(z);\n  return {\n    // TODO: Types allow z.array etc here but it will break stuff\n    parse: input => {\n      const result = schema.safeParse(input);\n      if (result.success) {\n        return result.data;\n      }\n\n      throw new Error(result.error.issues.map(formatIssue).join('; '));\n    },\n    // TODO: Verify why we are not compatible with the latest zodToJsonSchema.\n    schema: zodToJsonSchema(schema) as JsonObject,\n  };\n}\n\nfunction formatIssue(issue: z.ZodIssue): string {\n  if (issue.code === 'invalid_union') {\n    return formatIssue(issue.unionErrors[0].issues[0]);\n  }\n  let message = issue.message;\n  if (message === 'Required') {\n    message = `Missing required value`;\n  }\n  if (issue.path.length) {\n    message += ` at '${issue.path.join('.')}'`;\n  }\n  return message;\n}\n"],"names":[],"mappings":";;;AAsBO,SAAS,oBACd,aACyB,EAAA;AACzB,EAAM,MAAA,MAAA,GAAS,cAAc,CAAC,CAAA,CAAA;AAC9B,EAAO,OAAA;AAAA;AAAA,IAEL,OAAO,CAAS,KAAA,KAAA;AACd,MAAM,MAAA,MAAA,GAAS,MAAO,CAAA,SAAA,CAAU,KAAK,CAAA,CAAA;AACrC,MAAA,IAAI,OAAO,OAAS,EAAA;AAClB,QAAA,OAAO,MAAO,CAAA,IAAA,CAAA;AAAA,OAChB;AAEA,MAAM,MAAA,IAAI,KAAM,CAAA,MAAA,CAAO,KAAM,CAAA,MAAA,CAAO,IAAI,WAAW,CAAA,CAAE,IAAK,CAAA,IAAI,CAAC,CAAA,CAAA;AAAA,KACjE;AAAA;AAAA,IAEA,MAAA,EAAQ,gBAAgB,MAAM,CAAA;AAAA,GAChC,CAAA;AACF,CAAA;AAEA,SAAS,YAAY,KAA2B,EAAA;AAC9C,EAAI,IAAA,KAAA,CAAM,SAAS,eAAiB,EAAA;AAClC,IAAA,OAAO,YAAY,KAAM,CAAA,WAAA,CAAY,CAAC,CAAE,CAAA,MAAA,CAAO,CAAC,CAAC,CAAA,CAAA;AAAA,GACnD;AACA,EAAA,IAAI,UAAU,KAAM,CAAA,OAAA,CAAA;AACpB,EAAA,IAAI,YAAY,UAAY,EAAA;AAC1B,IAAU,OAAA,GAAA,CAAA,sBAAA,CAAA,CAAA;AAAA,GACZ;AACA,EAAI,IAAA,KAAA,CAAM,KAAK,MAAQ,EAAA;AACrB,IAAA,OAAA,IAAW,CAAQ,KAAA,EAAA,KAAA,CAAM,IAAK,CAAA,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA,CAAA;AAAA,GACzC;AACA,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}
+{"version":3,"file":"createSchemaFromZod.esm.js","sources":["../../src/schema/createSchemaFromZod.ts"],"sourcesContent":["/*\n * Copyright 2023 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { JsonObject } from '@backstage/types';\nimport { z, ZodSchema, ZodTypeDef } from 'zod';\nimport zodToJsonSchema from 'zod-to-json-schema';\nimport { PortableSchema } from './types';\n\n/**\n * @public\n * @deprecated Use the `config.schema` option of `createExtension` instead, or use `createExtensionBlueprint`.\n */\nexport function createSchemaFromZod<TOutput, TInput>(\n  schemaCreator: (zImpl: typeof z) => ZodSchema<TOutput, ZodTypeDef, TInput>,\n): PortableSchema<TOutput, TInput> {\n  const schema = schemaCreator(z);\n  return {\n    // TODO: Types allow z.array etc here but it will break stuff\n    parse: input => {\n      const result = schema.safeParse(input);\n      if (result.success) {\n        return result.data;\n      }\n\n      throw new Error(result.error.issues.map(formatIssue).join('; '));\n    },\n    // TODO: Verify why we are not compatible with the latest zodToJsonSchema.\n    schema: zodToJsonSchema(schema) as JsonObject,\n  };\n}\n\nfunction formatIssue(issue: z.ZodIssue): string {\n  if (issue.code === 'invalid_union') {\n    return formatIssue(issue.unionErrors[0].issues[0]);\n  }\n  let message = issue.message;\n  if (message === 'Required') {\n    message = `Missing required value`;\n  }\n  if (issue.path.length) {\n    message += ` at '${issue.path.join('.')}'`;\n  }\n  return message;\n}\n"],"names":[],"mappings":";;;AAyBO,SAAS,oBACd,aACiC,EAAA;AACjC,EAAM,MAAA,MAAA,GAAS,cAAc,CAAC,CAAA,CAAA;AAC9B,EAAO,OAAA;AAAA;AAAA,IAEL,OAAO,CAAS,KAAA,KAAA;AACd,MAAM,MAAA,MAAA,GAAS,MAAO,CAAA,SAAA,CAAU,KAAK,CAAA,CAAA;AACrC,MAAA,IAAI,OAAO,OAAS,EAAA;AAClB,QAAA,OAAO,MAAO,CAAA,IAAA,CAAA;AAAA,OAChB;AAEA,MAAM,MAAA,IAAI,KAAM,CAAA,MAAA,CAAO,KAAM,CAAA,MAAA,CAAO,IAAI,WAAW,CAAA,CAAE,IAAK,CAAA,IAAI,CAAC,CAAA,CAAA;AAAA,KACjE;AAAA;AAAA,IAEA,MAAA,EAAQ,gBAAgB,MAAM,CAAA;AAAA,GAChC,CAAA;AACF,CAAA;AAEA,SAAS,YAAY,KAA2B,EAAA;AAC9C,EAAI,IAAA,KAAA,CAAM,SAAS,eAAiB,EAAA;AAClC,IAAA,OAAO,YAAY,KAAM,CAAA,WAAA,CAAY,CAAC,CAAE,CAAA,MAAA,CAAO,CAAC,CAAC,CAAA,CAAA;AAAA,GACnD;AACA,EAAA,IAAI,UAAU,KAAM,CAAA,OAAA,CAAA;AACpB,EAAA,IAAI,YAAY,UAAY,EAAA;AAC1B,IAAU,OAAA,GAAA,CAAA,sBAAA,CAAA,CAAA;AAAA,GACZ;AACA,EAAI,IAAA,KAAA,CAAM,KAAK,MAAQ,EAAA;AACrB,IAAA,OAAA,IAAW,CAAQ,KAAA,EAAA,KAAA,CAAM,IAAK,CAAA,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA,CAAA;AAAA,GACzC;AACA,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}