@mengine/medeo-client 1.2.0 → 1.2.1-alpha.0

package/dist/index-InEWX9rk.d.ts

@@ -0,0 +1,609 @@
+import { z } from "zod";
+
+//#region src/editor/schemas/add-speeches.d.ts
+/**
+ * Add speeches (and their captions). TTS runs upstream; the stable speech /
+ * caption parts arrive materialized (see `speech-assets.ts`). The op writes the
+ * parts and each speech's `{ mode:'anchored', anchorPartId, offsetMs }` fact
+ * verbatim — no write-time host-picking, no cascade (RFC 02 §4). The projection
+ * derives absolute positions on read.
+ */
+declare const addSpeechesInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AddSpeechesInput = z.infer<typeof addSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/add-video-clips.d.ts
+/**
+ * Add video clips to a track. Each clip's duration facts are separated so a
+ * single number is never overloaded (RFC 02 / `reference/16` §0b):
+ *
+ * - `media_duration_ms` is the source media's intrinsic full length (a resource
+ *   fact, written to the part);
+ * - `play_in` / `play_out` are the optional trim window into that media; when
+ *   omitted the whole media is used (`play_in=0`, `play_out=media_duration_ms`).
+ *
+ * The clip's effective timeline duration is derived by the projection from the
+ * trim window and `speed_shift` — it is never an input here.
+ */
+declare const addVideoClipsInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    media_id: z.ZodString;
+    start_ms: z.ZodOptional<z.ZodNumber>;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodOptional<z.ZodNumber>;
+    play_out: z.ZodOptional<z.ZodNumber>;
+    track_id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  before_clip_id: z.ZodOptional<z.ZodString>;
+  after_clip_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AddVideoClipsInput = z.infer<typeof addVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-bgm-volume.d.ts
+declare const adjustBgmVolumeInputSchema: z.ZodObject<{
+  bgm: z.ZodArray<z.ZodObject<{
+    bgm_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustBgmVolumeInput = z.infer<typeof adjustBgmVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-speech-volume.d.ts
+declare const adjustSpeechVolumeInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustSpeechVolumeInput = z.infer<typeof adjustSpeechVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-duration.d.ts
+/**
+ * Re-trim existing video clips (the user-facing "adjust duration" gesture is a
+ * trim of the source window). The new `play_in` / `play_out` are the facts; the
+ * effective timeline duration is derived from them and the clip's `speed_shift`,
+ * and the change reflows downstream clips, speeches, and the timeline inside the
+ * op's transaction (no caller-materialized cascade).
+ */
+declare const adjustVideoClipDurationInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    play_in: z.ZodNumber;
+    play_out: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustVideoClipDurationInput = z.infer<typeof adjustVideoClipDurationInputSchema>;
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-volume.d.ts
+declare const adjustVideoClipVolumeInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AdjustVideoClipVolumeInput = z.infer<typeof adjustVideoClipVolumeInputSchema>;
+//#endregion
+//#region src/editor/schemas/change-speech.d.ts
+/**
+ * Change a speech's script or voice. Both re-run TTS upstream and return the
+ * regenerated speech / caption parts in the same materialized shape as
+ * `AddSpeeches` (`speech-assets.ts`); the op upserts them by id (the speech part
+ * id is preserved across a re-TTS), re-seats at `start_ms`, and reflows. Old
+ * caption parts no longer owned by the speech are removed via `caption_ids`.
+ */
+declare const changeSpeechScriptInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const changeSpeechVoiceInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ChangeSpeechScriptInput = z.infer<typeof changeSpeechScriptInputSchema>;
+type ChangeSpeechVoiceInput = z.infer<typeof changeSpeechVoiceInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-bgm.d.ts
+/**
+ * Remove the document BGM. Pure document edit: clears the bgm lane and removes
+ * the bgm part. Takes no input (a document holds at most one bgm); an empty
+ * object keeps the op signature uniform with the rest.
+ */
+declare const deleteBgmInputSchema: z.ZodObject<{}, z.core.$strip>;
+type DeleteBgmInput = z.infer<typeof deleteBgmInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-speeches.d.ts
+/**
+ * Delete speeches with their captions. Pure document edit (no side effect): the
+ * op removes each speech part, cascade-deletes the captions it owns (via
+ * `caption_ids` / `speech_part_id`), drops their track items, and reflows.
+ */
+declare const deleteSpeechesInputSchema: z.ZodObject<{
+  speech_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type DeleteSpeechesInput = z.infer<typeof deleteSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/delete-video-clips.d.ts
+/**
+ * How a delete handles the anchored subtree (speeches anchored to a deleted clip,
+ * and their captions) — a delete-op policy, not a data-model field (reference/17
+ * §6). `cascade` (default) removes the subtree; `detach` keeps the direct
+ * anchored children, re-pinning them to `absolute` so they stay on the timeline.
+ */
+declare const anchoredDeletePolicySchema: z.ZodEnum<{
+  cascade: "cascade";
+  detach: "detach";
+}>;
+type AnchoredDeletePolicy = z.infer<typeof anchoredDeletePolicySchema>;
+declare const deleteVideoClipsInputSchema: z.ZodObject<{
+  clip_ids: z.ZodArray<z.ZodString>;
+  on_anchored: z.ZodOptional<z.ZodEnum<{
+    cascade: "cascade";
+    detach: "detach";
+  }>>;
+}, z.core.$strip>;
+type DeleteVideoClipsInput = z.infer<typeof deleteVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-speeches.d.ts
+/**
+ * Move speeches in time. Pure document edit: the op re-seats each speech at its
+ * new absolute `start_ms`; the cascade reassigns it to the host video clip,
+ * resolves overlaps, and reflows. Captions follow their speech.
+ */
+declare const moveSpeechesInputSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    new_start_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MoveSpeechesInput = z.infer<typeof moveSpeechesInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-video-clips-by-anchor.d.ts
+/**
+ * Where the moved block lands on the main track.
+ *
+ * A discriminated union rather than two optional `before_clip_id` /
+ * `after_clip_id` fields (the shape `addVideoClips` had to use, because there the
+ * two modes share a whole clip description): here the alternatives carry nothing
+ * in common, so making them mutually exclusive *by type* removes three runtime
+ * `superRefine` checks that would otherwise have to be written and tested.
+ *
+ * `track_start` is an explicit member, not the absence of an anchor. The
+ * agent-harness mutation this maps from treats "neither anchor given" as
+ * "move to the front" (`applyBatchMoveVideoClips` falls back to `insertIndex = 0`),
+ * which is a default buried in a tool description. Requiring the caller to name
+ * that intent keeps a forgotten field from silently reordering the timeline.
+ */
+declare const moveAnchorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  position: z.ZodLiteral<"before">;
+  clip_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  position: z.ZodLiteral<"after">;
+  clip_id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  position: z.ZodLiteral<"track_start">;
+}, z.core.$strip>], "position">;
+/**
+ * What happens to the speeches anchored to the clips being moved.
+ *
+ * - `follow` keeps each speech anchored where it is, so it travels with its clip
+ *   to the new position. In the anchored model this is the *no-op* branch: a
+ *   speech's authoritative fact is `{ anchorPartId, offsetMs }` and its absolute
+ *   time is derived on read from the host's position, so moving the host moves
+ *   the speech with no write to the speech at all.
+ * - `keep_absolute` preserves each speech's current absolute landing instead, then
+ *   re-anchors it to whichever clip now covers that time (RFC 02 §9.1/§11.1). This
+ *   is the branch that costs an extra pass, and the one the FE timeline uses.
+ *
+ * **Required, with no default**, matching `deleteVideoClips` and
+ * `replaceVideoClipSequence`. The two branches decide which picture the user's
+ * narration ends up over, which is too consequential to infer from a missing
+ * field — and neither branch is "safe enough" to be the implicit one.
+ */
+declare const movedClipAnchoredPolicySchema: z.ZodEnum<{
+  follow: "follow";
+  keep_absolute: "keep_absolute";
+}>;
+/**
+ * Reorder a set of main-track clips relative to a reference clip.
+ *
+ * Distinct from `moveVideoClips`, which positions clips by absolute time
+ * (`new_start_ms`) and is what the FE timeline dispatches after a drag. Main-track
+ * clips are `sequential`-positioned, so absolute time is not authoritative state
+ * there (RFC 02 §4/§7): `moveVideoClips` has to *guess* an index back out of the
+ * time it was handed, whereas an anchor already is the ordinal fact being changed.
+ * Keeping them separate also isolates blast radius — this method can diverge on
+ * speech policy without touching the FE path.
+ *
+ * `clip_ids` need not be contiguous. They move as one block, keeping their
+ * relative order, which is the agent-harness `batch_move_video_clips` contract.
+ */
+declare const moveVideoClipsByAnchorInputSchema: z.ZodObject<{
+  clip_ids: z.ZodArray<z.ZodString>;
+  anchor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    position: z.ZodLiteral<"before">;
+    clip_id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    position: z.ZodLiteral<"after">;
+    clip_id: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    position: z.ZodLiteral<"track_start">;
+  }, z.core.$strip>], "position">;
+  on_anchored: z.ZodEnum<{
+    follow: "follow";
+    keep_absolute: "keep_absolute";
+  }>;
+}, z.core.$strip>;
+type MoveAnchor = z.infer<typeof moveAnchorSchema>;
+type MovedClipAnchoredPolicy = z.infer<typeof movedClipAnchoredPolicySchema>;
+type MoveVideoClipsByAnchorInput = z.infer<typeof moveVideoClipsByAnchorInputSchema>;
+//#endregion
+//#region src/editor/schemas/move-video-clips.d.ts
+declare const moveVideoClipsInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    new_start_ms: z.ZodNumber;
+    new_track_id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MoveVideoClipsInput = z.infer<typeof moveVideoClipsInputSchema>;
+//#endregion
+//#region src/editor/schemas/replace-video-clip-content.d.ts
+/**
+ * Replace the media backing existing video clips. The media import runs upstream
+ * (Director); its stable result — the new media id, intrinsic length, and the
+ * reset trim window — arrives materialized (see
+ * `results/phase-4-side-effect-payload-contract.md` §4). Director resets
+ * `play_in=0` / `play_out=media_duration_ms` and clears `speed_shift` on
+ * replacement. The clip `part_id`s (hence their track items) are unchanged; the
+ * editor reflows the main track from the new effective durations.
+ */
+declare const replaceVideoClipContentInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    origin_media_id: z.ZodString;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodNumber;
+    play_out: z.ZodNumber;
+    volume: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ReplaceVideoClipContentInput = z.infer<typeof replaceVideoClipContentInputSchema>;
+//#endregion
+//#region src/editor/schemas/replace-video-clip-sequence.d.ts
+/**
+ * What happens to the speeches anchored to the clips being replaced.
+ *
+ * - `remap` re-anchors each surviving speech to the new clip in the SAME POSITION
+ *   of the sequence, keeping its offset — old[i]'s children become new[i]'s
+ *   children. An old clip with no counterpart (fewer new clips than old) has its
+ *   subtree deleted, because there is nothing left to anchor to.
+ * - `cascade` deletes every anchored speech (and its captions) outright, like
+ *   `deleteVideoClips`.
+ *
+ * **Required, with no default.** The two branches differ in whether the user's
+ * narration survives, and the agent tool that drives this op makes its
+ * `preserve_speeches` flag required for that reason. A default here would let a
+ * caller that forgot the field silently delete speech.
+ */
+declare const anchoredReplacePolicySchema: z.ZodEnum<{
+  cascade: "cascade";
+  remap: "remap";
+}>;
+type AnchoredReplacePolicy = z.infer<typeof anchoredReplacePolicySchema>;
+/**
+ * Replace a contiguous run of main-track clips with a new run.
+ *
+ * A composite of delete + insert that cannot be expressed as the two ops in
+ * sequence, because the anchored speeches have to survive *across* the swap: with
+ * `remap` they are re-anchored positionally, which needs both the old and the new
+ * ids in the same transaction (ADR 0009 — the cascade stays in the editor, callers
+ * never re-wire anchors themselves).
+ *
+ * Duration facts follow `addVideoClips`: `media_duration_ms` is the source's
+ * intrinsic length and the trim window defaults to the whole media. The effective
+ * timeline duration is derived by the projection, never an input.
+ *
+ * `media_id` is optional: omitting it creates a **deliberate empty placeholder
+ * clip** (`origin_media_id: ''`) — structure with no picture. This is the only op
+ * that can produce one, and it is authoritative state, unlike the gap fillers the
+ * read-side solve mints (which never enter the document).
+ */
+declare const replaceVideoClipSequenceInputSchema: z.ZodObject<{
+  old_clip_ids: z.ZodArray<z.ZodString>;
+  new_clips: z.ZodArray<z.ZodObject<{
+    media_id: z.ZodOptional<z.ZodString>;
+    media_duration_ms: z.ZodNumber;
+    play_in: z.ZodOptional<z.ZodNumber>;
+    play_out: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  on_anchored: z.ZodEnum<{
+    cascade: "cascade";
+    remap: "remap";
+  }>;
+}, z.core.$strip>;
+type ReplaceVideoClipSequenceInput = z.infer<typeof replaceVideoClipSequenceInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-bgm.d.ts
+/**
+ * Set the document BGM. The media's stable result (storage key) arrives
+ * materialized from upstream (see
+ * `results/phase-4-side-effect-payload-contract.md` §3). The op upserts the bgm
+ * part and seats it on the bgm lane; its effective length is always the whole
+ * timeline, derived by the projection on read — so there is no `duration_ms`
+ * input or fact (RFC 02 / `reference/16` §0b). A `bgm_id` lets the op replace an
+ * existing bgm part by id.
+ */
+declare const setBgmInputSchema: z.ZodObject<{
+  bgm_id: z.ZodString;
+  audio_storage_key: z.ZodString;
+  origin_media_id: z.ZodString;
+  volume: z.ZodNumber;
+}, z.core.$strip>;
+type SetBgmInput = z.infer<typeof setBgmInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-caption-style.d.ts
+/**
+ * Set the caption visual style. GLOBAL by design: the style applies to every
+ * caption part in the document — it carries NO `caption_id`. This mirrors the FE,
+ * whose caption-style store (`caption-style.ts:persistCaptionStylePatch`) iterates
+ * ALL captions and writes the same normalized style to each; the product has a
+ * single document-wide caption style, not per-caption styling.
+ *
+ * Every field is optional and maps to a `CaptionStyle` attribute (snake_case
+ * IDL). A field present in the input is written to every caption; a field ABSENT
+ * from the input is left untouched on each caption (the editor merges the patch
+ * onto each caption's existing style — this is a value edit, not a full-style
+ * replace, so a partial patch such as "recolor only" does not wipe font size).
+ *
+ * Pure document edit, no cascade — captions keep their positions; only the style
+ * sub-map of each caption part changes.
+ */
+declare const setCaptionStyleInputSchema: z.ZodObject<{
+  font_id: z.ZodOptional<z.ZodString>;
+  font_size: z.ZodOptional<z.ZodNumber>;
+  font_color: z.ZodOptional<z.ZodString>;
+  font_weight: z.ZodOptional<z.ZodNumber>;
+  entrance_animation: z.ZodOptional<z.ZodString>;
+  entrance_animation_duration_ms: z.ZodOptional<z.ZodNumber>;
+  stroke_color: z.ZodOptional<z.ZodString>;
+  stroke_width: z.ZodOptional<z.ZodNumber>;
+  position_x: z.ZodOptional<z.ZodNumber>;
+  position_y: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SetCaptionStyleInput = z.infer<typeof setCaptionStyleInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-caption-visibility.d.ts
+/**
+ * Toggle caption visibility (the caption track's `is_hidden` flag). Pure
+ * document edit, no cascade — captions keep their positions; only the lane's
+ * hidden flag changes.
+ */
+declare const setCaptionVisibilityInputSchema: z.ZodObject<{
+  is_hidden: z.ZodBoolean;
+}, z.core.$strip>;
+type SetCaptionVisibilityInput = z.infer<typeof setCaptionVisibilityInputSchema>;
+//#endregion
+//#region src/editor/schemas/set-video-clip-speed-shift.d.ts
+/**
+ * Set the playback speed of existing video clips. Per the speed-shift decision
+ * (`reference/16` §0): the op writes only the `speed_shift` fact — it does NOT
+ * store an effective `duration_ms` (projection derives it from the trim window /
+ * speed) and does NOT scale anchored speeches' relative offsets (offsets stay
+ * put; the cascade reflows absolute positions). A `null` speed_shift clears the
+ * speed back to original (1×).
+ */
+declare const setVideoClipSpeedShiftInputSchema: z.ZodObject<{
+  clips: z.ZodArray<z.ZodObject<{
+    clip_id: z.ZodString;
+    speed_shift: z.ZodNullable<z.ZodObject<{
+      category: z.ZodEnum<{
+        curve: "curve";
+        linear: "linear";
+      }>;
+      mode: z.ZodString;
+      config: z.ZodUnion<readonly [z.ZodObject<{
+        linear: z.ZodObject<{
+          speed: z.ZodNumber;
+        }, z.core.$strip>;
+      }, z.core.$strip>, z.ZodObject<{
+        curve: z.ZodObject<{
+          keyframes: z.ZodArray<z.ZodObject<{
+            position: z.ZodNumber;
+            rate: z.ZodNumber;
+            in_tangent: z.ZodOptional<z.ZodObject<{
+              x: z.ZodNumber;
+              y: z.ZodNumber;
+            }, z.core.$strip>>;
+            out_tangent: z.ZodOptional<z.ZodObject<{
+              x: z.ZodNumber;
+              y: z.ZodNumber;
+            }, z.core.$strip>>;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SetVideoClipSpeedShiftInput = z.infer<typeof setVideoClipSpeedShiftInputSchema>;
+//#endregion
+//#region src/editor/schemas/shared.d.ts
+declare const clipIdSchema: z.ZodString;
+declare const clipIdsSchema: z.ZodArray<z.ZodString>;
+declare const mediaIdSchema: z.ZodString;
+declare const speechIdSchema: z.ZodString;
+declare const timelineMsSchema: z.ZodNumber;
+declare const positiveMsSchema: z.ZodNumber;
+declare const volumeSchema: z.ZodNumber;
+declare const speechIdsSchema: z.ZodArray<z.ZodString>;
+/**
+ * A clip's playback-speed fact, the only thing `SetVideoClipSpeedShift` writes.
+ * Mirrors the IDL `SpeedShift`: `category` is `linear` | `curve`, and `config`
+ * is a discriminated union — `{ linear: { speed } }` for a constant multiplier
+ * (the multiplier projection reads at `config.linear.speed`) or `{ curve: {
+ * keyframes } }` for a Bezier-controlled variable speed (RFC 02 / `reference/16`
+ * §0). Exactly one of `linear` / `curve` is present.
+ */
+declare const speedShiftSchema: z.ZodObject<{
+  category: z.ZodEnum<{
+    curve: "curve";
+    linear: "linear";
+  }>;
+  mode: z.ZodString;
+  config: z.ZodUnion<readonly [z.ZodObject<{
+    linear: z.ZodObject<{
+      speed: z.ZodNumber;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    curve: z.ZodObject<{
+      keyframes: z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        rate: z.ZodNumber;
+        in_tangent: z.ZodOptional<z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>>;
+        out_tangent: z.ZodOptional<z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>]>;
+}, z.core.$strip>;
+declare const voiceSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>;
+//#endregion
+//#region src/editor/schemas/speech-assets.d.ts
+/**
+ * The materialized TTS result shared by `AddSpeeches` / `ChangeSpeechScript` /
+ * `ChangeSpeechVoice` (see `results/phase-4-side-effect-payload-contract.md`
+ * §1/§2). The side effect (TTS/ASR + billing) runs upstream; the op receives the
+ * stable speech + caption parts and writes them as authoritative facts. No
+ * cascade runs on write — the projection derives absolute positions on read.
+ *
+ * Each speech carries the anchoring fact directly (RFC 02 §4): the host video
+ * clip `anchor_part_id` and the `offset_ms` within it. The upstream caller
+ * already knows which clip a speech attaches to, so the op writes
+ * `{ mode:'anchored', anchorPartId, offsetMs }` verbatim — no write-time
+ * host-picking. Captions anchor to their speech via the caption part's
+ * `start_ms` (offset within the speech).
+ */
+declare const speechAssetSchema: z.ZodObject<{
+  speech_id: z.ZodString;
+  anchor_part_id: z.ZodString;
+  offset_ms: z.ZodNumber;
+  audio_storage_key: z.ZodString;
+  duration_ms: z.ZodNumber;
+  audio_script: z.ZodString;
+  volume: z.ZodNumber;
+  voice: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strip>;
+  origin_speech_id: z.ZodString;
+  caption_ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const captionAssetSchema: z.ZodObject<{
+  caption_id: z.ZodString;
+  speech_part_id: z.ZodString;
+  text: z.ZodString;
+  start_ms: z.ZodNumber;
+  duration_ms: z.ZodNumber;
+}, z.core.$strip>;
+/** A materialized speech-subtree write (speeches + their captions). */
+declare const speechAssetsSchema: z.ZodObject<{
+  speeches: z.ZodArray<z.ZodObject<{
+    speech_id: z.ZodString;
+    anchor_part_id: z.ZodString;
+    offset_ms: z.ZodNumber;
+    audio_storage_key: z.ZodString;
+    duration_ms: z.ZodNumber;
+    audio_script: z.ZodString;
+    volume: z.ZodNumber;
+    voice: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$strip>;
+    origin_speech_id: z.ZodString;
+    caption_ids: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  captions: z.ZodArray<z.ZodObject<{
+    caption_id: z.ZodString;
+    speech_part_id: z.ZodString;
+    text: z.ZodString;
+    start_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SpeechAsset = z.infer<typeof speechAssetSchema>;
+type CaptionAsset = z.infer<typeof captionAssetSchema>;
+type SpeechAssets = z.infer<typeof speechAssetsSchema>;
+declare namespace index_d_exports {
+  export { AddSpeechesInput, AddVideoClipsInput, AdjustBgmVolumeInput, AdjustSpeechVolumeInput, AdjustVideoClipDurationInput, AdjustVideoClipVolumeInput, AnchoredDeletePolicy, AnchoredReplacePolicy, CaptionAsset, ChangeSpeechScriptInput, ChangeSpeechVoiceInput, DeleteBgmInput, DeleteSpeechesInput, DeleteVideoClipsInput, MoveAnchor, MoveSpeechesInput, MoveVideoClipsByAnchorInput, MoveVideoClipsInput, MovedClipAnchoredPolicy, ReplaceVideoClipContentInput, ReplaceVideoClipSequenceInput, SetBgmInput, SetCaptionStyleInput, SetCaptionVisibilityInput, SetVideoClipSpeedShiftInput, SpeechAsset, SpeechAssets, addSpeechesInputSchema, addVideoClipsInputSchema, adjustBgmVolumeInputSchema, adjustSpeechVolumeInputSchema, adjustVideoClipDurationInputSchema, adjustVideoClipVolumeInputSchema, anchoredDeletePolicySchema, anchoredReplacePolicySchema, changeSpeechScriptInputSchema, changeSpeechVoiceInputSchema, clipIdSchema, clipIdsSchema, deleteBgmInputSchema, deleteSpeechesInputSchema, deleteVideoClipsInputSchema, mediaIdSchema, moveAnchorSchema, moveSpeechesInputSchema, moveVideoClipsByAnchorInputSchema, moveVideoClipsInputSchema, movedClipAnchoredPolicySchema, positiveMsSchema, replaceVideoClipContentInputSchema, replaceVideoClipSequenceInputSchema, setBgmInputSchema, setCaptionStyleInputSchema, setCaptionVisibilityInputSchema, setVideoClipSpeedShiftInputSchema, speechAssetsSchema, speechIdSchema, speechIdsSchema, speedShiftSchema, timelineMsSchema, voiceSchema, volumeSchema };
+}
+//#endregion
+export { adjustVideoClipVolumeInputSchema as $, MoveVideoClipsInput as A, AnchoredDeletePolicy as B, setBgmInputSchema as C, replaceVideoClipSequenceInputSchema as D, anchoredReplacePolicySchema as E, moveAnchorSchema as F, deleteSpeechesInputSchema as G, anchoredDeletePolicySchema as H, moveVideoClipsByAnchorInputSchema as I, ChangeSpeechScriptInput as J, DeleteBgmInput as K, movedClipAnchoredPolicySchema as L, MoveAnchor as M, MoveVideoClipsByAnchorInput as N, ReplaceVideoClipContentInput as O, MovedClipAnchoredPolicy as P, AdjustVideoClipVolumeInput as Q, MoveSpeechesInput as R, SetBgmInput as S, ReplaceVideoClipSequenceInput as T, deleteVideoClipsInputSchema as U, DeleteVideoClipsInput as V, DeleteSpeechesInput as W, changeSpeechScriptInputSchema as X, ChangeSpeechVoiceInput as Y, changeSpeechVoiceInputSchema as Z, setVideoClipSpeedShiftInputSchema as _, speechAssetsSchema as a, adjustBgmVolumeInputSchema as at, SetCaptionStyleInput as b, mediaIdSchema as c, AddSpeechesInput as ct, speechIdsSchema as d, AdjustVideoClipDurationInput as et, speedShiftSchema as f, SetVideoClipSpeedShiftInput as g, volumeSchema as h, SpeechAssets as i, AdjustBgmVolumeInput as it, moveVideoClipsInputSchema as j, replaceVideoClipContentInputSchema as k, positiveMsSchema as l, addSpeechesInputSchema as lt, voiceSchema as m, CaptionAsset as n, AdjustSpeechVolumeInput as nt, clipIdSchema as o, AddVideoClipsInput as ot, timelineMsSchema as p, deleteBgmInputSchema as q, SpeechAsset as r, adjustSpeechVolumeInputSchema as rt, clipIdsSchema as s, addVideoClipsInputSchema as st, index_d_exports as t, adjustVideoClipDurationInputSchema as tt, speechIdSchema as u, SetCaptionVisibilityInput as v, AnchoredReplacePolicy as w, setCaptionStyleInputSchema as x, setCaptionVisibilityInputSchema as y, moveSpeechesInputSchema as z };