@nodaro/sdk 2.29.0 → 2.31.0

package/dist/studio-productions-vbCNSbtf.d.ts

@@ -0,0 +1,572 @@
+import { N as NodaroClientCore } from './developer-apps-zSQXWmEG.js';
+
+/**
+ * Studio productions — `/v1/studio/productions`.
+ *
+ * A production is a Nodaro workflow whose `settings.studio` holds the shots:
+ * each shot a framed still, an optional animated clip, and the plan, looks,
+ * cast bindings and voice that made them. These routes are the platform's own
+ * reader and writer of that document, so an agent, a script and the studio app
+ * are looking at ONE production rather than three opinions about one row.
+ *
+ * Two rules run through the whole surface:
+ *
+ * - **Every change is an OPERATION** ({@link StudioProductionsResource.ops}),
+ *   addressed by stable key — a shot id, a role slug, a result's job id or url
+ *   — and never by position. That is what lets two writers hold the same
+ *   production open: a batch composed against a slightly older version still
+ *   applies correctly to the newest one, and the response says whether it was
+ *   rebased.
+ * - **Generation is run-then-poll.** A still or clip run returns job ids and
+ *   records a marker on the production; the results land when anyone — your
+ *   poll, the app, a later {@link StudioProductionsResource.reconcile} —
+ *   reports the finished job. Nothing waits minutes inside a request.
+ *
+ * Reads are `detail: "summary"` by default (counts and the active urls);
+ * `detail: "full"` adds every result with the context that regenerates it.
+ *
+ * **The ENVELOPES are typed here; the production DOCUMENT is not.** A view, a
+ * summary, a shot and an operation are open JSON on this surface
+ * ({@link StudioProduction}, `ops: unknown[]`) — their field-level types ship
+ * with the studio app, which is the one consumer that narrows them, and a
+ * second spelling of that vocabulary in the SDK would drift from it the first
+ * time either grew. Everything a caller branches on — `version`, `rebased`,
+ * `receipts`, `warnings`, a quote's `credits`, a run's `jobIds` — is typed.
+ *
+ * Cloud edition only: these routes 404 on deployments that do not serve them.
+ * Feature-detect once with `list()` — a deployment without them 404s that too,
+ * where a deployment with them answers an empty page.
+ */
+/**
+ * A production, a summary, a shot, a receipt's target: open JSON.
+ *
+ * Deliberately not narrowed here — see the note at the top of this module.
+ */
+type StudioProduction = Record<string, unknown>;
+/** How much of a production a read returns. */
+type StudioProductionDetail = "summary" | "full";
+/** One thing wrong with a plan, addressed at the field that is wrong. */
+interface StudioPlanIssue {
+    path: string;
+    message: string;
+    hint?: string;
+}
+/** `GET …/skill` — the authoring skill, rendered at request time from what is live. */
+interface StudioSkillResponse {
+    /** The authoring guide. */
+    skill: string;
+    /** Every picker, model and enum, in full. */
+    catalog: string;
+    /** The strict JSON Schema a plan is validated against. */
+    schema: Record<string, unknown>;
+    /** The operating guide: the tool map, the loops, the rules. */
+    operating: string;
+    /** The versions the three were rendered from — bare semver, no package names. */
+    generatedFrom: {
+        prompts: string;
+        shared: string;
+        codec: string;
+    };
+}
+interface StudioValidatePlanResponse {
+    valid: boolean;
+    errors: StudioPlanIssue[];
+    warnings: StudioPlanIssue[];
+    summary?: {
+        name?: string;
+        scenes: number;
+        shots: number;
+        cast: number;
+        /** Cast entries that matched a row in the caller's library. */
+        bound: number;
+    };
+}
+interface StudioListProductionsResponse {
+    data: StudioProduction[];
+    nextCursor?: string;
+}
+/** What a create or an import did, in the words a receipt would use. */
+interface StudioImportSummary {
+    shotsAdded: number;
+    castEnrolled: number;
+    /** Cast entries that resolved to a row in the caller's library. */
+    castBound: number;
+}
+interface StudioProductionResponse {
+    production: StudioProduction;
+    warnings?: StudioPlanIssue[];
+    summary?: StudioImportSummary;
+}
+interface StudioCreateProductionRequest {
+    name?: string;
+    plan?: Record<string, unknown>;
+}
+/** The caller's own retry token — 8–128 chars of `A-Za-z0-9_.:-`, never derived. */
+type StudioClientRequestId = string;
+/**
+ * A batch of operations, applied atomically.
+ *
+ * `ops` is `unknown[]`: the operation union is the studio app's vocabulary and
+ * the route validates it, refusing the whole batch with the offending index.
+ * The served operating guide is the runtime reference for what an operation
+ * looks like.
+ */
+interface StudioOpsRequest {
+    /** Applied in order. At most 100 per request. */
+    ops: unknown[];
+    /**
+     * The version the batch was composed against. INFORMATIONAL by default: the
+     * operations address by stable KEY, so a batch built on a slightly older
+     * document still applies exactly to the newest one, and the response says
+     * `rebased: true`. Omitting it means "apply to whatever is there".
+     */
+    baseVersion?: number;
+    /**
+     * Refuse to rebase. With `strict: true` a `baseVersion` older than the stored
+     * one is a 409 `workflow_conflict` carrying the current production, instead
+     * of a rebased apply — for the rare "replace exactly what I read" intent.
+     */
+    strict?: boolean;
+    /** Your own token for this batch, so a transport retry is not applied twice. */
+    clientRequestId?: StudioClientRequestId;
+}
+/**
+ * What else an operation touched — the work that now has to follow it.
+ *
+ * Reported by the operations whose effect reaches past the thing they name: a
+ * frame review re-opens every frame derived from it and every shot bound to
+ * those, a sequence fork mints a whole parallel set. Both lists are always
+ * present and either may be empty; ids, never counts, because the caller's job
+ * is to go and refresh THOSE.
+ */
+interface StudioOpsImpact {
+    /** Planned frames the operation reaches, the named one first. */
+    keyframeIds: string[];
+    /** Shots bound to any of those frames. */
+    shotIds: string[];
+}
+/**
+ * One line of what an operation did, in the words a change log would use.
+ *
+ * Past tense, the target named the way the user sees it, the side effect in a
+ * trailing parenthetical: `Deleted take 2 of Shot 1 (in the bin).`
+ */
+interface StudioOpsReceipt {
+    /** The operation this line reports, by name. */
+    op: string;
+    /** Past tense, naming the target the way a person would. */
+    summary: string;
+    /** Ids the operation MINTED — never ids the caller supplied. */
+    ids?: string[];
+    /**
+     * The dependency scope, where the operation reports one — absent for the
+     * many that touch only what they name. The route projects a receipt ONCE for
+     * both answers, so this reads the same on an apply and on a preview.
+     */
+    impact?: StudioOpsImpact;
+}
+/** What a batch produced. Adopt `production` whole; do not merge into it. */
+interface StudioOpsResponse {
+    /** The canonical production AFTER the batch. */
+    production: StudioProduction;
+    /** The version the batch produced. Carry it as the next `baseVersion`. */
+    version: number;
+    /** True when the batch was applied to a newer document than it named. */
+    rebased: boolean;
+    /** One per operation, in order. */
+    receipts: StudioOpsReceipt[];
+    /**
+     * Things worth saying that are not failures — an operation that changed
+     * nothing, a rename that rewrote four prompts. A warning never rejects a
+     * batch; a refusal does.
+     */
+    warnings: string[];
+}
+/**
+ * An operation's confirmation class — the vocabulary's own four letters.
+ *
+ * `S` safe · `D` delete · `P` changes who can reach the work · `$` spends
+ * credits. The table that assigns them ships with the production codec and is
+ * pinned complete over the operation union there; this is the wire's spelling
+ * of its values, not a second table.
+ */
+type StudioOpClass = "S" | "D" | "P" | "$";
+/**
+ * One line of what an operation WOULD do, for a person deciding whether to let
+ * it. Everything {@link StudioOpsReceipt} says — the same summary, the same ids
+ * and the same {@link StudioOpsImpact}, read in the conditional — plus the two
+ * things the decision turns on and only a preview needs: which kind of change
+ * it is, and whether it can be taken back.
+ */
+interface StudioOpsDryRunReceipt extends StudioOpsReceipt {
+    /**
+     * The confirmation class, read out of the operation vocabulary's own table:
+     * `S` safe, `D` deletes, `P` changes who can reach the work, `$` spends
+     * credits. Narrow rather than open, because it is what a caller branches on
+     * — a rule like "never a `D` without asking" is only writable if the
+     * compiler knows the letters.
+     */
+    class: StudioOpClass;
+    /**
+     * Present, and always `true`, when this operation put something in the bin
+     * that can be brought back. ABSENT is the honest answer for everything else,
+     * including a delete that destroys: there is no entry to name, so there is no
+     * promise to make. Read it as `restorable ?? false`, never as `!restorable`
+     * meaning "kept".
+     */
+    restorable?: true;
+}
+/**
+ * What a batch WOULD do. Nothing was written: there is no production here and
+ * no new version, because none was produced.
+ */
+interface StudioOpsDryRunResponse {
+    /** Always present, and the marker the two-request protocol reads. */
+    dryRun: true;
+    /** The version the preview was computed against. */
+    version: number;
+    /** One per operation, in order. */
+    receipts: StudioOpsDryRunReceipt[];
+    /** The same things an apply would have said. */
+    warnings: string[];
+}
+/** What landing the finished jobs did. */
+interface StudioReconcileResponse {
+    /** Job ids whose media is now on the production. */
+    landed: string[];
+    /** Job ids still running — their markers stay; call again later. */
+    pending: string[];
+    /** Job ids that failed or were cancelled; their markers are cleared. */
+    failed: string[];
+    /** One line per landing that had something to say. */
+    warnings: string[];
+    /** The production after the landings. */
+    production: StudioProduction;
+    /** Its version — unchanged when nothing landed. */
+    version: number;
+}
+/** `POST …/:id/describe` — a Director run that will land as scenes. */
+interface StudioDescribeRequest {
+    brief: string;
+    llmModel: string;
+    /** `"append"` adds the drafted scenes; `"replace"` rewrites the film. */
+    mode?: "append" | "replace";
+    label?: string;
+    clientRequestId?: StudioClientRequestId;
+}
+/**
+ * `POST …/:id/generate` — one framing or directing run for one shot.
+ *
+ * `overrides` is what the CALL owns over what the shot's plan says: the model,
+ * the prose, the aspect, the direction ids. Open JSON, because the request
+ * builders' own option types are the contract and they ship with the studio.
+ */
+interface StudioGenerateRequest {
+    kind: "still" | "clip";
+    shotId: string;
+    /** Candidates to fan out (stills); the builder clamps it to the catalog's range. */
+    count?: number;
+    /**
+     * The directing input mode for a clip; absent ⇒ derived from the scene's saved
+     * inputs (a pinned end frame included). `start` sends ONLY the start frame;
+     * `start-end` sends the start and the end frame.
+     */
+    mode?: "start" | "start-end" | "references";
+    /** Price the run and return; nothing is submitted and nothing is written. */
+    dryRun?: boolean;
+    clientRequestId?: StudioClientRequestId;
+    overrides?: Record<string, unknown>;
+}
+/** Which video route a directing run went to — chosen from the inputs, never asked for. */
+type StudioVideoLane = "generate-video" | "text-to-video";
+/** `dryRun: true` — what this run would cost, and nothing else. */
+interface StudioGenerateEstimate {
+    dryRun: true;
+    provider: string;
+    count: number;
+    /** `null` when the model is unpriced or the instance runs without credits. */
+    credits: number | null;
+    lane?: StudioVideoLane;
+}
+/**
+ * A started (or already-started) run.
+ *
+ * `deduped` means the same `clientRequestId` came back and the job ids were
+ * answered from the production's own markers — nothing was submitted and
+ * nothing was charged, so `production` is absent.
+ */
+interface StudioGenerateResponse {
+    jobIds: string[];
+    lane?: StudioVideoLane;
+    deduped?: true;
+    production?: StudioProduction;
+    receipts?: StudioOpsReceipt[];
+    warnings?: string[];
+}
+/** `POST …/:id/frame` — a still pulled out of the shot's clip. */
+interface StudioFrameRequest {
+    shotId: string;
+    mode?: "first" | "last" | "timestamp";
+    /** Seconds, when `mode` is `"timestamp"`. */
+    timestamp?: number;
+    /** Where the grabbed image lands. `"new-shot"` inserts a shot after this one. */
+    target?: "new-shot" | "start-frame" | "end-frame" | "still";
+    clientRequestId?: StudioClientRequestId;
+}
+/** `POST …/:id/voice` — synthesize a shot's spoken line and record it. */
+interface StudioVoiceRequest {
+    shotId: string;
+    text: string;
+    voiceId?: string;
+    voiceType?: "premade" | "custom" | "library";
+    ttsProvider?: string;
+    /** The delivery levers; the text-to-speech route owns their bounds. */
+    delivery?: Record<string, number>;
+    clientRequestId?: StudioClientRequestId;
+}
+/** `POST …/:id/revoice` — recast the voices of the shot's active clip. */
+interface StudioRevoiceRequest {
+    shotId: string;
+    /** The speaker-ordered recast plan, forwarded to the voice route verbatim. */
+    plan: Record<string, unknown>;
+    clientRequestId?: StudioClientRequestId;
+}
+/** `POST …/:id/music` — the film's soundtrack. */
+interface StudioMusicRequest {
+    prompt: string;
+    duration?: number;
+    instrumental?: boolean;
+    vocalGender?: string;
+    model?: string;
+    clientRequestId?: StudioClientRequestId;
+}
+/**
+ * What a route that finished its work answers with: the production as it now
+ * stands, plus whatever that route produced.
+ *
+ * `jobId` is present on the routes that only STARTED something (a revoice, a
+ * soundtrack, a draft) — the result lands through its marker.
+ */
+interface StudioMediaResponse {
+    production: StudioProduction;
+    /** The grabbed frame's url, on the frame route. */
+    url?: string;
+    jobId?: string;
+    receipts?: StudioOpsReceipt[];
+    warnings?: string[];
+}
+/**
+ * `GET …/:id/export-plan` — the ordered steps an export would run.
+ *
+ * The caller runs them with the verbs that already exist; a route that chained
+ * three minutes-long jobs is the long-lived request every client times out on.
+ */
+interface StudioExportPlanResponse {
+    /** False when the production has fewer than two clips — nothing to stitch. */
+    canExport: boolean;
+    steps: StudioExportStep[];
+    /** The step whose output IS the film, or `null` when nothing can run. */
+    resultStepId: string | null;
+    /** Total credits, or `null` when ANY step is unpriced (a partial sum understates). */
+    estimate: number | null;
+    /** The credit models with no price, each named once, in step order. */
+    unpriced: string[];
+}
+interface StudioExportStep {
+    /** Stable within one plan and derived from the production, never minted. */
+    id: string;
+    label: string;
+    /** The node this step runs — `merge-video-audio`, `combine-videos`, `video-upscale`. */
+    node: string;
+    creditModel: string;
+    credits: number | null;
+    params: Record<string, unknown>;
+}
+/** `POST …/:id/clone` — a copy, which always starts private and visible. */
+interface StudioCloneRequest {
+    name?: string;
+}
+/** Either arm of a generation reply: the quote, or the run that started. */
+type StudioGenerateResult = StudioGenerateEstimate | StudioGenerateResponse;
+/** True when a generation reply is the `dryRun` QUOTE rather than a started run. */
+declare function isStudioGenerateEstimate(result: StudioGenerateResult): result is StudioGenerateEstimate;
+/** What a `generateStill` / `generateClip` call decides, beyond `kind` and the shot. */
+type StudioGenerateOptions = Omit<StudioGenerateRequest, "kind" | "shotId">;
+/**
+ * A route that only STARTED something — a draft, a revoice, a soundtrack. Its
+ * `jobId` is always there, which is what makes `const { jobId } = await …` and
+ * a poll the honest next line.
+ *
+ * `StudioMediaResponse` leaves `jobId` optional because the routes that FINISH
+ * their work (a frame, a voiceover) share the shape and have no job to name.
+ */
+type StudioJobStartedResponse = StudioMediaResponse & {
+    jobId: string;
+};
+interface ListStudioProductionsOptions {
+    limit?: number;
+    /** From a previous page's `nextCursor`. */
+    cursor?: string;
+    /** Include the rows the dashboard hides. Off by default. */
+    includeArchived?: boolean;
+}
+interface GetProductionOptions {
+    detail?: StudioProductionDetail;
+    /** Read ONE shot — the cheap way to re-read after a generation. */
+    shotId?: string;
+}
+interface StudioExportPlanOptions {
+    /** Plan the 4K finish too. Expensive, so it is always explicit. */
+    upscale?: boolean;
+}
+/** `client.studio.productions` — see the note at the top of this module. */
+declare class StudioProductionsResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    private path;
+    /**
+     * The authoring guide, the full catalog, the plan's JSON Schema and the
+     * operating guide — rendered server-side from the version that is live, so
+     * they describe the platform you are actually talking to. Free.
+     */
+    skill(): Promise<StudioSkillResponse>;
+    /**
+     * Check a plan before it becomes anything. Free, persists nothing, and
+     * resolves cast names against YOUR library — loop on `errors` until
+     * `valid: true`, then `create({ plan })`.
+     */
+    validatePlan(plan: Record<string, unknown>): Promise<StudioValidatePlanResponse>;
+    /** Your productions, newest first. Archived rows are hidden unless asked for. */
+    list(opts?: ListStudioProductionsOptions): Promise<StudioListProductionsResponse>;
+    /**
+     * One production. A pure read — it never lands a finished job, so call
+     * {@link reconcile} first if you are waiting on one.
+     */
+    get(productionId: string, opts?: GetProductionOptions): Promise<StudioProduction>;
+    /**
+     * The ordered steps that assemble the film, with what they will cost. Run
+     * them yourself with the ordinary verbs — nothing here blocks for minutes,
+     * and nothing here spends.
+     */
+    exportPlan(productionId: string, opts?: StudioExportPlanOptions): Promise<StudioExportPlanResponse>;
+    /** A new production, optionally landed from a plan in the same call. */
+    create(input?: StudioCreateProductionRequest): Promise<StudioProductionResponse>;
+    /**
+     * Apply a batch of operations. Atomic: one bad operation refuses the whole
+     * batch with a `StudioOpError` naming its index, and nothing is written. On
+     * success adopt `production` wholesale and carry `version` forward as the
+     * next `baseVersion`.
+     *
+     * `dryRun: true` — the LITERAL, which is what selects the preview reply —
+     * asks what the batch would do, so a person can approve an assistant's edits
+     * before they land. Spell it in THIS call's own object literal: a flag passed
+     * through a variable widens `true` to `boolean`, which selects the apply
+     * overload while the runtime still takes the preview path.
+     *
+     * A preview is TWO requests, deliberately. The route's body is parsed in
+     * strip mode, so a deployment that predates the preview drops the flag and
+     * APPLIES the batch: a caller that sent its batch and read the answer
+     * afterwards would already have written it. So the flag is proved on an EMPTY
+     * batch first and the real batch goes only when that answer carries the
+     * marker. An older deployment either answers the apply shape — this throws
+     * `StudioPreviewUnavailable`, and the batch never leaves — or refuses the
+     * empty batch with its own error, which is passed through as it stands.
+     *
+     * The ping proves the deployment that answered IT, and a fleet mid-rollout
+     * can serve the second request from another one. So the second answer is
+     * checked too: when the batch came back APPLIED, this throws
+     * `StudioPreviewAppliedError`, which carries that write. The SDK cannot
+     * un-send a request; what it can do is refuse to call the result a preview.
+     *
+     * An apply stays exactly one request.
+     */
+    ops(productionId: string, input: StudioOpsRequest & {
+        dryRun: true;
+    }): Promise<StudioOpsDryRunResponse>;
+    ops(productionId: string, input: StudioOpsRequest): Promise<StudioOpsResponse>;
+    /**
+     * Land every generation that has finished since you last looked, and report
+     * what is still running. The one call that turns finished jobs into results
+     * without a browser open. It writes only when something actually landed.
+     */
+    reconcile(productionId: string): Promise<StudioReconcileResponse>;
+    /** Add a plan's scenes to a production that already exists. */
+    importPlan(productionId: string, plan: Record<string, unknown>, opts?: {
+        mode?: "append";
+    }): Promise<StudioProductionResponse>;
+    /**
+     * Turn a brief into scenes. The run is a platform job: poll it, and its
+     * scenes land through {@link reconcile}. The production comes back with the
+     * run recorded on it as a pending draft.
+     */
+    describe(productionId: string, input: StudioDescribeRequest): Promise<StudioJobStartedResponse>;
+    /**
+     * Frame or animate one shot.
+     *
+     * The request is assembled server-side from the shot's own plan, looks and
+     * bound references, so a scripted run and a press of the button in the app
+     * produce the same media; `overrides` changes THIS run without changing the
+     * shot. Prefer {@link generateStill} / {@link generateClip}, which say which
+     * kind they mean.
+     *
+     * `dryRun: true` returns the quote and writes nothing — narrow the reply with
+     * {@link isStudioGenerateEstimate}.
+     */
+    generate(productionId: string, input: StudioGenerateRequest & {
+        dryRun: true;
+    }): Promise<StudioGenerateEstimate>;
+    generate(productionId: string, input: StudioGenerateRequest): Promise<StudioGenerateResult>;
+    /**
+     * Frame a shot: submit `count` candidates and record a pending marker for
+     * each. Results ACCUMULATE — a generate never replaces what is there.
+     *
+     * `clientRequestId` makes a retry safe: the same token answers with the jobs
+     * the first call started (`deduped: true`) and submits nothing. Never retry a
+     * spend without it.
+     */
+    generateStill(productionId: string, shotId: string, opts: StudioGenerateOptions & {
+        dryRun: true;
+    }): Promise<StudioGenerateEstimate>;
+    generateStill(productionId: string, shotId: string, opts?: StudioGenerateOptions): Promise<StudioGenerateResult>;
+    /**
+     * Animate a shot. The LANE is chosen from the shot's inputs (a start frame,
+     * references, a prompt) — never passed in — and reported back as `lane`.
+     */
+    generateClip(productionId: string, shotId: string, opts: StudioGenerateOptions & {
+        dryRun: true;
+    }): Promise<StudioGenerateEstimate>;
+    generateClip(productionId: string, shotId: string, opts?: StudioGenerateOptions): Promise<StudioGenerateResult>;
+    /**
+     * Extract a frame from a shot's active clip and put it where `target` says —
+     * a new shot after this one (the default), this shot's sticky start or end
+     * frame, or another still of the same shot. Seconds, not minutes: this one
+     * waits for the job and answers with the changed production.
+     */
+    frame(productionId: string, input: StudioFrameRequest): Promise<StudioMediaResponse>;
+    /** Synthesize a shot's spoken line and record it. Waits for the job. */
+    voice(productionId: string, input: StudioVoiceRequest): Promise<StudioMediaResponse>;
+    /**
+     * Recast the voices of a shot's active clip. Minutes of work, so it answers
+     * `jobId` and the new clip lands as a result through its own marker.
+     */
+    revoice(productionId: string, input: StudioRevoiceRequest): Promise<StudioJobStartedResponse>;
+    /** Score the film. The finished track lands through its pending marker. */
+    music(productionId: string, input: StudioMusicRequest): Promise<StudioJobStartedResponse>;
+    /**
+     * Open the share-by-link read. Deliberately its own route rather than an
+     * operation: who may see the work is decided by the owner, never as a side
+     * effect of a batch that was editing something else.
+     */
+    share(productionId: string): Promise<StudioProduction>;
+    /** Close it again. Sharing is opt-in AND reversible. */
+    unshare(productionId: string): Promise<StudioProduction>;
+    /**
+     * Copy a production you own or can see into your own Studio project. The
+     * copy starts PRIVATE and visible — sharing and archiving never travel — and
+     * it is copied through YOUR view of the source, so somebody else's bin does
+     * not come with it.
+     */
+    clone(productionId: string, input?: StudioCloneRequest): Promise<StudioProduction>;
+}
+
+export { type StudioProductionDetail as A, type StudioProductionResponse as B, StudioProductionsResource as C, type StudioReconcileResponse as D, type StudioRevoiceRequest as E, type StudioSkillResponse as F, type GetProductionOptions as G, type StudioValidatePlanResponse as H, type StudioVideoLane as I, type StudioVoiceRequest as J, isStudioGenerateEstimate as K, type ListStudioProductionsOptions as L, type StudioClientRequestId as S, type StudioCloneRequest as a, type StudioCreateProductionRequest as b, type StudioDescribeRequest as c, type StudioExportPlanOptions as d, type StudioExportPlanResponse as e, type StudioExportStep as f, type StudioFrameRequest as g, type StudioGenerateEstimate as h, type StudioGenerateOptions as i, type StudioGenerateRequest as j, type StudioGenerateResponse as k, type StudioGenerateResult as l, type StudioImportSummary as m, type StudioJobStartedResponse as n, type StudioListProductionsResponse as o, type StudioMediaResponse as p, type StudioMusicRequest as q, type StudioOpClass as r, type StudioOpsDryRunReceipt as s, type StudioOpsDryRunResponse as t, type StudioOpsImpact as u, type StudioOpsReceipt as v, type StudioOpsRequest as w, type StudioOpsResponse as x, type StudioPlanIssue as y, type StudioProduction as z };