@pixerate/editor 0.22.0 → 0.24.0

package/dist/generation/index.d.cts

@@ -0,0 +1,554 @@
+import { J as JsonSchema } from '../schema-DYDGdYL9.cjs';
+export { S as SchemaValidationError, v as validateJsonSchema } from '../schema-DYDGdYL9.cjs';
+import { A as AgentToolProvider } from '../registry-DnzpgY27.cjs';
+export { a as AgentTool, d as McpToolDefinition, e as McpToolResult } from '../registry-DnzpgY27.cjs';
+import { S as SourceMapSegment } from '../sourcemap-C8AH3MBQ.cjs';
+import { T as Template, P as PromptValues } from '../tokens-D7yXvUU6.cjs';
+
+/**
+ * Declarative descriptions of generative models (what a model accepts) and of
+ * the requests sent to them. Everything here is plain data so capabilities can
+ * come from a server, be merged with local presentation overlays, and be
+ * turned into JSON Schema for agents.
+ */
+type GenerationMediaKind = 'image' | 'video' | 'audio' | 'text';
+/** What a reference input is used for. */
+type ReferenceRole = 'start_frame' | 'end_frame' | 'style_ref' | 'character_ref' | 'background_ref' | 'mask' | 'image_ref' | 'video_ref' | 'audio_ref';
+/** Every reference role, in a stable display order. */
+declare const REFERENCE_ROLES: readonly ReferenceRole[];
+/** Human-readable default labels for reference roles. */
+declare const REFERENCE_ROLE_LABELS: Readonly<Record<ReferenceRole, string>>;
+/** A choice from a fixed list. `options` order matters (low → high where it applies). */
+interface EnumCapability<T extends string | number = string> {
+    options: readonly T[];
+    default?: T;
+    /** Display labels by option value. */
+    labels?: Readonly<Record<string, string>>;
+}
+interface TextFieldCapability {
+    maxLength?: number;
+}
+interface PromptCapability extends TextFieldCapability {
+    /**
+     * Count the resolved prompt (templates expanded, variables substituted)
+     * against `maxLength` rather than the raw template text. Default `true`.
+     * Pass the resolved text to the planner as `resolvedPrompt`.
+     */
+    countResolved?: boolean;
+    /** The prompt must be non-empty. */
+    required?: boolean;
+}
+interface CountCapability {
+    /** Largest number of outputs per request. */
+    max: number;
+    /** Predefined choices; when given, requests snap to one of them. */
+    options?: readonly number[];
+    default?: number;
+}
+interface DurationCapability {
+    /** Seconds. */
+    min?: number;
+    max?: number;
+    /** Predefined choices; when given, requests snap to one of them. */
+    options?: readonly number[];
+    default?: number;
+    step?: number;
+}
+interface SeedCapability {
+    min?: number;
+    max?: number;
+}
+interface ReferenceRoleCapability {
+    /** Most references of this role. */
+    max: number;
+    /** Fewest references of this role (e.g. an image-to-video model needs a `start_frame`). */
+    min?: number;
+    label?: string;
+    description?: string;
+}
+interface ReferenceCapability {
+    /** Supported roles and their per-role limits. Roles not listed are unsupported. */
+    roles: Partial<Readonly<Record<ReferenceRole, ReferenceRoleCapability>>>;
+    /** Most references across all roles. */
+    maxTotal?: number;
+}
+interface NumberParamSpec {
+    type: 'number' | 'integer';
+    min?: number;
+    max?: number;
+    step?: number;
+    default?: number;
+    label?: string;
+    description?: string;
+}
+interface EnumParamSpec {
+    type: 'enum';
+    options: readonly (string | number)[];
+    default?: string | number;
+    label?: string;
+    description?: string;
+}
+interface BooleanParamSpec {
+    type: 'boolean';
+    default?: boolean;
+    label?: string;
+    description?: string;
+}
+/** A model-specific parameter (`guidance`, `motion_strength`, `style`, …). */
+type ExtraParamSpec = NumberParamSpec | EnumParamSpec | BooleanParamSpec;
+/** Rough timing used for progress estimates (`expectedDurationFor`). */
+interface TimingCapability {
+    /** Fixed cost of one request in ms. */
+    baseMs: number;
+    /** Extra ms per output beyond the first. */
+    perItemMs?: number;
+    /** Extra ms per second of requested duration (video/audio). */
+    perSecondMs?: number;
+    /** Extra ms per megapixel of the requested resolution. */
+    perMegapixelMs?: number;
+}
+/** Presentation-only fields; overlays may set these (see `mergeCapabilities`). */
+interface CapabilityPresentation {
+    name?: string;
+    description?: string;
+    badges?: readonly string[];
+    icon?: string;
+    group?: string;
+}
+/** Everything a generative model accepts. Absent sections mean "unsupported". */
+interface ModelCapabilities extends CapabilityPresentation {
+    id: string;
+    media: GenerationMediaKind;
+    prompt?: PromptCapability;
+    /** Negative prompt support (`true` or limits). */
+    negativePrompt?: boolean | TextFieldCapability;
+    /** System prompt support (`true` or limits). */
+    systemPrompt?: boolean | TextFieldCapability;
+    /** E.g. `['1:1', '16:9', '9:16']`. */
+    aspectRatios?: EnumCapability<string>;
+    /** E.g. `['512x512', '1024x1024']`, `['720p', '1080p']` or `['1k', '2k', '4k']`, low → high. */
+    resolutions?: EnumCapability<string>;
+    /** Ordered low → high, e.g. `['draft', 'standard', 'high']`. */
+    quality?: EnumCapability<string>;
+    count?: CountCapability;
+    duration?: DurationCapability;
+    seed?: boolean | SeedCapability;
+    references?: ReferenceCapability;
+    /** Accepts a source to edit (`mode: 'edit'`). */
+    editing?: boolean;
+    /** Accepts a source plus a `mask` reference (`mode: 'inpaint'`). */
+    inpainting?: boolean;
+    params?: Readonly<Record<string, ExtraParamSpec>>;
+    timing?: TimingCapability;
+}
+interface GenerationReference {
+    /** Asset id (opaque to this library). */
+    id: string;
+    role: ReferenceRole;
+    url?: string;
+}
+type GenerationMode = 'generate' | 'edit' | 'inpaint';
+type GenerationParamValue = string | number | boolean;
+/** A request for one model. Every field is optional; the planner fills and fixes. */
+interface GenerationRequest {
+    model?: string;
+    prompt?: string;
+    negativePrompt?: string;
+    systemPrompt?: string;
+    aspectRatio?: string;
+    resolution?: string;
+    quality?: string;
+    count?: number;
+    /** Seconds. */
+    duration?: number;
+    seed?: number;
+    mode?: GenerationMode;
+    references?: GenerationReference[];
+    params?: Record<string, GenerationParamValue>;
+}
+/** Fields of {@link GenerationRequest} the planner knows about, in planning order. */
+declare const GENERATION_REQUEST_FIELDS: readonly ["model", "prompt", "negativePrompt", "systemPrompt", "aspectRatio", "resolution", "quality", "count", "duration", "seed", "mode", "references", "params"];
+/** Text field limits normalized from `boolean | TextFieldCapability`. */
+declare function textFieldCapability(value: boolean | TextFieldCapability | undefined): TextFieldCapability | null;
+/** Seed limits normalized from `boolean | SeedCapability`. */
+declare function seedCapability(value: boolean | SeedCapability | undefined): SeedCapability | null;
+/** Supported reference roles of a model in {@link REFERENCE_ROLES} order. */
+declare function supportedReferenceRoles(caps: ModelCapabilities): ReferenceRole[];
+/** Supported generation modes of a model. */
+declare function supportedModes(caps: ModelCapabilities): GenerationMode[];
+/** A partial model entry used to decorate (or add) models locally. */
+type CapabilityOverlay = Partial<ModelCapabilities> & {
+    id: string;
+};
+/**
+ * Merges server-reported capabilities with a local overlay. For models the
+ * server knows, every capability value comes from `remote`; the overlay only
+ * contributes presentation fields (`name`, `description`, `badges`, `icon`,
+ * `group`), filling in or replacing the remote ones. Overlay entries for
+ * models the server does not report are appended when they are complete
+ * (have a `media` kind). Remote order is kept; overlay-only models follow in
+ * overlay order.
+ */
+declare function mergeCapabilities(remote: readonly ModelCapabilities[], overlay?: readonly CapabilityOverlay[]): ModelCapabilities[];
+
+/**
+ * How the planner treats values the model does not support:
+ *
+ * - `error`: nothing is changed; every mismatch is an error.
+ * - `nearest`: snap to the closest supported value (ties go to the higher
+ *   value), clamp ranges, truncate lists, drop unsupported fields and
+ *   unsupported references.
+ * - `downgrade`: like `nearest`, but ties go to the lower value.
+ * - `upgrade`: like `nearest`, but never drops references the model cannot
+ *   use (that would lose intent), so those are errors.
+ *
+ * "Lower" means a narrower aspect ratio, fewer pixels, an earlier quality
+ * option, a smaller number.
+ */
+type PlanStrategy = 'error' | 'upgrade' | 'downgrade' | 'nearest';
+type PlanAdjustmentKind = 'snapped' | 'clamped' | 'truncated' | 'dropped' | 'defaulted';
+interface PlanAdjustment {
+    /** Request path, e.g. `aspectRatio`, `params.guidance`, `references.style_ref`. */
+    field: string;
+    from: unknown;
+    to: unknown;
+    reason: string;
+    kind: PlanAdjustmentKind;
+}
+interface PlanError {
+    field: string;
+    value: unknown;
+    message: string;
+}
+interface GenerationPlan {
+    /** `true` when there are no errors and `request` can be sent. */
+    ok: boolean;
+    /** The adjusted request (always a copy; the input is never mutated). */
+    request: GenerationRequest;
+    adjustments: PlanAdjustment[];
+    errors: PlanError[];
+    /** Model the plan was made for. */
+    model: string;
+    strategy: PlanStrategy;
+}
+interface PlanOptions {
+    /** Default `nearest`. */
+    strategy?: PlanStrategy;
+    /**
+     * The prompt with templates and variables resolved. Measured against
+     * `prompt.maxLength` when the model counts resolved text (the default).
+     */
+    resolvedPrompt?: string;
+    /** Fill missing fields that have a capability `default` (reported as `defaulted`). */
+    fillDefaults?: boolean;
+    /** Override whether references with unsupported roles may be dropped (default: `nearest` and `downgrade` only). */
+    dropUnsupportedReferences?: boolean;
+}
+/** Numeric rank of an aspect ratio such as `16:9` (log of width / height). */
+declare function aspectRatioRank(value: string): number | undefined;
+/**
+ * Numeric rank of a resolution: `1024x768` (pixels), `720p` (16:9 pixels at
+ * that height) or `2k` (square of that many kibi-pixels). Log scale.
+ */
+declare function resolutionRank(value: string): number | undefined;
+/** Megapixels of a resolution string, when it can be parsed. */
+declare function resolutionMegapixels(value: string): number | undefined;
+/** Common quality names, low → high. Used to compare values missing from a model's options. */
+declare const QUALITY_LADDER: Readonly<Record<string, number>>;
+declare function qualityRank(value: string): number | undefined;
+/**
+ * Picks the option closest to `value` by `rank`. Ties go to the lower or
+ * higher rank. Returns `undefined` when `value` or no option can be ranked.
+ */
+declare function snapToOption<T>(value: unknown, options: readonly T[], rank: (value: any) => number | undefined, tie: 'lower' | 'higher'): T | undefined;
+/**
+ * Plans `request` against a model's capabilities before sending it: snaps
+ * enum values (aspect ratio, resolution, quality, count/duration choices) to
+ * the nearest supported option, clamps ranges, truncates text and reference
+ * lists over their limits, drops unsupported fields, and reports every change
+ * in `adjustments` and every unfixable problem in `errors`.
+ *
+ * Pure and deterministic: the input is not mutated and the same input always
+ * gives the same plan.
+ */
+declare function planGenerationRequest(request: GenerationRequest, caps: ModelCapabilities, options?: PlanOptions): GenerationPlan;
+
+/**
+ * JSON Schema for a request to one model: enums for choices, `minimum` /
+ * `maximum` for ranges, `maxItems` for reference lists and `description`s that
+ * spell out limits the schema cannot express (per-role reference counts,
+ * resolved-prompt length). Unsupported fields are absent and
+ * `additionalProperties` is `false`, so `validateJsonSchema` rejects them.
+ */
+declare function capabilitiesToJsonSchema(caps: ModelCapabilities): JsonSchema & {
+    type: 'object';
+};
+
+interface GenerateContext {
+    model: ModelCapabilities;
+    plan: GenerationPlan;
+    idempotencyKey: string;
+    signal?: AbortSignal;
+}
+interface EstimateContext {
+    model: ModelCapabilities;
+    plan: GenerationPlan;
+    signal?: AbortSignal;
+}
+interface GenerationToolProviderOptions {
+    /** Provider id (default `generation`). */
+    id?: string;
+    namespace?: string;
+    /** Models, or a function returning the current models (re-read on every list/call). */
+    models: readonly ModelCapabilities[] | (() => readonly ModelCapabilities[]);
+    /** Sends a planned request. Its resolved value is the tool result (e.g. `{ jobId }`). */
+    generate: (request: GenerationRequest, context: GenerateContext) => unknown | Promise<unknown>;
+    /** Optional cost/time estimate; adds the `estimate_generation` tool. */
+    estimate?: (request: GenerationRequest, context: EstimateContext) => unknown | Promise<unknown>;
+    /** Strategy used when the caller does not pass one (default `nearest`). */
+    defaultStrategy?: PlanStrategy;
+    /** Completed idempotency keys remembered (default 500, oldest evicted first). */
+    maxIdempotencyKeys?: number;
+    /** Lets the host signal that the model list changed. */
+    subscribe?: AgentToolProvider['subscribe'];
+}
+interface GenerationToolProvider extends AgentToolProvider {
+    /** Forgets remembered idempotency keys (all, or one). */
+    clearIdempotencyKeys(key?: string): void;
+}
+/**
+ * Exposes generation models to a `ToolRegistry`:
+ *
+ * - `list_models` (read-only): ids, presentation fields and per-model request schemas.
+ * - `plan_generation` (read-only): the adjusted request, adjustments and errors.
+ * - `estimate_generation` (read-only, only with `estimate`): your estimate for the planned request.
+ * - `generate` (destructive): plans, then calls `generate` with the adjusted
+ *   request. Requires an `idempotencyKey`: a retry with the same key and
+ *   arguments returns the first call's result (or joins it while in flight)
+ *   instead of generating again; the same key with different arguments is
+ *   rejected. Failed calls forget their key so they can be retried.
+ */
+declare function createGenerationToolProvider(options: GenerationToolProviderOptions): GenerationToolProvider;
+
+declare const PROVENANCE_FORMAT = "pixerate.generation-provenance";
+declare const PROVENANCE_VERSION = 1;
+/** The exact template body a generation used. */
+interface PinnedTemplate {
+    name: string;
+    templateId?: string;
+    /** Version id or version label the body came from (absent for unversioned templates). */
+    versionId?: string;
+    version?: string | number;
+    body: string;
+}
+/** Everything needed to explain and reproduce one generation. */
+interface GenerationProvenance {
+    format: typeof PROVENANCE_FORMAT;
+    version: typeof PROVENANCE_VERSION;
+    /** Raw prompt as typed, with `{{templates}}` and `{variables}`. */
+    rawPrompt: string;
+    /** Every template the prompt reached (recursively), pinned to the body used. */
+    templates: PinnedTemplate[];
+    /** Version bindings in effect (`{ templateName: versionId }`) for every pinned versioned template. */
+    bindings: Record<string, string>;
+    /** Variable values, or `null` when variables were left unresolved. */
+    values: PromptValues | null;
+    resolvedPrompt: string;
+    sourceMap: SourceMapSegment[];
+    modelId: string;
+    /** The planned (adjusted) request that was sent. */
+    request: GenerationRequest;
+    adjustments: PlanAdjustment[];
+    references: {
+        id: string;
+        role: ReferenceRole;
+    }[];
+    /** ISO timestamps. */
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    /** Ids of the outputs this generation produced. */
+    outputIds?: string[];
+    meta?: Record<string, unknown>;
+}
+interface CreateProvenanceOptions {
+    rawPrompt: string;
+    templates?: Template[];
+    /** Template version bindings (`{ templateName: versionIdOrVersion }`). */
+    bindings?: Record<string, string>;
+    values?: PromptValues;
+    model: string | ModelCapabilities;
+    /** The plan the request came from (its request and adjustments are recorded) … */
+    plan?: GenerationPlan;
+    /** … or the request that was sent. */
+    request?: GenerationRequest;
+    adjustments?: PlanAdjustment[];
+    /** Creation time (default `Date.now()`). */
+    createdAt?: Date | number | string;
+    startedAt?: Date | number | string;
+    completedAt?: Date | number | string;
+    outputIds?: string[];
+    meta?: Record<string, unknown>;
+    maxDepth?: number;
+}
+declare class ProvenanceParseError extends Error {
+    constructor(message: string);
+}
+/** Templates that reproduce the pinned bodies exactly (one single-version template each). */
+declare function pinnedTemplatesToTemplates(pinned: readonly PinnedTemplate[]): Template[];
+/**
+ * Records what produced an output: the raw prompt, the exact template bodies
+ * and versions it reached, variable values, the resolved prompt and its
+ * source map, the model, the planned settings and adjustments, and the
+ * references by role.
+ */
+declare function createProvenance(options: CreateProvenanceOptions): GenerationProvenance;
+/** Versioned JSON for storage next to an output. */
+declare function serializeProvenance(provenance: GenerationProvenance): string;
+/** Parses and checks serialized provenance. Throws {@link ProvenanceParseError}. */
+declare function parseProvenance(input: string | unknown): GenerationProvenance;
+/**
+ * A request that reproduces the recorded generation exactly: the planned
+ * settings, model, seed and references that were sent, with the prompt as
+ * resolved at the time (not re-resolved against today's templates).
+ */
+declare function recreateRequest(provenance: GenerationProvenance): GenerationRequest;
+/**
+ * Re-resolves the raw prompt against the pinned template bodies and values,
+ * e.g. to check a record or to open it in an editor with its source map.
+ */
+declare function replayProvenancePrompt(provenance: GenerationProvenance): {
+    text: string;
+    map: SourceMapSegment[];
+    matches: boolean;
+};
+
+interface BatchResolverOptions<K, V> {
+    /** Loads many keys at once. Keys missing from the map resolve to `undefined`. */
+    fetch: (keys: K[]) => Promise<Map<K, V>>;
+    /** Largest batch passed to `fetch` (default 50). */
+    maxBatch?: number;
+    /** How long to collect keys before fetching, in ms (default 0: the same tick). */
+    delayMs?: number;
+    /** Called once per failed batch. The batch's keys are recorded as resolved-empty. */
+    onError?: (error: unknown, keys: K[]) => void;
+}
+interface BatchResolver<K, V> {
+    /** Resolves one key, batched with other loads in the same window. Never rejects. */
+    load(key: K): Promise<V | undefined>;
+    loadMany(keys: readonly K[]): Promise<(V | undefined)[]>;
+    /** The settled value for a key, if it has been resolved. */
+    peek(key: K): V | undefined;
+    /** Whether a key has settled (found, missing or failed). */
+    has(key: K): boolean;
+    /** Whether a key's last fetch failed. */
+    failed(key: K): boolean;
+    /** Seeds a value without fetching. */
+    prime(key: K, value: V): void;
+    /** Forgets one key (or all) so the next `load` fetches again. */
+    clear(key?: K): void;
+    /** Fetches anything still waiting now, without waiting for `delayMs`. */
+    flush(): void;
+}
+/**
+ * Coalesces lookups (e.g. asset ids → thumbnails, template ids → bodies) into
+ * batched `fetch` calls: keys requested within `delayMs` share a batch of at
+ * most `maxBatch`, duplicate keys are fetched once, and results are cached.
+ * A failed batch resolves its keys to `undefined` and records them as
+ * resolved-empty (`failed(key)` is `true`) so one bad response does not cause
+ * a retry storm; `clear(key)` allows a retry.
+ */
+declare function createBatchResolver<K, V>(options: BatchResolverOptions<K, V>): BatchResolver<K, V>;
+
+interface JobProgressInput {
+    /** Start time (ms since epoch, `Date` or ISO string). */
+    startedAt: number | Date | string;
+    /** Current time (default `Date.now()`). */
+    now?: number | Date | string;
+    /** Expected total duration in ms. Without it progress eases towards 95%. */
+    expectedMs?: number;
+    /** The job finished. */
+    done?: boolean;
+}
+interface JobProgressEstimate {
+    /** 0–100. Never above 95 until `done`. */
+    percent: number;
+    /** E.g. `~2m left`, `~40s left`, `Almost done…`, `Starting…`, `Done`. */
+    label: string;
+    elapsedMs: number;
+    /** Estimated ms left (`undefined` without `expectedMs`). */
+    remainingMs?: number;
+    /** Running longer than expected. */
+    overdue: boolean;
+}
+/** Highest percentage shown before a job reports completion. */
+declare const MAX_PENDING_PERCENT = 95;
+/** `~45s left`, `~2m left`, `~1h 5m left`. Minutes and seconds round up. */
+declare function formatRemaining(ms: number): string;
+/**
+ * Progress for a job that reports no progress of its own: linear in elapsed
+ * time over `expectedMs`, held at 95% until `done` (so the bar never sits at
+ * 100% while still waiting), with a "~2m left" style label that turns into
+ * "Almost done…" near or past the expected end. Pure: pass `now` to test.
+ */
+declare function estimateJobProgress(input: JobProgressInput): JobProgressEstimate;
+/**
+ * Expected duration of a request from the model's `timing`: `baseMs`, plus
+ * `perItemMs` per output beyond the first, `perSecondMs` per second of
+ * duration and `perMegapixelMs` per megapixel of resolution. `undefined` when
+ * the model has no timing.
+ */
+declare function expectedDurationFor(caps: ModelCapabilities, request?: GenerationRequest): number | undefined;
+
+interface GenerationControlOption {
+    value: string | number;
+    label: string;
+}
+/**
+ * A UI control derived from capabilities. `key` is a request path:
+ * `aspectRatio`, `count`, `params.guidance`, …
+ */
+interface GenerationControl {
+    key: string;
+    label: string;
+    /** `select` for choices, `range` for bounded numbers, `number` for open numbers. */
+    kind: 'select' | 'range' | 'number' | 'textarea' | 'checkbox';
+    valueType: 'string' | 'number' | 'boolean';
+    options?: GenerationControlOption[];
+    min?: number;
+    max?: number;
+    step?: number;
+    maxLength?: number;
+    defaultValue?: string | number | boolean;
+    description?: string;
+}
+interface ReferenceSlot {
+    role: ReferenceRole;
+    label: string;
+    description?: string;
+    min: number;
+    max: number;
+    references: GenerationReference[];
+    /** More references of this role fit (per role and in total). */
+    canAdd: boolean;
+}
+/**
+ * The settings controls a model supports, in display order. Excludes the
+ * prompt (edited by the prompt editor) and references (see
+ * {@link getReferenceSlots}).
+ */
+declare function getGenerationControls(caps: ModelCapabilities): GenerationControl[];
+/** Reads a request value by control key (`params.x` reads a param). */
+declare function getRequestValue(request: GenerationRequest, key: string): unknown;
+/** Returns a copy of `request` with `key` set (`undefined` or `''` removes it). */
+declare function setRequestValue(request: GenerationRequest, key: string, value: unknown): GenerationRequest;
+/** Parses a DOM control's string value into the control's value type. */
+declare function parseControlValue(control: GenerationControl, raw: string | boolean): string | number | boolean | undefined;
+/** Reference slots for every role the model accepts, filled from `request`. */
+declare function getReferenceSlots(caps: ModelCapabilities, request?: GenerationRequest): ReferenceSlot[];
+/** Returns a copy of `request` with a reference appended. */
+declare function addReference(request: GenerationRequest, reference: GenerationReference): GenerationRequest;
+/** Returns a copy of `request` without the reference `id` in `role`. */
+declare function removeReference(request: GenerationRequest, role: ReferenceRole, id: string): GenerationRequest;
+
+export { AgentToolProvider, type BatchResolver, type BatchResolverOptions, type BooleanParamSpec, type CapabilityOverlay, type CapabilityPresentation, type CountCapability, type CreateProvenanceOptions, type DurationCapability, type EnumCapability, type EnumParamSpec, type EstimateContext, type ExtraParamSpec, GENERATION_REQUEST_FIELDS, type GenerateContext, type GenerationControl, type GenerationControlOption, type GenerationMediaKind, type GenerationMode, type GenerationParamValue, type GenerationPlan, type GenerationProvenance, type GenerationReference, type GenerationRequest, type GenerationToolProvider, type GenerationToolProviderOptions, type JobProgressEstimate, type JobProgressInput, JsonSchema, MAX_PENDING_PERCENT, type ModelCapabilities, type NumberParamSpec, PROVENANCE_FORMAT, PROVENANCE_VERSION, type PinnedTemplate, type PlanAdjustment, type PlanAdjustmentKind, type PlanError, type PlanOptions, type PlanStrategy, type PromptCapability, ProvenanceParseError, QUALITY_LADDER, REFERENCE_ROLES, REFERENCE_ROLE_LABELS, type ReferenceCapability, type ReferenceRole, type ReferenceRoleCapability, type ReferenceSlot, type SeedCapability, type TextFieldCapability, type TimingCapability, addReference, aspectRatioRank, capabilitiesToJsonSchema, createBatchResolver, createGenerationToolProvider, createProvenance, estimateJobProgress, expectedDurationFor, formatRemaining, getGenerationControls, getReferenceSlots, getRequestValue, mergeCapabilities, parseControlValue, parseProvenance, pinnedTemplatesToTemplates, planGenerationRequest, qualityRank, recreateRequest, removeReference, replayProvenancePrompt, resolutionMegapixels, resolutionRank, seedCapability, serializeProvenance, setRequestValue, snapToOption, supportedModes, supportedReferenceRoles, textFieldCapability };