@imgly/plugin-ai-generation-web 0.1.9 → 0.2.0

package/dist/__tests__/ActionRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/compactSeparators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/createConfirmationRenderFunction.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{generation → assets}/getAssetResultForGenerated.d.ts

@@ -1,4 +1,4 @@
 import { type AssetResult } from '@cesdk/cesdk-js';
-import { type OutputKind, GetBlockInputResult, Output } from './provider';
+import { type OutputKind, GetBlockInputResult, Output } from '../core/provider';
 declare function getAssetResultForGenerated<K extends OutputKind>(id: string, kind: K, blockInputs: GetBlockInputResult<K>, output: Output): Promise<AssetResult>;
 export default getAssetResultForGenerated;

package/dist/{generation → assets}/getAssetResultForPlaceholder.d.ts

@@ -1,4 +1,4 @@
 import { type AssetResult } from '@cesdk/cesdk-js';
-import { type OutputKind, GetBlockInputResult } from './provider';
+import { type OutputKind, GetBlockInputResult } from '../core/provider';
 declare function getAssetResultForPlaceholder<K extends OutputKind>(id: string, kind: K, blockInput: GetBlockInputResult<K>): AssetResult;
 export default getAssetResultForPlaceholder;

package/dist/assets/initializeHistoryAssetLibraryEntry.d.ts

@@ -0,0 +1,7 @@
+import { OutputKind, Output } from '../core/provider';
+import { InitializationContext } from '../types';
+/**
+ * Initializes the history asset source for the given provider.
+ */
+declare function initializeHistoryAssetLibraryEntry<K extends OutputKind, I, O extends Output>(context: InitializationContext<K, I, O>, historyAssetSourceId?: string): string | undefined;
+export default initializeHistoryAssetLibraryEntry;

package/dist/assets/initializeHistoryAssetSource.d.ts

@@ -0,0 +1,7 @@
+import { OutputKind, Output } from '../core/provider';
+import { InitializationContext } from '../types';
+/**
+ * Initializes the history asset source for the given provider.
+ */
+declare function initializeHistoryAssetSource<K extends OutputKind, I, O extends Output>(context: InitializationContext<K, I, O>): string | undefined;
+export default initializeHistoryAssetSource;

package/dist/assets/initializeHistoryCompositeAssetSource.d.ts

@@ -0,0 +1,11 @@
+import { OutputKind } from '../core/provider';
+import CreativeEditorSDK from '@cesdk/cesdk-js';
+/**
+ * Initializes the combined history asset source for the given asset sources.
+ */
+declare function initializeHistoryCompositeAssetSource<K extends OutputKind>(options: {
+    kind: K;
+    cesdk: CreativeEditorSDK;
+    historAssetSourceIds: string[];
+}): string | undefined;
+export default initializeHistoryCompositeAssetSource;

package/dist/assets/integrateIntoDefaultAssetLibraryEntry.d.ts

@@ -0,0 +1,8 @@
+import { OutputKind } from '../core/provider';
+import CreativeEditorSDK from '@cesdk/cesdk-js';
+/**
+ * Integrates the asset sources into the default asset library entry for the
+ * given kind.
+ */
+declare function integrateIntoDefaultAssetLibraryEntry<K extends OutputKind>(kind: K, historAssetSourceIds: string[], cesdk: CreativeEditorSDK): string | undefined;
+export default integrateIntoDefaultAssetLibraryEntry;

package/dist/core/ActionRegistry.d.ts

@@ -0,0 +1,201 @@
+import { BuilderRenderFunctionContext, CreativeEngine, SceneMode, Scope } from '@cesdk/cesdk-js';
+import { OutputKind, Output } from './provider';
+import { Result } from '../generation/createGenerateFunction';
+/**
+ * Base properties shared by all action definitions.
+ */
+interface BaseActionDefinition {
+    /** Unique identifier for the action */
+    id: string;
+    /** Human-readable label for the action */
+    label?: string;
+    /** Detailed description of what the action does */
+    description?: string;
+    /** Optional metadata for additional information */
+    meta?: Record<string, any>;
+    /** The scene mode for which this action is only applicable */
+    sceneMode?: SceneMode;
+}
+/**
+ * Definition for a plugin action - a global action that can be invoked from apps, command palettes, etc.
+ */
+export interface PluginActionDefinition extends BaseActionDefinition {
+    /** Action type discriminator */
+    type: 'plugin';
+    /** ID of the plugin that registered this action */
+    pluginId: string;
+    /** Function to execute the action */
+    execute: () => void;
+}
+/**
+ * Render context for quick actions with generation capability.
+ */
+export interface QuickActionRenderContext<Q = Record<string, any>> {
+    /** Toggle between collapsed and expanded state */
+    toggleExpand: () => void;
+    /** Whether the quick action is currently expanded */
+    isExpanded: boolean;
+    /** Close the entire quick action popover */
+    close: () => void;
+    /** Generate output using the quick action input */
+    generate: (input: Q, options?: {
+        blockIds?: number[];
+    }) => Promise<Result<Output>>;
+    /** The ID of the provider used for this quick action */
+    providerId: string;
+}
+/**
+ * Definition for a quick action - a context-sensitive action that operates on selected blocks.
+ */
+export interface QuickActionDefinition<Q extends Record<string, any>> extends BaseActionDefinition {
+    /** Action type discriminator */
+    type: 'quick';
+    /** The kind of block this action operates on */
+    kind: OutputKind;
+    /**
+     * Defines if the quick action is enabled or not by using the
+     * feature api.
+     */
+    enable: boolean | ((context: {
+        engine: CreativeEngine;
+    }) => boolean);
+    /**
+     * Define the necessary scopes for this quick action.
+     */
+    scopes?: Scope[];
+    /**
+     * Overrides the defaults for this quick action.
+     */
+    defaults?: {
+        /** Should the generation be directly applied or does it need confirmation */
+        confirmation?: boolean;
+        /** Whether the block should be locked */
+        lock?: boolean;
+    };
+    /** Render function for the quick action UI */
+    render: (context: BuilderRenderFunctionContext<any> & QuickActionRenderContext<Q>) => void;
+}
+/**
+ * Union type of all supported action definitions.
+ */
+export type ActionDefinition = PluginActionDefinition | QuickActionDefinition<Record<string, any>>;
+/**
+ * Event types for ActionRegistry subscriptions.
+ */
+export type ActionRegistryEventType = 'registered' | 'unregistered';
+/**
+ * Callback function for ActionRegistry subscriptions.
+ */
+export type ActionRegistrySubscriberCallback = (action: ActionDefinition, event: ActionRegistryEventType) => void;
+/**
+ * Filters for querying and subscribing to specific types of actions.
+ * Used by both getBy() and subscribeBy() methods.
+ */
+export interface ActionRegistryFilters {
+    /** Filter by action type */
+    type?: ActionDefinition['type'];
+    /** Filter by plugin ID */
+    pluginId?: string;
+    /** Filter by action ID */
+    id?: string;
+    /** Filter by kind (only applicable for quick actions) */
+    kind?: OutputKind;
+}
+/**
+ * Global registry for managing plugin actions and quick actions.
+ * Uses singleton pattern to ensure a single source of truth across the application.
+ */
+export declare class ActionRegistry {
+    /** Map storing all registered actions by their ID */
+    private actions;
+    /** Map storing subscribers with their filters (null = subscribe to all) */
+    private subscribers;
+    private constructor();
+    /**
+     * Gets the singleton instance of the ActionRegistry.
+     * Uses global object storage to ensure singleton across different bundle contexts.
+     * @returns The ActionRegistry instance
+     */
+    static get(): ActionRegistry;
+    /**
+     * Registers an action in the registry.
+     * @param action The action definition to register
+     * @returns A disposer function that unregisters the action when called
+     */
+    register(action: ActionDefinition): () => void;
+    /**
+     * Gets all registered actions.
+     * @returns Array of all action definitions
+     */
+    getAll(): ActionDefinition[];
+    /**
+     * Gets actions matching the specified filters with full type safety.
+     * @param filters Object containing optional filters for type, pluginId, and id
+     * @returns Array of matching actions, typed based on the type filter
+     * @example
+     * // Get all plugin actions
+     * registry.getBy({ type: 'plugin' }) // Returns PluginActionDefinition[]
+     *
+     * // Get all actions from a specific plugin
+     * registry.getBy({ pluginId: 'ai-image-generation' }) // Returns ActionDefinition[]
+     *
+     * // Get specific action by ID
+     * registry.getBy({ id: 'generate-image' }) // Returns ActionDefinition[]
+     *
+     * // Combine filters
+     * registry.getBy({ type: 'quick', pluginId: 'ai-text' }) // Returns QuickActionDefinition[]
+     *
+     * // Filter quick actions by kind
+     * registry.getBy({ type: 'quick', kind: 'image' }) // Returns QuickActionDefinition[]
+     */
+    getBy<T extends ActionDefinition['type'] | undefined = undefined>(filters: {
+        /** Filter by action type */
+        type?: T;
+        /** Filter by plugin ID */
+        pluginId?: string;
+        /** Filter by action ID */
+        id?: string;
+        /** Filter by kind (only applicable for quick actions) */
+        kind?: OutputKind;
+    }): T extends ActionDefinition['type'] ? Extract<ActionDefinition, {
+        type: T;
+    }>[] : ActionDefinition[];
+    /**
+     * Subscribes to all registry events (register/unregister).
+     * @param callback Function to call when any action is registered or unregistered
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: ActionRegistrySubscriberCallback): () => void;
+    /**
+     * Subscribes to registry events for actions matching the specified filters.
+     * @param filters Filters to match actions against
+     * @param callback Function to call when matching actions are registered or unregistered
+     * @returns Unsubscribe function
+     * @example
+     * // Subscribe to plugin actions only
+     * registry.subscribeBy({ type: 'plugin' }, (action, event) => {
+     *   console.log(`Plugin action ${action.id} was ${event}`);
+     * });
+     *
+     * // Subscribe to actions from specific plugin
+     * registry.subscribeBy({ pluginId: 'ai-image' }, (action, event) => {
+     *   updateUIForPlugin(action, event);
+     * });
+     */
+    subscribeBy(filters: ActionRegistryFilters, callback: ActionRegistrySubscriberCallback): () => void;
+    /**
+     * Notifies all relevant subscribers about an action event.
+     * @param action The action that was registered or unregistered
+     * @param event The type of event that occurred
+     */
+    private notifySubscribers;
+    /**
+     * Checks if an action matches the given filters.
+     * Used by both getBy() and subscribeBy() methods.
+     * @param action The action to check
+     * @param filters The filters to match against
+     * @returns True if the action matches all filters
+     */
+    private matchesFilters;
+}
+export {};

package/dist/core/ProviderRegistry.d.ts

@@ -0,0 +1,40 @@
+import { ProviderInitializationResult } from '../providers/initializeProvider';
+import { OutputKind } from './provider';
+/**
+ * Global registry for managing AI generation providers across all plugins.
+ * Uses singleton pattern to ensure cross-plugin provider discovery.
+ */
+export declare class ProviderRegistry {
+    /** Map storing all registered providers by their ID */
+    private providers;
+    private constructor();
+    /**
+     * Gets the singleton instance of the ProviderRegistry.
+     * Uses global object storage to ensure singleton across different bundle contexts.
+     * @returns The ProviderRegistry instance
+     */
+    static get(): ProviderRegistry;
+    /**
+     * Registers a provider in the registry.
+     * @param providerInitializationResult The provider to register
+     * @returns A disposer function that unregisters the provider when called
+     */
+    register(providerInitializationResult: ProviderInitializationResult<any, any, any>): () => void;
+    /**
+     * Gets all registered providers.
+     * @returns Array of all provider instances
+     */
+    getAll(): ProviderInitializationResult<any, any, any>[];
+    /**
+     * Gets a provider by its ID.
+     * @param id The provider ID to look up
+     * @returns The provider instance or undefined if not found
+     */
+    getById(id: string): ProviderInitializationResult<any, any, any> | undefined;
+    /**
+     * Gets all providers of a specific kind.
+     * @param kind The output kind to filter by
+     * @returns Array of providers matching the specified kind
+     */
+    getByKind<K extends OutputKind>(kind: K): ProviderInitializationResult<K, any, any>[];
+}

package/dist/core/constants.d.ts

@@ -0,0 +1 @@
+export declare const ABORT_REASON_USER_CANCEL = "USER_CANCEL";

package/dist/{generation → core}/provider.d.ts

@@ -1,8 +1,8 @@
 import { type OpenAPIV3 } from 'openapi-types';
 import type CreativeEditorSDK from '@cesdk/cesdk-js';
-import { type NotificationDuration, type BuilderRenderFunctionContext, type CreativeEngine, Scope } from '@cesdk/cesdk-js';
-import { GetPropertyInput, Property } from './openapi/types';
-import { Middleware } from './middleware/middleware';
+import { type NotificationDuration, type BuilderRenderFunctionContext, type CreativeEngine } from '@cesdk/cesdk-js';
+import { GetPropertyInput, Property } from '../openapi/types';
+import { Middleware } from '../middleware/middleware';
 interface Provider<K extends OutputKind, I, O extends Output, C = O> {
     /**
      * Defines the kind of the generated asset. Maps to the kind
@@ -39,7 +39,10 @@ interface Provider<K extends OutputKind, I, O extends Output, C = O> {
          * Is used to generate panel content for the input.
          */
         panel?: PanelInput<K, I>;
-        quickActions?: QuickActionsInput<I, O>;
+        /**
+         * Defines the input for the generation.
+         */
+        quickActions?: QuickActionsInput<I>;
     };
     /**
      * Defines the output of the provider, i.e. the asset gneration.
@@ -57,7 +60,7 @@ interface Provider<K extends OutputKind, I, O extends Output, C = O> {
          * - '@imgly/indexedDB': The asset is stored in the browser's indexed db. On reload, the generated assets are still available, but only in the same browser.
          * - string: Any other string is used as the asset source ID. The user has to add the asset source during initialization. This can be used for instance to store generated assets in a outside database.
          */
-        history?: false | '@imgly/local' | '@imgly/indexedDB' | string;
+        history?: false | '@imgly/local' | '@imgly/indexedDB' | (string & {});
         /**
          * Configure if and what notification is shown after success and error.
          */
@@ -166,7 +169,7 @@ export type GenerationResult<O extends Output, C = O> = O | AsyncGenerator<O, C>
  * The options for the generation function.
  */
 export type GenerationOptions = {
-    abortSignal: AbortSignal;
+    abortSignal?: AbortSignal;
     engine: CreativeEngine;
     cesdk?: CreativeEditorSDK;
 };
@@ -277,7 +280,7 @@ export type GetBlockInputResult<K extends OutputKind> = Record<K, InputByKind[K]
 /**
  * All possible output kinds.
  */
-export type OutputKind = 'image' | 'video' | 'audio' | 'text';
+export type OutputKind = 'image' | 'video' | 'audio' | 'text' | 'sticker';
 /**
  * Mandatory kind-specific input needed for the generation.
  */
@@ -302,11 +305,16 @@ export type InputByKind = {
         label?: string;
         length: number;
     };
+    sticker: {
+        label?: string;
+        width: number;
+        height: number;
+    };
 };
 /**
  * The generated output of the provider.
  */
-export type Output = ImageOutput | VideoOutput | AudioOutput | TextOutput;
+export type Output = ImageOutput | VideoOutput | AudioOutput | TextOutput | StickerOutput;
 type OutputBase<K extends OutputKind> = {
     kind: K;
 };
@@ -328,60 +336,32 @@ export interface TextOutput extends OutputBase<'text'> {
     kind: 'text';
     text: string;
 }
-export type QuickActionContext<I, O extends Output> = {
-    blockIds: number[];
-    closeMenu: () => void;
-    toggleExpand: () => void;
-    /**
-     * Trigger generation with the given input.
-     *
-     * @param input The input for the generation.
-     * @param options The options for the generation.
-     * @param options.blockIds Use these blocks ids for the generation instead of the currently selected blocks.
-     */
-    generate: (input: I, options?: {
-        blockIds?: number[];
-    }) => Promise<O>;
+export interface StickerOutput extends OutputBase<'sticker'> {
+    kind: 'sticker';
+    url: string;
+}
+/**
+ * Support mapping for a specific quick action.
+ * Maps quick action input to provider input.
+ * Allows `true` or empty object `{}` as shorthand when quick action input is compatible with provider input.
+ */
+export type QuickActionSupport<I> = true | {
     /**
-     * Can be called to show a notification after the generation as it is
-     * configured for the provider.
+     * Map quick action input to provider input.
+     * @param quickActionInput The input from the quick action
+     * @returns The mapped input for the provider
      */
-    handleGenerationError: (error: unknown) => void;
+    mapInput: (quickActionInput: any) => I;
+} | {
+    [key: string]: any;
 };
-export type QuickActionsInput<I, O extends Output> = {
-    actions: QuickAction<I, O>[];
-};
-export type QuickAction<I, O extends Output> = {
-    id: string;
-    /**
-     * If set, the quick action is shown in the menu for this kind, instead
-     * of the kind of the provider. E.g. a video provider can add a quick action,
-     * to add a button in the image menu to generate a video from.
-     */
-    kind?: OutputKind;
-    version: '1';
-    /**
-     * Defines if the quick action is enabled or not by using the
-     * feature api.
-     */
-    enable: boolean | ((contxt: {
-        engine: CreativeEngine;
-    }) => boolean);
-    /**
-     * Define the necessary scopes for this quick action.
-     */
-    scopes?: Scope[];
+export type QuickActionsInput<I> = {
     /**
-     * If set to `true`, after the generation, the canvas menu
-     * will show a confirmation UI to confirm the generation.
+     * Supported global quick actions with input transformations.
+     * Key is the quick action ID, value is the transformation mapping.
      */
-    confirmation?: boolean;
-    /**
-     * If set to `true`, the selection is locked during the confirmation.
-     * The user cannot change the selection until the confirmation is done.
-     */
-    lockDuringConfirmation?: boolean;
-    render: (context: BuilderRenderFunctionContext<any>, quickActionContext: QuickActionContext<I, O>) => void;
-    renderExpanded?: (context: BuilderRenderFunctionContext<any>, quickActionContext: QuickActionContext<I, O>) => void;
+    supported?: {
+        [quickActionId: string]: QuickActionSupport<I>;
+    };
 };
 export default Provider;

package/dist/generation/CallbacksRegistry.d.ts

@@ -0,0 +1,34 @@
+import { ApplyCallbacks } from '../providers/getApplyCallbacks';
+export type Callbacks = {
+    /**
+     * Callbacks for the confirmation process.
+     */
+    applyCallbacks?: ApplyCallbacks;
+    /**
+     * Callback when generation is cancelled.
+     */
+    onCancelGeneration?: () => void;
+};
+/**
+ * Global registry for managing callbacks for quick action menus across different
+ * components.
+ */
+export declare class CallbacksRegistry {
+    /** Map storing all registered callbacks by their ID */
+    private actions;
+    private constructor();
+    /**
+     * Gets the singleton instance of the CallbacksRegistry.
+     * Uses global object storage to ensure singleton across different bundle contexts.
+     */
+    static get(): CallbacksRegistry;
+    /**
+     * Registers apply callbacks in the registry.
+     */
+    register(blockId: number, callbacks: Partial<Callbacks>): void;
+    /**
+     * Gets the callbacks for the given block id.
+     */
+    get(blockId: number): Callbacks;
+}
+export default CallbacksRegistry;

package/dist/generation/createGenerateFunction.d.ts

@@ -0,0 +1,30 @@
+import Provider, { Output, OutputKind } from '../core/provider';
+import { Middleware } from '../middleware/middleware';
+import CreativeEditorSDK, { CreativeEngine } from '@cesdk/cesdk-js';
+export type ResultSuccess<O> = {
+    status: 'success';
+    type: 'async';
+    output: AsyncGenerator<O>;
+} | {
+    status: 'success';
+    type: 'sync';
+    output: O;
+};
+export type Result<O> = ResultSuccess<O> | {
+    status: 'error';
+    message: string;
+} | {
+    status: 'aborted';
+};
+export type Generate<I, O extends Output> = (input: I, options?: {
+    abortSignal?: AbortSignal;
+    middlewares?: Middleware<I, O>[];
+    debug?: boolean;
+    dryRun?: boolean;
+}) => Promise<Result<O>>;
+declare function createGenerateFunction<K extends OutputKind, I, O extends Output>(context: {
+    provider: Provider<K, I, O>;
+    cesdk: CreativeEditorSDK;
+    engine: CreativeEngine;
+}): Generate<I, O>;
+export default createGenerateFunction;

package/dist/generation/handleGenerateFromPanel.d.ts

@@ -0,0 +1,50 @@
+import { type GetBlockInput, OutputKind, type Output } from '../core/provider';
+import { Generate, Result } from './createGenerateFunction';
+import CreativeEditorSDK from '@cesdk/cesdk-js';
+import { Middleware } from '../middleware/middleware';
+type PanelGenerationOptions<K extends OutputKind, I, O extends Output> = {
+    /**
+     * The kind to generate.
+     */
+    kind: K;
+    /**
+     * Initialized generate function
+     */
+    generate: Generate<I, O>;
+    /**
+     * The user flow for the generation process.
+     */
+    userFlow: 'placeholder' | 'generation-only';
+    /**
+     * Function to get block input from the generated input.
+     */
+    getBlockInput: GetBlockInput<K, I>;
+    /**
+     * Asset source id of the history library where a generated asset
+     * will be added.
+     */
+    historyAssetSourceId?: string;
+    /**
+     * Additional middlewares added to the generation process.
+     */
+    middlewares?: Middleware<I, O>[];
+    /**
+     * Print debug information to the console.
+     */
+    debug?: boolean;
+    /**
+     * Enable dry run mode for testing.
+     */
+    dryRun?: boolean;
+    /**
+     * Signal to check if process was aborted.
+     */
+    abortSignal: AbortSignal;
+    cesdk: CreativeEditorSDK;
+};
+/**
+ * Handler for generating content from a panel interface.
+ * Creates placeholder blocks and manages the generation process.
+ */
+declare function handleGenerateFromPanel<K extends OutputKind, I, O extends Output>(options: PanelGenerationOptions<K, I, O>): (input: I) => Promise<Result<O>>;
+export default handleGenerateFromPanel;

package/dist/generation/handleGenerateFromQuickAction.d.ts

@@ -0,0 +1,56 @@
+import { QuickActionDefinition } from '../core/ActionRegistry';
+import { Result } from './createGenerateFunction';
+import { ProviderInitializationResult } from '../providers/initializeProvider';
+import { Middleware } from '../middleware/middleware';
+import { Output, OutputKind } from '../core/provider';
+import CreativeEditorSDK from '@cesdk/cesdk-js';
+type GenerationOptions<Q extends Record<string, any>, K extends OutputKind, I, O extends Output> = {
+    /**
+     * The blocks that this quick action is running on.
+     */
+    blockIds: number[];
+    /**
+     * The initlaized provider that is used to generate the output.
+     */
+    providerInitializationResult?: ProviderInitializationResult<K, I, O>;
+    /**
+     * The quick action definition that is used to generate input for the provider
+     */
+    quickAction: QuickActionDefinition<Q>;
+    /**
+     * Shall the generation be confirmed before applying the result? Or directly applied?
+     */
+    confirmation?: boolean;
+    /**
+     * Should the blocks be locked to edit mode while the generation is running?
+     */
+    lock?: boolean;
+    /**
+     * Additional middlewares added to the generation process.
+     */
+    middlewares?: Middleware<I, O>[];
+    /**
+     * Print debug information to the console.
+     */
+    debug?: boolean;
+    /**
+     * Enable dry run mode for testing.
+     */
+    dryRun?: boolean;
+    /**
+     * Signal to check if process was aborted
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Close the quick action menu
+     */
+    close: () => void;
+    cesdk: CreativeEditorSDK;
+};
+/**
+ * Handler for generating output from a quick action.
+ */
+declare function handleGenerateFromQuickAction<Q extends Record<string, any>, K extends OutputKind, I, O extends Output>(options: GenerationOptions<Q, K, I, O>): (input: Q, generateOptions?: {
+    blockIds?: number[];
+}) => Promise<Result<O>>;
+export default handleGenerateFromQuickAction;

package/dist/generation/handleGenerationError.d.ts

@@ -1,9 +1,8 @@
 import CreativeEditorSDK from '@cesdk/cesdk-js';
-import Provider, { GetInput, Output, OutputKind } from './provider';
-import { InitProviderConfiguration } from './types';
+import Provider, { GetInput, Output, OutputKind } from '../core/provider';
 declare function handleGenerationError<K extends OutputKind, I, O extends Output>(error: unknown, options: {
     cesdk: CreativeEditorSDK;
     provider: Provider<K, I, O>;
     getInput?: GetInput<I>;
-}, config: InitProviderConfiguration): void;
+}): void;
 export default handleGenerationError;