@imgly/plugin-ai-generation-web 1.86.0-nightly.20261102 → 1.87.0-nightly.20261104

package/dist/index.d.ts

@@ -1,36 +1,1991 @@
-import renderImageUrlProperty, { attachImageToPrompt, canAttachImageToPrompt } from './ui/common/renderImageUrlProperty';
-import renderStyleTransferProperty from './ui/common/renderStyleTransferProperty';
+import CreativeEditorSDK, { BuilderRenderFunction, BuilderRenderFunctionContext, CreativeEngine, NotificationDuration, SceneMode, Scope } from "@cesdk/cesdk-js";
+import CreativeEngine$1 from "@cesdk/engine";
+declare namespace OpenAPIV3 {
+  interface Document<T extends {} = {}> {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject<T>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+    'x-express-openapi-validation-strict'?: boolean;
+  }
+  interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+  }
+  interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+  }
+  interface LicenseObject {
+    name: string;
+    url?: string;
+  }
+  interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+      [variable: string]: ServerVariableObject;
+    };
+  }
+  interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }
+  interface PathsObject<T extends {} = {}, P extends {} = {}> {
+    [pattern: string]: (PathItemObject<T> & P) | undefined;
+  }
+  enum HttpMethods {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head",
+    PATCH = "patch",
+    TRACE = "trace"
+  }
+  type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  } & { [method in HttpMethods]?: OperationObject<T>; };
+  type OperationObject<T extends {} = {}> = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: {
+      [callback: string]: ReferenceObject | CallbackObject;
+    };
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+  } & T;
+  interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+  }
+  interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+  }
+  interface HeaderObject extends ParameterBaseObject {}
+  interface ParameterBaseObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+  }
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface BaseSchemaObject {
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+  }
+  interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+      [value: string]: string;
+    };
+  }
+  interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  }
+  interface ReferenceObject {
+    $ref: string;
+  }
+  interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+  }
+  interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+      [media: string]: EncodingObject;
+    };
+  }
+  interface EncodingObject {
+    contentType?: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+  }
+  interface RequestBodyObject {
+    description?: string;
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+  }
+  interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+  }
+  interface ResponseObject {
+    description: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }
+  interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+      [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+  }
+  interface CallbackObject {
+    [url: string]: PathItemObject;
+  }
+  interface SecurityRequirementObject {
+    [name: string]: string[];
+  }
+  interface ComponentsObject {
+    schemas?: {
+      [key: string]: ReferenceObject | SchemaObject;
+    };
+    responses?: {
+      [key: string]: ReferenceObject | ResponseObject;
+    };
+    parameters?: {
+      [key: string]: ReferenceObject | ParameterObject;
+    };
+    examples?: {
+      [key: string]: ReferenceObject | ExampleObject;
+    };
+    requestBodies?: {
+      [key: string]: ReferenceObject | RequestBodyObject;
+    };
+    headers?: {
+      [key: string]: ReferenceObject | HeaderObject;
+    };
+    securitySchemes?: {
+      [key: string]: ReferenceObject | SecuritySchemeObject;
+    };
+    links?: {
+      [key: string]: ReferenceObject | LinkObject;
+    };
+    callbacks?: {
+      [key: string]: ReferenceObject | CallbackObject;
+    };
+  }
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  interface HttpSecurityScheme {
+    type: 'http';
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+  }
+  interface ApiKeySecurityScheme {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: string;
+  }
+  interface OAuth2SecurityScheme {
+    type: 'oauth2';
+    description?: string;
+    flows: {
+      implicit?: {
+        authorizationUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+    };
+  }
+  interface OpenIdSecurityScheme {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+  }
+  interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+  }
+}
+interface Property {
+  id: string;
+  schema?: OpenAPIV3.SchemaObject;
+}
+type PropertyInputBase = {
+  id: string;
+};
+type PropertyInputForString = PropertyInputBase & {
+  type: 'string';
+  value: string;
+};
+type PropertyInputForBoolean = PropertyInputBase & {
+  type: 'boolean';
+  value: boolean;
+};
+type PropertyInputForInteger = PropertyInputBase & {
+  type: 'integer';
+  value: number;
+};
+type PropertyInputForObject = PropertyInputBase & {
+  type: 'object';
+  value: Record<string, PropertyInput>;
+};
+type PropertyInputForStringArray = PropertyInputBase & {
+  type: 'array';
+  value: string[];
+};
+type PropertyInput = PropertyInputForString | PropertyInputForBoolean | PropertyInputForInteger | PropertyInputForObject | PropertyInputForStringArray;
+type GetPropertyInput = () => PropertyInput;
+/**
+ * Result of the generation with a dispose function to clean up
+ */
+interface DisposableGenerationResult<O extends Output> {
+  /**
+   * The actual generation result
+   */
+  result: GenerationResult<O>;
+  /**
+   * Function to dispose/clean up resources created during generation
+   * This should be called when the generation is cancelled or completely
+   * finished including the confirmation of the generation if applicable.
+   */
+  dispose: () => Promise<void>;
+}
+/**
+ * Define the type for middleware functions
+ */
+type Middleware<I, O extends Output> = (input: I, options: GenerationOptions & {
+  /**
+   * Adds a disposer function to this generation which is called
+   * when the generation is cancelled or completely finished
+   * including the confirmation of the generation if applicable.
+   */
+  addDisposer: (dispose: () => Promise<void>) => void;
+}, next: (input: I, options: GenerationOptions) => Promise<GenerationResult<O>>) => Promise<GenerationResult<O>>;
+export declare function composeMiddlewares<I, O extends Output>(middlewares: (Middleware<I, O> | false | undefined | null)[]): (baseHandler: (input: I, options: GenerationOptions) => Promise<GenerationResult<O>>) => (input: I, options: GenerationOptions) => Promise<DisposableGenerationResult<O>>;
+interface Provider<K extends OutputKind, I, O extends Output, C = O> {
+  /**
+   * Defines the kind of the generated asset. Maps to the kind
+   * CE.SDK
+   */
+  kind: K;
+  /**
+   * The unique identifier of the provider. Is used to generate other
+   * identifiers, like the panel ID or keys for translation.
+   */
+  id: string;
+  /**
+   * The human-readable name of the provider.
+   *
+   * Can be a string or a function that returns the current best-known name.
+   * The function form lets providers resolve the name asynchronously after
+   * registration (e.g. once a remote schema has loaded) without blocking
+   * `cesdk.addPlugin`. Consumers must call the function each time they
+   * render the label so that updates are picked up.
+   */
+  name?: string | (() => string);
+  /**
+   * Provider-specific configuration passed during initialization
+   * @internal
+   */
+  configuration?: any;
+  /**
+   * Initialize the provider when the plugin is loaded.
+   * Can be used to initialize libraries, and register additional UI components.
+   */
+  initialize?: (options: {
+    engine: CreativeEngine;
+    /**
+     * If undefined, this indicates that the plugin was loaded
+     * just with the engine and probably without an UI.
+     */
+    cesdk?: CreativeEditorSDK;
+  }) => Promise<void>;
+  /**
+   * Defines what inputs are needed for the generation and how
+   * to create an UI for them.
+   */
+  input: {
+    /**
+     * Is used to generate panel content for the input.
+     */
+    panel?: PanelInput<K, I>;
+    /**
+     * Defines the input for the generation.
+     */
+    quickActions?: QuickActionsInput<I>;
+  };
+  /**
+   * Defines the output of the provider, i.e. the asset gneration.
+   */
+  output: {
+    /**
+     * Can the generation of the output be aborted?
+     */
+    abortable?: boolean;
+    /**
+     * Defines if a generated asset should be stored in the history.
+     *
+     * - false: The generated asset is not stored in the history.
+     * - `@imgly/local`: The asset is stored in a local asset source. On reload, the generated assets are gone.
+     * - '@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 & {});
+    /**
+     * Configure if and what notification is shown after success and error.
+     */
+    notification?: {
+      /**
+       * Configure if and what notification is shown when the asset is generated.
+       */
+      success?: {
+        /**
+         * If true, the notification is shown. If false, the notification is not shown.
+         * Can be a function that returns a boolean.
+         */
+        show?: boolean | ((context: {
+          input: I;
+          output: O;
+        }) => boolean);
+        /**
+         * The message that is shown when the asset generation was successful. Can be a i18n key.
+         * A function can be used to dynamically generate the message based on the input and output.
+         */
+        message?: string | ((context: {
+          input: I;
+          output: O;
+        }) => string);
+        /**
+         * The action that is shown when the asset generation was successful.
+         */
+        action?: {
+          label: string | ((context: {
+            input: I;
+            output: O;
+          }) => string);
+          onClick: (context: {
+            input: I;
+            output: O;
+          }) => void;
+        };
+        /**
+         * The duration the notification is shown.
+         */
+        duration?: NotificationDuration;
+      };
+      /**
+       * Configure if and what notification is shown when generation failed
+       * If not set, a generic error message is shown.
+       */
+      error?: {
+        show?: boolean | ((context: {
+          input?: I;
+          error: unknown;
+        }) => boolean);
+        /**
+         * The message that is shown when the asset generation failed. Can be a i18n key.
+         * A function can be used to dynamically generate the message based on the input and output.
+         */
+        message?: string | ((context: {
+          input?: I;
+          error: unknown;
+        }) => string);
+        /**
+         * The action that is shown when the asset generation failed.
+         */
+        action?: {
+          label: string | ((context: {
+            input?: I;
+            error: unknown;
+          }) => string);
+          onClick: (context: {
+            input?: I;
+            error: unknown;
+          }) => void;
+        };
+        /**
+         * The duration the notification is shown.
+         */
+        duration?: NotificationDuration;
+      };
+    };
+    /**
+     * Generate the asset given the input.
+     *
+     * @returns The generated asset
+     */
+    generate: (input: I, options: GenerationOptions) => Promise<GenerationResult<O, C>>;
+    /**
+     * Short informational text to display below the generation button.
+     */
+    generationHintText?: string;
+    /**
+     * Middlware functions that can be used to hook into the
+     * generation process.
+     */
+    middleware?: Middleware<I, O>[];
+  };
+}
+/**
+ * The result of the generation function.
+ *
+ * Is either a promise that is directly returning
+ * the result of the generation, or an async generator
+ * that streams the result in chunks (C) and finally
+ * returns the final result (O).
+ */
+type GenerationResult<O extends Output, C = O> = O | AsyncGenerator<O, C>;
+/**
+ * The options for the generation function.
+ */
+type GenerationOptions = {
+  /**
+   * The block IDs that this generation is operating on.
+   * Middleware can use this to target specific blocks.
+   * - undefined: Middleware typically fall back to selected blocks
+   * - []: Explicitly target no blocks
+   * - [1, 2, 3]: Target specific blocks
+   *
+   * Note: This is passed through to middleware but not required by provider implementations.
+   */
+  blockIds?: number[];
+  abortSignal?: AbortSignal;
+  engine: CreativeEngine;
+  cesdk?: CreativeEditorSDK;
+  /**
+   * Prevents default UI feedback behaviors for this generation.
+   *
+   * **What gets prevented:**
+   * - Error/success notifications
+   * - Block error state
+   * - Console error logging
+   *
+   * **What is NOT prevented (always happens):**
+   * - Pending → Ready block state transition (loading spinner always stops)
+   * - Block validity checks
+   * - Middleware execution flow
+   *
+   * @example
+   * ```typescript
+   * catch (error) {
+   *   options.preventDefault();
+   *   myCustomErrorHandler(error);
+   *   throw error;
+   * }
+   * ```
+   */
+  preventDefault(): void;
+  /**
+   * Check if default behaviors have been prevented.
+   *
+   * @returns `true` if preventDefault() was called
+   *
+   * @example
+   * ```typescript
+   * if (!options.defaultPrevented()) {
+   *   // Show default notification
+   * }
+   * ```
+   *
+   * @internal
+   */
+  defaultPrevented(): boolean;
+};
+/**
+ * The context a custom property renderer is called with: the panel's builder
+ * context, plus what a schema property gets for free — the provider it belongs
+ * to and the configuration that may override it.
+ *
+ * Every extra is optional. A renderer can be called from a panel that has no
+ * provider behind it.
+ */
+type CustomPropertyContext = BuilderRenderFunctionContext<any> & {
+  provider?: {
+    id: string;
+  };
+  kind?: OutputKind;
+  /**
+   * The properties the panel renders. A renderer that pairs two properties
+   * uses it to tell whether its partner exists, and what its schema allows.
+   */
+  properties?: Property[];
+  providerConfig?: any;
+  config?: any;
+};
+type RenderCustomProperty = {
+  [key: string]: (context: CustomPropertyContext, property: Property) => GetPropertyInput;
+};
+type PanelInput<K extends OutputKind, I> = PanelInputCustom<K, I> | PanelInputSchema<K, I>;
+interface PanelInputBase {
+  /**
+   * Determines the flow of the asset generation.
+   *
+   * - `placeholder`: When `Generate` is clicked, the asset generation is triggered and a block is created as a placeholder with a loading state. Once the asset is generated, the block is updated with the asset and we add a history entry.
+   * - `generation-only`: When `Generate` is clicked, only the asset generation is triggered. No block is created.
+   *
+   *   @default 'generation-only'
+   */
+  userFlow?: 'placeholder' | 'generation-only';
+  /**
+   * If true, the history library is appended to the panel.
+   *
+   * @default true
+   */
+  includeHistoryLibrary?: boolean;
+}
+interface PanelInputSchema<K extends OutputKind, I> extends PanelInputBase {
+  type: 'schema';
+  /**
+   * The OpenAPI document/schema for a service.
+   *
+   * Can be provided as a static document or a lazy function that returns
+   * the document (or a Promise of it) — useful when the schema is fetched
+   * from the network only when the panel first opens.
+   */
+  document: OpenAPIV3.Document | (() => OpenAPIV3.Document | Promise<OpenAPIV3.Document>);
+  /**
+   * The reference to the input in the OpenAPI document.
+   * This is used to determine the input components for the generation panel.
+   *
+   * @example
+   * `#/components/schemas/GenerationInput`
+   */
+  inputReference: string;
+  /**
+   * The keyword that determines the order of properties. the
+   * referenced extension keyword should contain an array of strings
+   * representing the properties.
+   */
+  orderExtensionKeyword?: string | string[];
+  /**
+   * Defined the order of the properties in the panel. Takes precedence over
+   * the order defined in the schema (also see `orderExtensionKeyword`).
+   *
+   * If a function is provided, it receives the current order of properties from
+   * the schema and can return a new order.
+   */
+  order?: string[] | ((order: string[]) => string[]);
+  /**
+   * Returns the necessary input for the creation of a block.
+   *
+   */
+  getBlockInput: GetBlockInput<K, I>;
+  /**
+   * Allows to customize the components for some properties.
+   */
+  renderCustomProperty?: RenderCustomProperty;
+}
+interface PanelInputCustom<K extends OutputKind, I> extends PanelInputBase {
+  type: 'custom';
+  /**
+     * Is called to render custom UI components for the generation panel.
+     *
+     * @returns A function that returns the current input state and the context when called.
+     *
+     * @example
+     *
+       ```ts
+       render: ({ builder, state }, options) => {
+         const promptState = state('prompt', '');
+         builder.PromptInput('prompt', {
+           label: 'Prompt',
+           ...promptState
+         });
+  
+         return {
+           getInput: () => ({ prompt: promptState.value }),
+           getBlockInput: () => ({ image: { width: 1024, height: 1024 } })
+         };
+       }
+       ```
+     */
+  render: (context: BuilderRenderFunctionContext<any>, options: {
+    cesdk: CreativeEditorSDK;
+    isGenerating: boolean;
+  }) => {
+    getInput: GetInput<I>;
+    getBlockInput: GetBlockInput<K, I>;
+  };
+}
+/**
+ * Returns the current input state when called.
+ * This input is used for the AI generation
+ */
+type GetInput<I> = () => {
+  input: I;
+};
+/**
+ * Returns the input that is needed to create a block
+ * for a given output kind.
+ */
+type GetBlockInput<K extends OutputKind, I> = (input: I) => Promise<GetBlockInputResult<K>>;
+type GetBlockInputResult<K extends OutputKind> = Record<K, InputByKind[K]>;
+/**
+ * All possible output kinds.
+ */
+type OutputKind = 'image' | 'video' | 'audio' | 'text' | 'sticker';
+/**
+ * Mandatory kind-specific input needed for the generation.
+ */
+type InputByKind = {
+  image: {
+    label?: string;
+    width: number;
+    height: number;
+  };
+  video: {
+    label?: string;
+    width: number;
+    height: number;
+    duration: number;
+  };
+  audio: {
+    label?: string;
+    thumbnailUrl?: string;
+    duration?: number;
+  };
+  text: {
+    label?: string;
+    length: number;
+  };
+  sticker: {
+    label?: string;
+    width: number;
+    height: number;
+  };
+};
+/**
+ * The generated output of the provider.
+ */
+type Output = ImageOutput | VideoOutput | AudioOutput | TextOutput | StickerOutput;
+type OutputBase<K extends OutputKind> = {
+  kind: K;
+};
+interface ImageOutput extends OutputBase<'image'> {
+  kind: 'image';
+  url: string;
+}
+interface VideoOutput extends OutputBase<'video'> {
+  kind: 'video';
+  url: string;
+}
+interface AudioOutput extends OutputBase<'audio'> {
+  kind: 'audio';
+  url: string;
+  duration: number;
+  thumbnailUrl?: string;
+}
+interface TextOutput extends OutputBase<'text'> {
+  kind: 'text';
+  text: string;
+}
+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.
+ */
+type QuickActionSupport<I> = true | {
+  /**
+   * Map quick action input to provider input.
+   * @param quickActionInput The input from the quick action
+   * @returns The mapped input for the provider
+   */
+  mapInput: (quickActionInput: any) => I;
+} | {
+  [key: string]: any;
+};
+type QuickActionsInput<I> = {
+  /**
+   * Supported global quick actions with input transformations.
+   * Key is the quick action ID, value is the transformation mapping.
+   */
+  supported?: {
+    [quickActionId: string]: QuickActionSupport<I>;
+  };
+};
+/**
+ * Provides the render functions for an image url property, and for the prompt
+ * that refers to it.
+ *
+ * The image is not a control of its own: it shows inside the prompt, which is
+ * the one place a user describes what to generate. So this returns two
+ * renderers — the image property contributes only its value, and the prompt
+ * property draws the field plus the image row.
+ *
+ * The row takes as many images as the image property's schema allows: one for
+ * a string, `maxItems` for an array. An array without `maxItems` takes one,
+ * as the model's own limit is unknown.
+ *
+ * By default this expects the property key to be `image_url` and the prompt to
+ * be `prompt`. Both can be changed in the options.
+ */
+declare function renderImageUrlProperty(provderId: string, options: {
+  cesdk: CreativeEditorSDK;
+  propertyKey?: string;
+  promptPropertyKey?: string;
+  defaultUrl?: string;
+}): RenderCustomProperty;
+/**
+ * Whether the prompt of a provider's generation panel has room for one more
+ * image. False for a provider without an image row.
+ *
+ * @param cesdk The editor whose panel state holds the images.
+ * @param providerId The provider whose prompt would receive the image.
+ * @returns Whether `attachImageToPrompt` would attach an image.
+ */
+export declare function canAttachImageToPrompt(cesdk: CreativeEditorSDK, providerId: string): boolean;
+/**
+ * Attaches an image to the prompt of a provider's generation panel, beside
+ * the images already there, as picking it from the library would.
+ *
+ * @param cesdk The editor whose panel state holds the images.
+ * @param providerId The provider whose prompt receives the image.
+ * @param uri The image to attach.
+ * @returns Whether the image is attached afterwards. False for a provider
+ * without an image row, and for a row with no room left.
+ */
+export declare function attachImageToPrompt(cesdk: CreativeEditorSDK, providerId: string, uri: string): boolean;
+type Style = {
+  id: 'none' | (string & {});
+  label: string;
+  prompt: string;
+  thumbUri: string;
+};
+/**
+ * Provides render function for a style transfer property that allows
+ * to change a style (of an image) from a library.
+ *
+ * The style will be appended to the prompt property, so the model does
+ * not need to support style transfer directly.
+ *
+ * By default this expects the property key to be `style`. This can be changed with the option
+ * `propertyKey`.
+ */
+declare function renderStyleTransferProperty(providerId: string, options: {
+  cesdk?: CreativeEditorSDK;
+  /**
+   * Base URL used for the UI assets used in the plugin.
+   */
+  baseURL?: string;
+  /**
+   * What property key to use for the style property.
+   */
+  propertyKey?: string;
+  /**
+   * What property key to use for the prompt property.
+   */
+  propertyKeyForPrompt?: string;
+  /**
+   * Override the default styles
+   */
+  styles?: Style[] | ((defaultStyles: Style[]) => Style[]);
+  /**
+   * Overrides the default i18n translations for the prompt input.
+   */
+  i18n?: {
+    prompt?: {
+      inputLabel?: string;
+      placeholder?: string;
+    };
+  };
+}): RenderCustomProperty;
+/**
+ * Base context provided to all property default functions
+ */
+interface PropertyContext {
+  /**
+   * Creative Engine instance
+   * Always available for engine-level operations
+   */
+  engine: CreativeEngine;
+  /**
+   * Creative Editor SDK instance
+   * May be undefined if running headless or without UI
+   */
+  cesdk?: CreativeEditorSDK;
+  /**
+   * Current locale for internationalization
+   * Format: ISO 639-1 language code (e.g., 'en', 'de', 'ja')
+   * Defaults to 'en' if not available
+   */
+  locale: string;
+}
+/**
+ * Configuration for a single property
+ * @template T - The type of the property value
+ * @template C - The context type (defaults to PropertyContext)
+ */
+interface PropertyConfig<T, C extends PropertyContext = PropertyContext> {
+  /**
+   * Default value for the property
+   * Can be a static value or a function that returns the value
+   */
+  default?: T | ((context: C) => T);
+}
+/**
+ * Properties configuration for a provider
+ * @template I - The input type of the provider
+ */
+type PropertiesConfiguration<I> = { [K in keyof Partial<I>]?: PropertyConfig<I[K]>; };
+/**
+ * Utility type for extending property contexts selectively
+ * @template I - The input type of the provider
+ * @template ContextMap - Map of property names to their extended context types
+ *
+ * @example
+ * ```typescript
+ * type MyConfig = ExtendPropertyContexts<MyInput, {
+ *   style: StyleContext;  // style property gets StyleContext
+ *   // other properties get PropertyContext
+ * }>;
+ * ```
+ */
+type ExtendPropertyContexts<I, ContextMap extends Partial<Record<keyof I, PropertyContext>>> = { [K in keyof Partial<I>]: K extends keyof ContextMap ? ContextMap[K] extends PropertyContext ? PropertyConfig<I[K], ContextMap[K]> : PropertyConfig<I[K]> : PropertyConfig<I[K]>; };
+/**
+ * A common configuration used by the plugins and the provider.
+ */
+interface CommonConfiguration<I, O extends Output> {
+  /**
+   * Render console logs for debugging purposes.
+   */
+  debug?: boolean;
+  /**
+   * Dry run mode. If set to true, the plugin will not make any API calls.
+   */
+  dryRun?: boolean;
+  /**
+   * Middlewares to add to the provider generation
+   */
+  middlewares?: Middleware<I, O>[];
+}
+/**
+ * Configuration to set provider and models for image generation.
+ */
+interface CommonPluginConfiguration<K extends OutputKind, I, O extends Output> extends CommonConfiguration<I, O> {
+  /**
+   * Base URL used for the UI assets used in the plugin.
+   *
+   * By default, we load the assets from the IMG.LY CDN. You can copy the assets.
+   * from the `/assets` folder to your own server and set the base URL to your server.
+   */
+  baseURL?: string;
+}
+/**
+ * Returns a provider for a given cesdk instance.
+ */
+type GetProvider<K extends OutputKind> = ({ cesdk }: {
+  cesdk: CreativeEditorSDK;
+}) => Promise<Provider<K, any, any>>;
+/**
+ * Common provider configuration that all providers should provide.
+ */
+interface CommonProviderConfiguration<I, O extends Output> extends CommonConfiguration<I, O> {
+  /**
+   * The proxy URL to use for the provider.
+   */
+  proxyUrl: string;
+  /**
+   * Headers that shall be sent with the request of the provider.
+   */
+  headers?: Record<string, string>;
+  /**
+   * Middlewares to add to the provider generation
+   * @deprecated Use `middlewares` instead.
+   */
+  middleware?: Middleware<I, O>[];
+  /**
+   * Override provider's default history asset source that is used to show the generation history
+   *
+   * - false: Disable history storage
+   * - '@imgly/local': Use temporary local storage (not persistent)
+   * - '@imgly/indexedDB': Use browser storage that is persistent across sessions in the same browser
+   * - string: Use your own custom asset source ID
+   */
+  history?: false | '@imgly/local' | '@imgly/indexedDB' | (string & {});
+  /**
+   * Configure supported quick actions
+   * - Set to false/null to disable a quick action
+   * - Partial<QuickActionSupport<I>> to override the default configuration
+   */
+  supportedQuickActions?: {
+    [quickActionId: string]: Partial<QuickActionSupport<I>> | false | null;
+  };
+  /**
+   * Configure property behavior and defaults
+   * @example
+   * ```typescript
+   * {
+   *   properties: {
+   *     style: { default: 'realistic_image' },
+   *     prompt: { default: (ctx) => ctx.locale === 'de' ? 'Erstelle...' : 'Create...' }
+   *   }
+   * }
+   * ```
+   */
+  properties?: PropertiesConfiguration<I>;
+}
+/**
+ * Internal configuration interface for provider initialization.
+ * This extends the public CommonPluginConfiguration with required provider field.
+ */
+interface InternalPluginConfiguration<K extends OutputKind, I, O extends Output> extends CommonConfiguration<I, O> {
+  /**
+   * The provider to use for generation.
+   */
+  provider: Provider<K, I, O>;
+  /**
+   * The panel input schema to use for the provider.
+   */
+  panelInput?: PanelInput<K, I>;
+}
+/**
+ * Options for UI interactions
+ */
+type UIOptions = {
+  cesdk: CreativeEditorSDK;
+  engine: CreativeEngine;
+  historyAssetSourceId?: string;
+  historyAssetLibraryEntryId?: string;
+};
+/**
+ * Build the base property context from available sources
+ */
+export declare function buildPropertyContext(engine: CreativeEngine, cesdk?: CreativeEditorSDK): PropertyContext;
+/**
+ * Context cache for performance optimization
+ */
+export declare class PropertyContextCache {
+  private cache;
+  /**
+   * Get cached context or build new one
+   */
+  getContext(engine: CreativeEngine, cesdk?: CreativeEditorSDK): PropertyContext;
+  /**
+   * Clear the cache (e.g., when locale changes)
+   */
+  clear(): void;
+}
+/**
+ * Resolve the default value for a property
+ * @template T - The property value type
+ * @template C - The context type
+ */
+export declare function resolvePropertyDefault<T, C extends PropertyContext = PropertyContext>(propertyId: string, propertyConfig: PropertyConfig<T, C> | undefined, context: C, schemaDefault?: T, fallback?: T): T | undefined;
+/**
+ * Batch resolve multiple property defaults
+ */
+export declare function resolvePropertyDefaults<I, C extends PropertyContext = PropertyContext>(properties: Array<{
+  id: keyof I;
+  config?: PropertyConfig<I[keyof I], C>;
+  schemaDefault?: I[keyof I];
+  fallback?: I[keyof I];
+}>, context: C): Partial<I>;
+/**
+ * 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;
+type ResultSuccess<O> = {
+  status: 'success';
+  type: 'async';
+  output: AsyncGenerator<O>;
+  middlewareOptions?: GenerationOptions;
+} | {
+  status: 'success';
+  type: 'sync';
+  output: O;
+  middlewareOptions?: GenerationOptions;
+};
+type Result<O> = ResultSuccess<O> | {
+  status: 'error';
+  message: string;
+  /**
+   * The value that was thrown, preserved so consumers can inspect it
+   * instead of pattern-matching `message`. Gateway failures carry a
+   * `GatewayError` here — narrow it with `isGatewayError`.
+   */
+  error?: unknown;
+  middlewareOptions?: GenerationOptions;
+} | {
+  status: 'aborted';
+  middlewareOptions?: GenerationOptions;
+};
+type Generate<I, O extends Output> = (input: I, options?: {
+  /**
+   * The block IDs that this generation is operating on.
+   * - undefined: Middleware will fall back to selected blocks
+   * - []: Explicitly target no blocks
+   * - [1, 2, 3]: Target specific blocks (e.g., placeholder block)
+   */
+  blockIds?: number[];
+  abortSignal?: AbortSignal;
+  middlewares?: Middleware<I, O>[];
+  debug?: boolean;
+  dryRun?: boolean;
+}) => Promise<Result<O>>;
+/**
+ * Base properties shared by all action definitions.
+ */
+interface BaseActionDefinition {
+  /** Unique identifier for the action */
+  id: string;
+  /** Human-readable label for the action (fallback when labelKey is not available) */
+  label?: string;
+  /** Translation key for the label (preferred for i18n support) */
+  labelKey?: 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.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+type ActionDefinition = PluginActionDefinition | QuickActionDefinition<Record<string, any>>;
+/**
+ * Event types for ActionRegistry subscriptions.
+ */
+type ActionRegistryEventType = 'registered' | 'unregistered';
+/**
+ * Callback function for ActionRegistry subscriptions.
+ */
+type ActionRegistrySubscriberCallback = (action: ActionDefinition, event: ActionRegistryEventType) => void;
+/**
+ * Filters for querying and subscribing to specific types of actions.
+ * Used by both getBy() and subscribeBy() methods.
+ */
+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;
+}
+type ProviderInitializationResult<K extends OutputKind, I, O extends Output> = {
+  provider: Provider<K, I, O>;
+  panel: {
+    builderRenderFunction?: BuilderRenderFunction;
+  };
+  history: {
+    assetSourceId?: string;
+    assetLibraryEntryId?: string;
+  };
+  generate: Generate<I, O>;
+};
+/**
+ * Initializes a provider with the given configuration and options.
+ */
+declare function initializeProvider<K extends OutputKind, I, O extends Output>(_kind: K, provider: Provider<K, I, O>, options: {
+  cesdk: CreativeEditorSDK;
+}, config: CommonPluginConfiguration<K, I, O>): Promise<ProviderInitializationResult<K, I, O>>;
+/**
+ * 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>[];
+}
+declare function loggingMiddleware<I, O extends Output>({ enable }: {
+  enable: boolean | undefined;
+}): Middleware<I, O>;
+/**
+ * Middleware to upload the output of a generation process.
+ *
+ * Sometimes it is not possible to use the result of a provider or
+ * not even allowed to use it directly. This middleware allows you to upload
+ * the result of a generation process to a server or a cloud storage.
+ *
+ * @param upload The function to upload the output. It should return a promise
+ */
+declare function uploadMiddleware<I, O extends Output>(upload: (output: O) => Promise<O>): Middleware<I, O>;
+/**
+ * Merge quick actions configuration by combining provider defaults with user configuration overrides
+ *
+ * @param providerDefaults - The default quick actions from the provider
+ * @param userConfig - The user's configuration overrides
+ * @returns Merged quick actions configuration
+ */
+export declare function mergeQuickActionsConfig<T extends Record<string, any>>(providerDefaults: T, userConfig?: {
+  [quickActionId: string]: any | false | null;
+}): T;
+interface RateLimitOptions<I> {
+  /**
+   * Maximum number of requests allowed in the time window
+   */
+  maxRequests: number;
+  /**
+   * Time window in milliseconds
+   */
+  timeWindowMs: number;
+  /**
+   * Optional key function or string to create different rate limits for different inputs
+   * - If not provided, all requests share the same 'global' rate limit
+   * - If a string is provided, that string is used as a static key
+   * - If a function is provided, it generates a key based on input and options
+   */
+  keyFn?: string | ((input: I, options: GenerationOptions) => string);
+  /**
+   * Callback function that is called when rate limit is exceeded
+   * Return value determines if the operation should be rejected (throw error) or allowed
+   * If true is returned, the operation will proceed despite exceeding the rate limit
+   * If false or undefined is returned, the operation will be rejected with a default error
+   */
+  onRateLimitExceeded?: (input: I, options: GenerationOptions, rateLimitInfo: {
+    key: string;
+    currentCount: number;
+    maxRequests: number;
+    timeWindowMs: number;
+    remainingTimeMs: number;
+  }) => boolean | Promise<boolean> | void;
+  /**
+   * Optional database name for the IndexedDB store
+   * If not provided, a default name will be used
+   */
+  dbName?: string;
+  /**
+   * Disable the rate limit middleware
+   */
+  disable?: boolean | (() => boolean);
+}
+/**
+ * Middleware that implements rate limiting for AI generation requests
+ * Uses IndexedDB for storage when available, with in-memory fallback
+ * Each middleware instance has its own isolated set of rate limits
+ */
+declare function rateLimitMiddleware<I, O extends Output>(middlewareOptions: RateLimitOptions<I>): Middleware<I, O>;
+/**
+ * Returns a consistent panel ID for a provider ID
+ */
+export declare function getPanelId(providerId: string): string;
+/**
+ * Gets the duration of a video from a URL
+ * @param url - The URL of the video
+ * @returns A promise that resolves to the duration of the video in seconds
+ */
+export declare function getDurationForVideo(url: string): Promise<number>;
+/**
+ * Gets a thumbnail image from a video URL
+ * @param url - The URL of the video
+ * @param seekTime - Time in seconds to capture the thumbnail (default: 0)
+ * @param format - Image format for the thumbnail (default: 'image/jpeg')
+ * @param quality - Image quality between 0 and 1 (default: 0.8)
+ * @returns A promise that resolves to the thumbnail data URL
+ */
+export declare function getThumbnailForVideo(url: string, seekTime?: number, format?: string, quality?: number): Promise<string>;
+/**
+ * Converts an ID string to a human-readable label
+ * @param id - The ID string to convert
+ * @returns A human-readable label derived from the ID
+ *
+ * Examples:
+ * - snake_case_id → Snake Case Id
+ * - kebab-case-id → Kebab Case Id
+ * - camelCaseId → Camel Case Id
+ * - PascalCaseId → Pascal Case Id
+ */
+export declare function getLabelFromId(id: string): string;
+/**
+ * Type guard to check if a value is an AsyncGenerator rather than a Promise
+ *
+ * @param value - Value of type Promise<O> | AsyncGenerator<O, C>
+ * @returns Boolean indicating if the value is an AsyncGenerator
+ */
+export declare function isAsyncGenerator<O extends Output, C>(value: GenerationResult<O, C>): value is AsyncGenerator<O, C>;
+/**
+ * Adds an icon set to the CreativeEditorSDK UI only once. Marks
+ * it as added in the global state to prevent multiple additions.
+ */
+export declare function addIconSetOnce(cesdk: CreativeEditorSDK, id: string, icons: string): void;
+/**
+ * Normalizes a base URL to ensure it has exactly one trailing slash.
+ *
+ * @param url - The base URL to normalize
+ * @returns The normalized URL with exactly one trailing slash
+ *
+ * @example
+ * normalizeBaseURL('https://example.com') // 'https://example.com/'
+ * normalizeBaseURL('https://example.com/') // 'https://example.com/'
+ * normalizeBaseURL('https://example.com//') // 'https://example.com/'
+ */
+export declare function normalizeBaseURL(url: string): string;
+/**
+ * Checks if the current AI plugin version matches the shared version across all AI plugins.
+ * Issues a console warning if versions don't match.
+ *
+ * @param cesdk - The CreativeEditorSDK instance
+ * @param pluginId - The ID of the current plugin
+ * @param currentVersion - The version of the current plugin
+ */
+export declare function checkAiPluginVersion(cesdk: CreativeEditorSDK, pluginId: string, currentVersion: string): void;
+/**
+ * Registers a dock component for AI generation that opens
+ * the AI generation panel and closes any other AI panels.
+ */
+declare function registerDockComponent(options: {
+  cesdk: CreativeEditorSDK;
+  panelId: string;
+}): void;
+/**
+ * Enable function for a single image fill block selected.
+ */
+declare function enableImageFill(): ({ engine }: {
+  engine: CreativeEngine$1;
+}) => boolean;
+export declare function isGeneratingStateKey(providerId: string): string;
+export declare function abortGenerationStateKey(providerId: string): string;
+type ProvidersInitializationResult<K extends OutputKind, I, O extends Output> = {
+  /**
+   * Combined panel render function for all providers.
+   */
+  panel: {
+    builderRenderFunction?: BuilderRenderFunction;
+  };
+  /**
+   * Combined history asset source and library entry IDs for the providers.
+   */
+  history?: {
+    assetSourceId?: string;
+    assetLibraryEntryId?: string;
+  };
+  /**
+   * All individual initialization results of the providers, i.e.
+   * the result of `initializeProvider` for every provider.
+   */
+  providerInitializationResults: ProviderInitializationResult<K, I, O>[];
+};
+/**
+ * Initializes the given providers for the specified output kind.
+ *
+ * - It will create a combined render function for all providers
+ *   that can be used in a panel
+ *
+ */
+declare function initializeProviders<K extends OutputKind, I, O extends Output>(kind: K, providers: {
+  fromText: Provider<K, I, O>[];
+  fromImage: Provider<K, I, O>[];
+} | Provider<K, I, O>[], options: {
+  cesdk: CreativeEditorSDK;
+}, config: CommonPluginConfiguration<K, I, O>): Promise<ProvidersInitializationResult<K, I, O>>;
+declare function initializeQuickActionComponents<K extends OutputKind, I, O extends Output>(context: {
+  kind: K;
+  providerInitializationResults: ProviderInitializationResult<K, I, O>[];
+  cesdk: CreativeEditorSDK;
+  engine: CreativeEngine;
+  debug?: boolean;
+  dryRun?: boolean;
+  defaultOrder?: string[];
+}): Promise<{
+  renderFunction: BuilderRenderFunction<any>;
+}>;
+/**
+ * Extracts translations from OpenAPI schema properties and sets them via cesdk.i18n
+ * This includes:
+ * - Schema property titles as `ly.img.plugin-ai-${kind}-generation-web.${provider.id}.defaults.property.${property.id}`
+ * - Enum value labels as `ly.img.plugin-ai-${kind}-generation-web.${provider.id}.defaults.property.${property.id}.${valueId}`
+ * - AnyOf enum value labels with the same pattern
+ */
+export declare function extractAndSetSchemaTranslations<K extends OutputKind, I, O extends Output>(properties: Property[], provider: Provider<K, I, O>, options: UIOptions, kind: K): void;
+export declare const AI_EDIT_MODE = "ly.img.ai.editMode";
+export declare const AI_METADATA_KEY = "ly.img.ai.metadata";
+interface GatewayClient {
+  fetchSchema: (modelId: string) => Promise<GatewaySchemaResult>;
+  upload: (data: Blob, contentType: string) => Promise<GatewayUploadResult>;
+  /**
+   * URL-based generation (image, video, audio).
+   * Waits for `generation.completed` and returns the output URL.
+   */
+  generate: (modelId: string, input: Record<string, unknown>, options: {
+    abortSignal?: AbortSignal;
+    outputFilter?: (output: GatewaySSEOutput) => boolean;
+  }) => Promise<string>;
+  /**
+   * Streaming text generation.
+   * Yields accumulated text on each `generation.delta` event.
+   * Returns the final accumulated text on `generation.completed`.
+   */
+  generateStream: (modelId: string, input: Record<string, unknown>, options: {
+    abortSignal?: AbortSignal;
+  }) => AsyncGenerator<string, string>;
+}
+export declare function createGatewayClient(gatewayUrl: string, getToken: () => Promise<string>, headers?: Record<string, string>, tokenCacheTTLMs?: number): GatewayClient;
+interface GatewayProviderConfiguration {
+  /**
+   * Base URL of the gateway service.
+   *
+   * @default 'https://gateway.img.ly'
+   */
+  gatewayUrl?: string;
+  /**
+   * Human-readable display name for this model. Overrides the name
+   * returned by the gateway schema. When omitted, the provider uses
+   * `schema.name` once the schema resolves, falling back to `modelId`
+   * in the brief window before the schema is available.
+   */
+  modelName?: string;
+  /**
+   * The action ID used to retrieve an auth token via `cesdk.ui.actions.run()`.
+   * The registered action should return a token string.
+   *
+   * @default 'ly.img.ai.getToken'
+   */
+  tokenActionId?: string;
+  /**
+   * Additional headers to send with gateway requests.
+   */
+  headers?: Record<string, string>;
+  /**
+   * History storage strategy for generated assets.
+   *
+   * @default '@imgly/indexedDB'
+   */
+  history?: false | '@imgly/local' | '@imgly/indexedDB' | (string & {});
+  /**
+   * Called when an error occurs during schema loading or provider initialization.
+   * Generation errors are handled separately via middleware.
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Middlewares to add to the provider generation. Middlewares run around the
+   * base `generate` call and can observe/modify input, retry on failure, add
+   * logging, rate limiting, etc.
+   */
+  middlewares?: Middleware<any, any>[];
+  /**
+   * How long (in milliseconds) to cache auth tokens before re-fetching.
+   * Concurrent requests while a fetch is in-flight share the same call.
+   *
+   * @default 300000 (5 minutes)
+   */
+  tokenCacheTTL?: number;
+  /**
+   * Override or disable individual quick actions on top of the provider's
+   * capability-derived defaults.
+   *
+   * - Set a quick-action ID to `false` (or `null`) to disable it for this provider.
+   * - Set it to an object with `mapInput` to override how the quick action's
+   *   input is mapped to the provider's input.
+   *
+   * @example
+   * ```ts
+   * ImageGatewayProvider('fal-ai/some-model', {
+   *   gatewayUrl,
+   *   supportedQuickActions: {
+   *     'ly.img.editImage': false,                       // disable
+   *     'ly.img.swapBackground': {                       // override mapping
+   *       mapInput: (input) => ({ prompt: input.prompt, image_urls: [input.uri] })
+   *     }
+   *   }
+   * })
+   * ```
+   */
+  supportedQuickActions?: {
+    [quickActionId: string]: {
+      mapInput: (input: any) => GatewayInput;
+    } | {
+      [key: string]: any;
+    } | true | false | null;
+  };
+  /**
+   * Enable debug logging.
+   */
+  debug?: boolean;
+}
+/**
+ * Return type for the gateway token action.
+ *
+ * - Return a **string** for short-lived credentials (JWT, Clerk token, session token).
+ * - Return `{ dangerouslyExposeApiKey: string }` if you intentionally want to use
+ *   a raw API key. This exposes the key to anyone with browser DevTools access.
+ */
+type GatewayTokenActionResult = string | {
+  dangerouslyExposeApiKey: string;
+};
+type GatewayInput = Record<string, any>;
+interface GatewayProviderOptions<K extends OutputKind, O extends Output> {
+  /** The output kind (e.g., 'image', 'video', 'audio', 'text'). */
+  kind: K;
+  /**
+   * Called once when the provider initializes (e.g., to register icons).
+   */
+  onInitialize?: (cesdk: CreativeEditorSDK) => void;
+  /**
+   * Called after the schema resolves. Return a `renderCustomProperty` map
+   * to customize how specific schema properties are rendered in the panel.
+   *
+   * Only called when a schema-driven panel is used (i.e., `createOutput` is provided).
+   */
+  onSchemaReady?: (context: {
+    schema: GatewaySchemaResult;
+    providerId: string;
+    cesdk: CreativeEditorSDK;
+  }) => RenderCustomProperty | undefined;
+  /**
+   * Preprocess input before generation (e.g., upload local blob: URLs).
+   * If omitted, input is forwarded to the gateway as-is.
+   */
+  processInput?: (input: GatewayInput, client: GatewayClient, cesdk: CreativeEditorSDK) => Promise<GatewayInput>;
+  /**
+   * Construct the typed output from a generated URL.
+   * Used for URL-based outputs (image, video, audio).
+   *
+   * When provided, a schema-driven panel is set up and `getBlockInput` is required.
+   * Mutually exclusive with `createStreamOutput`.
+   */
+  createOutput?: (url: string) => O | Promise<O>;
+  /**
+   * Construct the typed output from accumulated streamed text.
+   * Used for streaming outputs (text).
+   *
+   * When provided, no schema panel is created — use `quickActions` for input.
+   * Mutually exclusive with `createOutput`.
+   */
+  createStreamOutput?: (accumulatedText: string) => O;
+  /**
+   * Extract block input from user input (for placeholder creation).
+   * Required when `createOutput` is provided (panel mode).
+   */
+  getBlockInput?: (input: GatewayInput) => Promise<Record<K, any>>;
+  /**
+   * Filter the SSE output array to find the relevant result.
+   * If omitted, the first output entry is used.
+   * Only used in URL mode (`createOutput`).
+   */
+  outputFilter?: (output: GatewaySSEOutput) => boolean;
+  /**
+   * Returns the default quick actions for this model based on its schema
+   * (specifically `schema.capability`). Called once after the schema
+   * resolves; the result is merged with any `supportedQuickActions`
+   * overrides from the provider configuration.
+   *
+   * Return `undefined` when the model has no quick actions (e.g. a pure
+   * text2image model).
+   */
+  resolveQuickActions?: (context: {
+    schema: GatewaySchemaResult;
+    providerId: string;
+    cesdk: CreativeEditorSDK;
+  }) => QuickActionsInput<GatewayInput> | undefined;
+  /**
+   * Unconditional quick actions for this provider. Used by content types
+   * with a single capability (e.g., text generation where every model
+   * accepts the same chat-style input). Mutually exclusive with
+   * `resolveQuickActions`.
+   */
+  quickActions?: QuickActionsInput<GatewayInput>;
+  /**
+   * Panel user flow.
+   * @default 'placeholder'
+   */
+  userFlow?: 'placeholder' | 'generation-only';
+}
+/**
+ * Known gateway capabilities. Unknown string values are allowed for
+ * forward compatibility with capabilities added on the server side
+ * before the client is updated.
+ */
+type GatewayCapability = 'text2text' | 'text2image' | 'image2image' | 'text2video' | 'image2video' | 'text2speech' | (string & {});
+interface GatewaySchemaResult {
+  model: string;
+  name?: string;
+  type: string;
+  /**
+   * The model's capability (e.g., 'image2image'). Used by the gateway
+   * providers to decide which default quick actions to offer.
+   */
+  capability: GatewayCapability;
+  input_schema: {
+    type: 'object';
+    required: string[];
+    properties: Record<string, unknown>;
+    'x-property-order'?: string[];
+  };
+}
+interface GatewaySSEOutput {
+  type: string;
+  url: string;
+  content_type: string;
+}
+interface GatewaySSECompletedData {
+  request_id: string;
+  status: 'completed';
+  output: GatewaySSEOutput[];
+}
+interface GatewaySSEFailedData {
+  request_id: string;
+  status: 'failed';
+  error: {
+    message: string;
+    /**
+     * Same catalog as the HTTP error envelope. Optional because the gateway does
+     * not put it on every failed event yet — without it the client can report
+     * that the generation failed, but not why.
+     */
+    code?: string;
+    /** Upstream model provider, for provider-originated failures. */
+    provider?: string;
+    /** Status the upstream provider returned. */
+    upstream_status?: number;
+  };
+}
+interface GatewaySSEDeltaData {
+  contentType: 'text' | 'tool_call';
+  data: string;
+  request_id: string;
+}
+interface GatewayUploadResult {
+  id: string;
+  upload_url: string;
+  asset_url: string;
+  expires_in: number;
+}
+/**
+ * Creates a provider that talks to the IMG.LY gateway.
+ *
+ * This is the generic, content-type-agnostic factory. Content-type-specific
+ * behavior (icons, input preprocessing, output filtering, block dimensions)
+ * is injected via `GatewayProviderOptions`.
+ *
+ * The schema is fetched lazily in the background — the provider registers
+ * immediately without blocking on the network request.
+ *
+ * Providers sharing the same `cesdk` instance and gateway URL automatically
+ * share a single HTTP client and token cache.
+ *
+ * @param modelId   - The model identifier (e.g., 'fal-ai/flux/dev')
+ * @param config    - Gateway connection configuration
+ * @param options   - Content-type-specific behavior
+ */
+export declare function createGatewayProvider<K extends OutputKind, O extends Output>(modelId: string, config: GatewayProviderConfiguration, options: GatewayProviderOptions<K, O>): (context: {
+  cesdk: CreativeEditorSDK;
+}) => Promise<Provider<K, GatewayInput, O>>;
+/**
+ * Typed representation of a failed IMG.LY gateway request.
+ *
+ * The gateway answers every failure with a single JSON envelope:
+ *
+ * ```json
+ * { "error": { "code": "insufficient_credits", "message": "Insufficient credits" } }
+ * ```
+ *
+ * Provider-originated failures add two more fields:
+ *
+ * ```json
+ * { "error": { "code": "upstream_error", "message": "Rate limit exceeded",
+ *              "provider": "fal.ai", "upstream_status": 429 } }
+ * ```
+ *
+ * This module turns that envelope into an `Error` subclass so callers can branch
+ * on `code` instead of pattern-matching a message string.
+ */
+/**
+ * Machine-readable failure reason reported by the gateway.
+ *
+ * The listed members mirror the gateway's own error catalog, but the type stays
+ * open on purpose: the gateway may introduce codes before this package is
+ * updated, and a closed union would silently mistype them.
+ *
+ * Two members are client-side sentinels rather than gateway codes: `'unknown'`
+ * when no code could be determined (unparseable body, non-gateway origin such as
+ * the presigned upload URL), and `'network_error'` when the request never
+ * produced a readable response at all.
+ */
+type GatewayErrorCode = 'network_error' | 'insufficient_credits' | 'unauthorized' | 'provider_not_authorized' | 'invalid_request' | 'invalid_model_id' | 'validation_error' | 'provider_not_supported' | 'model_not_found' | 'provider_unavailable' | 'upstream_error' | 'generation_failed' | 'timeout' | 'internal_error' | 'service_error' | 'unknown' | (string & {});
+/** Which gateway interaction failed. */
+type GatewayOperation = 'schema' | 'upload' | 'generate';
+interface GatewayErrorInit {
+  code: GatewayErrorCode;
+  status: number;
+  operation: GatewayOperation;
+  /** Message reported by the gateway, used to build the developer-facing text. */
+  detail?: string;
+  provider?: string;
+  upstreamStatus?: number;
+  requestId?: string;
+}
+export declare class GatewayError extends Error {
+  /** Machine-readable failure reason. Prefer this over parsing `message`. */
+  readonly code: GatewayErrorCode;
+  /**
+   * HTTP status of the failed response. `0` when there is no status: a failure
+   * reported inside an already-open SSE stream, or a request that never reached
+   * the gateway (`network_error`).
+   */
+  readonly status: number;
+  /** Which gateway interaction failed. */
+  readonly operation: GatewayOperation;
+  /** Upstream model provider, present only for `upstream_error`. */
+  readonly provider?: string;
+  /** Status the upstream provider returned, present only for `upstream_error`. */
+  readonly upstreamStatus?: number;
+  /**
+   * Gateway request id. Include this when reporting a problem to support.
+   *
+   * Only present when the gateway makes it reachable: `x-request-id` is not a
+   * CORS-safelisted response header, so a cross-origin gateway must send
+   * `Access-Control-Expose-Headers: x-request-id` for the header to be readable
+   * — otherwise the id has to travel in the error body as `request_id`.
+   */
+  readonly requestId?: string;
+  constructor(init: GatewayErrorInit);
+}
+/**
+ * Narrows an unknown thrown value to a `GatewayError`.
+ *
+ * Uses a structural check rather than `instanceof` so it keeps working when the
+ * plugin packages are bundled separately and end up with distinct copies of this
+ * module.
+ */
+export declare function isGatewayError(error: unknown): error is GatewayError;
+type TranslationDefinition = Partial<Record<string, Partial<Record<string, string>>>>;
+/**
+ * Sets default translations only for keys that don't already exist.
+ *
+ * This allows integrators to set custom translations BEFORE plugins load,
+ * and the plugins won't override those custom values with their defaults.
+ *
+ * @param cesdk - The CE.SDK instance
+ * @param definition - The translations to set (same format as setTranslations)
+ *
+ * @example
+ * ```ts
+ * // Integrator sets custom translation BEFORE plugin loads
+ * cesdk.i18n.setTranslations({ en: { 'my.key': 'Custom Value' } });
+ *
+ * // Plugin uses setDefaultTranslations - won't override 'my.key'
+ * setDefaultTranslations(cesdk, { en: { 'my.key': 'Default Value', 'other.key': 'Other' } });
+ *
+ * // Result: 'my.key' = 'Custom Value', 'other.key' = 'Other'
+ * ```
+ */
+export declare function setDefaultTranslations(cesdk: CreativeEditorSDK, definition: TranslationDefinition): void;
+/**
+ * Creates a translation callback function for AI asset sources
+ * @param cesdk - The CE.SDK instance
+ * @param modelKey - The model/provider key (e.g., 'fal-ai/recraft-v3')
+ * @param propertyName - The property name (e.g., 'style', 'aspect_ratio')
+ * @param pluginType - The plugin type (e.g., 'image', 'video', 'sticker')
+ * @returns A translation callback function for use with CustomAssetSource
+ */
+export declare function createTranslationCallback(cesdk: CreativeEditorSDK, modelKey: string, propertyName?: string, pluginType?: string): (assetId: string, fallbackLabel: string, locale: string) => string;
+/**
+ * Build translation keys array for AI plugin property values
+ * @param modelKey - The model/provider key
+ * @param propertyName - The property name
+ * @param value - The property value
+ * @param pluginType - The plugin type (image, video, sticker, etc.)
+ * @returns Array of translation keys in fallback order
+ */
+export declare function buildTranslationKeys(modelKey: string, propertyName: string, value: string, pluginType?: string): string[];
 declare const CommonProperties: {
-    ImageUrl: typeof renderImageUrlProperty;
-    StyleTransfer: typeof renderStyleTransferProperty;
-};
-export { CommonProperties, attachImageToPrompt, canAttachImageToPrompt };
-export { type default as Provider, type ImageOutput, type VideoOutput, type TextOutput, type AudioOutput, type StickerOutput, type Output, type OutputKind, type PanelInputSchema, type RenderCustomProperty, type GetBlockInput, type GetBlockInputResult, type GetInput, type QuickActionsInput } from './core/provider';
-export { type GetPropertyInput, type Property } from './openapi/types';
-export { type GetProvider, type CommonProviderConfiguration, type CommonPluginConfiguration, type CommonConfiguration, type InternalPluginConfiguration } from './types';
-export type { PropertyContext, PropertyConfig, PropertiesConfiguration, ExtendPropertyContexts } from './core/propertyConfiguration';
-export { buildPropertyContext, PropertyContextCache } from './utils/propertyContext';
-export { resolvePropertyDefault, resolvePropertyDefaults } from './utils/propertyResolver';
-export { default as integrateIntoDefaultAssetLibraryEntry } from './assets/integrateIntoDefaultAssetLibraryEntry';
-export { ActionRegistry, type BaseActionDefinition, type PluginActionDefinition, type QuickActionDefinition, type ActionDefinition, type ActionRegistryEventType, type ActionRegistrySubscriberCallback, type ActionRegistryFilters } from './core/ActionRegistry';
-export { ProviderRegistry } from './core/ProviderRegistry';
-export { composeMiddlewares, type Middleware } from './middleware/middleware';
-export { default as loggingMiddleware } from './middleware/loggingMiddleware';
-export { default as uploadMiddleware } from './middleware/uploadMiddleware';
-export { mergeQuickActionsConfig } from './utils/mergeQuickActionsConfig';
-export { default as rateLimitMiddleware, type RateLimitOptions } from './middleware/rateLimitMiddleware';
-export { getPanelId, getDurationForVideo, getThumbnailForVideo, getLabelFromId, isAsyncGenerator, addIconSetOnce, normalizeBaseURL } from './utils/utils';
-export { checkAiPluginVersion } from './utils/checkAiPluginVersion';
-export { default as registerDockComponent } from './ui/components/registerDockComponent';
-export { default as enableQuickActionForImageFill } from './ui/quickActions/enableImageFill';
-export { isGeneratingStateKey, abortGenerationStateKey } from './ui/components/renderGenerationComponents';
-export { default as initializeProviders } from './providers/initializeProviders';
-export { default as initializeProvider } from './providers/initializeProvider';
-export { default as initializeQuickActionComponents } from './ui/quickActions/initializeQuickActionComponents';
-export { extractAndSetSchemaTranslations } from './openapi/extractSchemaTranslations';
-export { AI_EDIT_MODE, AI_METADATA_KEY } from './ui/quickActions/utils';
-export { createGatewayProvider } from './gateway/createGatewayProvider';
-export { createGatewayClient, type GatewayClient } from './gateway/createGatewayClient';
-export { GatewayError, isGatewayError, type GatewayErrorCode, type GatewayOperation } from './gateway/GatewayError';
-export type { GatewayProviderConfiguration, GatewayProviderOptions, GatewayInput, GatewaySchemaResult, GatewaySSEOutput, GatewaySSECompletedData, GatewaySSEDeltaData, GatewaySSEFailedData, GatewayUploadResult, GatewayTokenActionResult } from './gateway/types';
-export { setDefaultTranslations, createTranslationCallback, buildTranslationKeys } from './utils/translationHelpers';
+  ImageUrl: typeof renderImageUrlProperty;
+  StyleTransfer: typeof renderStyleTransferProperty;
+};
+export { type ActionDefinition, type ActionRegistryEventType, type ActionRegistryFilters, type ActionRegistrySubscriberCallback, type AudioOutput, type BaseActionDefinition, type CommonConfiguration, type CommonPluginConfiguration, CommonProperties, type CommonProviderConfiguration, type ExtendPropertyContexts, type GatewayClient, type GatewayErrorCode, type GatewayInput, type GatewayOperation, type GatewayProviderConfiguration, type GatewayProviderOptions, type GatewaySSECompletedData, type GatewaySSEDeltaData, type GatewaySSEFailedData, type GatewaySSEOutput, type GatewaySchemaResult, type GatewayTokenActionResult, type GatewayUploadResult, type GetBlockInput, type GetBlockInputResult, type GetInput, type GetPropertyInput, type GetProvider, type ImageOutput, type InternalPluginConfiguration, type Middleware, type Output, type OutputKind, type PanelInputSchema, type PluginActionDefinition, type PropertiesConfiguration, type Property, type PropertyConfig, type PropertyContext, type Provider, type QuickActionDefinition, type QuickActionsInput, type RateLimitOptions, type RenderCustomProperty, type StickerOutput, type TextOutput, type VideoOutput, enableImageFill as enableQuickActionForImageFill, initializeProvider, initializeProviders, initializeQuickActionComponents, integrateIntoDefaultAssetLibraryEntry, loggingMiddleware, rateLimitMiddleware, registerDockComponent, uploadMiddleware };