@nodaro/shared 3.10.0 → 3.12.0

package/dist/index.d.ts

@@ -954,6 +954,38 @@ declare const VIDEO_GEN_COLLAPSED_T2V_IDS: ReadonlySet<string>;
 /** Video-to-video providers */
 declare const VIDEO_TO_VIDEO_PROVIDERS: readonly ["wan", "wan-flash", "wan-videoedit", "luma-modify", "runway-aleph", "happyhorse-edit"];
 type VideoToVideoProvider = typeof VIDEO_TO_VIDEO_PROVIDERS[number];
+/**
+ * Seedance models the Video to Video NODE offers as a whole-clip, prompt-driven
+ * EDIT ("make it black and white", "she wears @image_1").
+ *
+ * These are deliberately NOT members of {@link VIDEO_TO_VIDEO_PROVIDERS} (the
+ * `/v1/video-to-video` route's own enum): Seedance has no separate edit
+ * endpoint — it edits a REFERENCE video when the prompt reads as an edit. So
+ * every surface (single-node run, DAG payload builder, MCP `modify_video`)
+ * dispatches these through the ONE existing Seedance reference-video lane
+ * (`text-to-video`), with the source clip as `@video_1` and the edit shape
+ * below. Reference-clip bounds, the unit×(input+output) reservation, the
+ * measured settlement, the edit-mode retry and the reconcile recovery are that
+ * lane's — there is no second copy to keep in step.
+ */
+declare const SEEDANCE_VIDEO_EDIT_PROVIDERS: readonly ["seedance-2-5"];
+type SeedanceVideoEditProvider = typeof SEEDANCE_VIDEO_EDIT_PROVIDERS[number];
+declare function isSeedanceVideoEditProvider(provider: string | undefined): provider is SeedanceVideoEditProvider;
+/** Every model the Video to Video node can be set to: the route's own providers
+ *  plus the Seedance edit models dispatched through the text-to-video lane. */
+declare const VIDEO_TO_VIDEO_NODE_PROVIDERS: readonly ["wan", "wan-flash", "wan-videoedit", "luma-modify", "runway-aleph", "happyhorse-edit", "seedance-2-5"];
+type VideoToVideoNodeProvider = typeof VIDEO_TO_VIDEO_NODE_PROVIDERS[number];
+/**
+ * The request shape Seedance edit mode requires, sent UP FRONT by the Video to
+ * Video node: the output takes the source clip's own ratio and length
+ * (`adaptive`, and Auto = `VIDEO_DURATION_AUTO`). Camel-cased twin of the KIE
+ * wire pair the provider layer resubmits with when Seedance reclassifies an
+ * ordinary run as an edit.
+ */
+declare const SEEDANCE_VIDEO_EDIT_SHAPE: {
+    readonly aspectRatio: "adaptive";
+    readonly duration: -1;
+};
 /** Face swap providers */
 declare const FACE_SWAP_PROVIDERS: readonly ["roop"];
 type FaceSwapProvider = typeof FACE_SWAP_PROVIDERS[number];
@@ -997,9 +1029,70 @@ type TextToAudioProvider = typeof TEXT_TO_AUDIO_PROVIDERS[number];
 /** Music generation providers */
 declare const MUSIC_PROVIDERS: readonly ["minimax"];
 type MusicProvider = typeof MUSIC_PROVIDERS[number];
-/** Transcription providers */
-declare const TRANSCRIBE_PROVIDERS: readonly ["elevenlabs-stt"];
+/**
+ * Transcription providers a caller may name — on `/v1/transcribe`, the SDK/CLI
+ * and the canvas Transcribe node. All three lanes are served on cloud again
+ * (the canvas picker re-offered the two Replicate lanes in #768 while this enum
+ * still hid them, so a single-node Run on Whisper 400'd where the same node in a
+ * workflow Run worked). `elevenlabs-stt` stays FIRST: several call sites take
+ * "the first enabled word-capable provider" from this order.
+ */
+declare const TRANSCRIBE_PROVIDERS: readonly ["elevenlabs-stt", "whisper", "incredibly-fast-whisper"];
 type TranscribeProvider = typeof TRANSCRIBE_PROVIDERS[number];
+/**
+ * Every transcription LANE the platform implements. Today this is the same set
+ * as `TRANSCRIBE_PROVIDERS`; it stays a separate name because the two answer
+ * different questions — "what may a caller name" vs "what can run" — and they
+ * have diverged before (the Replicate lanes were hidden from callers for months
+ * while still reached at runtime via the route default and add-captions'
+ * auto-transcribe). Capability questions must be asked over THIS union.
+ */
+declare const TRANSCRIBE_LANES: readonly ["whisper", "incredibly-fast-whisper", "elevenlabs-stt"];
+type TranscribeLane = typeof TRANSCRIBE_LANES[number];
+/**
+ * What each transcription lane can actually DO. Single source of truth — never
+ * re-derive a capability from a provider-name check.
+ *
+ * `wordTimestamps`: does the lane return per-word start/end times?
+ *  - `whisper` (Replicate `openai/whisper`) — NO. Its input schema has no
+ *    `word_timestamps` field in ANY published version, so Replicate silently
+ *    drops the key and the segments come back without `words`. Asking this lane
+ *    for word timings yields an empty array, never an error.
+ *  - `incredibly-fast-whisper` — yes, via `timestamp: "word"`.
+ *  - `elevenlabs-stt` (direct Scribe) — always word-level, flag or not.
+ */
+declare const TRANSCRIBE_PROVIDER_CAPABILITIES: Record<TranscribeLane, {
+    wordTimestamps: boolean;
+}>;
+/** The lanes that can honour a word-timestamps request, in declaration order. */
+declare function transcribeProvidersWithWordTimestamps(): TranscribeLane[];
+/**
+ * Capability question for a lane id that came from UNTRUSTED data — node data,
+ * an imported workflow, a wire body — where the string may be anything at all.
+ * An unknown lane answers `false`: we cannot promise word timings from a lane
+ * we know nothing about, and "false" is always the safe answer (it suppresses
+ * an INFERRED request, and turns an EXPLICIT one into the honest refusal in
+ * `transcribe()` instead of a `Cannot read properties of undefined` TypeError).
+ */
+declare function transcribeLaneSupportsWordTimestamps(lane: string | null | undefined): boolean;
+/**
+ * The lane an absent `provider` resolves to — the historical `/v1/transcribe`
+ * default, kept as-is because the credit guard reserves on the provider id
+ * (changing it would silently change what bills).
+ */
+declare const DEFAULT_TRANSCRIBE_PROVIDER: TranscribeLane;
+/**
+ * The lane a transcribe NODE with no `provider` in its data resolves to —
+ * deliberately NOT `DEFAULT_TRANSCRIBE_PROVIDER`. The route's default is the
+ * legacy whisper lane and exists only so a pre-existing REST caller keeps
+ * billing the same id; a node authored/imported without a provider is a fresh
+ * request, and the canvas picker's own default is this one. Single-sourced so
+ * the backend DAG (`payload-builder.ts`) and the frontend run
+ * (`execute-node.ts`) cannot drift into sending different engines for the same
+ * node — they did, and the frontend's silent whisper fallback started 400ing
+ * once the Replicate lanes left `TRANSCRIBE_PROVIDERS`.
+ */
+declare const DEFAULT_TRANSCRIBE_NODE_PROVIDER: TranscribeLane;
 /** Script generation providers */
 declare const SCRIPT_PROVIDERS: readonly ["gemini", "claude", "gpt"];
 type ScriptProvider = typeof SCRIPT_PROVIDERS[number];
@@ -1664,6 +1757,11 @@ declare const PRICING_DEFAULT_DURATION_SEC: Record<string, number>;
  * closes.
  */
 declare function pricedOutputDurationSec(provider: string, requested: number | string | undefined): number;
+/** Models that accept `VIDEO_DURATION_AUTO` — a catalog capability (docs.kie.ai:
+ *  the Seedance 2 family, "4-15 seconds or -1" / 2.5 "Special values -1"). */
+declare function supportsAutoVideoDuration(provider: string | undefined): boolean;
+/** The longest clip a duration-tiered provider can render (its top priced tier). */
+declare function maxVideoDurationSec(provider: string): number | undefined;
 /**
  * Resolution assumed for PRICING when a request names a provider but omits
  * `resolution` — the resolution twin of {@link PRICING_DEFAULT_DURATION_SEC},
@@ -2168,6 +2266,14 @@ interface ModelCatalogEntry {
     unlistedResolutionRendersAs?: string;
     qualities?: readonly string[];
     durations?: readonly number[];
+    /**
+     * The model accepts an AUTO duration (`duration: -1`, see
+     * `VIDEO_DURATION_AUTO`): it picks the clip length itself — the source clip's
+     * length on a video edit, a length within `durations` otherwise. A capability,
+     * not a member of `durations` (which stay real seconds). Runs are reserved at
+     * the longest clip and settled on the delivered one.
+     */
+    autoDuration?: boolean;
     pricing: readonly PriceVariant[];
     /** Editorial highlight — "best in tier". Surfaces in MCP output as a ⭐. */
     featured?: boolean;
@@ -2561,6 +2667,24 @@ declare function resolveImageGenCreditIdentifier(opts: {
     swapToI2i?: boolean;
 }): string;
 declare function buildVideoCreditModelIdentifier(provider: string, duration?: number | string, sound?: boolean, nodeType?: "image-to-video" | "text-to-video", mode?: string, resolution?: string, hasVideoRef?: boolean): string;
+/**
+ * The credit identifier a Video to Video node's Seedance EDIT lane reserves
+ * under. Seedance has no v2v endpoint — the lane is a text-to-video job in edit
+ * shape with the source clip as reference video 1 — so it prices on the
+ * REFERENCE-VIDEO ladder at the model's LONGEST clip (Auto duration), and the
+ * measured settlement refunds down to what was actually delivered.
+ *
+ * It exists because that is a 7-positional-argument call with four
+ * easy-to-transpose slots, and FOUR surfaces must agree on it exactly: the
+ * orchestrator's reservation (payload-builder.ts), the backend pre-run
+ * estimator (ee/billing/credits.ts), the node's cost pill, and the frontend
+ * run-level estimate (config-panels/helpers.ts). A quote that disagrees with
+ * the reserve is the documented `price_not_configured` / blank-pill trap.
+ *
+ * `resolution` is the node's one `v2vResolution` field; when unset the model's
+ * own UI fill is priced, which is what the lane will send.
+ */
+declare function seedanceVideoEditCreditId(provider: string, resolution?: string): string;
 /** What the video credit identifier PRICES for a request, for the levers whose
  *  priced value must also be the value we SEND. */
 interface PricedVideoSelection {
@@ -2780,6 +2904,18 @@ declare function imageOverlayCredits(variants: ReadonlyArray<unknown> | undefine
  *  Lives in `@nodaro/shared` so frontend (store walks) and backend
  *  (orchestrator input-resolver) can use one source of truth. */
 declare function extractVideoDurationFromNode(data: Record<string, unknown> | undefined): number | undefined;
+/** Duration (seconds) of an edit-plan SOURCE node's media, for the reserve
+ *  bucket. Extends {@link extractVideoDurationFromNode} with the AUDIO lane:
+ *  `upload-audio` (and URL-imported audio) write their length to
+ *  `metadata.durationSeconds` ONLY — never `generatedResults[].duration` /
+ *  `data.duration` — so a podcast's audio master would otherwise resolve to
+ *  undefined and reserve the 180-minute ceiling (a ~6× overbill). A
+ *  `reference-audio` node records its extracted file's length in the same field,
+ *  stamped with `metadata.mediaUrl` (see the binding check below).
+ *
+ *  Deliberately a NEW function, not a change to `extractVideoDurationFromNode`,
+ *  so no other node's duration read shifts — this fallback is edit-plan-scoped. */
+declare function editPlanSourceDurationSec(data: Record<string, unknown> | undefined): number | undefined;
 
 /**
  * Topaz image upscale — the single authority for "which lever did the user
@@ -2945,6 +3081,24 @@ interface InputFieldSchema {
 }
 /** Get the overridable field schema for an input node type. */
 declare function getInputFieldSchema(nodeType: string): InputFieldSchema | undefined;
+/**
+ * Shallow-merge run-time input overrides (a published app's inputs, an API-token
+ * run, MCP `run_app` / `run_workflow` inputs, a wired component handle) over a
+ * node's SAVED data — the one merge every such lane must use.
+ *
+ * `metadata` holds facts measured FROM the node's media (its length, its
+ * dimensions). When an override swaps that media — the node's primary input
+ * field is a media url (`INPUT_FIELD_MAP`) and the override changes it — the
+ * snapshot's facts describe a file that is no longer there, so they are dropped
+ * unless the override supplies its own. Left behind, a publisher's
+ * `metadata.durationSeconds` outranks the run's own transcript as Edit Plan's
+ * duration basis and under-buckets a caller's longer episode: an estimate that
+ * passes the balance precheck for a run the reserve then refuses.
+ *
+ * Schema-driven on purpose: a new media input node is covered by its
+ * `INPUT_FIELD_MAP` row, with no list to remember here.
+ */
+declare function mergeNodeInputOverrides(nodeType: string | undefined, data: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
 /** Migrate a legacy string[] order to PresentationItem[]. */
 declare function migrateToItems(order: string[] | undefined): PresentationItem[] | undefined;
 /** Strip nested groups — groups may only contain non-group items. */
@@ -3146,13 +3300,34 @@ interface LlmModelDef {
      *
      * Consumers MUST give such a model output headroom regardless of the
      * requested effort, or reasoning silently eats a small legacy cap and the
-     * answer truncates with `stop_reason: max_tokens` — a paid-for empty reply,
-     * not an error. `deriveParams` (llm-client.ts) and the film-pipeline's
-     * `callLLM` both floor on this flag; keep it in sync with the vendor's
+     * answer truncates with `stop_reason: max_tokens` — a paid-for empty reply
+     * (since #1588 the client fails such a call rather than return the
+     * fragment, but the floor is what keeps it from happening). `deriveParams`
+     * (llm-client.ts) floors to {@link reasoningOutputFloor}; the film
+     * pipeline's `callLLM` — Anthropic SDK only, so only its Claude members
+     * matter — floors at the default. Keep the flag in sync with the vendor's
      * documented default rather than inferring it from the model name.
      */
     thinkingDefaultOn?: true;
+    /**
+     * The output-token cap a REASONING call on this model is floored to — the
+     * room its thinking shares with the answer (`thinkingDefaultOn`, or an
+     * xhigh/max effort). Absent = {@link REASONING_OUTPUT_FLOOR}; read it through
+     * {@link reasoningOutputFloor}, never directly.
+     *
+     * Declare it ONLY where a lane serving this model is not known to accept the
+     * default: the floor rides every lane the model can be served on (KIE AND its
+     * direct fallback), so it has to sit at the intersection of what they take —
+     * the rule `maxOutputTokens` already follows for the Gemini flash entries.
+     * Never below `maxOutputTokens` (a floor under the default cap is not a
+     * floor — guarded by a registry test).
+     */
+    reasoningOutputFloor?: number;
 }
+/** The reasoning floor for a model that declares no lane limit of its own. */
+declare const REASONING_OUTPUT_FLOOR = 32768;
+/** The output cap a reasoning call on `model` is floored to (see `LlmModelDef.reasoningOutputFloor`). */
+declare function reasoningOutputFloor(model: LlmModelDef): number;
 declare const LLM_MODELS: readonly LlmModelDef[];
 declare const LLM_MODEL_IDS: string[];
 /** Vision models that can return GUARANTEED structured output — the
@@ -3190,7 +3365,7 @@ declare function groupLlmModelsByVendor(models?: readonly LlmModelDef[]): LlmMod
  *  group headers (e.g. the compact node quick strips) but should still read
  *  vendor-clustered and tier-ordered. */
 declare function orderedLlmModels(models?: readonly LlmModelDef[]): LlmModelDef[];
-type LlmFeature = "ai-writer" | "llm-chat" | "prompt-helper" | "scene-graph-ai" | "after-effects" | "motion-graphics" | "motion-graphics-lottie" | "lottie-overlay" | "3d-title" | "3d-scene" | "image-to-text" | "describe-to-picker" | "qa-check" | "generate-script" | "translate" | "image-critic" | "pick-best-llm" | "workflow-copilot";
+type LlmFeature = "ai-writer" | "llm-chat" | "prompt-helper" | "scene-graph-ai" | "after-effects" | "motion-graphics" | "motion-graphics-lottie" | "lottie-overlay" | "3d-title" | "3d-scene" | "image-to-text" | "meta-ads-analysis" | "describe-to-picker" | "qa-check" | "generate-script" | "translate" | "image-critic" | "pick-best-llm" | "workflow-copilot";
 /** Engine-dependent LlmFeature for the motion-graphics node (design §8: every credit-id site must branch on engine). */
 declare function motionGraphicsFeature(engine?: string): LlmFeature;
 /** Feature → default model when user hasn't selected one */
@@ -3804,6 +3979,113 @@ declare function getEffectiveRepeatCount(nodeData: Record<string, unknown>): num
  */
 declare function expandItemsWithRepeat(listItems: string[] | undefined, nodeType: string, nodeData: Record<string, unknown>): string[] | null;
 
+/**
+ * The text LANES the input resolvers route somewhere OTHER than the prompt slot
+ * (`negative` → negativePrompt, `system-prompt` → systemPrompt, an avatar's
+ * `script`, an editor's `transcript`, …). A list that drives a fan-out through
+ * one of these must NOT also be written into the prompt: the per-row resolution
+ * already delivered it where it belongs.
+ *
+ * Keyed by handle, scoped by node type, because the routers are: `transcript`
+ * is the caption track of Add Captions but the very text Forced Alignment
+ * aligns. `"*"` = every node type (the router branch is unconditional).
+ *
+ * DERIVED, not remembered: each engine has a totality test
+ * (`fanout-text-handle-totality`) that routes a text source into EVERY input
+ * handle of EVERY node type through the real resolver and fails the build on any
+ * pair where this table and the router disagree — in either direction. An
+ * unlisted lane keeps the old behavior (the item is the prompt), so a miss can
+ * only ever reproduce the old bug on that one lane, never a new one.
+ */
+declare const NON_PROMPT_TEXT_LANES: Readonly<Record<string, "*" | readonly string[]>>;
+/** Does a TEXT list wired to `targetHandle` of a `nodeType` node feed its prompt slot? */
+declare function fanOutTextFeedsPrompt(nodeType: string | null | undefined, targetHandle: string | null | undefined): boolean;
+/**
+ * Drop the empty entries of a row-aligned list, remembering the row every kept
+ * value came from. The items are what drives a fan-out (nothing runs for an
+ * empty cell); the rows are what keeps the OTHER wires on the same row.
+ */
+declare function compactWithRows(aligned: readonly string[]): {
+    items: string[];
+    rowIndices: number[];
+};
+/**
+ * One column of a manual List table, row-aligned: a row is dropped only when
+ * EVERY cell of it is blank (the trailing empty row the editor keeps), and an
+ * empty cell of a row that has content stays in place as "".
+ */
+declare function liveRowColumn(rows: ReadonlyArray<ReadonlyArray<string | undefined>>, colIndex: number): string[];
+/** One list wire that could drive a fan-out. */
+interface FanOutCandidate {
+    /** Target handle of the consumer-side wire. */
+    targetHandle: string | null | undefined;
+    /** The wire's values in row order — may hold "" for an empty row. */
+    aligned: readonly string[];
+}
+/**
+ * Turn the lists that reach a node into ONE fan-out, so that nothing depends on
+ * the order the wires were drawn in. `candidates` are the "each" lists that hold
+ * more than one value, in wire order.
+ *
+ * The PRIMARY is the list that holds the most values (the first of them when
+ * several tie): it sets the row space. Both engines get it from here, so the
+ * orchestrator and the in-browser executor cannot disagree on how many times a
+ * node runs. Lists with the SAME number of rows share that row space — two
+ * columns of one table, two Extract Field lists cut from one array — and are
+ * settled together:
+ *
+ *   - the DRIVER (its item becomes the per-row override) is a text list that
+ *     feeds the prompt, when there is one: that item is what must win over the
+ *     typed prompt, and a list wired to `negative` must never supply it;
+ *   - a ROW runs when ANY of those lists has a value in it. A row is never
+ *     dropped because one column is empty there — that column just contributes
+ *     nothing for the row — and a row with no value anywhere does not run.
+ *
+ * A list with a different number of rows is not part of this: it keeps
+ * wrapping around per iteration, as it always has.
+ */
+declare function resolveListFanOut<C extends FanOutCandidate>(candidates: readonly C[], nodeType: string | null | undefined): ListFanOut | undefined;
+/**
+ * Is this fan-out item a media URL (as opposed to text)? The ONE guess both
+ * engines make when a list item has to be applied as an override — kept here so
+ * the backend worker and the in-browser executor cannot disagree on it.
+ */
+declare function isFanOutUrlItem(item: string): boolean;
+/** What a fan-out source resolved to. */
+interface ListFanOut {
+    /** The driving list's value for every row that runs — "" where the driver has
+     *  none for a row another list keeps alive (nothing is overridden there). */
+    items: string[];
+    /** `rowIndices[k]` = the row `items[k]` came from, in the driver's row space. */
+    rowIndices: number[];
+    /** Target handle of the consumer-side wire that drives the fan-out. */
+    targetHandle: string | null | undefined;
+}
+/** The iterations a node will run, in order. */
+interface FanOutPlan {
+    /** One entry per iteration (list items, repeat / provider sentinels). */
+    items: string[];
+    /** Row each iteration reads its inputs from; undefined when nothing is list-driven. */
+    rows: Array<number | undefined>;
+    /** Handle the driving list is wired to; undefined when nothing is list-driven. */
+    targetHandle: string | null | undefined;
+}
+/**
+ * Expand a fan-out into its iterations (list x Repeat xN, providers, repeats —
+ * `expandItemsWithRepeat` stays the single rule for that) and pin every
+ * iteration to the ROW its item came from. Repeat xN runs a row N times: the
+ * copies share the row, they do not walk on to the next one.
+ */
+declare function planFanOut(fanOut: ListFanOut | undefined, nodeType: string, nodeData: Record<string, unknown>): FanOutPlan | null;
+/**
+ * Extract Field, List output, over a root ARRAY: one entry per element, "" where
+ * the element has no value — so two Extract Field lists cut from the same array
+ * stay row-aligned. Returns undefined when rows cannot be defined (the root is
+ * not an array, an element fans into several values, or no element carries the
+ * field at all) — the caller then keeps the plain "values that exist" list.
+ */
+declare function alignedFieldList(value: unknown, path: string): string[] | undefined;
+
 /**
  * Like Promise.allSettled but limits how many tasks run concurrently.
  * Uses a worker-pool pattern so a new task starts as soon as a slot frees up.
@@ -4455,11 +4737,35 @@ declare const HINT_EXEMPT_PARAMETER_TYPES: ReadonlySet<string>;
 declare const VIDEO_ONLY_PARAMETER_NODE_TYPES: ReadonlySet<string>;
 /**
  * Pickers whose fragment depends on OTHER nodes wired into them — camera
- * motion's start / end states, character motion's target and partner names —
- * so both executors must pass the graph to `getParameterPromptHint` for them.
- * Transition and Character FX compose from the graph in the editor preview but
- * are deliberately NOT here: adding them changes the prompt of workflows that
- * already exist, which is its own reviewed change.
+ * motion's and transition's start / end states, character motion's target and
+ * partner names, character FX's target name — so both executors must pass the
+ * graph to `getParameterPromptHint` for them.
+ *
+ * TRANSITION AND CHARACTER-FX JOINED THIS SET (signed off). They compose from
+ * the graph everywhere a human LOOKS at them — the config panel's injection
+ * preview and the canvas card both run
+ * `getParameterPromptHint(node, { nodes, edges })` — and on the frontend
+ * `{Label}` path (`execution-graph.ts :: extractNodeOutput`), but the two
+ * cinematography collectors that read THIS set dispatched them without the
+ * graph, so a wired `startState` / `target` was promised in the preview and
+ * dropped at execution. Admitting them here closes that gap on BOTH executors
+ * at once.
+ *
+ * THE BOUND, and it is proved rather than asserted: a picker with NOTHING
+ * wired to its own `startState` / `endState` / `target` handles emits
+ * byte-identical text with and without the graph — the composers are simply
+ * called with empty clause arrays either way. So only workflows that actually
+ * wire those handles change at all, and they change to the text their own
+ * preview already shows. The prompts package's
+ * `graph-composed-unwired-identity.test.ts` walks every transition and
+ * character-fx catalog entry in both hint modes, under two unwired graph
+ * shapes, and asserts that equality — with a wired positive control so it
+ * cannot go vacuous.
+ *
+ * ADD A NEW GRAPH-COMPOSED PICKER HERE AND TO
+ * `LABEL_REF_GRAPH_COMPOSED_PARAMETER_TYPES` (backend
+ * `services/workflow-engine/label-ref-hint-context.ts`) when it ships, so its
+ * `{Label}` text and its directly-wired text agree from its first release.
  */
 declare const EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES: ReadonlySet<string>;
 declare function setRegisteredPersonPackFields(fields: readonly string[]): void;
@@ -4757,6 +5063,479 @@ declare const SUNO_FIELD_HANDLE_FIELDS: readonly ["style", "lyrics", "title", "n
 /** Map a `field-<key>` handle id to its data key, or null if not a field handle. */
 declare function fieldKeyFromHandle(handleId: string): string | null;
 
+/**
+ * The node types the server projects onto `workflow_triggers` rows when a
+ * workflow is saved (backend `lib/workflow-trigger-sync.ts`), and that the
+ * editor therefore asks the server to re-project after its own saves. One
+ * vocabulary for both sides: a projected type added here reaches the
+ * editor's "does this save need a sync?" question by construction.
+ */
+declare const SCHEDULE_TRIGGER_NODE_TYPE = "schedule-trigger";
+declare const WEBHOOK_TRIGGER_NODE_TYPE = "webhook-trigger";
+declare const TELEGRAM_TRIGGER_NODE_TYPE = "telegram-trigger";
+declare const PROJECTED_TRIGGER_NODE_TYPES: ReadonlySet<string>;
+declare function isProjectedTriggerNodeType(type: unknown): type is string;
+
+/**
+ * Every way one node FEEDS another — the ONE definition the server's run
+ * scope (`triggerRunScope`) and the editor's "is this trigger wired?" read
+ * from, so the card can never say "the branch" while the server runs the
+ * whole workflow, or the other way round:
+ *
+ * - a drawn edge whose two ends are both on the graph (a delta that deleted a
+ *   node leaves its edges behind; those feed nothing);
+ * - Group membership: a node inside a Group feeds the group (`parentId`),
+ *   the way the engine orders a group after its members;
+ * - a field mapping: `data.fieldMappings[field].sourceNodeId` feeds the node
+ *   that carries the mapping, even after the edge it was made from is gone.
+ */
+interface FeedNode {
+    readonly id: string;
+    readonly parentId?: string | null;
+    readonly data?: unknown;
+}
+interface FeedEdge {
+    readonly source: string;
+    readonly target: string;
+}
+interface FeedMaps {
+    /** node id → the ids it feeds */
+    readonly children: ReadonlyMap<string, ReadonlyArray<string>>;
+    /** node id → the ids that feed it */
+    readonly parents: ReadonlyMap<string, ReadonlyArray<string>>;
+}
+declare function buildFeedMaps(nodes: ReadonlyArray<FeedNode>, edges: ReadonlyArray<FeedEdge>): FeedMaps;
+/** Does this node feed anything? A trigger that does not runs the whole workflow. */
+declare function nodeFeedsAnything(nodes: ReadonlyArray<FeedNode>, edges: ReadonlyArray<FeedEdge>, nodeId: string): boolean;
+
+/**
+ * Schedule Trigger rules — the ONE model both sides read.
+ *
+ * A schedule is a list of rules; the workflow runs whenever any rule says
+ * "this minute". The editor previews a schedule (headline, today's timeline,
+ * the next runs, runs per day) and the server decides whether to fire — from
+ * the same functions here, so what the panel shows is what the cron does.
+ *
+ * Kinds, with the fields each reads (everything else on the rule is ignored):
+ * - `minutes` — `every` (1–59): at minute 0, N, 2N… of every hour (cron `*\/N`).
+ * - `hours`   — `every` (1–23) at `minute`: at hour 0, N, 2N… of every day.
+ * - `days`    — `every` (1–31) at `hour:minute`: every Nth calendar day.
+ * - `weeks`   — `every` (1–52) on `weekdays` at `hour:minute`: every Nth week.
+ * - `months`  — `every` (1–12) on `dayOfMonth` at `hour:minute`: every Nth month
+ *               (a day the month lacks — 31 in April — runs on its last day).
+ * - `cron`    — a 5-field cron expression, for the person who wants one.
+ *
+ * "Every Nth day / week / month" counts from a fixed origin (the Unix epoch,
+ * in the schedule's timezone; weeks start on Monday) rather than from the
+ * moment the rule was saved — so the preview and the server agree, a re-save
+ * never shifts the phase, and two people reading the rule get the same days.
+ *
+ * Time is read in the schedule's timezone (an IANA name; missing or unknown
+ * → UTC — callers validate with `isValidTimezone` and refuse the unknown
+ * ones, so that fallback is only ever a defence). Resolution is one minute:
+ * the cron ticks once a minute and asks "does this minute match?" — there is
+ * no sub-minute scheduling.
+ *
+ * Daylight-saving: a wall-clock minute that does not exist on the day the
+ * clocks jump forward is skipped that day. On the day they fall back, a rule
+ * that names a time of day (`hours` / `days` / `weeks` / `months` / `cron`)
+ * runs once — the second pass is the same wall-clock minute
+ * (`localMinuteKey`) as the fire just before it, and both the server and the
+ * preview drop it — while a `minutes` rule keeps its cadence through the
+ * repeated hour, because real time keeps passing.
+ */
+declare const SCHEDULE_RULE_KINDS: readonly ["minutes", "hours", "days", "weeks", "months", "cron"];
+type ScheduleRuleKind = (typeof SCHEDULE_RULE_KINDS)[number];
+interface ScheduleRule {
+    readonly id: string;
+    readonly kind: ScheduleRuleKind;
+    /** Every N units (see `SCHEDULE_EVERY_LIMITS`). */
+    readonly every?: number;
+    /** 0–23, in the schedule's timezone. Read by days / weeks / months. */
+    readonly hour?: number;
+    /** 0–59. Read by every kind but `minutes` and `cron`. */
+    readonly minute?: number;
+    /** 0 = Sunday … 6 = Saturday (the cron / JavaScript convention). Read by `weeks`. */
+    readonly weekdays?: ReadonlyArray<number>;
+    /** 1–31. Read by `months`. */
+    readonly dayOfMonth?: number;
+    /** A 5-field cron expression. Read by `cron`. */
+    readonly cron?: string;
+}
+interface ScheduleSpec {
+    readonly rules: ReadonlyArray<ScheduleRule>;
+    /** IANA timezone; missing or unknown means UTC. */
+    readonly timezone?: string;
+    /** Stop after this many runs; missing means unlimited. */
+    readonly maxExecutions?: number;
+}
+/** `every` limits per kind — the panel's range hints and the normaliser's clamps. */
+declare const SCHEDULE_EVERY_LIMITS: Readonly<Record<Exclude<ScheduleRuleKind, "cron">, readonly [number, number]>>;
+/** A 5-field cron expression — the only shape the matcher understands. */
+declare function isCronExpression(value: unknown): value is string;
+/**
+ * One rule as the user typed it → one rule the engine can run, or `null` when
+ * there is nothing to run (unknown kind, a cron rule with no expression, a
+ * weeks rule with no weekday). Out-of-range numbers are clamped, never
+ * refused: a half-typed "0" must not silently disable a schedule.
+ */
+declare function normalizeScheduleRule(raw: unknown, fallbackId?: string): ScheduleRule | null;
+/** Every usable rule, in order; unusable ones dropped. */
+declare function normalizeScheduleRules(raw: unknown): ScheduleRule[];
+/**
+ * The schedule an OLD node carried — `interval` ("5m" / "1h" / "1d" or one of
+ * the editor's cron presets) and/or `cron` — as rules. Seconds cannot be
+ * scheduled (the cron ticks once a minute) and become "every minute".
+ */
+declare function legacyScheduleToRules(data: {
+    interval?: unknown;
+    cron?: unknown;
+    cronExpression?: unknown;
+}): ScheduleRule[];
+interface LocalTime {
+    readonly year: number;
+    /** 1–12 */
+    readonly month: number;
+    /** 1–31 */
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    /** 0 = Sunday … 6 = Saturday */
+    readonly weekday: number;
+    /** Calendar days since 1970-01-01, in the schedule's timezone. */
+    readonly epochDay: number;
+}
+/** A timezone this runtime can read the clock in (an IANA name such as `Asia/Jerusalem`). */
+declare function isValidTimezone(value: unknown): value is string;
+/** One wall-clock minute, as a key: the same key twice means the clocks fell back. */
+declare function localMinuteKey(local: LocalTime): string;
+/** The wall-clock time in the schedule's timezone (UTC when it is missing or unknown). */
+declare function localTimeIn(date: Date, timezone?: string): LocalTime;
+/** How far the timezone's wall clock is ahead of UTC at this instant, in minutes. */
+declare function timezoneOffsetMinutes(date: Date, timezone?: string): number;
+/** Standard 5-field cron field: `*`, `N`, `a-b`, `a,b`, `*\/N`, `a-b/N`, `a/N`. */
+declare function matchesCronField(field: string, value: number, min: number, max: number): boolean;
+/** Does this wall-clock minute match the cron expression? */
+declare function matchesCron(expression: string, local: LocalTime): boolean;
+/** Does this wall-clock minute match the rule? */
+declare function ruleMatches(rule: ScheduleRule, local: LocalTime): boolean;
+/** Does the schedule run at this instant (any rule, this minute)? */
+declare function scheduleMatchesAt(spec: ScheduleSpec, at: Date): boolean;
+/**
+ * Every minute in [from, until] at which the schedule runs, oldest first, at
+ * most `cap`. Scans minute by minute with the timezone offset re-read once per
+ * quarter hour, so a 62-day horizon costs ~90k cheap checks and ~6k clock
+ * reads. A wall-clock minute the clocks fall back onto is listed once.
+ */
+declare function scheduleOccurrences(spec: ScheduleSpec, from: Date, until: Date, cap: number): Date[];
+/**
+ * How far ahead a preview must look to find the schedule's next run: two
+ * periods of its slowest rule (a quarterly rule needs half a year, a yearly
+ * one two), never less than two months and never more than ~two years.
+ */
+declare function previewHorizonMs(rules: ReadonlyArray<ScheduleRule>): number;
+/**
+ * The next `count` runs strictly after `from` (the minute `from` is in does
+ * not count, the very next one does), looking `horizonMs` ahead — by default
+ * as far as the rules need (`previewHorizonMs`).
+ */
+declare function nextScheduleRuns(spec: ScheduleSpec, from: Date, count: number, horizonMs?: number): Date[];
+
+declare const META_ADS_SCRAPE_NODE_TYPE: "meta-ads-scrape";
+/** The WIRE modes — what `POST /v1/meta-ads-scrape` accepts. */
+declare const META_ADS_SCRAPE_MODES: readonly ["search", "pages"];
+type MetaAdsScrapeMode = (typeof META_ADS_SCRAPE_MODES)[number];
+/** The NODE modes — the wire modes plus the editor-only advertiser picker (runs as pages). */
+declare const META_ADS_NODE_MODES: readonly ["search", "pages", "advertiser"];
+type MetaAdsNodeMode = (typeof META_ADS_NODE_MODES)[number];
+/** Coerce stored node data to a node mode; anything unknown is the default keyword search. */
+declare function metaAdsNodeMode(value: unknown): MetaAdsNodeMode;
+/** An advertiser the user picked by name — stored on the node, run as its Page url. */
+interface MetaAdsAdvertiser {
+    readonly pageId: string;
+    readonly name: string;
+    /** The Facebook Page url. The actor resolves it to the Ad Library advertiser itself — the Page id and the advertiser id are NOT the same number. */
+    readonly url: string;
+    readonly imageUrl?: string;
+    readonly verified?: boolean;
+}
+/** How many matches an advertiser lookup returns — more than the pick cap, so a same-name brand can be told apart by its badge / avatar. */
+declare const META_ADS_ADVERTISER_MAX_RESULTS = 8;
+/** http(s) url on facebook.com (any subdomain) — the ONE predicate for a Page address, on the route's Zod and on stored picks alike. */
+declare function isFacebookPageUrl(value: unknown): value is string;
+/** A Page avatar lives on Meta's CDN; anything else is not stored (it would be fetched by every viewer's browser and our image proxy). */
+declare function isMetaCdnImageUrl(value: unknown): value is string;
+/** Stored / relayed advertisers, sanitized: a page id, a name, a facebook.com url, a Meta-CDN avatar; deduped by page id; at most `limit` (the pick cap by default). */
+declare function metaAdsAdvertisersFrom(raw: unknown, limit?: number): MetaAdsAdvertiser[];
+declare const META_ADS_SCRAPE_PERIODS: readonly ["24h", "7d", "30d", "all"];
+type MetaAdsScrapePeriod = (typeof META_ADS_SCRAPE_PERIODS)[number];
+declare const META_ADS_SCRAPE_STATUSES: readonly ["active", "inactive", "all"];
+type MetaAdsScrapeStatus = (typeof META_ADS_SCRAPE_STATUSES)[number];
+/** Meta's `publisher_platform` vocabulary — the values an ad's `platforms` carries and the filter the node accepts. */
+declare const META_ADS_PLATFORMS: readonly ["FACEBOOK", "INSTAGRAM", "AUDIENCE_NETWORK", "MESSENGER", "WHATSAPP", "THREADS"];
+type MetaAdsPlatform = (typeof META_ADS_PLATFORMS)[number];
+declare function isMetaAdsPlatform(value: unknown): value is MetaAdsPlatform;
+/**
+ * Creative format, classified from the creative's measured pixels — the
+ * user's "phone vs web" question. `vertical` = Stories / Reels / mobile feed
+ * (9:16, 4:5), `square` = 1:1 (±5 %), `horizontal` = feed / web / banners
+ * (16:9, 1.91:1). One classifier for the route (node setting), the Results
+ * chips and the card, so they can never disagree.
+ */
+declare const META_ADS_FORMATS: readonly ["vertical", "square", "horizontal"];
+type MetaAdsFormat = (typeof META_ADS_FORMATS)[number];
+type MetaAdsCreativeFormat = MetaAdsFormat | "unknown";
+declare function isMetaAdsFormat(value: unknown): value is MetaAdsFormat;
+/** The featured ad index, clamped so a rerun that returned fewer ads never indexes past the end. */
+declare function clampMetaAdsFeaturedIndex(stored: unknown, count: number): number;
+interface FeaturedMetaAdOutputs {
+    readonly text?: string;
+    readonly imageUrl?: string;
+    readonly videoUrl?: string;
+}
+/**
+ * What the node's typed `text` / `image` / `video` handles carry: the
+ * FEATURED ad's copy (headline + body), first image (else the video poster)
+ * and first video. ONE derivation for the route's output_data, the backend
+ * saved-output hydration and the editor's extractNodeOutput, so a thumb pick
+ * re-hydrates the handles identically everywhere.
+ */
+declare function featuredMetaAdOutputs(json: unknown, featuredIndex: unknown): FeaturedMetaAdOutputs;
+declare function classifyCreativeFormat(width: unknown, height: unknown): MetaAdsCreativeFormat;
+/** Presets the config panel offers; the route accepts any integer 1..MAX_COUNT. */
+declare const META_ADS_SCRAPE_COUNT_OPTIONS: readonly [10, 20, 50, 100];
+declare const META_ADS_SCRAPE_DEFAULT_COUNT = 20;
+declare const META_ADS_SCRAPE_MAX_COUNT = 100;
+declare const META_ADS_SCRAPE_MAX_SOURCES = 5;
+/** Meta caps Ad Library search terms at 100 characters. */
+declare const META_ADS_SCRAPE_MAX_QUERY_LENGTH = 100;
+declare const META_ADS_SCRAPE_DEFAULT_COUNTRY = "ALL";
+/** Requested-total buckets. Sorted ascending; the last one is `MAX_COUNT × MAX_SOURCES`. */
+declare const META_ADS_SCRAPE_TIERS: readonly [10, 20, 50, 100, 200, 500];
+type MetaAdsScrapeTier = (typeof META_ADS_SCRAPE_TIERS)[number];
+/**
+ * Optional per-ad AI analysis — the "expert competitor ad analyst" pass.
+ * Priced per REQUESTED ad like the scrape, by the analysing model's tier,
+ * and folded into the SAME tiered identifier so every quote (guard,
+ * reservation, card badge, run total, backend estimator) stays one SKU:
+ *
+ *   meta-ads-scrape:<tier>                             tier
+ *   meta-ads-scrape:<tier>:analysis                    tier × (1 + 3)   standard models
+ *   meta-ads-scrape:<tier>:analysis:economy            tier × (1 + 1)
+ *   meta-ads-scrape:<tier>:analysis:premium            tier × (1 + 4)
+ *
+ * The per-ad SKUs (`meta-ads-analysis[:economy|:premium]`) price the
+ * SETTLEMENT: a run commits tier + per-ad × ads actually analysed and
+ * refunds the rest (an ad the model failed on, or one the deadline skipped).
+ */
+declare const META_ADS_ANALYSIS_TIERS: readonly ["economy", "standard", "premium"];
+type MetaAdsAnalysisTier = (typeof META_ADS_ANALYSIS_TIERS)[number];
+declare const META_ADS_ANALYSIS_CREDITS_PER_AD: Record<MetaAdsAnalysisTier, number>;
+declare const META_ADS_ANALYSIS_CREDIT_ID: "meta-ads-analysis";
+/** The user's optional analyst focus, appended to the fixed prompt. */
+declare const META_ADS_ANALYSIS_FOCUS_MAX = 500;
+/** The per-ad settlement SKU for a tier (the bare id is the standard tier). */
+declare function metaAdsAnalysisCreditId(tier: MetaAdsAnalysisTier): string;
+/** The analysing model's tier; an absent model is the feature default. */
+declare function metaAdsAnalysisTier(modelId?: unknown): MetaAdsAnalysisTier;
+/** What one analysed ad carries (`ad.analysis`); fixed fields + string lists only — never a map (Gemini via KIE drops map fields). */
+interface AdCreativeAnalysis {
+    readonly assetType: "static" | "motion" | "carousel" | "unknown";
+    readonly format: string;
+    readonly visualHooks: readonly string[];
+    readonly audiences: readonly string[];
+    readonly graphicIdentity: string;
+    readonly copywritingHooks: readonly string[];
+    readonly usps: readonly string[];
+    readonly cta: string;
+    readonly summary: string;
+}
+/** Read a stored analysis back defensively (a node's saved JSON is untrusted shape); null when there is none. */
+declare function adCreativeAnalysisFrom(raw: unknown): AdCreativeAnalysis | null;
+/**
+ * Credit cost per SKU — mirror of the backend `STATIC_CREDIT_COSTS` rows and
+ * migrations 428 / 429, for the frontend badge / estimator. 1 credit per
+ * requested ad at every tier, plus the analysis multiples above; the bare
+ * identifier is the pre-Zod fallback (mid tier, never the max).
+ */
+declare const META_ADS_SCRAPE_CREDIT_COSTS: Record<string, number>;
+declare const META_ADS_SCRAPE_FALLBACK_CREDIT_ID = "meta-ads-scrape:20";
+/**
+ * Page urls are typed one per line in the config panel (a FieldMapping
+ * injects the same text); the route wants an array. Tolerates commas and
+ * whitespace as separators (a url never contains either) and an array that
+ * already went through this once.
+ */
+declare function splitMetaAdsPageUrls(value: unknown): string[];
+declare function isMetaAdsScrapeMode(value: unknown): value is MetaAdsScrapeMode;
+/**
+ * Advertiser NAMES to resolve at run time (advertiser mode driven by the `in`
+ * input) — one per line or comma-separated. Unlike page urls, a name contains
+ * spaces, so this never splits on whitespace. Trimmed, de-duped, each 2..100
+ * chars, capped at `MAX_SOURCES`.
+ */
+declare function splitMetaAdsAdvertiserNames(value: unknown): string[];
+/** The node-data fields that decide what a run scrapes (and therefore what it costs). Index-signature so any node-data bag is accepted as-is. */
+interface MetaAdsNodeSourceFields {
+    readonly [key: string]: unknown;
+    readonly mode?: unknown;
+    readonly query?: unknown;
+    readonly pageUrls?: unknown;
+    readonly advertisers?: unknown;
+}
+/**
+ * How many sources a run bills — the number the card badge, the run total,
+ * the pre-run estimator and the backend quote must all read, so an advertiser
+ * pick can never be quoted as one source while the server reserves five. An
+ * empty page list / no picks counts as one (the run then fails validation
+ * before anything is reserved).
+ */
+declare function metaAdsScrapeSources(data: MetaAdsNodeSourceFields): number;
+type MetaAdsWireSources = {
+    readonly mode: "search";
+    readonly query: string | undefined;
+} | {
+    readonly mode: "pages";
+    readonly pageUrls: string[];
+    readonly advertiserNames?: string[];
+};
+/**
+ * The wire half of a request from node data — ONE mapping for the editor's
+ * executor and the orchestrator's payload builder. The keyword / page list
+ * falls back to the upstream text so a Prompt or List node can drive the
+ * scrape; advertiser picks are explicit (no upstream fallback) and run as
+ * their Page urls, which is why the route never sees "advertiser".
+ */
+declare function metaAdsScrapeWireSources(data: MetaAdsNodeSourceFields, upstream?: unknown): MetaAdsWireSources;
+declare function isMetaAdsScrapeCount(value: unknown): value is number;
+/** Smallest tier that fits the requested total; clamps to the top tier. */
+declare function metaAdsScrapeTier(requestedTotal: number): MetaAdsScrapeTier;
+interface MetaAdsScrapeCreditInput {
+    count: number;
+    /** Number of input URLs in pages mode; 1 for a keyword search. */
+    sources: number;
+    /** The analysing model's tier when per-ad analysis is on; absent / null = scrape only. */
+    analysis?: MetaAdsAnalysisTier | null;
+}
+declare function buildMetaAdsScrapeCreditId(input: MetaAdsScrapeCreditInput): string;
+/** The analysis tier a request / node asks for, or null when analysis is off. */
+declare function metaAdsAnalysisTierFrom(data: {
+    readonly analyze?: unknown;
+    readonly analysisModel?: unknown;
+}): MetaAdsAnalysisTier | null;
+/**
+ * Resolve the credit identifier from an UNVALIDATED request body (the
+ * creditGuard preHandler runs before Zod). It must land on the SAME tier the
+ * post-Zod reservation computes, so an OMITTED count is the route's default
+ * (Zod fills it in the same way); only a present-but-invalid body reserves
+ * the fixed mid tier, and the route then rejects it with a 400 and refunds.
+ */
+declare function resolveMetaAdsScrapeCreditId(body: unknown): string;
+/** The node-data fields a quote reads: what a run scrapes, how many, and whether it analyses. */
+interface MetaAdsNodeQuoteFields extends MetaAdsNodeSourceFields {
+    readonly count?: unknown;
+    readonly analyze?: unknown;
+    readonly analysisModel?: unknown;
+}
+/**
+ * The ONE credit identifier for a node's current settings — the card badge,
+ * the run total, the pre-run estimator and the backend quote all read this,
+ * and it is the same builder the route's guard + reservation use on the wire
+ * body, so no surface can quote a different SKU than the one reserved.
+ */
+declare function metaAdsScrapeCreditIdFromNode(data: MetaAdsNodeQuoteFields): string;
+
+/**
+ * Instagram scraper node — shared vocabulary + credit identifiers.
+ *
+ * Pulls PUBLIC Instagram posts (feed images, carousels, reels) by profile or
+ * by hashtag and emits a normalized JSON array. Same shape of contract as the
+ * Meta Ads node: everything the backend guard/reservation, the frontend credit
+ * badge and the docs formula must agree on lives here.
+ *
+ * Pricing: 1 credit per REQUESTED post, rounded UP to a fixed tier of
+ * `count × sources` (a profile / hashtag is one source, up to 5). Optional
+ * per-post AI analysis folds into the same identifier, priced by the model's
+ * tier — reusing the Meta analysis per-item values so the two nodes stay in
+ * lockstep.
+ */
+
+declare const INSTAGRAM_SCRAPE_NODE_TYPE: "instagram-scrape";
+declare const INSTAGRAM_SCRAPE_MODES: readonly ["profile", "hashtag"];
+type InstagramScrapeMode = (typeof INSTAGRAM_SCRAPE_MODES)[number];
+declare function isInstagramScrapeMode(value: unknown): value is InstagramScrapeMode;
+declare function instagramScrapeMode(value: unknown): InstagramScrapeMode;
+/** Same window vocabulary as Meta Ads; the Instagram actor honours it server-side (`onlyPostsNewerThan`). */
+declare const INSTAGRAM_SCRAPE_PERIODS: readonly ["24h", "7d", "30d", "all"];
+type InstagramScrapePeriod = (typeof INSTAGRAM_SCRAPE_PERIODS)[number];
+declare const INSTAGRAM_SCRAPE_DEFAULT_COUNT = 20;
+declare const INSTAGRAM_SCRAPE_MAX_COUNT = 100;
+declare const INSTAGRAM_SCRAPE_MAX_SOURCES = 5;
+/** Instagram usernames / hashtags are short; cap a single target well under a URL. */
+declare const INSTAGRAM_SCRAPE_MAX_TARGET_LENGTH = 200;
+/** Requested-total buckets — identical shape to Meta (the pricing model is the same). */
+declare const INSTAGRAM_SCRAPE_TIERS: readonly [10, 20, 50, 100, 200, 500];
+type InstagramScrapeTier = (typeof INSTAGRAM_SCRAPE_TIERS)[number];
+declare function instagramScrapeTier(requestedTotal: number): InstagramScrapeTier;
+/** The analysis tier a request / node asks for, or null when analysis is off. */
+declare function instagramAnalysisTierFrom(data: {
+    readonly analyze?: unknown;
+    readonly analysisModel?: unknown;
+}): MetaAdsAnalysisTier | null;
+/** Per-post settlement SKU for a tier (the bare id is the standard tier). */
+declare const INSTAGRAM_ANALYSIS_CREDIT_ID: "instagram-analysis";
+declare function instagramAnalysisCreditId(tier: MetaAdsAnalysisTier): string;
+interface InstagramScrapeCreditInput {
+    count: number;
+    sources: number;
+    analysis?: MetaAdsAnalysisTier | null;
+}
+declare function buildInstagramScrapeCreditId(input: InstagramScrapeCreditInput): string;
+/**
+ * Cost per SKU — mirror of the backend `STATIC_CREDIT_COSTS` rows / migration,
+ * for the frontend badge / estimator. 1 credit per requested post at every
+ * tier, plus the analysis multiples.
+ */
+declare const INSTAGRAM_SCRAPE_CREDIT_COSTS: Record<string, number>;
+declare const INSTAGRAM_SCRAPE_FALLBACK_CREDIT_ID = "instagram-scrape:20";
+declare function isInstagramScrapeCount(value: unknown): value is number;
+/**
+ * Targets (profile usernames/URLs or hashtags) are typed one per line; the
+ * route wants an array. Unlike page urls a target can be a bare username /
+ * `#tag`, so split on lines / commas only (never whitespace), strip a leading
+ * `@` or `#`, dedupe, cap at MAX_SOURCES.
+ */
+declare function splitInstagramTargets(value: unknown): string[];
+/** The featured post index, clamped. */
+declare function clampInstagramFeaturedIndex(stored: unknown, count: number): number;
+interface FeaturedInstagramOutputs {
+    readonly text?: string;
+    readonly imageUrl?: string;
+    readonly videoUrl?: string;
+}
+/** The featured post's caption (`text`), first image / cover (`image`), and first video (`video`). */
+declare function featuredInstagramOutputs(json: unknown, featuredIndex: unknown): FeaturedInstagramOutputs;
+/** The node-data fields a quote reads. */
+interface InstagramNodeQuoteFields {
+    readonly [key: string]: unknown;
+    readonly mode?: unknown;
+    readonly targets?: unknown;
+    readonly count?: unknown;
+    readonly analyze?: unknown;
+    readonly analysisModel?: unknown;
+}
+/** Billable source count: number of targets (min 1). */
+declare function instagramScrapeSources(data: InstagramNodeQuoteFields): number;
+/** The ONE credit identifier for a node's current settings. */
+declare function instagramScrapeCreditIdFromNode(data: InstagramNodeQuoteFields): string;
+/**
+ * Resolve the credit identifier from an UNVALIDATED request body (the guard
+ * runs before Zod). Lands on the SAME tier the reservation computes.
+ */
+declare function resolveInstagramScrapeCreditId(body: unknown): string;
+
+type InstagramFormat = MetaAdsFormat;
+
 /**
  * Build a label→output map for `{Node Label}` refs inside condition values
  * on filter-list and router nodes.
@@ -5485,6 +6264,21 @@ interface SafetyRetryPolicy {
  */
 declare function safetyRetryPolicy(modelId: string): SafetyRetryPolicy;
 
+/**
+ * Canonical list of font display names supported by the Remotion renderer.
+ *
+ * Single source of truth shared by:
+ *  - the backend Zod schemas (`z.enum(SUPPORTED_FONT_NAMES)`), which CANNOT
+ *    import `@nodaro/remotion` (its font-registry pulls the render runtime +
+ *    `@remotion/google-fonts` side-effects into a validation path), and
+ *  - `packages/remotion/src/lib/font-registry.ts`, which loads each face and
+ *    is kept in lock-step with this tuple by a compile-time `satisfies` guard.
+ *
+ * Order/spelling MUST match the keys of the `fonts` object in font-registry.ts.
+ */
+declare const SUPPORTED_FONT_NAMES: readonly ["Inter", "Roboto", "Open Sans", "Montserrat", "Poppins", "Raleway", "Nunito", "Lato", "Playfair Display", "Merriweather", "Lora", "EB Garamond", "Bebas Neue", "Oswald", "Anton", "Dancing Script", "Pacifico", "Caveat", "Roboto Mono", "Fira Code", "Rubik", "Heebo", "Cairo", "Tajawal"];
+type SupportedFontName = (typeof SUPPORTED_FONT_NAMES)[number];
+
 /**
  * Caption styles for the add-captions node. Static path uses FFmpeg drawtext;
  * kinetic styles render via Remotion (BurnCaptions composition).
@@ -5504,6 +6298,194 @@ type StaticCaptionStyle = (typeof STATIC_CAPTION_STYLES)[number];
 type KineticCaptionStyle = (typeof KINETIC_CAPTION_STYLES)[number];
 type CaptionStyle = (typeof ALL_CAPTION_STYLES)[number];
 declare function isKineticCaptionStyle(style: string | undefined | null): style is KineticCaptionStyle;
+declare const CAPTION_LOOK_IDS: readonly ["outline", "clean"];
+type CaptionLookId = (typeof CAPTION_LOOK_IDS)[number];
+/** What an unset `look` means on a KINETIC style. ONE-LINE FLIP: set to "clean"
+ *  to make an unset caption render as the pre-look-system lever set (face pinned)
+ *  instead. */
+declare const DEFAULT_CAPTION_LOOK: CaptionLookId;
+/** What an unset `look` means on the static `subtitle` style: the plain read —
+ *  a pinned neutral sans, no outline, no casing. A subtitle must never be left
+ *  with NO face: the Remotion render would fall back to headless Chrome's default
+ *  SERIF, so adding e.g. a stroke to a subtitle would silently flip its font away
+ *  from the sans the plain FFmpeg subtitle draws. */
+declare const DEFAULT_SUBTITLE_LOOK: CaptionLookId;
+/**
+ * The lever field names that are MEANINGLESS on a `subtitle` render and so are
+ * rejected on it: `highlightColor` (subtitle has no per-word spoken cursor to
+ * colour) and `animate` (subtitle has no motion to switch off). The STYLING
+ * levers (look/fontFamily/fontWeight/strokeColor/strokeWidth/uppercase/positionY)
+ * are NOT here any more — a `subtitle` carrying any of them now routes to the
+ * Remotion renderer (see `captionRoutesToRemotion`), which applies them exactly
+ * as it does for the kinetic styles. Single source of truth for the route's
+ * reject-on-subtitle guard and the frontend's "don't send a stale lever" strip.
+ * `color`/`backgroundColor` are deliberately absent — FFmpeg subtitle honours
+ * those too.
+ */
+declare const KINETIC_ONLY_CAPTION_LEVER_KEYS: readonly ["highlightColor", "animate"];
+type KineticOnlyCaptionLeverKey = (typeof KINETIC_ONLY_CAPTION_LEVER_KEYS)[number];
+/**
+ * Does an add-captions request need the Remotion renderer, vs the cheap static
+ * FFmpeg drawtext path? A caption routes to Remotion when it needs anything the
+ * one-fixed-string drawtext pass cannot do:
+ *   - per-segment treatments (`segments`),
+ *   - a kinetic style,
+ *   - any STYLING lever (look/font/weight/stroke/uppercase/position_y/
+ *     max_words_per_line) — FFmpeg drawtext can't apply a webfont face, weight,
+ *     outline, casing, a free vertical position, or line grouping,
+ *   - TIMED captions (a wired `transcript` or an explicit `captions[]` array),
+ *   - auto-transcription, i.e. no `text` to burn as one static block.
+ * Plain-`text` `subtitle` with no lever stays on FFmpeg (unchanged, cheap).
+ *
+ * SINGLE SOURCE for BOTH the worker dispatch (handleAddCaptions) AND the credit
+ * id (buildAddCaptionsCreditId) so the renderer and the price never drift: a
+ * Remotion render bills as `add-captions:kinetic`, a plain drawtext burn as
+ * `add-captions`.
+ */
+declare function captionRoutesToRemotion(input: {
+    style?: string | null;
+    text?: string | null;
+    segments?: readonly unknown[] | null;
+    transcript?: unknown;
+    captions?: readonly unknown[] | null;
+    look?: unknown;
+    fontFamily?: unknown;
+    fontWeight?: unknown;
+    strokeColor?: unknown;
+    strokeWidth?: unknown;
+    uppercase?: unknown;
+    positionY?: unknown;
+    maxWordsPerLine?: unknown;
+}): boolean;
+/**
+ * `maxWordsPerLine` — caps how many words a caption LINE (or tiktok-words page)
+ * may hold, on top of the frame-width budget, sentence ends and pauses that
+ * already close a line. 1–2 gives the punchy CapCut read; unset = fit the width.
+ * Applies to every line/page-grouped render (word-highlight, karaoke, bouncy,
+ * tiktok-words, and a Remotion-rendered subtitle); inert on word-pop (always one
+ * word). Bounds single-sourced here for the route Zod, the plan schema, the MCP
+ * schema, the CLI and the canvas panel.
+ */
+declare const CAPTION_MAX_WORDS_PER_LINE_MIN = 1;
+declare const CAPTION_MAX_WORDS_PER_LINE_MAX = 20;
+/**
+ * Numeric caption levers and their wire bounds — the SAME limits the route Zod
+ * and the render-plan schema enforce. Single-sourced so the coercion below and
+ * those schemas cannot disagree (a guard test pins the route to these).
+ */
+declare const CAPTION_LEVER_BOUNDS: {
+    readonly fontSize: {
+        readonly min: 12;
+        readonly max: 200;
+    };
+    readonly strokeWidth: {
+        readonly min: 0;
+        readonly max: 40;
+    };
+    readonly positionY: {
+        readonly min: 0;
+        readonly max: 100;
+    };
+    readonly fontWeight: {
+        readonly min: 100;
+        readonly max: 900;
+    };
+    readonly maxWordsPerLine: {
+        readonly min: 1;
+        readonly max: 20;
+    };
+};
+/**
+ * COERCE, never reject: bring the numeric caption levers of node data that
+ * never passed a Zod (a workflow written by an agent, an import, a template, a
+ * FieldMapping) into the range the render plan accepts. Without this an
+ * out-of-range value only surfaces when the plan schema throws — mid-run, after
+ * credits are reserved. A `null` / non-finite / non-numeric value is DROPPED (the
+ * render default applies); an out-of-range one is clamped; `fontWeight` snaps to the
+ * nearest 100 and `maxWordsPerLine` to a whole number. Pure; returns a copy and
+ * leaves every other field untouched. Applied by payload-builder to the node's
+ * top level and to each `segments[]` entry.
+ */
+declare function normalizeCaptionNumericLevers<T extends Record<string, unknown>>(input: T): T;
+/** The concrete levers a look (and any explicit override) resolves to. */
+interface CaptionLookLevers {
+    fontFamily?: SupportedFontName;
+    fontWeight?: number;
+    color?: string;
+    backgroundColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    highlightColor?: string;
+    uppercase?: boolean;
+}
+/** Outline width = 10% of font size (min 2px). `paint-order: stroke fill` puts
+ *  half the stroke OUTSIDE the glyph, so the visible rim is ~5% of font size. */
+declare function autoStrokeWidth(fontSize: number): number;
+/** Each look is a function of font size (so the outline tracks the text size). */
+declare const CAPTION_LOOKS: Record<CaptionLookId, (fontSize: number) => CaptionLookLevers>;
+/**
+ * Resolve a look + explicit overrides into concrete levers. An explicit lever
+ * always wins over the look; `strokeWidth: 0` explicitly means "no outline".
+ * The plan then carries concrete levers only — nothing to resolve at render.
+ */
+declare function resolveCaptionLook(look: CaptionLookId | undefined, explicit: CaptionLookLevers, fontSize: number): CaptionLookLevers;
+/**
+ * Resolve the concrete render levers for a caption, applying the DEFAULT look the
+ * way each STYLE expects: an unset `look` means `outline` on a kinetic style (the
+ * TikTok/CapCut read) and `clean` on the static `subtitle` (the plain read — a
+ * pinned neutral sans, no outline, no casing). So a subtitle that routes to
+ * Remotion never inherits the outline house-style unless asked, AND is never left
+ * with no face at all (which renders as headless Chrome's default serif). A named
+ * look always wins; explicit levers override either. SINGLE SOURCE for the worker
+ * top-level levers, the per-segment resolver, and the frontend config/preview
+ * mirror, so the per-style default can't drift between them.
+ */
+declare function resolveCaptionLevers(style: string | undefined | null, look: CaptionLookId | undefined, explicit: CaptionLookLevers, fontSize: number): CaptionLookLevers;
+
+/**
+ * Pre-run checks for the transcribe → captions chain.
+ *
+ * A transcription lane that cannot return per-word timings (`whisper`) still
+ * RUNS and BILLS — it just hands back phrase segments with `words: []`. Anything
+ * downstream that needs words then fails AFTER the transcription was paid for.
+ * These helpers let every run surface (the editor's DAG, the backend
+ * orchestrator, single-node Run) refuse BEFORE any spend, with one message.
+ * Pure: no I/O, no framework types — callers pass plain nodes/edges.
+ */
+/** The refusal for a lane that can't return word timings; `null` when it can.
+ *  An absent provider resolves to the transcribe NODE default. */
+declare function transcribeWordTimestampsRefusal(provider: string | null | undefined): string | null;
+interface PreflightGraphNode {
+    readonly id: string;
+    readonly type?: string | null;
+    readonly data?: Record<string, unknown> | null;
+}
+interface PreflightGraphEdge {
+    readonly source: string;
+    readonly target: string;
+    readonly sourceHandle?: string | null;
+    readonly targetHandle?: string | null;
+}
+interface WordlessTranscriptFeed {
+    readonly transcribeNodeId: string;
+    /** The add-captions node that would receive a transcript with no words. */
+    readonly consumerNodeId: string;
+    readonly provider: string;
+    readonly message: string;
+}
+/**
+ * Every transcribe node on a word-INCAPABLE lane whose `json` output reaches an
+ * add-captions `transcript` input — directly, or through apply-edl, which remaps
+ * the transcript and re-emits it on its own `json` handle. add-captions rejects a
+ * transcript with no words, so such a run can only fail, after paying for the
+ * transcription. Skipped nodes are ignored on both ends.
+ *
+ * The engine is read from node data and nothing else can change it: `provider`
+ * is not a mappable field on transcribe, so what this check sees IS what runs.
+ * add-captions' own "transcript has no words" guard stays as defence in depth
+ * for a transcript that arrives from anywhere other than a transcribe node.
+ */
+declare function findWordlessTranscriptFeeds(nodes: readonly PreflightGraphNode[], edges: readonly PreflightGraphEdge[]): WordlessTranscriptFeed[];
 
 /**
  * i18n resolver + lazy loader for parameter-node picker labels/descriptions.
@@ -5722,6 +6704,8 @@ interface WorkflowExport {
     /** Present only when the bundle references media another instance cannot fetch. */
     portability?: WorkflowPortability;
 }
+/** Clear owner-bound references (credential / connection ids). Returns new node objects; inputs are not mutated. */
+declare function stripUnownedRefs(nodes: GenericNode[]): GenericNode[];
 /** Strip generated/transient content from nodes for template export. Returns new node objects; inputs are not mutated. */
 declare function stripExportContent(nodes: GenericNode[]): GenericNode[];
 
@@ -9589,6 +10573,102 @@ declare const FAN_OUT_EACH_TYPES: ReadonlySet<string>;
  */
 declare const SUNO_TRACK_SOURCE_TYPES: ReadonlySet<string>;
 
+/**
+ * The Video URL node (`youtube-video`) and the social-video import path —
+ * structural vocabulary shared by the canvas, the orchestrator and the
+ * download routes. Host names and a node-output rule only; no prompt content.
+ *
+ * ONE list, three readers:
+ *   - the backend's yt-dlp routes (`lib/url-validator.ts` re-exports these),
+ *     where the list IS the SSRF gate — yt-dlp does its own DNS + HTTP, so
+ *     nothing but this exact-suffix match stands between a pasted link and an
+ *     internal address;
+ *   - the editor, which decides from the same list whether a pasted link is
+ *     one it should download (it must never offer a host the server refuses,
+ *     nor sit on one the server accepts);
+ *   - both workflow engines, which read a node's output through
+ *     `resolveVideoLinkOutput`.
+ *
+ * ⚠️ Adding a host here ADMITS it to a server-side fetch. It is a security
+ * decision, not a UI one — only fixed, reputable domains whose DNS an attacker
+ * cannot control.
+ */
+declare const SOCIAL_VIDEO_HOSTS: readonly ["youtube.com", "youtu.be", "tiktok.com", "instagram.com", "twitter.com", "x.com", "facebook.com", "fb.watch", "fb.com"];
+/** YouTube-only subset (the metadata probe and the client ladder are YouTube-only). */
+declare const YOUTUBE_HOSTS: readonly ["youtube.com", "youtu.be"];
+/** Instagram-only subset (the download path's proxy failover is Instagram-scoped). */
+declare const INSTAGRAM_HOSTS: readonly ["instagram.com"];
+/**
+ * Exact registrable-domain match against an allowlist: the domain itself or a
+ * true subdomain (`www.youtube.com`, `m.youtu.be`). A host that merely
+ * CONTAINS an allowlisted name (`evilyoutube.com`, `youtube.com.attacker.example`,
+ * or `netflix.com` for `x.com`) does not match.
+ */
+declare function hostnameMatchesAllowlist(hostname: string, domains: readonly string[]): boolean;
+/**
+ * True when the RAW link carries a character that URL parsers read differently:
+ * a backslash or an ASCII control character.
+ *
+ * Every check in this file parses the WHATWG way (Node, the browser), where a
+ * backslash in an http(s) URL is a slash — `https://tiktok.com\@10.0.0.1/x` has
+ * host `tiktok.com`. A parser that ends the authority at `/` alone reads the
+ * same string as a user name at host `10.0.0.1`. The download tools are handed
+ * the raw string and do their own parsing, DNS and HTTP, so a link the two
+ * readings can disagree on is refused outright rather than reasoned about. Tabs
+ * and newlines are dropped silently by one parser and kept by another — same
+ * answer. No real video link contains any of these.
+ */
+declare function hasUrlParserHazard(url: string): boolean;
+/** True for an http(s) URL whose host is on the allowlist. Never throws. */
+declare function isSocialVideoUrl(url: string, domains?: readonly string[]): boolean;
+type VideoLinkPlatform = "youtube" | "facebook" | "tiktok" | "instagram" | "twitter" | "unknown";
+/** Which supported platform a link belongs to — by exact host, never by substring. */
+declare function detectVideoLinkPlatform(url: string): VideoLinkPlatform;
+/**
+ * Node types that can use a Video URL node WITHOUT its downloaded file, because
+ * they never read the video: `suno-cover` and `transcribe` take the node's
+ * separately-fetched audio track (`downloadedAudioUrl`), and `dubbing` hands the
+ * page link to a provider that fetches it itself. A run whose only consumers of
+ * a link are these must not be made to download — or to choose a part of — a
+ * video nobody will look at. Structural vocabulary: it mirrors those three
+ * server-side readers; add a type here only together with its reader.
+ */
+declare const VIDEO_LINK_TOLERANT_CONSUMER_TYPES: ReadonlySet<string>;
+/**
+ * The fields of a Video URL node's data that decide what it emits. Open-ended
+ * on purpose: both engines hand over the node's whole `data` bag, and a closed
+ * shape with only optional members would refuse it as having nothing in common.
+ */
+interface VideoLinkNodeFields {
+    readonly youtubeUrl?: unknown;
+    readonly downloadedVideoUrl?: unknown;
+    readonly downloadedFromUrl?: unknown;
+    readonly [key: string]: unknown;
+}
+/**
+ * The stored file that belongs to the node's CURRENT link, or undefined.
+ *
+ * `downloadedFromUrl` binds a file to the link it came from. The editor clears
+ * the file whenever the link is edited, but a link can also change where no
+ * editor is looking — an agent or an import rewriting the workflow JSON — and
+ * without the binding the node would go on emitting the PREVIOUS video, which
+ * is worse than emitting none. A node saved before the field existed has no
+ * binding and is trusted as it always was.
+ */
+declare function videoLinkDownloadedFile(data: VideoLinkNodeFields): string | undefined;
+/**
+ * What a Video URL node emits on its `video` handle: the downloaded file when
+ * one matches the link, else the link itself. The fallback is load-bearing — a
+ * DIRECT file link (`https://cdn…/clip.mp4`) is a legitimate value of the URL
+ * field and is never downloaded, so it must pass through.
+ */
+declare function resolveVideoLinkOutput(data: VideoLinkNodeFields): string | undefined;
+/**
+ * True when the node holds a social link with no file for it yet — the state
+ * in which its output is a web PAGE, which no video consumer can read.
+ */
+declare function videoLinkNeedsDownload(data: VideoLinkNodeFields): boolean;
+
 /**
  * ElevenLabs speech-to-speech (voice changer) models — single source of truth
  * for the Voice Changer node's model picker (frontend config panel) AND the
@@ -10304,21 +11384,6 @@ declare const AUDIO_FX_PRESET_LABELS: Record<AudioFxPreset, string>;
 /** Presets that apply convolution reverb (afir + inline-synth IR). */
 declare const AUDIO_FX_REVERB_PRESETS: ReadonlySet<AudioFxPreset>;
 
-/**
- * Canonical list of font display names supported by the Remotion renderer.
- *
- * Single source of truth shared by:
- *  - the backend Zod schemas (`z.enum(SUPPORTED_FONT_NAMES)`), which CANNOT
- *    import `@nodaro/remotion` (its font-registry pulls the render runtime +
- *    `@remotion/google-fonts` side-effects into a validation path), and
- *  - `packages/remotion/src/lib/font-registry.ts`, which loads each face and
- *    is kept in lock-step with this tuple by a compile-time `satisfies` guard.
- *
- * Order/spelling MUST match the keys of the `fonts` object in font-registry.ts.
- */
-declare const SUPPORTED_FONT_NAMES: readonly ["Inter", "Roboto", "Open Sans", "Montserrat", "Poppins", "Raleway", "Nunito", "Lato", "Playfair Display", "Merriweather", "Lora", "EB Garamond", "Bebas Neue", "Oswald", "Anton", "Dancing Script", "Pacifico", "Caveat", "Roboto Mono", "Fira Code", "Rubik", "Heebo", "Cairo", "Tajawal"];
-type SupportedFontName = (typeof SUPPORTED_FONT_NAMES)[number];
-
 /**
  * Image Overlay — the layer KINDS a node can carry beyond a wired image, and
  * the wire contract for each. Shared by the route's Zod, the MCP tool, the
@@ -10671,7 +11736,10 @@ declare const AGGREGATE_LANE_SOURCE_TYPES: ReadonlySet<string>;
  * type for every `(type, handle)` pair EXCEPT:
  *   - an entity `image` handle → `"upload-image"` (a plain image producer);
  *   - an aggregate (group / collect) lane handle → the plain producer of that
- *     lane's media type (see AGGREGATE_LANE_EFFECTIVE_TYPE).
+ *     lane's media type (see AGGREGATE_LANE_EFFECTIVE_TYPE);
+ *   - a Meta Ads `text` / `image` / `video` handle → the plain producer of
+ *     that type (see META_ADS_HANDLE_EFFECTIVE_TYPE); its `json` handle keeps
+ *     the raw type.
  * Pure — safe for both frontend and backend.
  */
 declare function resolveEffectiveSourceType(rawSourceType: string | undefined | null, sourceHandleId: string | undefined | null): string;
@@ -10971,8 +12039,13 @@ declare const entitySlotSchema: z.ZodObject<{
         description: z.ZodString;
         refImageUrl: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    owner: z.ZodOptional<z.ZodObject<{
+        slotId: z.ZodString;
+        relation: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 type EntitySlot = z.infer<typeof entitySlotSchema>;
+type EntitySlotOwner = NonNullable<EntitySlot["owner"]>;
 /**
  * The sound LAYER vocabulary — what kind of thing this layer is.
  *
@@ -11019,12 +12092,12 @@ declare const windowSceneSchema: z.ZodObject<{
         "eye-level": "eye-level";
         high: "high";
         low: "low";
+        profile: "profile";
         pov: "pov";
         dutch: "dutch";
         overhead: "overhead";
         "worms-eye": "worms-eye";
         "over-the-shoulder": "over-the-shoulder";
-        profile: "profile";
         "from-behind": "from-behind";
     }>>;
     speed: z.ZodOptional<z.ZodEnum<{
@@ -11134,6 +12207,10 @@ declare const windowAnalysisSchema: z.ZodObject<{
             description: z.ZodString;
             refImageUrl: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        owner: z.ZodOptional<z.ZodObject<{
+            slotId: z.ZodString;
+            relation: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     scenes: z.ZodArray<z.ZodObject<{
         startSec: z.ZodNumber;
@@ -11145,12 +12222,12 @@ declare const windowAnalysisSchema: z.ZodObject<{
             "eye-level": "eye-level";
             high: "high";
             low: "low";
+            profile: "profile";
             pov: "pov";
             dutch: "dutch";
             overhead: "overhead";
             "worms-eye": "worms-eye";
             "over-the-shoulder": "over-the-shoulder";
-            profile: "profile";
             "from-behind": "from-behind";
         }>>;
         speed: z.ZodOptional<z.ZodEnum<{
@@ -11236,12 +12313,12 @@ declare const analyzedSceneSchema: z.ZodObject<{
         "eye-level": "eye-level";
         high: "high";
         low: "low";
+        profile: "profile";
         pov: "pov";
         dutch: "dutch";
         overhead: "overhead";
         "worms-eye": "worms-eye";
         "over-the-shoulder": "over-the-shoulder";
-        profile: "profile";
         "from-behind": "from-behind";
     }>>;
     speed: z.ZodOptional<z.ZodEnum<{
@@ -11361,6 +12438,10 @@ declare const videoAnalysisResultSchema: z.ZodObject<{
             description: z.ZodString;
             refImageUrl: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        owner: z.ZodOptional<z.ZodObject<{
+            slotId: z.ZodString;
+            relation: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     scenes: z.ZodArray<z.ZodObject<{
         startSec: z.ZodNumber;
@@ -11372,12 +12453,12 @@ declare const videoAnalysisResultSchema: z.ZodObject<{
             "eye-level": "eye-level";
             high: "high";
             low: "low";
+            profile: "profile";
             pov: "pov";
             dutch: "dutch";
             overhead: "overhead";
             "worms-eye": "worms-eye";
             "over-the-shoulder": "over-the-shoulder";
-            profile: "profile";
             "from-behind": "from-behind";
         }>>;
         speed: z.ZodOptional<z.ZodEnum<{
@@ -11810,6 +12891,26 @@ interface HintGraphContext {
     readonly edges: ReadonlyArray<HintEdgeLike>;
 }
 
+/** Structural public catalog API metadata. Authored values remain in @nodaro/prompts. */
+interface CharacterMotionMetadata {
+    /** Search terms, including previous display names. IDs remain stable. */
+    readonly aliases?: readonly string[];
+    /** Hidden from new choices; saved workflows still resolve this entry. */
+    readonly deprecated?: true;
+    readonly replacementId?: string;
+    /** Authored prerequisites; omission is unknown, never a compatibility claim. */
+    readonly requires?: readonly string[];
+    readonly startPose?: "standing" | "seated" | "floor" | "any";
+    readonly endPose?: "standing" | "seated" | "floor" | "any";
+    readonly endVisibility?: "in-frame" | "out-of-frame";
+    readonly handsAfter?: "free" | "occupied" | "holding-partner";
+    readonly needsFreeHands?: true;
+    readonly kind?: "single" | "compound";
+    readonly fixedPace?: true;
+    /** Non-human/dependent recipient substituted through the Partner handle. */
+    readonly counterpart?: string;
+}
+
 /**
  * Tag-free, policy-free wire shape for the `GET /v1/catalogs` projection — the
  * server-driven, pack-composed catalog view thin clients render their own
@@ -11833,6 +12934,8 @@ interface ProjectedCatalogOption {
      */
     term?: string;
     icon?: string;
+    /** Authored Character Motion prerequisites and sequence state. Missing means unknown. */
+    motion?: CharacterMotionMetadata;
 }
 interface ProjectedCatalogDimension {
     field: string;
@@ -16751,4 +17854,648 @@ declare function resolveScene3DAuthoringEngine(input: Scene3DEngineChoiceInput):
 /** v1's version constant, re-exported for callers narrowing a plan by hand. */
 declare const SCENE3D_BASIC_SCHEMA_VERSION = 1;
 
-export { ACCESS_LEVELS, ACTIVE_SCENE_HELPERS, ADVANCED_MODE_UNAVAILABLE_REASON, AGGREGATEABLE_TYPES, AGGREGATE_LANE_SOURCE_TYPES, AI_AVATAR_DURATION_BUCKETS, AI_AVATAR_MAX_AUDIO_SEC, AI_AVATAR_MAX_DURATION_SEC, AI_AVATAR_RESERVE_IDS, AI_WRITER_PROVIDERS, ALA_CARTE_BOARDS, ALL_CAPTION_STYLES, ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER, ASPECT_RATIO_DIMENSIONS, AUDIO_ADDON_PROVIDERS, AUDIO_CROSSFADE_CURVES, AUDIO_CROSSFADE_CURVE_IDS, AUDIO_FX_PRESETS, AUDIO_FX_PRESET_LABELS, AUDIO_FX_PRESET_SET, AUDIO_FX_REVERB_PRESETS, AUDIO_PRODUCER_TYPES, type AccessLevel, type AddBRollResult, AddBRollResultSchema, type AggregateableType, type AggregationBuckets, type AiAvatarDurationBucket, type AiAvatarEngine, type AiAvatarResolution, type AiWriterProvider, type AlaCarteBoard, type AnalyzedScene, type AnchorSceneStyleResult, AnchorSceneStyleResultSchema, type Animal, type AnimalSubcategory, type AssetRef, AssetRefSchema, type AudioCrossfadeCurve, type AudioFxPreset, type AudioLayer, type AuditImagesResult, AuditImagesResultSchema, type AuditImagesShotEntry, AuditImagesShotEntrySchema, AuditPromptIssueSchema, type AuditPromptResult, AuditPromptResultSchema, AvatarPayloadError, BOARD_TO_ASSET_TYPE, BOARD_TO_COLUMN, BOARD_VARIANTS, type BoardEntityKind, type BoardPromptContext, type BoardTemplate, BridgeToNextSceneInputSchema, type BridgeToNextSceneResult, BridgeToNextSceneResultSchema, type BrowseCommunityParams, type BrowseCommunityResult, CATEGORY_DURATION_DEFAULTS, CHARACTER_ASPECT_DEFAULTS, CHARACTER_ASPECT_OPTIONS, CHARACTER_ASSET_TYPES, CHARACTER_ASSET_VARIANTS, CHARACTER_ATTACH_COLUMNS, CHARACTER_FACETS, CHARACTER_FACET_IDS, CHARACTER_LORA_TRAINING_JOB_TYPE, CHARACTER_MOTION_PROVIDERS, CHARACTER_PICKER_DISPLAY_ORDER, CHARACTER_REFERENCE_PHOTO_KINDS, CHARACTER_STYLES, CHARACTER_VARIANT_ASSET_BUCKETS, CHAT_ENABLED_STAGES, CHAT_STAGES, CHAT_TURN_CAPS, CHAT_WIRED_STAGES, CINEMATIC_DEFAULT_DURATION_SEC, CINEMATIC_DEFAULT_RESOLUTION, CINEMATIC_MAX_DURATION_SEC, CINEMATIC_MAX_LOOKS, CINEMATIC_MAX_REFERENCE_IMAGES, CINEMATIC_MAX_REFERENCE_VIDEOS, CINEMATIC_MIN_DURATION_SEC, CINEMATIC_MIN_LOOKS, CINEMATIC_PROMPT_MAX, CINEMATIC_RESERVE_IDS, COLLABORATOR_ROLES, COLLECT_IN_HANDLE, COMBINE_TRANSITIONS, COMBINE_TRANSITION_GROUP_LABELS, COMBINE_TRANSITION_GROUP_ORDER, COMBINE_TRANSITION_IDS, COMPOSER_PLAN_FIELDS, COMPOSER_PLAN_MAP, CONTENT_TYPES_BY_PLATFORM, CREATURE_ATTACH_COLUMNS, CREDIT_BASE_USD, CREDIT_ROUNDING_RESOLUTION, type CaptionStyle, type CastCoverageCriticVerdict, CastCoverageCriticVerdictSchema, type CharacterAspectRatio, type CharacterAssetType, type CharacterAssetTypeForAspect, type CharacterAttachColumn, type CharacterDef, type CharacterFacet, type CharacterImageCriticVerdict, CharacterImageCriticVerdictSchema, type CharacterLoraFields, type CharacterMentionTokenInfo, CharacterMetadataSchema, type CharacterMotionProvider, type CharacterReferencePhoto, type CharacterReferencePhotoKind, type CharacterVariantAssetBucket, type CharacterVariantAssetItem, type CharacterVoiceSpec, type ChatEnabledStage, type ChatTurnResponse, ChatTurnResponseSchema, type CinematicResolution, type ClipLook, type CloneListingResult, type CollaboratorRole, type CombineTransition, type CombineTransitionGroup, type CombineVideosEstimatorInput, type CommunityCard, type CommunityEntityType, type CommunityFullDetail, type CommunityReportReason, type CommunitySort, type ComponentHandle, type ComponentMetadata, type ConnectedReference, type CreatureAttachColumn, CriticIssueSchema, type CustomEntry, DEFAULT_AUDIO_CROSSFADE_CURVE_ID, DEFAULT_CARRIED_FRACTION, DEFAULT_CHARACTER_ANGLE_COUNT, DEFAULT_CHARACTER_EXPRESSION_COUNT, DEFAULT_CHARACTER_FACET, DEFAULT_LABEL_BY_SOURCE, DEFAULT_LOCATION_USAGE_MODE, DEFAULT_OVERLAY_QR, DEFAULT_OVERLAY_SHAPE, DEFAULT_OVERLAY_TEXT, DEFAULT_PANEL_COUNT, DEFAULT_REF_IMAGE_MAX, DEFAULT_SECTIONS, DEFAULT_SUNO_MODEL, DEFAULT_TEMPLATE_CATEGORY, DEFAULT_USAGE_MODE, DEFAULT_VIDEO_ANALYSIS_MODEL, DEFAULT_VIDEO_ANALYSIS_TIER, DEFAULT_VIDEO_CLIP_COST, DEFAULT_VIDEO_DURATION_SEC, DEFAULT_VIDEO_PROVIDER, DEFAULT_VOICE_CHANGER_MODEL, DEFAULT_VOICE_DESIGN_MODEL, DETAIL_VARIANTS, DURATION_PRICED_PROVIDERS, DYNAMIC_PRODUCER_TYPES, type DescribedReference, type DetectionResult, DetectionResultSchema, type DialogueLine, EFFORT_TIER_BUMP, EMOTIONAL_BEAT, ENTITY_ASPECT_DEFAULTS, ENTITY_BUCKET_FIELDS, ENTITY_DB_ID_FIELD, ENTITY_IMAGE_HANDLE_TYPES, ENTITY_KIND_SCALAR_FIELDS, ENTITY_NAME_FIELD, ENTITY_NODE_KINDS, ENTITY_SCALAR_FIELDS, ENTITY_SECTIONS, ENTITY_STATUSES, ENTITY_TABLE, ENTITY_TOOL_RETRY_CAP, ENTITY_TYPES, EXECUTION_DATA_KEYS, EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES, EXTEND_VIDEO_PROVIDERS, type EntityKind, type EntityMentionTokenInfo, type EntityMetadata, EntityMetadataSchema, type EntityNodeKind, type EntityReferenceInput, type EntityRejectInput, EntityRejectInputSchema, type EntitySlot, type EntityStaleEvent, EntityStaleEventSchema, type EntityStateChangeEvent, EntityStateChangeEventSchema, type EntityStatus, type EntityStudioKind, type EntityStyle, type EntityType, type EvaluateConditionOptions, type ExportedPreset, type ExposableField, type ExposableOutput, type ExposedSetting, type ExtendVideoProvider, type ExtraRefCharacterContext, type ExtraRefInput, FACE_SWAP_PROVIDERS, FAL_LIP_SYNC_PROVIDERS, FAN_OUT_EACH_TYPES, FEATURED_ENTITIES, FILM_BASE_CREDITS, FLEXIBLE_INPUT_LIP_SYNC_PROVIDERS, FLUX2_RES_MP, FLUX_LORA_CHARACTER_MODEL_ID, FRAME_MODE_ADAPTIVE_ONLY_ASPECT, FRAME_TARGET_HANDLES, FREECUT_EXPORT_COMPLETE, FREECUT_EXPORT_PROGRESS, FREECUT_READY, FREECUT_REQUEST_IMPORT, FURNITURE, FURNITURE_SUBCATEGORY_LABELS, FURNITURE_SUBCATEGORY_ORDER, type FaceSwapProvider, type FavoriteListingResult, type FeaturedEntity, type FilmCreditEstimate, type FilterListCondition, type FilterListOperator, type FilterOperator, type FixContinuityInput, FixContinuityInputSchema, type FixContinuityResult, FixContinuityResultSchema, type Flux2Model, type FreecutExportCompletePayload, type FreecutExportProgressPayload, type FreecutImportFile, type FreecutRequestImportPayload, type FullSelectorMode, type Furniture, type FurnitureSubcategory, GEMINI_OMNI_PROVIDERS, GENERATE_TEXT_DELIMITER, GLOBAL_MAX_DURATION_SECONDS, GRANTED_ACCESS, GROUP_HANDLE_PREFIX, GUIDANCE_SCALE_SUPPORT, GVP_ANCHOR_CHOICES, GVP_DEFAULT_PROVIDER, GVP_END_FRAME_PROVIDERS, GVP_EXTEND_PROVIDERS, GVP_SUPPORTED_PROVIDERS, GenerateMotionInputSchema, type GenerateMotionResult, GenerateMotionResultSchema, type GenericEdge, type GenericNode, type GrantedAccess, type GvpAnchorChoice, type GvpAnchorWireMode, HANDLE_PORT_SEPARATOR, HELPERS_SHIPPED_IN_1B3, HIGH_QUALITY_PROVIDERS, HINT_EXEMPT_PARAMETER_TYPES, type HintEdgeLike, type HintGraphContext, type HintNodeLike, type I18nCatalogId, I2I_MASK_SUPPORT, I2I_STRENGTH_SUPPORT, IDEOGRAM_PROVIDERS, IMAGE_ASPECT_RATIO_VALUES, IMAGE_CRITIC_LEAF_MODES, IMAGE_CRITIC_MAX_RETRIES, IMAGE_CRITIC_METADATA_KEYS, IMAGE_CRITIC_MIN_ADHERENCE_SCORE, IMAGE_CRITIC_MODES, IMAGE_CRITIC_UNRESOLVABLE, IMAGE_EDIT_PROVIDERS, IMAGE_GEN_PROVIDERS, IMAGE_I2I_PROVIDERS, IMAGE_MASK_MODE, IMAGE_OVERLAY_BASE_CREDITS, IMAGE_OVERLAY_VARIANT_CREDITS, IMAGE_PROMPT_MAX, IMAGE_REF_TYPES, IMAGE_TO_VIDEO_PROVIDERS, INPUT_FIELD_MAP, INPUT_NODE_TYPES, INSTAGRAM_CAROUSEL_MAX_ITEMS, INSTAGRAM_CAROUSEL_MIN_ITEMS, ITER_CLONE_PATTERN, type IdentityFidelity, type IdentityMeta, type ImageAspectRatio, type ImageCriticIssue, ImageCriticIssueSchema, type ImageCriticLeafMode, type ImageCriticMetadataKey, type ImageCriticMode, type ImageCriticNodeIssue, type ImageCriticResult, ImageCriticResultSchema, type ImageCriticVerdict, ImageCriticVerdictSchema, type ImageEditProvider, type ImageGenProvider, type ImageI2IProvider, type ImageMaskMode, type ImageMentionTokenInfo, type ImageToVideoProvider, type ImprovePromptInput, ImprovePromptInputSchema, type ImprovePromptResult, ImprovePromptResultSchema, type InputFieldSchema, type InvitationDelivery, type InvitationPreview, type InvitationState, type InvitationView, type JoinCodeView, type JsonEvalResult, type JsonFilter, type JsonPatch, KEYFRAME_CREDITS_PER_SHOT, KINETIC_CAPTION_STYLES, type KieApiFormat, type KineticCaptionStyle, LANGUAGES, LEGACY_LOTTIE_HOST_REMAP, LEGACY_TEMPLATE_CATEGORIES, LIP_SYNC_DURATION_BUCKETS, LIP_SYNC_MAX_AUDIO_SECONDS, LIP_SYNC_PROVIDERS, LLM_FEATURE_DEFAULTS, LLM_MODALITY_CAPS, LLM_MODELS, LLM_MODEL_IDS, LLM_REASONING_EFFORTS, LLM_ROUTE_DEFAULTS, LLM_TEXT_INPUT_MAX, LLM_VENDOR_LABELS, LLM_VENDOR_ORDER, LOCATION_ASSET_TYPES, LOCATION_ASSET_VARIANTS, LOCATION_ATMOSPHERE_PROVIDERS, LOCATION_ATTACH_COLUMNS, LOCATION_BUCKET_TO_CATALOG_ID, LOCATION_PRESET_TO_CATALOG, LOCATION_REFERENCE_PHOTO_KINDS, LOCATION_REFERENCE_PHOTO_KIND_LABELS, LOCATION_USAGE_MODES, LOTTIE_OVERLAY_CATALOG, LOTTIE_SLOT_FIELD_PREFIX, type LabeledOption, type LipSyncDurationBucket, type LipSyncProvider, type LlmFeature, type LlmModelDef, type LlmModelGroup, type LlmReasoningEffort, type LlmRouteDefaults, type LlmTier, type LlmVendor, type LocaleCatalogMap, type LocaleDirection, type LocaleId, type LocationAssetType, type LocationAtmosphereProvider, type LocationAttachColumn, type LocationCatalogRef, type LocationImageCriticVerdict, LocationImageCriticVerdictSchema, type LocationMentionTokenInfo, LocationMetadataSchema, type LocationReferencePhotoKind, type LocationUsageMode, LocationsCoverageCriticIssueSchema, type LocationsCoverageCriticVerdict, LocationsCoverageCriticVerdictSchema, type LoopTrimEstimatorInput, type LoopVideoEstimatorInput, type LoraEligibleRef, type LoraRouting, type LottieOverlayCatalogEntry, type LottieSlotField, MAX_CUSTOM_ENTRIES_PER_BOARD, MAX_IMAGE_PROMPT_CHARS_BY_PROVIDER, MAX_LOCATION_VARIANTS, MAX_NEGATIVE_PROMPT_CHARS_BY_PROVIDER, MAX_PANELS_PER_SHEET, MAX_TTS_CHARS_BY_PROVIDER, MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER, MEMBER_STATUSES, MINIMAX_H3_DEFAULT_RESOLUTION, MINIMAX_H3_PROVIDERS, MODELS_WITH_REFERENCE_IMAGE_SUPPORT, MODEL_CATALOG, MODEL_KINDS, MODEL_PARAM_NODE_TYPES, MODEL_RECOMMENDATIONS, MODIFY_IMAGE_PROVIDERS, MOTION_COLUMN, MOTION_TRANSFER_PROVIDERS, MUSIC_PROVIDERS, type MaskRegionDescriptor, type MatchCutVerdict, MatchCutVerdictSchema, type MeOrganizations, type Member, type MemberStatus, type MinimalEdge, type MinimalNode, type ModelCatalogEntry, type ModelInputAdjustment, type ModelKind, type ModelMenuOption, type ModelMode, type ModelNodeTarget, type ModelPromptingStyle, type ModelRecommendation, type ModelTreeLine, type ModelTreeVariant, type ModelValidationIssue, type ModifyImageProvider, type MotionTransferProviderType, type MusicProvider, NATIVE_ADAPTIVE_ASPECT, NATIVE_NEGATIVE_PROMPT_MODELS, NATIVE_NEGATIVE_VIDEO_PROVIDERS, NEGATIVE_PROMPT_MAX, NODARO_IMPORT_FILES, NODARO_LOAD_TIMELINE, NODARO_LOAD_VIDEO, NODARO_RESET_PROJECT, NODE_DEFAULT_TYPES, NODE_MAPPABLE_FIELDS, NODE_PRESET_EXPORT_KIND, NODE_REF_PATTERN, NON_EN_LOCALE_IDS, NO_SPLIT_DELIMITER, type NodaroLoadTimelinePayload, type NodaroLoadVideoPayload, type NodeDefaultType, type NodeExecutionStateWire, type NodeExecutionStatus, type NodeParamAdjustment, type NodePresetExport, type NormalizedImageGen, type NormalizedModelInput, type NormalizedNodes, type NormalizedVideoRequest, OBJECT_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS, OBJECT_ASSET_TYPES, OBJECT_ASSET_VARIANTS, OBJECT_ATTACH_COLUMNS, OBJECT_MOTION_PROVIDERS, OBJECT_PICKER_NODE_TYPES, ORG_ERROR_CODES, ORG_KINDS, ORG_ROLES, ORG_STATUSES, OUTPUT_BEARING_NODE_STATUSES, OUTPUT_FIELD_MAP, OUTPUT_FORMATS, OVERLAY_ANCHORS, OVERLAY_FONTS, OVERLAY_FONT_IDS, OVERLAY_IMAGE_MASKS, OVERLAY_LAYER_KINDS, OVERLAY_MAX_VARIANTS, OVERLAY_PLATFORMS, OVERLAY_PLATFORM_IDS, OVERLAY_SHAPES, OVERLAY_TEXT_ALIGNS, OVERLAY_VARIANT_HANDLE_PREFIX, type ObjectAspectRatio, type ObjectAssetType, type ObjectAssetTypeForAspect, type ObjectAttachColumn, ObjectMetadataSchema, type ObjectMotionProvider, type ObjectsValidationIssue, type ObjectsValidationResult, OptimizeForModelInputSchema, type OptimizeForModelResult, OptimizeForModelResultSchema, type OrgAuditEntry, type OrgErrorCode, type OrgKind, type OrgMemberView, type OrgPage, type OrgRole, type OrgSettings, OrgSettingsSchema, type OrgStatus, type OrganizationSummary, type OrganizationView, type OutputFormat, type OutputMode, type OutputType, type OverlayAnchor, type OverlayFontId, type OverlayImageEffects, type OverlayImageMask, type OverlayLayerKind, type OverlayPlatformId, type OverlayPlatformPreset, type OverlayPlatformZone, type OverlayQrStyle, type OverlayShape, type OverlayShapeElement, type OverlayShapeStyle, type OverlayTextAlign, type OverlayTextStyle, PARAMETER_NODE_TYPES, PASSTHROUGH_TYPES, PAYG_RETENTION_DAYS, PER_FORMAT_DURATION_BOUNDS, PICKER_TO_COMBINE_TRANSITION, PIPELINE_ACTIVATION_MODES, PIPELINE_FORMATS, PIPELINE_HARD_TIMEOUT_MS, PIPELINE_MODEL_STAGES, PIPELINE_MODES, PIPELINE_OUTPUT_RESOLUTIONS, PIPELINE_PINNABLE_IMAGE_MODELS, PIPELINE_PINNABLE_SCRIPT_LLMS, PIPELINE_PINNABLE_VIDEO_MODELS, PIPELINE_STAGE_NAMES, PIPELINE_STAGE_TIMEOUT_MS, PIPELINE_TYPES, PLACEHOLDER_CHARACTER_NAME, PLATFORM_LABELS, PLATFORM_SPECS, PRESET_APPLY_CLEAR_KEYS, PRESET_EXCLUDED_KEYS, PRESET_LABELS, PRESET_SETTING_KEYS, PRICING_DEFAULT_DURATION_SEC, PRICING_DEFAULT_RESOLUTION, PRO3D_RENDER_ASPECT_RATIOS, PRO3D_RENDER_CREDIT_ID, PRO3D_RENDER_DEFAULT_ENGINE, PRO3D_RENDER_DEFAULT_QUALITY, PRO3D_RENDER_DEFAULT_REPAIR_PASSES, PRO3D_RENDER_DEFAULT_STYLE, PRO3D_RENDER_ENGINES, PRO3D_RENDER_LABEL, PRO3D_RENDER_LIMITS, PRO3D_RENDER_MAX_REPAIR_PASSES, PRO3D_RENDER_MIN_REPAIR_PASSES, PRO3D_RENDER_NODE_TYPE, PRO3D_RENDER_PROMPT_MAX, PRO3D_RENDER_QUALITY_PROFILES, PRO3D_RENDER_SOURCE_KINDS, PRO3D_RENDER_STYLES, PROMPT_HARD_CEILING, PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY, PROVIDER_DIRECTIVE_DEFAULTS, PROVIDER_PLACEHOLDER_PREFIX, type PanelGenRequest, type PanelRequest, type PanelSource, type PipelineActivationMode, type PipelineCompletedEvent, PipelineCompletedEventSchema, type PipelineConfig, PipelineConfigSchema, type PipelineDriftSummary, PipelineDriftSummarySchema, type PipelineEditorDecisionsReadyEvent, PipelineEditorDecisionsReadyEventSchema, type PipelineEvent, type PipelineForkedEvent, PipelineForkedEventSchema, type PipelineFormat, type PipelineInput, PipelineInputSchema, type PipelineLifecycleEvent, type PipelineMode, type PipelineModelStage, type PipelineMusicReadyEvent, PipelineMusicReadyEventSchema, type PipelineOutputResolution, type PipelinePinnableImageModel, type PipelinePinnableScriptLlm, type PipelinePinnableVideoModel, type PipelineStageName, PipelineStageNameSchema, type PipelineStageStatus, PipelineStageStatusSchema, type PipelineState, PipelineStateSchema, type PipelineStatus, PipelineStatusSchema, type PipelineType, type PixelBox, type PresentationItem, type PresetEntry, type PresetSettingKey, type PresetSettings, PresetSettingsSchema, type PriceVariant, type PricedVideoSelection, type Pro3DRenderAspectRatio, type Pro3DRenderCapabilities, type Pro3DRenderEngine, type Pro3DRenderJobOutput, type Pro3DRenderLocalExportSource, type Pro3DRenderPromptSource, type Pro3DRenderQuality, type Pro3DRenderQuote, type Pro3DRenderQuoteLine, type Pro3DRenderResultMetadata, type Pro3DRenderSceneSource, type Pro3DRenderShotStill, type Pro3DRenderSource, type Pro3DRenderSourceInput, type Pro3DRenderSourceKind, type Pro3DRenderSourceResult, type Pro3DRenderStyle, type Pro3DRenderValidationWarning, type ProgressSegment, type ProjectedCatalog, type ProjectedCatalogDimension, type ProjectedCatalogOption, type PromptAffixFields, type PromptAffixes, type ProposedChange, type PublishListingParams, type PublishListingResult, QA_CHECK_PROVIDERS, type QaCheckProvider, type QualityLevel, REDUCE_STRATEGIES, REDUCE_STRATEGY_IDS, REFERENCE_BOARD_PROVIDERS, REFERENCE_BOARD_TEMPLATES, REFERENCE_HANDLE_MAP, REFERENCE_ROLE_PRESETS, REF_HANDLE_CATEGORY, REF_IMAGE_MAX_LIMITS, REF_TOKEN_NAMESPACE_PREFIXES, RENDERING_SPEED_SUPPORT, RENDER_VIDEO_CREDIT_ID, REPEATABLE_NODE_TYPES, REPEAT_PLACEHOLDER, REPLICATE_LIP_SYNC_PROVIDERS, RESERVED_TEMPLATE_VARS, type ReduceMeta, type ReduceStrategy, type ReduceStrategyId, type RefCandidate, type RefModalityEdge, type RefTokenKind, type RefVideoDurationLimit, type ReferenceBoardProvider, type ReferenceModality, type ReferenceSheet, type ReferenceSource, type ReportListingResult, type ResolveCharacterAspectOptions, type ResolveObjectAspectOptions, type ResolveSeparatorOptions, type ResolvedDialogueVoiceLine, type RouterConditionGroup, SCENE3D_ASSERTION_RESTORED_CODE, SCENE3D_ASSET_KINDS, SCENE3D_ASSET_ROLES, SCENE3D_ASSET_ROLE_KINDS, SCENE3D_AUTHORING_ASSUMPTION_CODE, SCENE3D_AUTHORING_ENGINES, SCENE3D_BASIC_ENGINE, SCENE3D_BASIC_SCHEMA_VERSION, SCENE3D_CAMERA_TRACK_FORMAT, SCENE3D_CAMERA_TRACK_LIMITS, SCENE3D_CAMERA_TRACK_VERSION, SCENE3D_CLAY_LIGHTING_PRESETS, SCENE3D_DEFAULT_ADVANCED_ENGINE, SCENE3D_DEFAULT_DURATION_SECONDS, SCENE3D_DEFAULT_ENTITY_CAPABILITIES, SCENE3D_DEFAULT_FPS, SCENE3D_EDIT_NODE_TYPE, SCENE3D_ENTITY_CAPABILITIES, SCENE3D_ENTITY_ROLES, SCENE3D_GENERATE_NODE_TYPE, SCENE3D_GLB_EXTRAS_ALLOWLIST, SCENE3D_GLB_EXTRAS_ENTITY_ID, SCENE3D_GLB_EXTRAS_MATERIAL_ROLE, SCENE3D_GLB_EXTRAS_SUBPART_ID, SCENE3D_LIMITS, SCENE3D_PLAN_FIELD, SCENE3D_PLAN_TYPE, SCENE3D_PRIMITIVES, SCENE3D_PRIMITIVE_MATERIAL_ROLE, SCENE3D_REMEDY_AUTO_APPLIED_CODE, SCENE3D_RENDERER_ASSET_KINDS, SCENE3D_RENDER_BASE_MAX_PX, SCENE3D_RENDER_TIERS, SCENE3D_RENDER_TIER_MULTIPLIERS, SCENE3D_RENDER_XLARGE_MIN_AREA_PX, SCENE3D_REVIEW_REFUSED_CODE, SCENE3D_REVIEW_UNAVAILABLE_CODE, SCENE3D_REVIEW_UNAVAILABLE_REASONS, SCENE3D_SCHEMA_VERSION, SCENE3D_SCHEMA_VERSION_V2, SCENE3D_SUPPORTED_SCHEMA_VERSIONS, SCENE3D_V2_CONTENT_HASH_EXCLUDED, SCENE3D_V2_ENGINES, SCENE3D_V2_LIMITS, SCENE3D_V2_OVERRIDE_OPERATION_VERSION, SCENE3D_V2_PRIMITIVES, SCENE_HELPER_NAMES, SCRAPER_ACTOR_LABELS, SCRAPER_CREDIT_COSTS, SCRAPER_OUTPUT_FIELDS, SCRIPT_PROVIDERS, SEASONS, SECTION_BOARD, SECTION_KINDS, SEEDANCE_2_5_REF_LIMITS, SEEDANCE_2_CONTINUATION_REF_SEC, SEEDANCE_2_EXTEND_STITCH, SEEDANCE_2_PROVIDERS, SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER, SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC, SEEDANCE_2_REF_LIMITS, SEEDANCE_LIP_SYNC_PROVIDERS, SEED_SUPPORT, SEPARATOR_DISPLAY, SEPARATOR_PRESETS, SHEET_ASPECTS, SHEET_BACKGROUNDS, SHEET_PRESETS, SHEET_SKINS, SHEET_TYPES, SHORT_FILM_ANGLE_COUNT, SHORT_FILM_EXPRESSION_COUNT, SHORT_FILM_VARIANT_THRESHOLD_SEC, SLOT_TOKEN_RE, SMART_CUT_WINDOW_DEFAULT, SMART_CUT_WINDOW_MAX, SMART_CUT_WINDOW_MIN, SOCIAL_POST_NODE_TYPES, STAGE_PATCH_SCHEMA, STATIC_CAPTION_STYLES, STRUCTURAL_SECTIONS, STRUCTURED_VISION_MODELS, STUDIO_DEPENDENT_FRAMES_CAPABILITY, STUDIO_SHOT_TRANSIENT_KEYS, STUDIO_TRANSIENT_KEYS, SUBMISSION_STATUSES, SUNO_ACTIVE_MODELS, SUNO_ADD_TRACK_MODELS, SUNO_DURATION_MODELS, SUNO_FIELD_HANDLE_FIELDS, SUNO_HARD_CEILING, SUNO_LEGACY_MODELS, SUNO_MODELS, SUNO_SELECT_OPERATIONS, SUNO_TEXT_MAX, SUNO_TITLE_MAX, SUNO_TRACK_SOURCE_TYPES, SUNO_VERSION_CREDIT_KEYS, SUNO_VERSION_PRICED_OPERATIONS, SUPPORTED_FONT_NAMES, SURROUND_DIRECTIONS, SWITCHX_BLOCK_FRAMES, SWITCHX_FRAME_TIERS, type SafetyRetryPolicy, type Scene3DAnchor, type Scene3DAssetAnimation, type Scene3DAssetKind, type Scene3DAssetRef, type Scene3DAssetRole, type Scene3DAuthoringDelivery, type Scene3DAuthoringDeliveryMetadata, type Scene3DAuthoringEngine, type Scene3DAuthoringValidation, type Scene3DCamera, type Scene3DCameraChanges, type Scene3DCameraKeyframe, type Scene3DCameraSample, type Scene3DCameraTrackV1, type Scene3DClayLighting, type Scene3DClayLightingPreset, type Scene3DDeliveryWarning, type Scene3DEasing, type Scene3DEditErrorCode, type Scene3DEditOperation, type Scene3DEditOptions, type Scene3DEditResult, type Scene3DEngineChoice, type Scene3DEngineChoiceInput, type Scene3DEngineChoiceRefusalCode, type Scene3DEngineRequestFields, type Scene3DEntityCapability, type Scene3DEntityRole, type Scene3DEntityV2, type Scene3DEntityVisual, type Scene3DInputAsset, type Scene3DJobOutput, type Scene3DJobOutputAny, type Scene3DJobOutputV2, type Scene3DKnownEngine, type Scene3DLighting, type Scene3DLightingChanges, type Scene3DMaterialBinding, type Scene3DNormalizedAssetStats, type Scene3DObject, type Scene3DObjectChanges, type Scene3DObjectKeyframe, type Scene3DOverride, type Scene3DOverrideSpace, type Scene3DParseResult, type Scene3DPlan, type Scene3DPlanV1, type Scene3DPlanV2, type Scene3DPrimitive, type Scene3DProvenance, type Scene3DReference, type Scene3DReferenceKind, type Scene3DReferenceRole, type Scene3DRenderTier, type Scene3DRestoredAssertion, type Scene3DReviewFindings, type Scene3DReviewObjection, type Scene3DReviewRefused, type Scene3DReviewUnavailable, type Scene3DReviewUnavailableReason, type Scene3DReviewVerdict, type Scene3DSemanticIssue, type Scene3DShot, type Scene3DSupportedSchemaVersion, type Scene3DV2EditOperation, type Scene3DV2EditOptions, type Scene3DV2EditResult, type Scene3DV2OverrideInput, type Scene3DV2Primitive, type Scene3DV2ResourceUsage, type SceneData, type SceneHelperName, SceneHelperNameSchema, type SceneInputMode, SceneInputModeSchema, type SceneMetadata, SceneMetadataSchema, type SceneNodeData, SceneNodeDataSchema, SceneSpecSchema, type ScraperActorId, type ScriptCriticVerdict, ScriptCriticVerdictSchema, type ScriptProvider, type Season, type SectionKind, type SelectorConfig, type SelectorFields, type SelectorMode, type SelectorPredicateOp, type SelectorResult, type SemanticAspectRatio, type SeparatorPreset, SequenceExecutionRequiredError, type SharedListing, type SharedVoice, type SheetAspect, type SheetBackground, type SheetCostEstimate, type SheetEntry, type SheetFlavour, type SheetGenerationPlan, type SheetPreset, type SheetPresetId, type SheetSection, type SheetSkin, type SheetTextData, type SheetType, type ShotElement, type ShotImageElement, type ShotShapeElement, type ShotSpec, ShotSpecSchema, type ShotTextElement, type ShowrunnerPlan, ShowrunnerPlanSchema, type SidecarLoader, type SlotControlDescriptor, type SlotControlKind, type SlotVariation, type SocialMediaContentType, type SocialMediaPlatform, type SocialMediaSpec, type SortDirection, type SortListOptions, type SortType, type StageAwaitingSubGateEvent, StageAwaitingSubGateEventSchema, type StaticCaptionStyle, type StoryboardCohesionCriticVerdict, StoryboardCohesionCriticVerdictSchema, type StyleDirectives, StyleDirectivesSchema, type SubGateName, SubGateNameSchema, type SubmissionStatus, type SunoAddTrackModel, type SunoModel, type SupportedFontName, type SurroundDirection, type Swatch, T2I_TO_I2I_VARIANT, TASK_CHAINED_EDIT_PROVIDERS, TEMPLATE_CATEGORIES, TEXT_TO_AUDIO_PROVIDERS, TEXT_TO_VIDEO_PROVIDERS, TIER_MAX_PIPELINE_COST_CREDITS, TIER_PIPELINE_PARALLELISM, TILT_CARRIED_FRACTION, TOPAZ_DEFAULT_UPSCALE_FACTOR, TOPAZ_UPSCALE_FACTORS, TRANSCRIBE_PROVIDERS, TRANSIENT_RUNTIME_KEYS, TTS_PROVIDERS, TTS_TEXT_MAX, TWO_K_RESOLUTION_PROVIDERS, type TemplateCategory, type TextToAudioProvider, type TextToVideoProvider, type TopazUpscaleAdjustment, type TopazUpscaleFactor, type TopazUpscaleResolution, type TranscribeProvider, type TransitionType, TransitionTypeSchema, type TrimVideoEstimatorInput, type TtsProvider, UPSCALE_IMAGE_PROVIDERS, USAGE_GROUP_BYS, USAGE_MODES, type UpscaleImageProvider, type UsageGroupBy, type UsageLogEntry, type UsageMode, type UsageQuery, type UsageReport, type UsageReportRow, type UsageReportTotals, type UsageVarianceRow, VARIABLES_HANDLE_ID, VARIABLE_PRICING_MODELS, VEHICLES, VEHICLE_SUBCATEGORY_LABELS, VEHICLE_SUBCATEGORY_ORDER, VEO_PROVIDERS, VIDEO_ANALYSIS_AUDIO_MODES, VIDEO_ANALYSIS_BUCKET_CREDITS, VIDEO_ANALYSIS_CLIP_TRANSITIONS_IN, VIDEO_ANALYSIS_DEFAULT_VARIATION, VIDEO_ANALYSIS_DURATION_BUCKETS, VIDEO_ANALYSIS_DURATION_TOLERANCE_SEC, VIDEO_ANALYSIS_ENTITY_SOURCES, VIDEO_ANALYSIS_FACELESS_ANGLES, VIDEO_ANALYSIS_LEGACY_MODELS, VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_MAX_DURATION_SEC, VIDEO_ANALYSIS_MAX_SCENE_SEC, VIDEO_ANALYSIS_MAX_VARIATIONS, VIDEO_ANALYSIS_MIXED_TIERS, VIDEO_ANALYSIS_SHOT_ANGLES, VIDEO_ANALYSIS_SPEED_EFFECTS, VIDEO_ANALYSIS_STORY_JUMPS, VIDEO_ANALYSIS_TEXT_KINDS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_LABELS, VIDEO_ANALYSIS_TIER_ORDER, VIDEO_ANALYSIS_TIMES_OF_DAY, VIDEO_ANALYSIS_TRANSITIONS, VIDEO_ANALYSIS_VARIATION_SLUGS, VIDEO_ANALYSIS_VISUAL_EFFECTS, VIDEO_ANALYSIS_WINDOW, VIDEO_AUDIO_CAPABILITY, VIDEO_AUDIT_BUCKET_CREDITS, VIDEO_CLIP_CREDITS, VIDEO_CRITIC_CREDITS_PER_SHOT, VIDEO_CRITIC_FRAME_MODES, VIDEO_CRITIC_MAX_RETRIES, VIDEO_CRITIC_METADATA_KEYS, VIDEO_CRITIC_MIN_ADHERENCE_SCORE, VIDEO_DURATION_TIERS, VIDEO_GEN_COLLAPSED_T2V_IDS, VIDEO_GEN_PROVIDERS, VIDEO_INPUT_LIP_SYNC_PROVIDERS, VIDEO_MODEL_CAPS, VIDEO_MODE_ALIASES, VIDEO_ONLY_PARAMETER_NODE_TYPES, VIDEO_PRODUCER_TYPES, VIDEO_PROMPT_MAX, VIDEO_PROVIDERS_REQUIRING_IMAGE, VIDEO_PROVIDERS_WITHOUT_DISPATCH, VIDEO_REF_LIMITS_BY_PROVIDER, VIDEO_REF_VIDEO_DURATION_LIMITS, VIDEO_TO_VIDEO_PROVIDERS, VIDEO_UPSCALE_PROVIDERS, VIDEO_UTIL_PRICING, VIDEO_VARIABLE_PRICING, VOICE_CHANGER_MODELS, VOICE_CHANGER_MODEL_IDS, VOICE_DESIGN_MODELS, type ValidateMatchCutInput, ValidateMatchCutInputSchema, type ValidateMatchCutResult, ValidateMatchCutResultSchema, type ValidationField, type Vec3, type Vehicle, type VehicleSubcategory, type VideoAnalysisAudioMode, type VideoAnalysisClipTransitionIn, type VideoAnalysisEntitySource, type VideoAnalysisMixedTier, type VideoAnalysisModelTier, type VideoAnalysisResult, type VideoAnalysisShotAngle, type VideoAnalysisSpeedEffect, type VideoAnalysisTextKind, type VideoAnalysisTier, type VideoAnalysisTransition, type VideoAnalysisVisualEffect, type VideoAudioCapability, type VideoAudioMode, type VideoClipCost, type VideoCriticFrameMode, type VideoCriticMetadataKey, type VideoCriticShotFields, type VideoCriticVerdict, VideoCriticVerdictSchema, type VideoGenProvider, type VideoModeAlias, type VideoModelCapabilities, type VideoToVideoProvider, type VideoUpscaleProvider, type Voice, type VoiceChangerModel, type VoiceClone, type VoiceDesignModel, type VoiceLibraryParams, type VoiceLibraryResponse, type VoiceMatch, VoiceMatchSchema, type VoiceType, WAN_3_DEFAULT_RESOLUTION, WAN_3_PROVIDERS, WARDROBE_VARIANTS, WEAPONS, WEAPON_SUBCATEGORY_LABELS, WEAPON_SUBCATEGORY_ORDER, WORKFLOW_VISIBILITIES, WORKSPACE_HEADER, WORKSPACE_HEADER_LOWER, WORKSPACE_ROLES, type Weapon, type WeaponSubcategory, type WindowAnalysis, type WindowScene, type WorkflowAssetKind, type WorkflowExport, type WorkflowExportCharacter, type WorkflowExportCreature, type WorkflowExportLocation, type WorkflowExportObject, type WorkflowImportReport, type WorkflowImportSkippedAsset, type WorkflowMediaRef, type WorkflowPortability, type WorkflowVisibility, type WorkspaceMemberView, type WorkspaceRole, type WorkspaceSettings, WorkspaceSettingsSchema, type WorkspaceSummary, type WorkspaceView, aggregateByType, aiAvatarReserveCreditId, analyzedSceneSchema, applyDefaultVideoSelection, applyHandleInputOverride, applyRange, applyRangeIndices, applyScene3DEditOperations, applyScene3DV2EditOperations, applySlots, applyVideoAudioToggle, applyVideoNegativePrompt, aspectRatioFromDims, aspectRatioOptionsByKind, aspectRatioToNumber, assembleNarratedVideoCredits, assertCanvasExecutionAllowed, availableReasoningEfforts, bucketSecondsFromAuditCreditId, bucketSecondsFromCreditId, buildBoardPrompt, buildChildrenByParent, buildConditionVariables, buildCreditModelIdentifier, buildExpressionFromVisual, buildLipSyncCreditId, buildLlmCreditIdentifier, buildModelMenu, buildModelTree, buildMotionCreditModelIdentifier, buildNodePresetExport, buildPanelPrompt, buildPro3DRenderSource, buildProgressSegments, buildRangeLabel, buildScraperCreditId, buildVideoAnalysisCreditId, buildVideoAuditCreditId, buildVideoCreditModelIdentifier, calculateCombinedProgress, calculateMonetizationMarkup, calculateMonetizedCost, calculateProgress, canonicalScene3DPlanV2Json, canonicalVarName, characterBoardItems, characterBucketDisplayRank, characterMentionSlug, characterMentionableAssetArrays, characterSheetRefItems, characterVariantAssetArrays, checkRefVideoDurations, cinematicCreditId, clampCinematicDuration, clampSmartCutWindow, classifyRefToken, cleanOrphanedItems, clearImageCriticMetadata, clearVideoCriticMetadata, clipLookSchema, collectAncestorRefs, combineSameLabelRefs, computeAggregateLanes, computeScene3DPlanV2ContentHash, countRefModalityEdges, creditRangesAll, creditsToUsd, decodeProviderItem, defaultCarriedFraction, defaultResolutionFor, defaultRoleForSource, defaultVideoAspectRatio, deriveLinkedFields, deriveLottieSlotFields, deriveSlotRefs, describeEdgeBehavior, describeMaskRegion, describeNodeAdjustments, describeSlotControl, dropUnknownBindings, dropUnknownSpeakers, durationsByMode, effectiveReasoningEffort, encodeProviderItem, ensureLocaleCatalogLoaded, entityHydrationColumns, entityMentionSlug, entityMentionSlugForRef, entityScalarFields, entitySlotSchema, entryMatchesQuery, estimateCombineVideosCredits, estimateFilmCredits, estimateLoopTrimAddonCredits, estimateLoopVideoCredits, estimateScriptDurationSec, estimateSheetCost, estimateTrimVideoCredits, evaluateCondition, evaluateConditionGroup, evaluateJsonExpression, evaluateJsonPath, expandExtraRefsToConnectedReferences, expandItemsWithRepeat, extractAllGeneratedResults, extractCharacterLoraFields, extractGeneratedJsonAsList, extractPresetData, extractReferencedLabels, extractVideoDurationFromNode, fieldKeyFromHandle, filterCloneNodes, findCharacterMentionTokens, findEntityMentionTokens, findImageMentionTokens, findLocationMentionTokens, findSeedance2AudioOverLimit, firstSightExtraRole, flattenItems, getAnimal, getAnimalLabel, getAnimalPromptHint, getAnimalTerm, getAspectRatioOptions, getAudioCrossfadeCurve, getCharacterFacet, getCombineTransition, getCreditRange, getDurationsForModel, getEffectiveRepeatCount, getFeaturedEntities, getFurniture, getFurnitureLabel, getInputFieldSchema, getInputNodes, getItemSortId, getLipSyncMaxAudioSeconds, getLlmModalityCaps, getLlmModel, getLlmTier, getLocaleDirection, getMaxImagePromptChars, getMaxNegativePromptChars, getMaxSunoPromptChars, getMaxSunoStyleChars, getMaxTtsChars, getMaxVideoPromptChars, getModel, getNodeLabel, getNodeResult, getOutputNodes, getOutputType, getParameterValue, getQualityOptions, getResolutionOptions, getRouteReachableNodeIds, getStrategy, getTargetField, getValidValues, getVehicle, getVehicleLabel, getVideoAudioCapability, getWeapon, getWeaponLabel, groupByFamily, groupByKindAndFamily, groupHandleId, groupLlmModelsByVendor, hasContiguousSegmentDurations, hasFeature, hexToRgbaArray, humanizeSlotSid, imageMentionSlug, imageMentionSlugForRef, imageOverlayBillableVariants, imageOverlayCredits, imageReferenceLimit, inferMusicVideo, isAggregateableType, isCharacterAspectRatio, isCollectInEdge, isDefaultSelectorConfig, isExpandedClone, isFlux2Model, isGeminiOmniProvider, isGvpSupportedProvider, isHandleInputWired, isKineticCaptionStyle, isKnownScene3DEngine, isLegacySunoModel, isLocationUsageMode, isMinimaxH3Provider, isObjectAspectRatio, isOversizedScene, isPaygRetentionActive, isPerSecondLipSyncProvider, isPro3DRenderJobOutput, isPro3DRenderQuote, isPro3DRenderRenderOnly, isRtlText, isScene3DAuthoringEngine, isScene3DCameraTrack, isScene3DHttpUrl, isScene3DPlan, isScene3DPlanV1, isScene3DPlanV2, isScene3DReviewUnavailableReason, isScene3DSchemaVersionSupported, isScraperActor, isSeedance2Provider, isTemplateCategory, isTiltDirection, isUsageMode, isVeoProvider, isVideoAnalysisMixedTier, isVideoAnalysisTier, isWan3Provider, jsonResultToList, knownEntitySlugsFromRefs, knownImageSlugsFromRefs, listBoardTemplates, listModels, listSlotSids, llmRouteDefaults, locationMentionSlug, locationReferencePhotoKindLabel, locationUsageModeLabel, mapAspectRatio, mapQuality, mapShotIntentToProviderDirectives, matchVariant, maxSegmentSecFor, maxSegmentsFor, mergeClipLook, mergeExposedSettings, migrateEdgeOutputMode, migrateToItems, minSegmentSecFor, modelIdsByKindMode, modelToNodeTarget, modelsForInputMode, modelsWithFeature, motionGraphicsFeature, newScene3DRevisionId, nodeStateMayCarryOutput, normalizeLottieLayers, normalizeMinimaxH3Resolution, normalizeModelInput, normalizeNodeModelParams, normalizePinterestUrl, normalizeRoleSlug, normalizeTemplateCategory, normalizeVideoRequestParams, normalizeWan3Resolution, orderedLlmModels, overlayFontById, overlayImageEffectsSchema, overlayPlatformById, overlayQrStyleSchema, overlayShapeElement, overlayShapeStyleSchema, overlayStrokeSchema, overlayTextStyleSchema, overlayVariantHandle, overlayVariantIdFromHandle, parseAttributedDialogue, parseCharacterMentionToken, parseEntityMentionToken, parseGroupHandle, parseHandleId, parseImageMentionToken, parseListExpression, parseLocationMentionToken, parseNodePresetExport, parseNodeRef, parseScene3DCameraTrackJson, parseScene3DPlanV2Json, pickAiAvatarBucket, pickIds, pickLipSyncBucket, pickSwitchXFrameTier, pickVideoAnalysisBucket, planSheetGeneration, planSheetPanels, preferredInputModeForModel, presentTypes, presetApplyClearKeys, presetDataMatches, presetEntries, pricedOutputDurationSec, pricedVideoSelection, pro3DRenderCoreOutputSchema, pro3DRenderFrameUnit, pro3DRenderJobOutputSchema, pro3DRenderProducedSchemaVersion, pro3DRenderQuoteSchema, pro3DRenderReviewVerdictSchema, pro3DRenderShotStillSchema, pro3DRenderShotStills, pro3DRenderTimingOverrides, qualityOptionsByKind, readPromptAffixes, refHandleCategory, referenceModalityForHandle, referenceSheetCreditId, registerCatalogSidecars, registerSidecarLoaders, renderAnalyzedScene, renderVideoCreditId, requiresSequenceExecution, resetCatalogSidecars, resolutionOptionsByKind, resolveAiAvatarCreditId, resolveAudioCrossfadeCurve, resolveCharacterAspectRatio, resolveCinematicCreditId, resolveConditionValue, resolveDefaultRole, resolveDescription, resolveDialogueVoices, resolveEffectiveSourceType, resolveEffectiveTier, resolveEntityAspect, resolveFieldMappings, resolveGvpAnchorWire, resolveImageGenCreditIdentifier, resolveIndex, resolveLabel, resolveListExpression, resolveLlmCreditId, resolveLocationFields, resolveLocationPresetCatalog, resolveLottieOverlaySrc, resolveNodeRefs, resolveNormalizedImageGen, resolveObjectAspectRatio, resolvePipelineModel, resolveRelativeWindowToken, resolveScene3DAuthoringEngine, resolveScraperCreditId, resolveSelectorRefs, resolveSeparator, resolveSheetSections, resolveSlideshowTransition, resolveSourceThroughConnectedList, resolveStoredTier, resolveSwitchXCreditId, resolveTemplateCategory, resolveTopazUpscale, resolveVideoAnalysisModel, resolveVideoModeForInputs, resolveVideoProviderForMode, resolveXfadeName, rewriteSceneBindings, rewriteSlotTokens, rewriteSpeakerSlots, rgbaArrayToHex, roleToPhrase, rotationVec3Schema, runSelector, safetyRetryPolicy, sanitizeRole, scaleVec3Schema, scene3DAcceptedSchemaVersionsSchema, scene3DAnchorNameSchema, scene3DAnchorSchema, scene3DAnyPlanSchema, scene3DAssetAnimationSchema, scene3DAssetIdSchema, scene3DAssetRefSchema, scene3DCameraChangesSchema, scene3DCameraKeyframeSchema, scene3DCameraSampleSchema, scene3DCameraSchema, scene3DCameraTrackIssues, scene3DCameraTrackObjectSchema, scene3DCameraTrackPlanIssues, scene3DCameraTrackSchema, scene3DClayLightingSchema, scene3DColorSchema, scene3DDeepEqual, scene3DEasingSchema, scene3DEditOperationSchema, scene3DEditOperationsSchema, scene3DEngineIdSchema, scene3DEntityAcceptsOverlay, scene3DEntityCapabilitySchema, scene3DEntityV2Schema, scene3DEntityVisualSchema, scene3DIdSchema, scene3DInputAssetSchema, scene3DInputAssetsForEngine, scene3DInputAssetsSchema, scene3DJsonByteLength, scene3DLightingChangesSchema, scene3DLightingSchema, scene3DMaterialBindingSchema, scene3DMaterialNameSchema, scene3DMaterialRoleSchema, scene3DNodeIdSchema, scene3DNodeNameSchema, scene3DObjectChangesSchema, scene3DObjectKeyframeSchema, scene3DObjectSchema, scene3DOverrideSchema, scene3DPlanIssues, scene3DPlanSchema, scene3DPlanSchemaVersion, scene3DPlanV1Issues, scene3DPlanV1ObjectSchema, scene3DPlanV1Schema, scene3DPlanV2Issues, scene3DPlanV2ObjectSchema, scene3DPlanV2Schema, scene3DPrimitiveSchema, scene3DProjectionIssues, scene3DProvenanceSchema, scene3DReferenceSchema, scene3DRenderTier, scene3DRenderTierCredits, scene3DReviewNote, scene3DReviewVerdictOf, scene3DSampleForFrame, scene3DSha256Schema, scene3DShotForFrame, scene3DShotIndexForFrame, scene3DShotSchema, scene3DUrlSchema, scene3DV2AdmissionIssues, scene3DV2EditOperationSchema, scene3DV2EditOperationsSchema, scene3DV2HierarchyDepth, scene3DV2NormalizationIssues, scene3DV2OverrideInputSchema, scene3DV2ResourceUsage, scene3DVersionTokenSchema, scene3DZodIssues, searchModelVariants, seedance2AudioLimitSec, segmentDurationsFor, selectByModulo, selectByNamedKey, selectByPredicate, selectListItems, selectLoraRoutingForMentions, selectRandom, setRegisteredPersonPackFields, settledWithLimit, sizeVec3Schema, slotVariationSchema, sortCharacterEntriesForDisplay, sortListItems, sourceRefKey, spliceDelimitedRows, splitByLoopDelimiter, splitGeneratedItems, spreadJsonArrayIfSingleton, stringifyPathResults, stripDerivedAnalysisFields, stripExportContent, stripStudioTransientSettings, stripTransientRuntimeData, summarizeScene3DOperations, sunoCreditType, sunoModelHonoursDuration, supportedDefaultDimensions, supportsAdvancedMode, supportsEndAnchor, supportsExtendRender, templateCategoryStoredValues, toConnectedReference, toConnectedReferences, togglePick, tryParseJson, uiAspectRatioFill, uiDurationFill, uiResolutionFill, unresolvedRefTokens, unwrapUnresolvedTokens, usageModeDirective, usageModeIncludesName, usageModeLabel, usdToCredits, validateAiAvatarPayload, validateCinematicAvatarPayload, validateDurationForFormat, validateModeActivation, validateModelInput, validateNoNestedGroups, validateObjects, validateProviderForNodeType, validateSubWorkflowRoutes, variantJobId, vec3Schema, verifyScene3DPlanV2ContentHash, videoAnalysisCreditSegment, videoAnalysisNumWindows, videoAnalysisResultSchema, videoAuditCreditsForBucket, videoModelCanSpeakDialogue, videoModelSupportsAudio, videoNegativeSuffix, videoProviderFoldsLoneEndFrame, videoProviderRequiresImage, windowAnalysisSchema, zipMergeLists };
+/**
+ * Real output canvases per (video model, resolution, aspect ratio).
+ *
+ * Every entry is a pixel size read off a finished render with ffprobe — the
+ * geometry a model hands back, never a rate or a price. None of it is
+ * arithmetic either, because the providers do not follow arithmetic:
+ *
+ *   - minimax-h3 at 768P returns 768x1344 (0.5714) for a 9:16 request,
+ *   - seedance-2 at 480p 16:9 returns 864x496 (1.742) while seedance-2-5
+ *     returns 854x480 (1.778) for the same request,
+ *   - grok returns 736x400 (1.84), seedance 1.0 at 1080p 1:1 returns 1440x1440.
+ *
+ * A formula would get all four wrong, which is why `resolveOutputCanvas`
+ * answers `undefined` for anything not measured: callers must then leave the
+ * frame alone rather than invent geometry (see `computeFrameFitPlan`).
+ *
+ * HOW TO EXTEND: run `node tools/harvest-output-canvas.mjs` (it pages the admin
+ * jobs API, groups completed video jobs by provider/resolution/aspect and probes
+ * real outputs) and paste new rows here. Take rows from REFERENCE or
+ * TEXT-TO-VIDEO jobs only: in frame mode the adaptive models (the seedance and
+ * wan families) size the output from the INPUT image, so those rows describe the
+ * input that was sent, not the canvas the model would choose on its own.
+ *
+ * Seeded 2026-09-16 from 3000 completed production jobs.
+ */
+/** `[width, height]` in pixels. */
+type VideoOutputCanvas = readonly [number, number];
+/** provider → resolution (lower-cased) → aspect token → canvas. */
+declare const VIDEO_OUTPUT_CANVAS: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, VideoOutputCanvas>>>>>>;
+/**
+ * The canvas a model renders for this request, or `undefined` when we have never
+ * measured that combination. `undefined` means "leave the frame alone".
+ *
+ * Resolution matching is case-insensitive (`768P`, `2K`, `720p` all appear in
+ * the wild). An aspect of `adaptive` / `Auto` has no canvas of its own — the
+ * caller resolves it to a concrete ratio first (`resolveFrameFitAspect`).
+ */
+declare function resolveOutputCanvas(provider: string | undefined, resolution: string | undefined, aspect: string | undefined): VideoOutputCanvas | undefined;
+/** Every measured combination, for tests and for the harvest script's diff. */
+declare function measuredCanvasCombinations(): Array<{
+    provider: string;
+    resolution: string;
+    aspect: string;
+    canvas: VideoOutputCanvas;
+}>;
+
+/** How much of the frame we are allowed to reshape. */
+declare const FRAME_FITS: readonly ["original", "ratio", "resolution"];
+type FrameFit = (typeof FRAME_FITS)[number];
+/** `resolution` — the measured canvas — is the default everywhere. */
+declare const DEFAULT_FRAME_FIT: FrameFit;
+/** How the frame is handed to the model. */
+declare const FRAME_DELIVERIES: readonly ["auto", "frame", "reference"];
+type FrameDelivery = (typeof FRAME_DELIVERIES)[number];
+declare const DEFAULT_FRAME_DELIVERY: FrameDelivery;
+/**
+ * Stretching an image to a ratio it is nowhere near would squash the subject,
+ * so past this gap the frame is centre-cropped to the target ratio FIRST and
+ * only then resized. 5% covers every "1K image into a 720p canvas" case we
+ * measured (940x1672 into 9:16 is a 0.05% gap) while refusing to squash a
+ * square photo into 9:16 (a 78% gap).
+ */
+declare const FRAME_FIT_STRETCH_TOLERANCE = 0.05;
+/**
+ * Models whose frame mode is measurably worse than reference delivery.
+ *
+ * The Seedance 2.0 family crop-zooms the frame 2% and drifts 11-26% darker
+ * within six frames in frame mode; delivered as a reference with the opening-
+ * frame sentence, the same models hold a flat look from frame 0 and keep the
+ * image's true geometry. Every OTHER model measured (Seedance 2.5, Gemini Omni
+ * video + flash, Veo 3.1, Wan 3.0, Minimax H3) reproduces the opening frame
+ * better in frame mode, so the default stays `frame` for anything absent here.
+ */
+declare const FRAME_DELIVERY_BY_PROVIDER: Readonly<Record<string, Exclude<FrameDelivery, "auto">>>;
+/** `"16:9"` → 1.777…; anything unparseable → `undefined`. */
+declare function parseAspectToken(token: string | undefined): number | undefined;
+/**
+ * The aspect the fit should target.
+ *
+ * An explicit ratio is used as-is. `adaptive` / `Auto` (and an absent value,
+ * which the seedance family sends as adaptive whenever a frame is present) has
+ * no shape of its own: the provider will follow the IMAGE, so we snap the
+ * image's own ratio to the nearest one the model lists and target that. A model
+ * with no declared ratio list and an open token gives `undefined` — no fit.
+ */
+declare function resolveFrameFitAspect(args: {
+    provider: string | undefined;
+    requestedAspect: string | undefined;
+    sourceWidth: number;
+    sourceHeight: number;
+}): string | undefined;
+/** What `prepareVideoFrames` should do to one frame. `null` = nothing. */
+interface FrameFitPlan {
+    /** Final pixel size to produce. */
+    readonly width: number;
+    readonly height: number;
+    /** Centre-crop applied BEFORE the resize (only past the stretch tolerance). */
+    readonly crop?: {
+        readonly left: number;
+        readonly top: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    /** Why the plan exists — carried into logs and job output for traceability. */
+    readonly reason: "resolution" | "ratio";
+}
+/**
+ * The smallest change that makes `width x height` exactly `aspect`: keep the
+ * longer side, move the shorter one. Rounding to even can leave a sub-pixel
+ * residue, which is why the caller compares ratios with a tolerance rather than
+ * for equality.
+ */
+declare function minimalRatioDimensions(width: number, height: number, aspect: number): {
+    width: number;
+    height: number;
+};
+/**
+ * The centre-crop that turns `width x height` into exactly `aspect`, dropping
+ * the overhang on the long axis.
+ */
+declare function centreCropToAspect(width: number, height: number, aspect: number): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/**
+ * Turn a request into a concrete plan for ONE frame, or `null` when the frame
+ * should be sent untouched.
+ *
+ * Degradation ladder — a missing measurement must never invent geometry:
+ *   `resolution` with no measured canvas → behaves as `ratio`
+ *   `ratio` with no resolvable aspect    → no fit
+ *   any fit whose target equals the source (within a pixel) → no fit
+ */
+declare function computeFrameFitPlan(args: {
+    fit: FrameFit;
+    provider: string | undefined;
+    resolution: string | undefined;
+    /** The aspect as the request carries it: a ratio, `adaptive`/`Auto`, or absent. */
+    aspect: string | undefined;
+    sourceWidth: number;
+    sourceHeight: number;
+    /** Overrides the measured table (tests, and a caller that already looked up). */
+    canvas?: VideoOutputCanvas;
+    tolerance?: number;
+}): FrameFitPlan | null;
+/**
+ * Frame or reference? `auto` reads the per-provider default measured above.
+ * Reference delivery is only possible on models that accept reference images —
+ * on the others `reference` collapses back to `frame` rather than dropping the
+ * frame on the floor.
+ */
+declare function resolveFrameDelivery(args: {
+    provider: string | undefined;
+    requested: FrameDelivery | undefined;
+    supportsReferenceImages: boolean;
+}): Exclude<FrameDelivery, "auto">;
+
+/**
+ * Speaker-view presentation registries — the STRUCTURAL vocabulary behind an
+ * EDL segment's `layout` (see `EdlLayout` in `edl.ts`).
+ *
+ * What lives here is structure only: which layout ids exist, how many slots
+ * each takes, which output aspects a renderer exists for, which speaker-switch
+ * ids exist and whether they consume output time, and the atomic emphasis
+ * styles. Taste — default emphasis, which transitions are allowed or preferred
+ * for a show, timing defaults — is deliberately NOT here.
+ *
+ * Every list is widened ADDITIVELY. That is why a finding judged against one of
+ * these registries is a validation WARNING, never an issue: an older validator
+ * must never reject an EDL written by a newer producer that knows more ids.
+ * An executor that cannot honour an id refuses it itself.
+ */
+
+declare const EDL_TARGET_ASPECTS: readonly ["16:9", "9:16", "1:1", "4:5"];
+type EdlTargetAspect = (typeof EDL_TARGET_ASPECTS)[number];
+/** Narrow an open `Edl.meta.targetAspect` (or any value) to a known aspect. */
+declare function isEdlTargetAspect(v: unknown): v is EdlTargetAspect;
+interface SpeakerLayoutSheet {
+    readonly id: string;
+    /** Inclusive slot-count range when a segment lists `layout.slots`. */
+    readonly minSlots: number;
+    readonly maxSlots: number;
+    /** The output aspects this layout is DRAWN for (a renderer exists) — not "looks good". Widened additively. */
+    readonly aspects: readonly EdlTargetAspect[];
+}
+declare const SPEAKER_LAYOUTS: readonly SpeakerLayoutSheet[];
+declare const SPEAKER_LAYOUT_IDS: readonly string[];
+declare function getSpeakerLayout(id: string): SpeakerLayoutSheet | undefined;
+/** Omitted query fields are unconstrained. */
+declare function speakerLayoutAllows(sheet: SpeakerLayoutSheet, q: {
+    readonly aspect?: EdlTargetAspect;
+    readonly slotCount?: number;
+}): boolean;
+/** D17: a switch consumes output time iff it is in the `xfade:*` family. THE one overlap rule (edl.ts uses it). */
+declare function speakerSwitchOverlaps(type: string): boolean;
+interface SpeakerSwitchSheet {
+    /** "cut" | "pan" | "zoom" | `xfade:${combine id}` */
+    readonly id: string;
+    /** = `speakerSwitchOverlaps(id)`, derived, never hand-set. */
+    readonly overlaps: boolean;
+    /** true only for `pan`: an eased sweep between two regions of ONE picture source. */
+    readonly requiresSameSource: boolean;
+}
+/** `cut` / `pan` / `zoom` consume no time (pan: a geometry tween inside ONE
+ *  source; zoom: a tween inside each segment). The `xfade:*` family is DERIVED
+ *  from every combine-videos transition that is a real ffmpeg xfade (so never
+ *  `cut`, which has no xfade) — it is never hand-listed here. */
+declare const SPEAKER_SWITCHES: readonly SpeakerSwitchSheet[];
+declare const SPEAKER_SWITCH_IDS: readonly string[];
+/** A plain lookup: `undefined` for an unknown id (never throws). */
+declare function getSpeakerSwitch(id: string): SpeakerSwitchSheet | undefined;
+/** Atomic emphasis styles; `layout.emphasis.style` is a "+"-joined set of
+ *  them. `none` stands alone (it means "no emphasis"), and an atom appears at
+ *  most once. */
+declare const SPEAKER_EMPHASIS_STYLES: readonly ["none", "scale", "border", "dim"];
+type SpeakerEmphasisStyle = (typeof SPEAKER_EMPHASIS_STYLES)[number];
+/** Split a `+`-joined style into its atoms: trimmed, empties dropped. */
+declare function parseSpeakerEmphasisStyle(style: string): readonly string[];
+/** At least one atom, every atom a known `SPEAKER_EMPHASIS_STYLES` id, no
+ *  atom repeated, and `none` only on its own ("none+scale" contradicts itself). */
+declare function isKnownSpeakerEmphasisStyle(style: string): boolean;
+/** Registry-derived findings — ALL warning-class. Pure; never throws (guard non-array sources/segments the
+ *  way validateEdl does). `validateEdl` already includes these in its `warnings`; call this directly only
+ *  when you want the presentation findings alone. */
+declare function speakerPresentationWarnings(edl: Edl): readonly string[];
+
+/**
+ * EDL — the edit decision list contract.
+ *
+ * WHY THIS EXISTS
+ * The podcast-editing primitives (transcript-driven cut, clip finding,
+ * multicam, speaker view) compose because they share ONE data shape: every
+ * analysis node produces an EDL, every render node consumes one. This module
+ * is that shape plus the pure functions that read it. It is structural
+ * vocabulary — no prompts, no heuristics, no editorial judgment — which is why
+ * it lives in the Apache-licensed `@nodaro/shared` (the wire shape of
+ * `/v1/edl/*`, an SDK type, an MCP output). Every published version is an
+ * irrevocable grant, so the three resolved decisions (see below) all land in
+ * version 1: renaming a field, or adding a REQUIRED one, later would be a
+ * breaking major bump — so every later field is optional and additive.
+ *
+ * This module is PURE — no I/O, no ffmpeg, no network. The executors
+ * (`apply-edl`, `speaker-view`) turn an EDL into pixels; they live in the app
+ * and the plugins.
+ *
+ * DESIGN DECISIONS baked into v1 (so multicam and speaker view extend the
+ * contract additively rather than with a breaking bump):
+ *  - D17 OVERLAP: a crossfade consumes time from the outgoing segment (ffmpeg
+ *    `xfade`, as combine-videos already does), so the rendered timeline is
+ *    SHORTER than the sum of segment durations. `edlDurationMs` subtracts the
+ *    overlap transitions; cut/pan/zoom consume no time (pan: a geometry tween
+ *    inside ONE source; zoom: a tween inside each segment); only the `xfade:*`
+ *    family and a segment `crossfade` overlap.
+ *  - D19 CLOCK/SOURCE/SIGN: `Edl.clock` says whether `segments` are on the
+ *    source master clock or an output clock; `Transcript.sourceId` says which
+ *    source a transcript came from; the offset sign is `masterMs = sourceMs +
+ *    offsetMs(source)`, applied by the remap functions.
+ *  - D20 PRECEDENCE/RENAME: region precedence
+ *    `slot.region ▷ segment.region (single-slot only) ▷ a caller's per-slot
+ *    resolver (v3 tracks) ▷ regions[(source, speaker)] ▷ source.region ▷ full
+ *    frame`, implemented ONCE by `resolveEdlSegmentSlots` (edl-multicam.ts);
+ *    `segment.region` is invalid when the segment's layout has more than one
+ *    slot; `slots[].weight` (0..1, active = 1) replaces the design's
+ *    `slots[].emphasis` so it no longer collides with `layout.emphasis`
+ *    ({ style, durationMs }).
+ *
+ * Time is INTEGER MILLISECONDS everywhere. There is no seconds→ms guessing
+ * (`normalizeEdl` never reinterprets a unit — an implausible value is a
+ * validation error, not a silent 1000× edit).
+ */
+declare const EDL_VERSION: 1;
+/** A crop region, as fractions 0..1 of the source frame. */
+interface EdlRegion {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+declare const EDL_SOURCE_ROLES: readonly ["master-audio", "camera", "wide", "screen"];
+type EdlSourceRole = (typeof EDL_SOURCE_ROLES)[number];
+/** A media input to the edit. Ids are minted once (by `edit-plan`) and never
+ *  re-derived, so downstream nodes resolve media from `url` in the data, not
+ *  from canvas handle order. Keep the `url` key: the cloud relay re-hosts
+ *  private media by walking `url`-suffixed fields. */
+interface EdlSource {
+    readonly id: string;
+    readonly url: string;
+    readonly kind: "video" | "audio";
+    /** This source's origin on the master clock. `masterMs = sourceMs + offsetMs`. Default 0. */
+    readonly offsetMs?: number;
+    /** Known roles: EDL_SOURCE_ROLES. Open (`string & {}`) so an EDL written by a newer producer still type-checks
+     *  and still validates — an unknown role is a WARNING (validateEdl); an executor that cannot honour it refuses it. */
+    readonly role?: EdlSourceRole | (string & {});
+    /** Speaker labels this source frames (multicam). Empty = unknown. */
+    readonly speakers?: readonly string[];
+    /** A static crop for this source (speaker-view v1 framing). */
+    readonly region?: EdlRegion;
+}
+/** How a segment is presented on screen (speaker-view, phase 2). `mode` and
+ *  `transition.type` are ids from the `SPEAKER_LAYOUTS` / `SPEAKER_SWITCHES`
+ *  registries (speaker-layouts.ts); `emphasis.style` is a `+`-joined set of
+ *  atomic `SPEAKER_EMPHASIS_STYLES` (e.g. "scale+border"). Unknown ids are
+ *  validation WARNINGS, and `mode` stays an open string on purpose. v1 leaves
+ *  layout undefined (single camera). */
+interface EdlLayout {
+    /** "single" | "side-by-side" | "stacked" | "grid" | "pip" | … */
+    readonly mode: string;
+    readonly slots?: ReadonlyArray<{
+        readonly source: string;
+        readonly region?: EdlRegion;
+        readonly speaker?: string;
+        /** D20: 0..1, the active slot = 1. (Was `emphasis`; renamed to avoid
+         *  colliding with `layout.emphasis`.) */
+        readonly weight?: number;
+    }>;
+    /** A "+"-joined set of "none" | "scale" | "border" | "dim" | …, eased over durationMs. */
+    readonly emphasis?: {
+        readonly style: string;
+        readonly durationMs: number;
+    };
+    /** Into THIS segment. "cut" | "pan" | "zoom" consume no time; "xfade:<id>" overlaps (D17).
+     *  `durationMs` never consumes timeline time for the non-overlap types: it
+     *  is the tween length for `pan` / `zoom` and is ignored for `cut`. */
+    readonly transition?: {
+        readonly type: string;
+        readonly durationMs?: number;
+    };
+}
+interface EdlSegment {
+    readonly id: string;
+    /** On the MASTER clock. */
+    readonly inMs: number;
+    /** Exclusive, > inMs. */
+    readonly outMs: number;
+    /** `EdlSource.id` supplying picture. Omit = audio-only EDL. */
+    readonly video?: string;
+    /** `EdlSource.id` supplying sound. Default: the unique `role:"master-audio"` source, else `video`. */
+    readonly audio?: string;
+    /** Dominant speaker label (informational). */
+    readonly speaker?: string;
+    /** Into THIS segment. Only "crossfade" consumes time (D17); never on segments[0].
+     *  `durationMs` is optional and inert for "cut". */
+    readonly transition?: {
+        readonly type: "cut" | "crossfade";
+        readonly durationMs?: number;
+    };
+    /** Per-segment crop override — SINGLE-slot only (D20). */
+    readonly region?: EdlRegion;
+    readonly layout?: EdlLayout;
+    /** Free tags: "hook", "chapter:2", … (removed spans live in `Edl.dropped`). */
+    readonly labels?: readonly string[];
+}
+interface EdlDropped {
+    readonly inMs: number;
+    readonly outMs: number;
+    readonly reason: "silence" | "filler" | "false-start" | "tangent" | "manual" | string;
+}
+interface Edl {
+    readonly version: 1;
+    /** D19: are `segments` on the source master clock, or an already-rendered output clock? */
+    readonly clock: "master" | "output";
+    readonly sources: readonly EdlSource[];
+    /** The ordered output timeline. Output time = cumulative segment durations, less overlap transitions. */
+    readonly segments: readonly EdlSegment[];
+    readonly dropped?: readonly EdlDropped[];
+    /** Set when this EDL was re-cut from a rendered output (speaker-view after apply-edl). */
+    readonly derivedFrom?: {
+        readonly edlId: string;
+        readonly clock: "output";
+    };
+    readonly meta?: {
+        readonly title?: string;
+        readonly hook?: string;
+        /** Known aspects: `EDL_TARGET_ASPECTS`. Open (`string & {}`) so an EDL
+         *  written by a newer producer still type-checks — an unknown aspect is a
+         *  validation WARNING (validateEdl), never an issue. */
+        readonly targetAspect?: EdlTargetAspect | (string & {});
+        readonly platform?: string;
+        readonly notes?: string;
+    };
+}
+/** The `clips` mode's response/SDK shape. On the canvas the node emits a bare
+ *  `Edl[]` (T5: the `list` fan-out reads a top-level JSON array), and the
+ *  cloud relay writes `output_data` as this object — the unwrap to the bare
+ *  array happens in the output extractors, never in `output_data`. */
+interface EdlClipSet {
+    readonly version: 1;
+    readonly clips: readonly Edl[];
+}
+/** The `chapters` mode's `output_data` shape — a plain `data` list. */
+interface ChapterSet {
+    readonly version: 1;
+    readonly chapters: ReadonlyArray<{
+        readonly startMs: number;
+        readonly title: string;
+    }>;
+}
+/** The normalized JSON form of a transcribe result. */
+interface Transcript {
+    readonly version: 1;
+    /** D19: which `EdlSource` this transcript was made from (drives the offset in remap). */
+    readonly sourceId?: string;
+    readonly language?: string;
+    readonly words: ReadonlyArray<{
+        readonly text: string;
+        readonly startMs: number;
+        readonly endMs: number;
+        readonly speaker?: string;
+        readonly confidence?: number;
+    }>;
+    readonly segments?: ReadonlyArray<{
+        readonly startMs: number;
+        readonly endMs: number;
+        readonly text: string;
+        readonly speaker?: string;
+    }>;
+}
+/** Duration (seconds) implied by a transcript — the LATEST word/segment `endMs`
+ *  across the whole transcript, in seconds. The edit-plan reserve's duration
+ *  fallback BENEATH the master-source ffprobe (`computeEditPlanReserveId`): the
+ *  authoritative reserve basis is a probe of the master media, exactly like the
+ *  plugin route; this transcript clock is used only in `buildPayload` (which
+ *  cannot ffprobe) and when that probe can't run, for a MASTER source node that
+ *  exposes no length of its own (a `reference-audio`/youtube or direct-URL
+ *  master carries its length in neither `data.duration` nor
+ *  `metadata.durationSeconds` — see `editPlanSourceDurationSec` — and its live
+ *  orchestrator output is a bare URL). The transcript is a REQUIRED edit-plan
+ *  input and is the timing map of that same master, so its last word's `endMs`
+ *  is a lower bound on the source's own clock.
+ *
+ *  Accepts `unknown` because the cloud plugin's Zod is the transcript's schema
+ *  authority; this reads defensively and returns `undefined` for any shape it
+ *  can't measure (so the caller falls back to the ceiling bucket — the safe
+ *  over-reserve direction). Takes the MAX endMs rather than the last element so
+ *  an out-of-order words array can't under-report. NOTE the direction: a
+ *  transcript's last spoken word ends at or before the true media end (trailing
+ *  music/silence is not transcribed), so this can UNDER-estimate; bucket
+ *  round-up is the headroom, and the cloud re-probe money-gate refuses (never
+ *  overcharges) if the probed master still exceeds the reserved bucket. */
+declare function transcriptDurationSec(transcript: unknown): number | undefined;
+/** Rendered duration of the edit, in ms. Σ segment durations minus the
+ *  overlap transitions (D17: an `xfade`/`crossfade` compresses the timeline
+ *  by its duration per boundary; `cut`/`pan`/`zoom` do not). Total over BOTH
+ *  the segment- and layout-transition fields.
+ *
+ *  Derived FROM `segmentOutputStarts` so the invariant
+ *  `outputStart(last) + dur(last) === edlDurationMs` holds by construction on
+ *  every input — including a normalized-but-not-yet-validated EDL (the reserve
+ *  runs this before validate). The two must never be two independent overlap
+ *  implementations that can drift. */
+declare function edlDurationMs(edl: Edl): number;
+/** Library-produced (never construct one yourself — fields may be added). `ok` is `issues.length === 0`;
+ *  warnings never flip it. Issues = facts intrinsic to the EDL. Warnings = judgements against a REGISTRY
+ *  (source roles, speaker layouts/switches/emphasis, target aspects) that a newer version may widen — so an
+ *  older validator never rejects a newer EDL. */
+interface EdlValidation {
+    readonly ok: boolean;
+    readonly issues: readonly string[];
+    readonly warnings: readonly string[];
+}
+/** Structural validation. Coercion (defaults, clamping) is `normalizeEdl`'s
+ *  job; this reports what is still wrong after normalization. Segment ORDER is
+ *  the output timeline order and is NOT required to be monotonic on the master
+ *  clock — a legitimate multicam/clips EDL revisits earlier source time — so
+ *  the only per-segment ordering rule is `outMs > inMs`.
+ *
+ *  The transition duration bound is the per-boundary ffmpeg-`xfade` limit: the
+ *  blend must be shorter than the adjacent material, so we validate at
+ *  `0.9 · min(the two adjacent segments)`. (combine-videos uses a more
+ *  conservative GLOBAL `0.9 · min(all clips)`; the per-boundary bound here is
+ *  the correct one, and the `apply-edl` executor must clamp per-boundary too —
+ *  copying combine's global-min would let validate pass a transition the
+ *  renderer then silently shortens, the R5 silent-edit this bound prevents.)
+ *  It applies only to overlap transitions; `cut`/`pan`/`zoom` are unbounded. */
+declare function validateEdl(edl: Edl): EdlValidation;
+/** Validate a clip set (the `clips` mode output). */
+declare function validateEdlClipSet(set: EdlClipSet): EdlValidation;
+/**
+ * Map an instant on `sourceId`'s clock to the rendered output clock, or `null`
+ * if that instant was dropped (falls in no kept segment). Applies the D19
+ * offset (`masterMs = sourceMs + offsetMs`) and the D17 overlap compression.
+ * `sourceId` omitted ⇒ the instant is already on the master clock.
+ */
+declare function remapMsThroughEdl(edl: Edl, sourceMs: number, sourceId?: string): number | null;
+/**
+ * Remap a transcript onto the rendered output: drop words that fall entirely
+ * in removed material, clip a word that straddles a cut to its kept part, and
+ * apply the source offset (via `transcript.sourceId`). Captions, chapters and
+ * clip offsets all depend on this one function.
+ */
+declare function remapTranscriptThroughEdl(edl: Edl, transcript: Transcript): Transcript;
+/** Speaker turns: consecutive same-speaker words merged across gaps shorter
+ *  than `mergeGapMs`, then turns shorter than `minTurnMs` dropped. */
+declare function speakerTurns(transcript: Transcript, opts: {
+    minTurnMs: number;
+    mergeGapMs: number;
+}): Array<{
+    speaker: string;
+    startMs: number;
+    endMs: number;
+}>;
+/**
+ * Coerce an unknown value into a well-formed `Edl`: fill defaults, drop unknown
+ * fields, clamp regions to 0..1. All times are integer ms — there is NO
+ * seconds→ms guessing (an integer-seconds EDL would silently become a
+ * 1000×-longer edit; the contract is ms-only and a value that cannot be a
+ * plausible ms EDL is a validation error, not a reinterpretation).
+ *
+ * Segment ORDER is preserved verbatim: it is the output timeline order, and a
+ * multicam/clips EDL legitimately revisits earlier source time, so re-sorting
+ * would corrupt it. (`dropped` has no ordering semantics and is left as-is.)
+ */
+declare function normalizeEdl(input: unknown): Edl;
+/** Coerce an unknown value into a `Transcript`. ms-only, same rule as `normalizeEdl`. */
+declare function normalizeTranscript(input: unknown): Transcript;
+
+/**
+ * Multicam helpers over the EDL contract (`edl.ts`): folding measured source
+ * offsets into an EDL (D19) and resolving what each on-screen slot of a
+ * segment shows (D20). Pure — no I/O. Type-only imports from `edl.ts` keep the
+ * module graph free of runtime cycles.
+ */
+
+/** audio-sync → EDL source offsets (D19: masterMs = sourceMs + offsetMs).
+ *  `offsets` are measured against ONE common reference (audio-sync's `reference`, which need not be the master).
+ *  ANCHORED SET: anchor = opts.anchor ?? the unique role:"master-audio" source ?? none.
+ *   - The anchor's own offsetMs is NEVER changed (the segments are on its clock).
+ *   - Every other provided source s: offsetMs = round((anchor.offsetMs ?? 0) + offsets[s] − (offsets[anchor] ?? 0)).
+ *   - No anchor: offsetMs = round(offsets[s]) verbatim (offsets already relative to the master clock).
+ *  SET, never ADD (re-running is idempotent). Returns a new Edl; never mutates; never throws.
+ *  `ignored[].reason` is a documented open string: "unknown-source" | "not-finite" | "anchor-unknown" | "anchor-not-finite".
+ *  opts.anchor not in edl.sources → NOTHING applied, ignored = [{ sourceId: anchor, reason: "anchor-unknown" }].
+ *  offsets[anchor] present but non-finite → NOTHING applied, ignored = [{ sourceId: anchor, reason: "anchor-not-finite" }]. */
+declare function mergeEdlSourceOffsets(edl: Edl, offsets: Readonly<Record<string, number>>, opts?: {
+    readonly anchor?: string;
+}): {
+    readonly edl: Edl;
+    /** The source the offsets were anchored to — present whenever one resolved (it exists in `edl.sources`). */
+    readonly anchor?: string;
+    /** Source ids whose `offsetMs` was set, in `offsets` key order. */
+    readonly applied: readonly string[];
+    readonly ignored: ReadonlyArray<{
+        readonly sourceId: string;
+        readonly reason: string;
+    }>;
+};
+declare const EDL_FULL_FRAME: EdlRegion;
+interface EdlResolvedSlot {
+    readonly source: string;
+    readonly region: EdlRegion;
+    /** "resolver" = the caller's `regionFor` (v3 per-segment tracks). */
+    readonly regionFrom: "slot" | "segment" | "resolver" | "speaker" | "source" | "full";
+    readonly speaker?: string;
+    readonly weight?: number;
+}
+interface ResolveEdlSlotsOptions {
+    /** speaker-view's per-speaker framing table (a node SETTING, not an EDL field), keyed by (source, speaker) so a
+     *  wide-shot region never lands on a close-up camera framing the same person. */
+    readonly speakerRegions?: ReadonlyArray<{
+        readonly source: string;
+        readonly speaker: string;
+        readonly region: EdlRegion;
+    }>;
+    /** v3 hook: a per-(segment, slot) region, e.g. from a face track. Undefined = no opinion. */
+    readonly regionFor?: (q: {
+        readonly segment: EdlSegment;
+        readonly source: string;
+        readonly speaker?: string;
+    }) => EdlRegion | undefined;
+}
+/** D20 — the ONE region-precedence implementation:
+ *  slot.region ▷ segment.region (single-slot only) ▷ regionFor ▷ speakerRegions[(source, speaker)] ▷ source.region ▷ full frame.
+ *  Slots = layout.slots when non-empty, else ONE implicit slot from segment.video (no video → []).
+ *  A slot's speaker = slot.speaker ?? (single slot ? segment.speaker : undefined); no speaker → the speaker rung is skipped.
+ *  A rung whose region is not a valid in-frame box (finite, 0..1, w/h > 0, x+w ≤ 1, y+h ≤ 1) falls through to the next.
+ *  Unknown source id → the source rung is skipped. Pure; never throws on its own. */
+declare function resolveEdlSegmentSlots(edl: Edl, segment: EdlSegment, opts?: ResolveEdlSlotsOptions): readonly EdlResolvedSlot[];
+
+type EditPlanMode = "tighten" | "clips" | "chapters";
+type EditPlanTier = "economy" | "standard" | "premium";
+declare const EDIT_PLAN_MODES: readonly EditPlanMode[];
+declare const EDIT_PLAN_TIERS: readonly EditPlanTier[];
+/** The coarse duration ladder (MINUTES) a probed source duration rounds UP to;
+ *  the composite credit id carries the bucket. 3 modes × 3 tiers × 6 buckets =
+ *  54 composites (+ the bare `edit-plan`). */
+declare const EDIT_PLAN_BUCKET_MINUTES: readonly number[];
+/** Hard duration cap (design §7.4). */
+declare const EDIT_PLAN_MAX_MINUTES = 180;
+/** `clips` mode: how many clips a plan returns when the caller names no count,
+ *  and the most it may be asked for. One source for the credit estimate, the
+ *  orchestrated payload clamp and the request schema. */
+declare const EDIT_PLAN_DEFAULT_CLIP_COUNT = 8;
+declare const EDIT_PLAN_MAX_CLIP_COUNT = 50;
+/** Clamp a requested clip count into `[1, EDIT_PLAN_MAX_CLIP_COUNT]`; `undefined`
+ *  for anything that is not a positive number (the planner then uses its default). */
+declare function clampEditPlanClipCount(count: unknown): number | undefined;
+/** The bare estimator / DB-down fallback id. */
+declare const EDIT_PLAN_BASE_CREDIT_ID = "edit-plan";
+/** Round a source duration (seconds) UP to the smallest covering ladder bucket
+ *  (capped at the max), in minutes. `undefined` / non-finite → the ceiling
+ *  bucket (the safe over-reserve direction). */
+declare function editPlanBucketMinutes(durationSec: number | undefined): number;
+/** `edit-plan:<mode>:<tier>:<bucket>m`. `durationSec` undefined → the ceiling
+ *  bucket. Single source of truth for the composite id shape. */
+declare function buildEditPlanCreditId(mode: EditPlanMode, tier: EditPlanTier, durationSec?: number): string;
+/** Narrow an arbitrary value to a known edit-plan mode, defaulting to "tighten". */
+declare function asEditPlanMode(v: unknown): EditPlanMode;
+/** Narrow an arbitrary value to a known edit-plan tier, defaulting to "standard". */
+declare function asEditPlanTier(v: unknown): EditPlanTier;
+/**
+ * Unwrap an `edit-plan` job's `output_data` into the value stored on the node's
+ * `data.generatedJson`, which every output extractor then reads. This is the ONE
+ * place the three modes are normalized (the same rule on both engines and every
+ * result-application site, so audit-dag parity can't drift):
+ *   - `clips`    → the BARE `Edl[]` (T5: the `list` fan-out reads `Array.isArray`
+ *                  on `generatedJson`; each element becomes one JSON-stringified
+ *                  item a downstream `edl` input `normalizeEdl`-parses).
+ *   - `chapters` → the `{ version, chapters }` object.
+ *   - `tighten`  → the `Edl` object at top level.
+ *
+ * The cloud relay object-spreads `output_data` and adds `viaNodaroCloud: true`;
+ * that key (and any other bookkeeping) is stripped here. The unwrap lives HERE —
+ * NEVER in `output_data` — because a bare array written into `output_data` would
+ * be corrupted into numeric keys by the relay's object-spread (see `EdlClipSet`).
+ */
+declare function unwrapEditPlanOutput(outputData: unknown): unknown;
+
+/**
+ * "Auto" video duration — the model decides the clip length. The wire value is
+ * KIE's own (`duration: -1`): on a video EDIT the output takes the source
+ * clip's length, on any other run the model picks within its valid range.
+ * Stored in the ordinary numeric `duration` field (node data, routes, presets,
+ * MCP) so every surface that can carry a duration can carry Auto. Which models
+ * accept it is a catalog capability (`MODEL_CATALOG[id].autoDuration`), read
+ * through `supportsAutoVideoDuration`.
+ *
+ * Import-free on purpose: the catalog and the constants module both need it,
+ * and they already depend on each other.
+ */
+declare const VIDEO_DURATION_AUTO = -1;
+declare function isAutoVideoDuration(duration: unknown): boolean;
+
+export { ACCESS_LEVELS, ACTIVE_SCENE_HELPERS, ADVANCED_MODE_UNAVAILABLE_REASON, AGGREGATEABLE_TYPES, AGGREGATE_LANE_SOURCE_TYPES, AI_AVATAR_DURATION_BUCKETS, AI_AVATAR_MAX_AUDIO_SEC, AI_AVATAR_MAX_DURATION_SEC, AI_AVATAR_RESERVE_IDS, AI_WRITER_PROVIDERS, ALA_CARTE_BOARDS, ALL_CAPTION_STYLES, ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER, ASPECT_RATIO_DIMENSIONS, AUDIO_ADDON_PROVIDERS, AUDIO_CROSSFADE_CURVES, AUDIO_CROSSFADE_CURVE_IDS, AUDIO_FX_PRESETS, AUDIO_FX_PRESET_LABELS, AUDIO_FX_PRESET_SET, AUDIO_FX_REVERB_PRESETS, AUDIO_PRODUCER_TYPES, type AccessLevel, type AdCreativeAnalysis, type AddBRollResult, AddBRollResultSchema, type AggregateableType, type AggregationBuckets, type AiAvatarDurationBucket, type AiAvatarEngine, type AiAvatarResolution, type AiWriterProvider, type AlaCarteBoard, type AnalyzedScene, type AnchorSceneStyleResult, AnchorSceneStyleResultSchema, type Animal, type AnimalSubcategory, type AssetRef, AssetRefSchema, type AudioCrossfadeCurve, type AudioFxPreset, type AudioLayer, type AuditImagesResult, AuditImagesResultSchema, type AuditImagesShotEntry, AuditImagesShotEntrySchema, AuditPromptIssueSchema, type AuditPromptResult, AuditPromptResultSchema, AvatarPayloadError, BOARD_TO_ASSET_TYPE, BOARD_TO_COLUMN, BOARD_VARIANTS, type BoardEntityKind, type BoardPromptContext, type BoardTemplate, BridgeToNextSceneInputSchema, type BridgeToNextSceneResult, BridgeToNextSceneResultSchema, type BrowseCommunityParams, type BrowseCommunityResult, CAPTION_LEVER_BOUNDS, CAPTION_LOOKS, CAPTION_LOOK_IDS, CAPTION_MAX_WORDS_PER_LINE_MAX, CAPTION_MAX_WORDS_PER_LINE_MIN, CATEGORY_DURATION_DEFAULTS, CHARACTER_ASPECT_DEFAULTS, CHARACTER_ASPECT_OPTIONS, CHARACTER_ASSET_TYPES, CHARACTER_ASSET_VARIANTS, CHARACTER_ATTACH_COLUMNS, CHARACTER_FACETS, CHARACTER_FACET_IDS, CHARACTER_LORA_TRAINING_JOB_TYPE, CHARACTER_MOTION_PROVIDERS, CHARACTER_PICKER_DISPLAY_ORDER, CHARACTER_REFERENCE_PHOTO_KINDS, CHARACTER_STYLES, CHARACTER_VARIANT_ASSET_BUCKETS, CHAT_ENABLED_STAGES, CHAT_STAGES, CHAT_TURN_CAPS, CHAT_WIRED_STAGES, CINEMATIC_DEFAULT_DURATION_SEC, CINEMATIC_DEFAULT_RESOLUTION, CINEMATIC_MAX_DURATION_SEC, CINEMATIC_MAX_LOOKS, CINEMATIC_MAX_REFERENCE_IMAGES, CINEMATIC_MAX_REFERENCE_VIDEOS, CINEMATIC_MIN_DURATION_SEC, CINEMATIC_MIN_LOOKS, CINEMATIC_PROMPT_MAX, CINEMATIC_RESERVE_IDS, COLLABORATOR_ROLES, COLLECT_IN_HANDLE, COMBINE_TRANSITIONS, COMBINE_TRANSITION_GROUP_LABELS, COMBINE_TRANSITION_GROUP_ORDER, COMBINE_TRANSITION_IDS, COMPOSER_PLAN_FIELDS, COMPOSER_PLAN_MAP, CONTENT_TYPES_BY_PLATFORM, CREATURE_ATTACH_COLUMNS, CREDIT_BASE_USD, CREDIT_ROUNDING_RESOLUTION, type CaptionLookId, type CaptionLookLevers, type CaptionStyle, type CastCoverageCriticVerdict, CastCoverageCriticVerdictSchema, type ChapterSet, type CharacterAspectRatio, type CharacterAssetType, type CharacterAssetTypeForAspect, type CharacterAttachColumn, type CharacterDef, type CharacterFacet, type CharacterImageCriticVerdict, CharacterImageCriticVerdictSchema, type CharacterLoraFields, type CharacterMentionTokenInfo, CharacterMetadataSchema, type CharacterMotionMetadata, type CharacterMotionProvider, type CharacterReferencePhoto, type CharacterReferencePhotoKind, type CharacterVariantAssetBucket, type CharacterVariantAssetItem, type CharacterVoiceSpec, type ChatEnabledStage, type ChatTurnResponse, ChatTurnResponseSchema, type CinematicResolution, type ClipLook, type CloneListingResult, type CollaboratorRole, type CombineTransition, type CombineTransitionGroup, type CombineVideosEstimatorInput, type CommunityCard, type CommunityEntityType, type CommunityFullDetail, type CommunityReportReason, type CommunitySort, type ComponentHandle, type ComponentMetadata, type ConnectedReference, type CreatureAttachColumn, CriticIssueSchema, type CustomEntry, DEFAULT_AUDIO_CROSSFADE_CURVE_ID, DEFAULT_CAPTION_LOOK, DEFAULT_CARRIED_FRACTION, DEFAULT_CHARACTER_ANGLE_COUNT, DEFAULT_CHARACTER_EXPRESSION_COUNT, DEFAULT_CHARACTER_FACET, DEFAULT_FRAME_DELIVERY, DEFAULT_FRAME_FIT, DEFAULT_LABEL_BY_SOURCE, DEFAULT_LOCATION_USAGE_MODE, DEFAULT_OVERLAY_QR, DEFAULT_OVERLAY_SHAPE, DEFAULT_OVERLAY_TEXT, DEFAULT_PANEL_COUNT, DEFAULT_REF_IMAGE_MAX, DEFAULT_SECTIONS, DEFAULT_SUBTITLE_LOOK, DEFAULT_SUNO_MODEL, DEFAULT_TEMPLATE_CATEGORY, DEFAULT_TRANSCRIBE_NODE_PROVIDER, DEFAULT_TRANSCRIBE_PROVIDER, DEFAULT_USAGE_MODE, DEFAULT_VIDEO_ANALYSIS_MODEL, DEFAULT_VIDEO_ANALYSIS_TIER, DEFAULT_VIDEO_CLIP_COST, DEFAULT_VIDEO_DURATION_SEC, DEFAULT_VIDEO_PROVIDER, DEFAULT_VOICE_CHANGER_MODEL, DEFAULT_VOICE_DESIGN_MODEL, DETAIL_VARIANTS, DURATION_PRICED_PROVIDERS, DYNAMIC_PRODUCER_TYPES, type DescribedReference, type DetectionResult, DetectionResultSchema, type DialogueLine, EDIT_PLAN_BASE_CREDIT_ID, EDIT_PLAN_BUCKET_MINUTES, EDIT_PLAN_DEFAULT_CLIP_COUNT, EDIT_PLAN_MAX_CLIP_COUNT, EDIT_PLAN_MAX_MINUTES, EDIT_PLAN_MODES, EDIT_PLAN_TIERS, EDL_FULL_FRAME, EDL_SOURCE_ROLES, EDL_TARGET_ASPECTS, EDL_VERSION, EFFORT_TIER_BUMP, EMOTIONAL_BEAT, ENTITY_ASPECT_DEFAULTS, ENTITY_BUCKET_FIELDS, ENTITY_DB_ID_FIELD, ENTITY_IMAGE_HANDLE_TYPES, ENTITY_KIND_SCALAR_FIELDS, ENTITY_NAME_FIELD, ENTITY_NODE_KINDS, ENTITY_SCALAR_FIELDS, ENTITY_SECTIONS, ENTITY_STATUSES, ENTITY_TABLE, ENTITY_TOOL_RETRY_CAP, ENTITY_TYPES, EXECUTION_DATA_KEYS, EXECUTION_GRAPH_COMPOSED_PARAMETER_TYPES, EXTEND_VIDEO_PROVIDERS, type EditPlanMode, type EditPlanTier, type Edl, type EdlClipSet, type EdlDropped, type EdlLayout, type EdlRegion, type EdlResolvedSlot, type EdlSegment, type EdlSource, type EdlSourceRole, type EdlTargetAspect, type EdlValidation, type EntityKind, type EntityMentionTokenInfo, type EntityMetadata, EntityMetadataSchema, type EntityNodeKind, type EntityReferenceInput, type EntityRejectInput, EntityRejectInputSchema, type EntitySlot, type EntitySlotOwner, type EntityStaleEvent, EntityStaleEventSchema, type EntityStateChangeEvent, EntityStateChangeEventSchema, type EntityStatus, type EntityStudioKind, type EntityStyle, type EntityType, type EvaluateConditionOptions, type ExportedPreset, type ExposableField, type ExposableOutput, type ExposedSetting, type ExtendVideoProvider, type ExtraRefCharacterContext, type ExtraRefInput, FACE_SWAP_PROVIDERS, FAL_LIP_SYNC_PROVIDERS, FAN_OUT_EACH_TYPES, FEATURED_ENTITIES, FILM_BASE_CREDITS, FLEXIBLE_INPUT_LIP_SYNC_PROVIDERS, FLUX2_RES_MP, FLUX_LORA_CHARACTER_MODEL_ID, FRAME_DELIVERIES, FRAME_DELIVERY_BY_PROVIDER, FRAME_FITS, FRAME_FIT_STRETCH_TOLERANCE, FRAME_MODE_ADAPTIVE_ONLY_ASPECT, FRAME_TARGET_HANDLES, FREECUT_EXPORT_COMPLETE, FREECUT_EXPORT_PROGRESS, FREECUT_READY, FREECUT_REQUEST_IMPORT, FURNITURE, FURNITURE_SUBCATEGORY_LABELS, FURNITURE_SUBCATEGORY_ORDER, type FaceSwapProvider, type FanOutCandidate, type FanOutPlan, type FavoriteListingResult, type FeaturedEntity, type FeaturedInstagramOutputs, type FeaturedMetaAdOutputs, type FeedEdge, type FeedMaps, type FeedNode, type FilmCreditEstimate, type FilterListCondition, type FilterListOperator, type FilterOperator, type FixContinuityInput, FixContinuityInputSchema, type FixContinuityResult, FixContinuityResultSchema, type Flux2Model, type FrameDelivery, type FrameFit, type FrameFitPlan, type FreecutExportCompletePayload, type FreecutExportProgressPayload, type FreecutImportFile, type FreecutRequestImportPayload, type FullSelectorMode, type Furniture, type FurnitureSubcategory, GEMINI_OMNI_PROVIDERS, GENERATE_TEXT_DELIMITER, GLOBAL_MAX_DURATION_SECONDS, GRANTED_ACCESS, GROUP_HANDLE_PREFIX, GUIDANCE_SCALE_SUPPORT, GVP_ANCHOR_CHOICES, GVP_DEFAULT_PROVIDER, GVP_END_FRAME_PROVIDERS, GVP_EXTEND_PROVIDERS, GVP_SUPPORTED_PROVIDERS, GenerateMotionInputSchema, type GenerateMotionResult, GenerateMotionResultSchema, type GenericEdge, type GenericNode, type GrantedAccess, type GvpAnchorChoice, type GvpAnchorWireMode, HANDLE_PORT_SEPARATOR, HELPERS_SHIPPED_IN_1B3, HIGH_QUALITY_PROVIDERS, HINT_EXEMPT_PARAMETER_TYPES, type HintEdgeLike, type HintGraphContext, type HintNodeLike, type I18nCatalogId, I2I_MASK_SUPPORT, I2I_STRENGTH_SUPPORT, IDEOGRAM_PROVIDERS, IMAGE_ASPECT_RATIO_VALUES, IMAGE_CRITIC_LEAF_MODES, IMAGE_CRITIC_MAX_RETRIES, IMAGE_CRITIC_METADATA_KEYS, IMAGE_CRITIC_MIN_ADHERENCE_SCORE, IMAGE_CRITIC_MODES, IMAGE_CRITIC_UNRESOLVABLE, IMAGE_EDIT_PROVIDERS, IMAGE_GEN_PROVIDERS, IMAGE_I2I_PROVIDERS, IMAGE_MASK_MODE, IMAGE_OVERLAY_BASE_CREDITS, IMAGE_OVERLAY_VARIANT_CREDITS, IMAGE_PROMPT_MAX, IMAGE_REF_TYPES, IMAGE_TO_VIDEO_PROVIDERS, INPUT_FIELD_MAP, INPUT_NODE_TYPES, INSTAGRAM_ANALYSIS_CREDIT_ID, INSTAGRAM_CAROUSEL_MAX_ITEMS, INSTAGRAM_CAROUSEL_MIN_ITEMS, INSTAGRAM_HOSTS, INSTAGRAM_SCRAPE_CREDIT_COSTS, INSTAGRAM_SCRAPE_DEFAULT_COUNT, INSTAGRAM_SCRAPE_FALLBACK_CREDIT_ID, INSTAGRAM_SCRAPE_MAX_COUNT, INSTAGRAM_SCRAPE_MAX_SOURCES, INSTAGRAM_SCRAPE_MAX_TARGET_LENGTH, INSTAGRAM_SCRAPE_MODES, INSTAGRAM_SCRAPE_NODE_TYPE, INSTAGRAM_SCRAPE_PERIODS, INSTAGRAM_SCRAPE_TIERS, ITER_CLONE_PATTERN, type IdentityFidelity, type IdentityMeta, type ImageAspectRatio, type ImageCriticIssue, ImageCriticIssueSchema, type ImageCriticLeafMode, type ImageCriticMetadataKey, type ImageCriticMode, type ImageCriticNodeIssue, type ImageCriticResult, ImageCriticResultSchema, type ImageCriticVerdict, ImageCriticVerdictSchema, type ImageEditProvider, type ImageGenProvider, type ImageI2IProvider, type ImageMaskMode, type ImageMentionTokenInfo, type ImageToVideoProvider, type ImprovePromptInput, ImprovePromptInputSchema, type ImprovePromptResult, ImprovePromptResultSchema, type InputFieldSchema, type InstagramFormat, type InstagramNodeQuoteFields, type InstagramScrapeMode, type InstagramScrapePeriod, type InstagramScrapeTier, type InvitationDelivery, type InvitationPreview, type InvitationState, type InvitationView, type JoinCodeView, type JsonEvalResult, type JsonFilter, type JsonPatch, KEYFRAME_CREDITS_PER_SHOT, KINETIC_CAPTION_STYLES, KINETIC_ONLY_CAPTION_LEVER_KEYS, type KieApiFormat, type KineticCaptionStyle, type KineticOnlyCaptionLeverKey, LANGUAGES, LEGACY_LOTTIE_HOST_REMAP, LEGACY_TEMPLATE_CATEGORIES, LIP_SYNC_DURATION_BUCKETS, LIP_SYNC_MAX_AUDIO_SECONDS, LIP_SYNC_PROVIDERS, LLM_FEATURE_DEFAULTS, LLM_MODALITY_CAPS, LLM_MODELS, LLM_MODEL_IDS, LLM_REASONING_EFFORTS, LLM_ROUTE_DEFAULTS, LLM_TEXT_INPUT_MAX, LLM_VENDOR_LABELS, LLM_VENDOR_ORDER, LOCATION_ASSET_TYPES, LOCATION_ASSET_VARIANTS, LOCATION_ATMOSPHERE_PROVIDERS, LOCATION_ATTACH_COLUMNS, LOCATION_BUCKET_TO_CATALOG_ID, LOCATION_PRESET_TO_CATALOG, LOCATION_REFERENCE_PHOTO_KINDS, LOCATION_REFERENCE_PHOTO_KIND_LABELS, LOCATION_USAGE_MODES, LOTTIE_OVERLAY_CATALOG, LOTTIE_SLOT_FIELD_PREFIX, type LabeledOption, type LipSyncDurationBucket, type LipSyncProvider, type ListFanOut, type LlmFeature, type LlmModelDef, type LlmModelGroup, type LlmReasoningEffort, type LlmRouteDefaults, type LlmTier, type LlmVendor, type LocalTime, type LocaleCatalogMap, type LocaleDirection, type LocaleId, type LocationAssetType, type LocationAtmosphereProvider, type LocationAttachColumn, type LocationCatalogRef, type LocationImageCriticVerdict, LocationImageCriticVerdictSchema, type LocationMentionTokenInfo, LocationMetadataSchema, type LocationReferencePhotoKind, type LocationUsageMode, LocationsCoverageCriticIssueSchema, type LocationsCoverageCriticVerdict, LocationsCoverageCriticVerdictSchema, type LoopTrimEstimatorInput, type LoopVideoEstimatorInput, type LoraEligibleRef, type LoraRouting, type LottieOverlayCatalogEntry, type LottieSlotField, MAX_CUSTOM_ENTRIES_PER_BOARD, MAX_IMAGE_PROMPT_CHARS_BY_PROVIDER, MAX_LOCATION_VARIANTS, MAX_NEGATIVE_PROMPT_CHARS_BY_PROVIDER, MAX_PANELS_PER_SHEET, MAX_TTS_CHARS_BY_PROVIDER, MAX_VIDEO_PROMPT_CHARS_BY_PROVIDER, MEMBER_STATUSES, META_ADS_ADVERTISER_MAX_RESULTS, META_ADS_ANALYSIS_CREDITS_PER_AD, META_ADS_ANALYSIS_CREDIT_ID, META_ADS_ANALYSIS_FOCUS_MAX, META_ADS_ANALYSIS_TIERS, META_ADS_FORMATS, META_ADS_NODE_MODES, META_ADS_PLATFORMS, META_ADS_SCRAPE_COUNT_OPTIONS, META_ADS_SCRAPE_CREDIT_COSTS, META_ADS_SCRAPE_DEFAULT_COUNT, META_ADS_SCRAPE_DEFAULT_COUNTRY, META_ADS_SCRAPE_FALLBACK_CREDIT_ID, META_ADS_SCRAPE_MAX_COUNT, META_ADS_SCRAPE_MAX_QUERY_LENGTH, META_ADS_SCRAPE_MAX_SOURCES, META_ADS_SCRAPE_MODES, META_ADS_SCRAPE_NODE_TYPE, META_ADS_SCRAPE_PERIODS, META_ADS_SCRAPE_STATUSES, META_ADS_SCRAPE_TIERS, MINIMAX_H3_DEFAULT_RESOLUTION, MINIMAX_H3_PROVIDERS, MODELS_WITH_REFERENCE_IMAGE_SUPPORT, MODEL_CATALOG, MODEL_KINDS, MODEL_PARAM_NODE_TYPES, MODEL_RECOMMENDATIONS, MODIFY_IMAGE_PROVIDERS, MOTION_COLUMN, MOTION_TRANSFER_PROVIDERS, MUSIC_PROVIDERS, type MaskRegionDescriptor, type MatchCutVerdict, MatchCutVerdictSchema, type MeOrganizations, type Member, type MemberStatus, type MetaAdsAdvertiser, type MetaAdsAnalysisTier, type MetaAdsCreativeFormat, type MetaAdsFormat, type MetaAdsNodeMode, type MetaAdsNodeQuoteFields, type MetaAdsNodeSourceFields, type MetaAdsPlatform, type MetaAdsScrapeMode, type MetaAdsScrapePeriod, type MetaAdsScrapeStatus, type MetaAdsScrapeTier, type MetaAdsWireSources, type MinimalEdge, type MinimalNode, type ModelCatalogEntry, type ModelInputAdjustment, type ModelKind, type ModelMenuOption, type ModelMode, type ModelNodeTarget, type ModelPromptingStyle, type ModelRecommendation, type ModelTreeLine, type ModelTreeVariant, type ModelValidationIssue, type ModifyImageProvider, type MotionTransferProviderType, type MusicProvider, NATIVE_ADAPTIVE_ASPECT, NATIVE_NEGATIVE_PROMPT_MODELS, NATIVE_NEGATIVE_VIDEO_PROVIDERS, NEGATIVE_PROMPT_MAX, NODARO_IMPORT_FILES, NODARO_LOAD_TIMELINE, NODARO_LOAD_VIDEO, NODARO_RESET_PROJECT, NODE_DEFAULT_TYPES, NODE_MAPPABLE_FIELDS, NODE_PRESET_EXPORT_KIND, NODE_REF_PATTERN, NON_EN_LOCALE_IDS, NON_PROMPT_TEXT_LANES, NO_SPLIT_DELIMITER, type NodaroLoadTimelinePayload, type NodaroLoadVideoPayload, type NodeDefaultType, type NodeExecutionStateWire, type NodeExecutionStatus, type NodeParamAdjustment, type NodePresetExport, type NormalizedImageGen, type NormalizedModelInput, type NormalizedNodes, type NormalizedVideoRequest, OBJECT_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS, OBJECT_ASSET_TYPES, OBJECT_ASSET_VARIANTS, OBJECT_ATTACH_COLUMNS, OBJECT_MOTION_PROVIDERS, OBJECT_PICKER_NODE_TYPES, ORG_ERROR_CODES, ORG_KINDS, ORG_ROLES, ORG_STATUSES, OUTPUT_BEARING_NODE_STATUSES, OUTPUT_FIELD_MAP, OUTPUT_FORMATS, OVERLAY_ANCHORS, OVERLAY_FONTS, OVERLAY_FONT_IDS, OVERLAY_IMAGE_MASKS, OVERLAY_LAYER_KINDS, OVERLAY_MAX_VARIANTS, OVERLAY_PLATFORMS, OVERLAY_PLATFORM_IDS, OVERLAY_SHAPES, OVERLAY_TEXT_ALIGNS, OVERLAY_VARIANT_HANDLE_PREFIX, type ObjectAspectRatio, type ObjectAssetType, type ObjectAssetTypeForAspect, type ObjectAttachColumn, ObjectMetadataSchema, type ObjectMotionProvider, type ObjectsValidationIssue, type ObjectsValidationResult, OptimizeForModelInputSchema, type OptimizeForModelResult, OptimizeForModelResultSchema, type OrgAuditEntry, type OrgErrorCode, type OrgKind, type OrgMemberView, type OrgPage, type OrgRole, type OrgSettings, OrgSettingsSchema, type OrgStatus, type OrganizationSummary, type OrganizationView, type OutputFormat, type OutputMode, type OutputType, type OverlayAnchor, type OverlayFontId, type OverlayImageEffects, type OverlayImageMask, type OverlayLayerKind, type OverlayPlatformId, type OverlayPlatformPreset, type OverlayPlatformZone, type OverlayQrStyle, type OverlayShape, type OverlayShapeElement, type OverlayShapeStyle, type OverlayTextAlign, type OverlayTextStyle, PARAMETER_NODE_TYPES, PASSTHROUGH_TYPES, PAYG_RETENTION_DAYS, PER_FORMAT_DURATION_BOUNDS, PICKER_TO_COMBINE_TRANSITION, PIPELINE_ACTIVATION_MODES, PIPELINE_FORMATS, PIPELINE_HARD_TIMEOUT_MS, PIPELINE_MODEL_STAGES, PIPELINE_MODES, PIPELINE_OUTPUT_RESOLUTIONS, PIPELINE_PINNABLE_IMAGE_MODELS, PIPELINE_PINNABLE_SCRIPT_LLMS, PIPELINE_PINNABLE_VIDEO_MODELS, PIPELINE_STAGE_NAMES, PIPELINE_STAGE_TIMEOUT_MS, PIPELINE_TYPES, PLACEHOLDER_CHARACTER_NAME, PLATFORM_LABELS, PLATFORM_SPECS, PRESET_APPLY_CLEAR_KEYS, PRESET_EXCLUDED_KEYS, PRESET_LABELS, PRESET_SETTING_KEYS, PRICING_DEFAULT_DURATION_SEC, PRICING_DEFAULT_RESOLUTION, PRO3D_RENDER_ASPECT_RATIOS, PRO3D_RENDER_CREDIT_ID, PRO3D_RENDER_DEFAULT_ENGINE, PRO3D_RENDER_DEFAULT_QUALITY, PRO3D_RENDER_DEFAULT_REPAIR_PASSES, PRO3D_RENDER_DEFAULT_STYLE, PRO3D_RENDER_ENGINES, PRO3D_RENDER_LABEL, PRO3D_RENDER_LIMITS, PRO3D_RENDER_MAX_REPAIR_PASSES, PRO3D_RENDER_MIN_REPAIR_PASSES, PRO3D_RENDER_NODE_TYPE, PRO3D_RENDER_PROMPT_MAX, PRO3D_RENDER_QUALITY_PROFILES, PRO3D_RENDER_SOURCE_KINDS, PRO3D_RENDER_STYLES, PROJECTED_TRIGGER_NODE_TYPES, PROMPT_HARD_CEILING, PROMPT_PREFIX_KEY, PROMPT_SUFFIX_KEY, PROVIDER_DIRECTIVE_DEFAULTS, PROVIDER_PLACEHOLDER_PREFIX, type PanelGenRequest, type PanelRequest, type PanelSource, type PipelineActivationMode, type PipelineCompletedEvent, PipelineCompletedEventSchema, type PipelineConfig, PipelineConfigSchema, type PipelineDriftSummary, PipelineDriftSummarySchema, type PipelineEditorDecisionsReadyEvent, PipelineEditorDecisionsReadyEventSchema, type PipelineEvent, type PipelineForkedEvent, PipelineForkedEventSchema, type PipelineFormat, type PipelineInput, PipelineInputSchema, type PipelineLifecycleEvent, type PipelineMode, type PipelineModelStage, type PipelineMusicReadyEvent, PipelineMusicReadyEventSchema, type PipelineOutputResolution, type PipelinePinnableImageModel, type PipelinePinnableScriptLlm, type PipelinePinnableVideoModel, type PipelineStageName, PipelineStageNameSchema, type PipelineStageStatus, PipelineStageStatusSchema, type PipelineState, PipelineStateSchema, type PipelineStatus, PipelineStatusSchema, type PipelineType, type PixelBox, type PreflightGraphEdge, type PreflightGraphNode, type PresentationItem, type PresetEntry, type PresetSettingKey, type PresetSettings, PresetSettingsSchema, type PriceVariant, type PricedVideoSelection, type Pro3DRenderAspectRatio, type Pro3DRenderCapabilities, type Pro3DRenderEngine, type Pro3DRenderJobOutput, type Pro3DRenderLocalExportSource, type Pro3DRenderPromptSource, type Pro3DRenderQuality, type Pro3DRenderQuote, type Pro3DRenderQuoteLine, type Pro3DRenderResultMetadata, type Pro3DRenderSceneSource, type Pro3DRenderShotStill, type Pro3DRenderSource, type Pro3DRenderSourceInput, type Pro3DRenderSourceKind, type Pro3DRenderSourceResult, type Pro3DRenderStyle, type Pro3DRenderValidationWarning, type ProgressSegment, type ProjectedCatalog, type ProjectedCatalogDimension, type ProjectedCatalogOption, type PromptAffixFields, type PromptAffixes, type ProposedChange, type PublishListingParams, type PublishListingResult, QA_CHECK_PROVIDERS, type QaCheckProvider, type QualityLevel, REASONING_OUTPUT_FLOOR, REDUCE_STRATEGIES, REDUCE_STRATEGY_IDS, REFERENCE_BOARD_PROVIDERS, REFERENCE_BOARD_TEMPLATES, REFERENCE_HANDLE_MAP, REFERENCE_ROLE_PRESETS, REF_HANDLE_CATEGORY, REF_IMAGE_MAX_LIMITS, REF_TOKEN_NAMESPACE_PREFIXES, RENDERING_SPEED_SUPPORT, RENDER_VIDEO_CREDIT_ID, REPEATABLE_NODE_TYPES, REPEAT_PLACEHOLDER, REPLICATE_LIP_SYNC_PROVIDERS, RESERVED_TEMPLATE_VARS, type ReduceMeta, type ReduceStrategy, type ReduceStrategyId, type RefCandidate, type RefModalityEdge, type RefTokenKind, type RefVideoDurationLimit, type ReferenceBoardProvider, type ReferenceModality, type ReferenceSheet, type ReferenceSource, type ReportListingResult, type ResolveCharacterAspectOptions, type ResolveEdlSlotsOptions, type ResolveObjectAspectOptions, type ResolveSeparatorOptions, type ResolvedDialogueVoiceLine, type RouterConditionGroup, SCENE3D_ASSERTION_RESTORED_CODE, SCENE3D_ASSET_KINDS, SCENE3D_ASSET_ROLES, SCENE3D_ASSET_ROLE_KINDS, SCENE3D_AUTHORING_ASSUMPTION_CODE, SCENE3D_AUTHORING_ENGINES, SCENE3D_BASIC_ENGINE, SCENE3D_BASIC_SCHEMA_VERSION, SCENE3D_CAMERA_TRACK_FORMAT, SCENE3D_CAMERA_TRACK_LIMITS, SCENE3D_CAMERA_TRACK_VERSION, SCENE3D_CLAY_LIGHTING_PRESETS, SCENE3D_DEFAULT_ADVANCED_ENGINE, SCENE3D_DEFAULT_DURATION_SECONDS, SCENE3D_DEFAULT_ENTITY_CAPABILITIES, SCENE3D_DEFAULT_FPS, SCENE3D_EDIT_NODE_TYPE, SCENE3D_ENTITY_CAPABILITIES, SCENE3D_ENTITY_ROLES, SCENE3D_GENERATE_NODE_TYPE, SCENE3D_GLB_EXTRAS_ALLOWLIST, SCENE3D_GLB_EXTRAS_ENTITY_ID, SCENE3D_GLB_EXTRAS_MATERIAL_ROLE, SCENE3D_GLB_EXTRAS_SUBPART_ID, SCENE3D_LIMITS, SCENE3D_PLAN_FIELD, SCENE3D_PLAN_TYPE, SCENE3D_PRIMITIVES, SCENE3D_PRIMITIVE_MATERIAL_ROLE, SCENE3D_REMEDY_AUTO_APPLIED_CODE, SCENE3D_RENDERER_ASSET_KINDS, SCENE3D_RENDER_BASE_MAX_PX, SCENE3D_RENDER_TIERS, SCENE3D_RENDER_TIER_MULTIPLIERS, SCENE3D_RENDER_XLARGE_MIN_AREA_PX, SCENE3D_REVIEW_REFUSED_CODE, SCENE3D_REVIEW_UNAVAILABLE_CODE, SCENE3D_REVIEW_UNAVAILABLE_REASONS, SCENE3D_SCHEMA_VERSION, SCENE3D_SCHEMA_VERSION_V2, SCENE3D_SUPPORTED_SCHEMA_VERSIONS, SCENE3D_V2_CONTENT_HASH_EXCLUDED, SCENE3D_V2_ENGINES, SCENE3D_V2_LIMITS, SCENE3D_V2_OVERRIDE_OPERATION_VERSION, SCENE3D_V2_PRIMITIVES, SCENE_HELPER_NAMES, SCHEDULE_EVERY_LIMITS, SCHEDULE_RULE_KINDS, SCHEDULE_TRIGGER_NODE_TYPE, SCRAPER_ACTOR_LABELS, SCRAPER_CREDIT_COSTS, SCRAPER_OUTPUT_FIELDS, SCRIPT_PROVIDERS, SEASONS, SECTION_BOARD, SECTION_KINDS, SEEDANCE_2_5_REF_LIMITS, SEEDANCE_2_CONTINUATION_REF_SEC, SEEDANCE_2_EXTEND_STITCH, SEEDANCE_2_PROVIDERS, SEEDANCE_2_R2V_MAX_AUDIO_SEC_BY_PROVIDER, SEEDANCE_2_R2V_MIN_REF_VIDEO_SEC, SEEDANCE_2_REF_LIMITS, SEEDANCE_LIP_SYNC_PROVIDERS, SEEDANCE_VIDEO_EDIT_PROVIDERS, SEEDANCE_VIDEO_EDIT_SHAPE, SEED_SUPPORT, SEPARATOR_DISPLAY, SEPARATOR_PRESETS, SHEET_ASPECTS, SHEET_BACKGROUNDS, SHEET_PRESETS, SHEET_SKINS, SHEET_TYPES, SHORT_FILM_ANGLE_COUNT, SHORT_FILM_EXPRESSION_COUNT, SHORT_FILM_VARIANT_THRESHOLD_SEC, SLOT_TOKEN_RE, SMART_CUT_WINDOW_DEFAULT, SMART_CUT_WINDOW_MAX, SMART_CUT_WINDOW_MIN, SOCIAL_POST_NODE_TYPES, SOCIAL_VIDEO_HOSTS, SPEAKER_EMPHASIS_STYLES, SPEAKER_LAYOUTS, SPEAKER_LAYOUT_IDS, SPEAKER_SWITCHES, SPEAKER_SWITCH_IDS, STAGE_PATCH_SCHEMA, STATIC_CAPTION_STYLES, STRUCTURAL_SECTIONS, STRUCTURED_VISION_MODELS, STUDIO_DEPENDENT_FRAMES_CAPABILITY, STUDIO_SHOT_TRANSIENT_KEYS, STUDIO_TRANSIENT_KEYS, SUBMISSION_STATUSES, SUNO_ACTIVE_MODELS, SUNO_ADD_TRACK_MODELS, SUNO_DURATION_MODELS, SUNO_FIELD_HANDLE_FIELDS, SUNO_HARD_CEILING, SUNO_LEGACY_MODELS, SUNO_MODELS, SUNO_SELECT_OPERATIONS, SUNO_TEXT_MAX, SUNO_TITLE_MAX, SUNO_TRACK_SOURCE_TYPES, SUNO_VERSION_CREDIT_KEYS, SUNO_VERSION_PRICED_OPERATIONS, SUPPORTED_FONT_NAMES, SURROUND_DIRECTIONS, SWITCHX_BLOCK_FRAMES, SWITCHX_FRAME_TIERS, type SafetyRetryPolicy, type Scene3DAnchor, type Scene3DAssetAnimation, type Scene3DAssetKind, type Scene3DAssetRef, type Scene3DAssetRole, type Scene3DAuthoringDelivery, type Scene3DAuthoringDeliveryMetadata, type Scene3DAuthoringEngine, type Scene3DAuthoringValidation, type Scene3DCamera, type Scene3DCameraChanges, type Scene3DCameraKeyframe, type Scene3DCameraSample, type Scene3DCameraTrackV1, type Scene3DClayLighting, type Scene3DClayLightingPreset, type Scene3DDeliveryWarning, type Scene3DEasing, type Scene3DEditErrorCode, type Scene3DEditOperation, type Scene3DEditOptions, type Scene3DEditResult, type Scene3DEngineChoice, type Scene3DEngineChoiceInput, type Scene3DEngineChoiceRefusalCode, type Scene3DEngineRequestFields, type Scene3DEntityCapability, type Scene3DEntityRole, type Scene3DEntityV2, type Scene3DEntityVisual, type Scene3DInputAsset, type Scene3DJobOutput, type Scene3DJobOutputAny, type Scene3DJobOutputV2, type Scene3DKnownEngine, type Scene3DLighting, type Scene3DLightingChanges, type Scene3DMaterialBinding, type Scene3DNormalizedAssetStats, type Scene3DObject, type Scene3DObjectChanges, type Scene3DObjectKeyframe, type Scene3DOverride, type Scene3DOverrideSpace, type Scene3DParseResult, type Scene3DPlan, type Scene3DPlanV1, type Scene3DPlanV2, type Scene3DPrimitive, type Scene3DProvenance, type Scene3DReference, type Scene3DReferenceKind, type Scene3DReferenceRole, type Scene3DRenderTier, type Scene3DRestoredAssertion, type Scene3DReviewFindings, type Scene3DReviewObjection, type Scene3DReviewRefused, type Scene3DReviewUnavailable, type Scene3DReviewUnavailableReason, type Scene3DReviewVerdict, type Scene3DSemanticIssue, type Scene3DShot, type Scene3DSupportedSchemaVersion, type Scene3DV2EditOperation, type Scene3DV2EditOptions, type Scene3DV2EditResult, type Scene3DV2OverrideInput, type Scene3DV2Primitive, type Scene3DV2ResourceUsage, type SceneData, type SceneHelperName, SceneHelperNameSchema, type SceneInputMode, SceneInputModeSchema, type SceneMetadata, SceneMetadataSchema, type SceneNodeData, SceneNodeDataSchema, SceneSpecSchema, type ScheduleRule, type ScheduleRuleKind, type ScheduleSpec, type ScraperActorId, type ScriptCriticVerdict, ScriptCriticVerdictSchema, type ScriptProvider, type Season, type SectionKind, type SeedanceVideoEditProvider, type SelectorConfig, type SelectorFields, type SelectorMode, type SelectorPredicateOp, type SelectorResult, type SemanticAspectRatio, type SeparatorPreset, SequenceExecutionRequiredError, type SharedListing, type SharedVoice, type SheetAspect, type SheetBackground, type SheetCostEstimate, type SheetEntry, type SheetFlavour, type SheetGenerationPlan, type SheetPreset, type SheetPresetId, type SheetSection, type SheetSkin, type SheetTextData, type SheetType, type ShotElement, type ShotImageElement, type ShotShapeElement, type ShotSpec, ShotSpecSchema, type ShotTextElement, type ShowrunnerPlan, ShowrunnerPlanSchema, type SidecarLoader, type SlotControlDescriptor, type SlotControlKind, type SlotVariation, type SocialMediaContentType, type SocialMediaPlatform, type SocialMediaSpec, type SortDirection, type SortListOptions, type SortType, type SpeakerEmphasisStyle, type SpeakerLayoutSheet, type SpeakerSwitchSheet, type StageAwaitingSubGateEvent, StageAwaitingSubGateEventSchema, type StaticCaptionStyle, type StoryboardCohesionCriticVerdict, StoryboardCohesionCriticVerdictSchema, type StyleDirectives, StyleDirectivesSchema, type SubGateName, SubGateNameSchema, type SubmissionStatus, type SunoAddTrackModel, type SunoModel, type SupportedFontName, type SurroundDirection, type Swatch, T2I_TO_I2I_VARIANT, TASK_CHAINED_EDIT_PROVIDERS, TELEGRAM_TRIGGER_NODE_TYPE, TEMPLATE_CATEGORIES, TEXT_TO_AUDIO_PROVIDERS, TEXT_TO_VIDEO_PROVIDERS, TIER_MAX_PIPELINE_COST_CREDITS, TIER_PIPELINE_PARALLELISM, TILT_CARRIED_FRACTION, TOPAZ_DEFAULT_UPSCALE_FACTOR, TOPAZ_UPSCALE_FACTORS, TRANSCRIBE_LANES, TRANSCRIBE_PROVIDERS, TRANSCRIBE_PROVIDER_CAPABILITIES, TRANSIENT_RUNTIME_KEYS, TTS_PROVIDERS, TTS_TEXT_MAX, TWO_K_RESOLUTION_PROVIDERS, type TemplateCategory, type TextToAudioProvider, type TextToVideoProvider, type TopazUpscaleAdjustment, type TopazUpscaleFactor, type TopazUpscaleResolution, type TranscribeLane, type TranscribeProvider, type Transcript, type TransitionType, TransitionTypeSchema, type TrimVideoEstimatorInput, type TtsProvider, UPSCALE_IMAGE_PROVIDERS, USAGE_GROUP_BYS, USAGE_MODES, type UpscaleImageProvider, type UsageGroupBy, type UsageLogEntry, type UsageMode, type UsageQuery, type UsageReport, type UsageReportRow, type UsageReportTotals, type UsageVarianceRow, VARIABLES_HANDLE_ID, VARIABLE_PRICING_MODELS, VEHICLES, VEHICLE_SUBCATEGORY_LABELS, VEHICLE_SUBCATEGORY_ORDER, VEO_PROVIDERS, VIDEO_ANALYSIS_AUDIO_MODES, VIDEO_ANALYSIS_BUCKET_CREDITS, VIDEO_ANALYSIS_CLIP_TRANSITIONS_IN, VIDEO_ANALYSIS_DEFAULT_VARIATION, VIDEO_ANALYSIS_DURATION_BUCKETS, VIDEO_ANALYSIS_DURATION_TOLERANCE_SEC, VIDEO_ANALYSIS_ENTITY_SOURCES, VIDEO_ANALYSIS_FACELESS_ANGLES, VIDEO_ANALYSIS_LEGACY_MODELS, VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_MAX_DURATION_SEC, VIDEO_ANALYSIS_MAX_SCENE_SEC, VIDEO_ANALYSIS_MAX_VARIATIONS, VIDEO_ANALYSIS_MIXED_TIERS, VIDEO_ANALYSIS_SHOT_ANGLES, VIDEO_ANALYSIS_SPEED_EFFECTS, VIDEO_ANALYSIS_STORY_JUMPS, VIDEO_ANALYSIS_TEXT_KINDS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_LABELS, VIDEO_ANALYSIS_TIER_ORDER, VIDEO_ANALYSIS_TIMES_OF_DAY, VIDEO_ANALYSIS_TRANSITIONS, VIDEO_ANALYSIS_VARIATION_SLUGS, VIDEO_ANALYSIS_VISUAL_EFFECTS, VIDEO_ANALYSIS_WINDOW, VIDEO_AUDIO_CAPABILITY, VIDEO_AUDIT_BUCKET_CREDITS, VIDEO_CLIP_CREDITS, VIDEO_CRITIC_CREDITS_PER_SHOT, VIDEO_CRITIC_FRAME_MODES, VIDEO_CRITIC_MAX_RETRIES, VIDEO_CRITIC_METADATA_KEYS, VIDEO_CRITIC_MIN_ADHERENCE_SCORE, VIDEO_DURATION_AUTO, VIDEO_DURATION_TIERS, VIDEO_GEN_COLLAPSED_T2V_IDS, VIDEO_GEN_PROVIDERS, VIDEO_INPUT_LIP_SYNC_PROVIDERS, VIDEO_LINK_TOLERANT_CONSUMER_TYPES, VIDEO_MODEL_CAPS, VIDEO_MODE_ALIASES, VIDEO_ONLY_PARAMETER_NODE_TYPES, VIDEO_OUTPUT_CANVAS, VIDEO_PRODUCER_TYPES, VIDEO_PROMPT_MAX, VIDEO_PROVIDERS_REQUIRING_IMAGE, VIDEO_PROVIDERS_WITHOUT_DISPATCH, VIDEO_REF_LIMITS_BY_PROVIDER, VIDEO_REF_VIDEO_DURATION_LIMITS, VIDEO_TO_VIDEO_NODE_PROVIDERS, VIDEO_TO_VIDEO_PROVIDERS, VIDEO_UPSCALE_PROVIDERS, VIDEO_UTIL_PRICING, VIDEO_VARIABLE_PRICING, VOICE_CHANGER_MODELS, VOICE_CHANGER_MODEL_IDS, VOICE_DESIGN_MODELS, type ValidateMatchCutInput, ValidateMatchCutInputSchema, type ValidateMatchCutResult, ValidateMatchCutResultSchema, type ValidationField, type Vec3, type Vehicle, type VehicleSubcategory, type VideoAnalysisAudioMode, type VideoAnalysisClipTransitionIn, type VideoAnalysisEntitySource, type VideoAnalysisMixedTier, type VideoAnalysisModelTier, type VideoAnalysisResult, type VideoAnalysisShotAngle, type VideoAnalysisSpeedEffect, type VideoAnalysisTextKind, type VideoAnalysisTier, type VideoAnalysisTransition, type VideoAnalysisVisualEffect, type VideoAudioCapability, type VideoAudioMode, type VideoClipCost, type VideoCriticFrameMode, type VideoCriticMetadataKey, type VideoCriticShotFields, type VideoCriticVerdict, VideoCriticVerdictSchema, type VideoGenProvider, type VideoLinkNodeFields, type VideoLinkPlatform, type VideoModeAlias, type VideoModelCapabilities, type VideoOutputCanvas, type VideoToVideoNodeProvider, type VideoToVideoProvider, type VideoUpscaleProvider, type Voice, type VoiceChangerModel, type VoiceClone, type VoiceDesignModel, type VoiceLibraryParams, type VoiceLibraryResponse, type VoiceMatch, VoiceMatchSchema, type VoiceType, WAN_3_DEFAULT_RESOLUTION, WAN_3_PROVIDERS, WARDROBE_VARIANTS, WEAPONS, WEAPON_SUBCATEGORY_LABELS, WEAPON_SUBCATEGORY_ORDER, WEBHOOK_TRIGGER_NODE_TYPE, WORKFLOW_VISIBILITIES, WORKSPACE_HEADER, WORKSPACE_HEADER_LOWER, WORKSPACE_ROLES, type Weapon, type WeaponSubcategory, type WindowAnalysis, type WindowScene, type WordlessTranscriptFeed, type WorkflowAssetKind, type WorkflowExport, type WorkflowExportCharacter, type WorkflowExportCreature, type WorkflowExportLocation, type WorkflowExportObject, type WorkflowImportReport, type WorkflowImportSkippedAsset, type WorkflowMediaRef, type WorkflowPortability, type WorkflowVisibility, type WorkspaceMemberView, type WorkspaceRole, type WorkspaceSettings, WorkspaceSettingsSchema, type WorkspaceSummary, type WorkspaceView, YOUTUBE_HOSTS, adCreativeAnalysisFrom, aggregateByType, aiAvatarReserveCreditId, alignedFieldList, analyzedSceneSchema, applyDefaultVideoSelection, applyHandleInputOverride, applyRange, applyRangeIndices, applyScene3DEditOperations, applyScene3DV2EditOperations, applySlots, applyVideoAudioToggle, applyVideoNegativePrompt, asEditPlanMode, asEditPlanTier, aspectRatioFromDims, aspectRatioOptionsByKind, aspectRatioToNumber, assembleNarratedVideoCredits, assertCanvasExecutionAllowed, autoStrokeWidth, availableReasoningEfforts, bucketSecondsFromAuditCreditId, bucketSecondsFromCreditId, buildBoardPrompt, buildChildrenByParent, buildConditionVariables, buildCreditModelIdentifier, buildEditPlanCreditId, buildExpressionFromVisual, buildFeedMaps, buildInstagramScrapeCreditId, buildLipSyncCreditId, buildLlmCreditIdentifier, buildMetaAdsScrapeCreditId, buildModelMenu, buildModelTree, buildMotionCreditModelIdentifier, buildNodePresetExport, buildPanelPrompt, buildPro3DRenderSource, buildProgressSegments, buildRangeLabel, buildScraperCreditId, buildVideoAnalysisCreditId, buildVideoAuditCreditId, buildVideoCreditModelIdentifier, calculateCombinedProgress, calculateMonetizationMarkup, calculateMonetizedCost, calculateProgress, canonicalScene3DPlanV2Json, canonicalVarName, captionRoutesToRemotion, centreCropToAspect, characterBoardItems, characterBucketDisplayRank, characterMentionSlug, characterMentionableAssetArrays, characterSheetRefItems, characterVariantAssetArrays, checkRefVideoDurations, cinematicCreditId, clampCinematicDuration, clampEditPlanClipCount, clampInstagramFeaturedIndex, clampMetaAdsFeaturedIndex, clampSmartCutWindow, classifyCreativeFormat, classifyRefToken, cleanOrphanedItems, clearImageCriticMetadata, clearVideoCriticMetadata, clipLookSchema, collectAncestorRefs, combineSameLabelRefs, compactWithRows, computeAggregateLanes, computeFrameFitPlan, computeScene3DPlanV2ContentHash, countRefModalityEdges, creditRangesAll, creditsToUsd, decodeProviderItem, defaultCarriedFraction, defaultResolutionFor, defaultRoleForSource, defaultVideoAspectRatio, deriveLinkedFields, deriveLottieSlotFields, deriveSlotRefs, describeEdgeBehavior, describeMaskRegion, describeNodeAdjustments, describeSlotControl, detectVideoLinkPlatform, dropUnknownBindings, dropUnknownSpeakers, durationsByMode, editPlanBucketMinutes, editPlanSourceDurationSec, edlDurationMs, effectiveReasoningEffort, encodeProviderItem, ensureLocaleCatalogLoaded, entityHydrationColumns, entityMentionSlug, entityMentionSlugForRef, entityScalarFields, entitySlotSchema, entryMatchesQuery, estimateCombineVideosCredits, estimateFilmCredits, estimateLoopTrimAddonCredits, estimateLoopVideoCredits, estimateScriptDurationSec, estimateSheetCost, estimateTrimVideoCredits, evaluateCondition, evaluateConditionGroup, evaluateJsonExpression, evaluateJsonPath, expandExtraRefsToConnectedReferences, expandItemsWithRepeat, extractAllGeneratedResults, extractCharacterLoraFields, extractGeneratedJsonAsList, extractPresetData, extractReferencedLabels, extractVideoDurationFromNode, fanOutTextFeedsPrompt, featuredInstagramOutputs, featuredMetaAdOutputs, fieldKeyFromHandle, filterCloneNodes, findCharacterMentionTokens, findEntityMentionTokens, findImageMentionTokens, findLocationMentionTokens, findSeedance2AudioOverLimit, findWordlessTranscriptFeeds, firstSightExtraRole, flattenItems, getAnimal, getAnimalLabel, getAnimalPromptHint, getAnimalTerm, getAspectRatioOptions, getAudioCrossfadeCurve, getCharacterFacet, getCombineTransition, getCreditRange, getDurationsForModel, getEffectiveRepeatCount, getFeaturedEntities, getFurniture, getFurnitureLabel, getInputFieldSchema, getInputNodes, getItemSortId, getLipSyncMaxAudioSeconds, getLlmModalityCaps, getLlmModel, getLlmTier, getLocaleDirection, getMaxImagePromptChars, getMaxNegativePromptChars, getMaxSunoPromptChars, getMaxSunoStyleChars, getMaxTtsChars, getMaxVideoPromptChars, getModel, getNodeLabel, getNodeResult, getOutputNodes, getOutputType, getParameterValue, getQualityOptions, getResolutionOptions, getRouteReachableNodeIds, getSpeakerLayout, getSpeakerSwitch, getStrategy, getTargetField, getValidValues, getVehicle, getVehicleLabel, getVideoAudioCapability, getWeapon, getWeaponLabel, groupByFamily, groupByKindAndFamily, groupHandleId, groupLlmModelsByVendor, hasContiguousSegmentDurations, hasFeature, hasUrlParserHazard, hexToRgbaArray, hostnameMatchesAllowlist, humanizeSlotSid, imageMentionSlug, imageMentionSlugForRef, imageOverlayBillableVariants, imageOverlayCredits, imageReferenceLimit, inferMusicVideo, instagramAnalysisCreditId, instagramAnalysisTierFrom, instagramScrapeCreditIdFromNode, instagramScrapeMode, instagramScrapeSources, instagramScrapeTier, isAggregateableType, isAutoVideoDuration, isCharacterAspectRatio, isCollectInEdge, isCronExpression, isDefaultSelectorConfig, isEdlTargetAspect, isExpandedClone, isFacebookPageUrl, isFanOutUrlItem, isFlux2Model, isGeminiOmniProvider, isGvpSupportedProvider, isHandleInputWired, isInstagramScrapeCount, isInstagramScrapeMode, isKineticCaptionStyle, isKnownScene3DEngine, isKnownSpeakerEmphasisStyle, isLegacySunoModel, isLocationUsageMode, isMetaAdsFormat, isMetaAdsPlatform, isMetaAdsScrapeCount, isMetaAdsScrapeMode, isMetaCdnImageUrl, isMinimaxH3Provider, isObjectAspectRatio, isOversizedScene, isPaygRetentionActive, isPerSecondLipSyncProvider, isPro3DRenderJobOutput, isPro3DRenderQuote, isPro3DRenderRenderOnly, isProjectedTriggerNodeType, isRtlText, isScene3DAuthoringEngine, isScene3DCameraTrack, isScene3DHttpUrl, isScene3DPlan, isScene3DPlanV1, isScene3DPlanV2, isScene3DReviewUnavailableReason, isScene3DSchemaVersionSupported, isScraperActor, isSeedance2Provider, isSeedanceVideoEditProvider, isSocialVideoUrl, isTemplateCategory, isTiltDirection, isUsageMode, isValidTimezone, isVeoProvider, isVideoAnalysisMixedTier, isVideoAnalysisTier, isWan3Provider, jsonResultToList, knownEntitySlugsFromRefs, knownImageSlugsFromRefs, legacyScheduleToRules, listBoardTemplates, listModels, listSlotSids, liveRowColumn, llmRouteDefaults, localMinuteKey, localTimeIn, locationMentionSlug, locationReferencePhotoKindLabel, locationUsageModeLabel, mapAspectRatio, mapQuality, mapShotIntentToProviderDirectives, matchVariant, matchesCron, matchesCronField, maxSegmentSecFor, maxSegmentsFor, maxVideoDurationSec, measuredCanvasCombinations, mergeClipLook, mergeEdlSourceOffsets, mergeExposedSettings, mergeNodeInputOverrides, metaAdsAdvertisersFrom, metaAdsAnalysisCreditId, metaAdsAnalysisTier, metaAdsAnalysisTierFrom, metaAdsNodeMode, metaAdsScrapeCreditIdFromNode, metaAdsScrapeSources, metaAdsScrapeTier, metaAdsScrapeWireSources, migrateEdgeOutputMode, migrateToItems, minSegmentSecFor, minimalRatioDimensions, modelIdsByKindMode, modelToNodeTarget, modelsForInputMode, modelsWithFeature, motionGraphicsFeature, newScene3DRevisionId, nextScheduleRuns, nodeFeedsAnything, nodeStateMayCarryOutput, normalizeCaptionNumericLevers, normalizeEdl, normalizeLottieLayers, normalizeMinimaxH3Resolution, normalizeModelInput, normalizeNodeModelParams, normalizePinterestUrl, normalizeRoleSlug, normalizeScheduleRule, normalizeScheduleRules, normalizeTemplateCategory, normalizeTranscript, normalizeVideoRequestParams, normalizeWan3Resolution, orderedLlmModels, overlayFontById, overlayImageEffectsSchema, overlayPlatformById, overlayQrStyleSchema, overlayShapeElement, overlayShapeStyleSchema, overlayStrokeSchema, overlayTextStyleSchema, overlayVariantHandle, overlayVariantIdFromHandle, parseAspectToken, parseAttributedDialogue, parseCharacterMentionToken, parseEntityMentionToken, parseGroupHandle, parseHandleId, parseImageMentionToken, parseListExpression, parseLocationMentionToken, parseNodePresetExport, parseNodeRef, parseScene3DCameraTrackJson, parseScene3DPlanV2Json, parseSpeakerEmphasisStyle, pickAiAvatarBucket, pickIds, pickLipSyncBucket, pickSwitchXFrameTier, pickVideoAnalysisBucket, planFanOut, planSheetGeneration, planSheetPanels, preferredInputModeForModel, presentTypes, presetApplyClearKeys, presetDataMatches, presetEntries, previewHorizonMs, pricedOutputDurationSec, pricedVideoSelection, pro3DRenderCoreOutputSchema, pro3DRenderFrameUnit, pro3DRenderJobOutputSchema, pro3DRenderProducedSchemaVersion, pro3DRenderQuoteSchema, pro3DRenderReviewVerdictSchema, pro3DRenderShotStillSchema, pro3DRenderShotStills, pro3DRenderTimingOverrides, qualityOptionsByKind, readPromptAffixes, reasoningOutputFloor, refHandleCategory, referenceModalityForHandle, referenceSheetCreditId, registerCatalogSidecars, registerSidecarLoaders, remapMsThroughEdl, remapTranscriptThroughEdl, renderAnalyzedScene, renderVideoCreditId, requiresSequenceExecution, resetCatalogSidecars, resolutionOptionsByKind, resolveAiAvatarCreditId, resolveAudioCrossfadeCurve, resolveCaptionLevers, resolveCaptionLook, resolveCharacterAspectRatio, resolveCinematicCreditId, resolveConditionValue, resolveDefaultRole, resolveDescription, resolveDialogueVoices, resolveEdlSegmentSlots, resolveEffectiveSourceType, resolveEffectiveTier, resolveEntityAspect, resolveFieldMappings, resolveFrameDelivery, resolveFrameFitAspect, resolveGvpAnchorWire, resolveImageGenCreditIdentifier, resolveIndex, resolveInstagramScrapeCreditId, resolveLabel, resolveListExpression, resolveListFanOut, resolveLlmCreditId, resolveLocationFields, resolveLocationPresetCatalog, resolveLottieOverlaySrc, resolveMetaAdsScrapeCreditId, resolveNodeRefs, resolveNormalizedImageGen, resolveObjectAspectRatio, resolveOutputCanvas, resolvePipelineModel, resolveRelativeWindowToken, resolveScene3DAuthoringEngine, resolveScraperCreditId, resolveSelectorRefs, resolveSeparator, resolveSheetSections, resolveSlideshowTransition, resolveSourceThroughConnectedList, resolveStoredTier, resolveSwitchXCreditId, resolveTemplateCategory, resolveTopazUpscale, resolveVideoAnalysisModel, resolveVideoLinkOutput, resolveVideoModeForInputs, resolveVideoProviderForMode, resolveXfadeName, rewriteSceneBindings, rewriteSlotTokens, rewriteSpeakerSlots, rgbaArrayToHex, roleToPhrase, rotationVec3Schema, ruleMatches, runSelector, safetyRetryPolicy, sanitizeRole, scaleVec3Schema, scene3DAcceptedSchemaVersionsSchema, scene3DAnchorNameSchema, scene3DAnchorSchema, scene3DAnyPlanSchema, scene3DAssetAnimationSchema, scene3DAssetIdSchema, scene3DAssetRefSchema, scene3DCameraChangesSchema, scene3DCameraKeyframeSchema, scene3DCameraSampleSchema, scene3DCameraSchema, scene3DCameraTrackIssues, scene3DCameraTrackObjectSchema, scene3DCameraTrackPlanIssues, scene3DCameraTrackSchema, scene3DClayLightingSchema, scene3DColorSchema, scene3DDeepEqual, scene3DEasingSchema, scene3DEditOperationSchema, scene3DEditOperationsSchema, scene3DEngineIdSchema, scene3DEntityAcceptsOverlay, scene3DEntityCapabilitySchema, scene3DEntityV2Schema, scene3DEntityVisualSchema, scene3DIdSchema, scene3DInputAssetSchema, scene3DInputAssetsForEngine, scene3DInputAssetsSchema, scene3DJsonByteLength, scene3DLightingChangesSchema, scene3DLightingSchema, scene3DMaterialBindingSchema, scene3DMaterialNameSchema, scene3DMaterialRoleSchema, scene3DNodeIdSchema, scene3DNodeNameSchema, scene3DObjectChangesSchema, scene3DObjectKeyframeSchema, scene3DObjectSchema, scene3DOverrideSchema, scene3DPlanIssues, scene3DPlanSchema, scene3DPlanSchemaVersion, scene3DPlanV1Issues, scene3DPlanV1ObjectSchema, scene3DPlanV1Schema, scene3DPlanV2Issues, scene3DPlanV2ObjectSchema, scene3DPlanV2Schema, scene3DPrimitiveSchema, scene3DProjectionIssues, scene3DProvenanceSchema, scene3DReferenceSchema, scene3DRenderTier, scene3DRenderTierCredits, scene3DReviewNote, scene3DReviewVerdictOf, scene3DSampleForFrame, scene3DSha256Schema, scene3DShotForFrame, scene3DShotIndexForFrame, scene3DShotSchema, scene3DUrlSchema, scene3DV2AdmissionIssues, scene3DV2EditOperationSchema, scene3DV2EditOperationsSchema, scene3DV2HierarchyDepth, scene3DV2NormalizationIssues, scene3DV2OverrideInputSchema, scene3DV2ResourceUsage, scene3DVersionTokenSchema, scene3DZodIssues, scheduleMatchesAt, scheduleOccurrences, searchModelVariants, seedance2AudioLimitSec, seedanceVideoEditCreditId, segmentDurationsFor, selectByModulo, selectByNamedKey, selectByPredicate, selectListItems, selectLoraRoutingForMentions, selectRandom, setRegisteredPersonPackFields, settledWithLimit, sizeVec3Schema, slotVariationSchema, sortCharacterEntriesForDisplay, sortListItems, sourceRefKey, speakerLayoutAllows, speakerPresentationWarnings, speakerSwitchOverlaps, speakerTurns, spliceDelimitedRows, splitByLoopDelimiter, splitGeneratedItems, splitInstagramTargets, splitMetaAdsAdvertiserNames, splitMetaAdsPageUrls, spreadJsonArrayIfSingleton, stringifyPathResults, stripDerivedAnalysisFields, stripExportContent, stripStudioTransientSettings, stripTransientRuntimeData, stripUnownedRefs, summarizeScene3DOperations, sunoCreditType, sunoModelHonoursDuration, supportedDefaultDimensions, supportsAdvancedMode, supportsAutoVideoDuration, supportsEndAnchor, supportsExtendRender, templateCategoryStoredValues, timezoneOffsetMinutes, toConnectedReference, toConnectedReferences, togglePick, transcribeLaneSupportsWordTimestamps, transcribeProvidersWithWordTimestamps, transcribeWordTimestampsRefusal, transcriptDurationSec, tryParseJson, uiAspectRatioFill, uiDurationFill, uiResolutionFill, unresolvedRefTokens, unwrapEditPlanOutput, unwrapUnresolvedTokens, usageModeDirective, usageModeIncludesName, usageModeLabel, usdToCredits, validateAiAvatarPayload, validateCinematicAvatarPayload, validateDurationForFormat, validateEdl, validateEdlClipSet, validateModeActivation, validateModelInput, validateNoNestedGroups, validateObjects, validateProviderForNodeType, validateSubWorkflowRoutes, variantJobId, vec3Schema, verifyScene3DPlanV2ContentHash, videoAnalysisCreditSegment, videoAnalysisNumWindows, videoAnalysisResultSchema, videoAuditCreditsForBucket, videoLinkDownloadedFile, videoLinkNeedsDownload, videoModelCanSpeakDialogue, videoModelSupportsAudio, videoNegativeSuffix, videoProviderFoldsLoneEndFrame, videoProviderRequiresImage, windowAnalysisSchema, zipMergeLists };