@cutcraft/kit 0.0.0-stage → 0.1.0

package/dist/index-CLhXqOpF.d.mts

@@ -0,0 +1,1281 @@
+import { z } from "zod";
+declare const TRACK_LAYOUTS: readonly ["sequence", "free"];
+declare const TRACK_ROLES: readonly ["general", "captions", "dialogue", "music", "effects", "ambience"];
+declare const FIT_MODES: readonly ["contain", "cover", "stretch", "none"];
+declare const BLEND_MODES: readonly ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity", "add", "linear-dodge"];
+declare const EASINGS: readonly ["linear", "ease", "ease-in", "ease-out", "ease-in-out", "hold", "bezier", "smoothstep", "smootherstep", "snappy", "smooth", "spring", "easeInQuad", "easeOutQuad", "easeInOutQuad", "easeInCubic", "easeOutCubic", "easeInOutCubic", "easeInQuart", "easeOutQuart", "easeInOutQuart", "easeInQuint", "easeOutQuint", "easeInOutQuint", "easeInSine", "easeOutSine", "easeInOutSine", "easeInExpo", "easeOutExpo", "easeInOutExpo", "easeInCirc", "easeOutCirc", "easeInOutCirc", "easeInBack", "easeOutBack", "easeInOutBack", "easeInBackStrong", "easeOutBackStrong", "easeInOutBackStrong", "easeInElastic", "easeOutElastic", "easeInOutElastic", "easeInElasticSoft", "easeOutElasticSoft", "easeInOutElasticSoft", "easeInBounce", "easeOutBounce", "easeInOutBounce", "easeInBounceSmall", "easeOutBounceSmall", "easeInOutBounceSmall"];
+declare const MASK_EASINGS: readonly ["linear", "ease-in", "ease-out", "ease-in-out"];
+declare const TRANSITION_TYPES: readonly ["crossfade", "dipToBlack", "dipToWhite", "wipe", "slide", "zoom", "push", "circleReveal", "blur", "whipPan", "radialWipe", "pixelate", "glitch", "blinds", "diamondReveal", "spin", "flip", "splitReveal", "flash", "filmBurn", "mosaic", "ripple", "pageTurn", "colorSplit"];
+declare const VIDEO_EFFECT_TYPES: readonly ["brightness", "contrast", "saturation", "hue", "temperature", "tint", "blur", "sharpen", "vignette", "grain", "shadow", "glow", "motion-blur", "radial-blur", "chromatic-aberration", "grayscale", "sepia", "invert", "levels", "hue-saturation"];
+declare const AUDIO_EFFECT_TYPES: readonly ["gain", "pan", "eq", "compressor", "reverb", "delay", "noiseReduction", "fadeIn", "fadeOut"];
+declare const TEXT_ANIMATION_PRESETS: readonly ["none", "typewriter", "fade", "slide-up", "slide-down", "slide-left", "slide-right", "scale", "blur", "bounce", "rotate", "pop", "flip", "split", "word-by-word", "rise", "drop", "elastic", "swing", "zoom-blur", "cascade", "wave", "shake", "rainbow", "glitch"];
+declare const CAPTION_ANIMATIONS: readonly ["none", "word-highlight", "word-by-word", "karaoke", "bounce", "typewriter"];
+declare const GRAPHIC_ANIMATIONS: readonly ["none", "fade", "slide-left", "slide-right", "slide-up", "slide-down", "scale", "rotate", "bounce", "pop", "draw", "wipe-left", "wipe-right", "wipe-up", "wipe-down", "reveal-center", "reveal-edges", "elastic", "flip-horizontal", "flip-vertical"];
+declare const EMPHASIS_ANIMATIONS: readonly ["none", "pulse", "shake", "bounce", "float", "spin", "flash", "heartbeat", "swing", "wobble", "jello", "rubber-band", "tada", "vibrate", "flicker", "glow", "breathe", "wave", "tilt", "zoom-pulse", "focus-zoom", "pan-left", "pan-right", "pan-up", "pan-down", "ken-burns"];
+declare const SHAPE_TYPES: readonly ["rectangle", "circle", "ellipse", "triangle", "arrow", "line", "polygon", "path", "star"];
+declare const KEYFRAME_PROPERTIES: readonly ["transform.position.x", "transform.position.y", "transform.position.z", "transform.scale.x", "transform.scale.y", "transform.rotation", "transform.rotation.x", "transform.rotation.y", "transform.perspective", "transform.opacity", "transform.anchor.x", "transform.anchor.y", "transform.borderRadius", "transform.crop.x", "transform.crop.y", "transform.crop.width", "transform.crop.height", "audio.volume", "audio.pan", "colorGrade.temperature", "colorGrade.tint", "path"];
+/** `effect.<effectId>.<param>` is also a valid keyframe property; see `isKeyframeProperty`. */
+declare const KEYFRAME_PROPERTY_PATTERN: RegExp;
+declare function isKeyframeProperty(value: string): boolean;
+declare const CAPTION_POSITIONS: readonly ["top", "center", "bottom"];
+declare const TEXT_ALIGNS: readonly ["left", "center", "right", "justify"];
+declare const TEXT_VALIGNS: readonly ["top", "middle", "bottom"];
+declare const TEXT_DECORATIONS: readonly ["none", "underline", "line-through", "overline"];
+declare const ANIMATION_UNITS: readonly ["character", "word", "line"];
+declare const MASK_TYPES: readonly ["shape", "drawn", "matte"];
+declare const MATTE_CHANNELS: readonly ["alpha", "luminance", "bounds"];
+declare const INTERPOLATION_QUALITIES: readonly ["low", "medium", "high"];
+declare const STABILIZE_CROP_MODES: readonly ["auto", "none"];
+declare const SVG_COLOR_MODES: readonly ["none", "tint", "replace"];
+declare const AUTOMATION_LANES: readonly ["volume", "pan"];
+declare const TRACK_FLAGS: readonly ["locked", "hidden", "muted", "solo"];
+declare const zTrackLayout: z.ZodEnum<{
+  sequence: "sequence";
+  free: "free";
+}>;
+declare const zTrackRole: z.ZodEnum<{
+  general: "general";
+  captions: "captions";
+  dialogue: "dialogue";
+  music: "music";
+  effects: "effects";
+  ambience: "ambience";
+}>;
+declare const zFitMode: z.ZodEnum<{
+  contain: "contain";
+  cover: "cover";
+  stretch: "stretch";
+  none: "none";
+}>;
+declare const zBlendMode: z.ZodEnum<{
+  normal: "normal";
+  multiply: "multiply";
+  screen: "screen";
+  overlay: "overlay";
+  darken: "darken";
+  lighten: "lighten";
+  "color-dodge": "color-dodge";
+  "color-burn": "color-burn";
+  "hard-light": "hard-light";
+  "soft-light": "soft-light";
+  difference: "difference";
+  exclusion: "exclusion";
+  hue: "hue";
+  saturation: "saturation";
+  color: "color";
+  luminosity: "luminosity";
+  add: "add";
+  "linear-dodge": "linear-dodge";
+}>;
+declare const zEasing: z.ZodEnum<{
+  linear: "linear";
+  ease: "ease";
+  "ease-in": "ease-in";
+  "ease-out": "ease-out";
+  "ease-in-out": "ease-in-out";
+  hold: "hold";
+  bezier: "bezier";
+  smoothstep: "smoothstep";
+  smootherstep: "smootherstep";
+  snappy: "snappy";
+  smooth: "smooth";
+  spring: "spring";
+  easeInQuad: "easeInQuad";
+  easeOutQuad: "easeOutQuad";
+  easeInOutQuad: "easeInOutQuad";
+  easeInCubic: "easeInCubic";
+  easeOutCubic: "easeOutCubic";
+  easeInOutCubic: "easeInOutCubic";
+  easeInQuart: "easeInQuart";
+  easeOutQuart: "easeOutQuart";
+  easeInOutQuart: "easeInOutQuart";
+  easeInQuint: "easeInQuint";
+  easeOutQuint: "easeOutQuint";
+  easeInOutQuint: "easeInOutQuint";
+  easeInSine: "easeInSine";
+  easeOutSine: "easeOutSine";
+  easeInOutSine: "easeInOutSine";
+  easeInExpo: "easeInExpo";
+  easeOutExpo: "easeOutExpo";
+  easeInOutExpo: "easeInOutExpo";
+  easeInCirc: "easeInCirc";
+  easeOutCirc: "easeOutCirc";
+  easeInOutCirc: "easeInOutCirc";
+  easeInBack: "easeInBack";
+  easeOutBack: "easeOutBack";
+  easeInOutBack: "easeInOutBack";
+  easeInBackStrong: "easeInBackStrong";
+  easeOutBackStrong: "easeOutBackStrong";
+  easeInOutBackStrong: "easeInOutBackStrong";
+  easeInElastic: "easeInElastic";
+  easeOutElastic: "easeOutElastic";
+  easeInOutElastic: "easeInOutElastic";
+  easeInElasticSoft: "easeInElasticSoft";
+  easeOutElasticSoft: "easeOutElasticSoft";
+  easeInOutElasticSoft: "easeInOutElasticSoft";
+  easeInBounce: "easeInBounce";
+  easeOutBounce: "easeOutBounce";
+  easeInOutBounce: "easeInOutBounce";
+  easeInBounceSmall: "easeInBounceSmall";
+  easeOutBounceSmall: "easeOutBounceSmall";
+  easeInOutBounceSmall: "easeInOutBounceSmall";
+}>;
+declare const zMaskEasing: z.ZodEnum<{
+  linear: "linear";
+  "ease-in": "ease-in";
+  "ease-out": "ease-out";
+  "ease-in-out": "ease-in-out";
+}>;
+declare const zTransitionType: z.ZodEnum<{
+  crossfade: "crossfade";
+  dipToBlack: "dipToBlack";
+  dipToWhite: "dipToWhite";
+  wipe: "wipe";
+  slide: "slide";
+  zoom: "zoom";
+  push: "push";
+  circleReveal: "circleReveal";
+  blur: "blur";
+  whipPan: "whipPan";
+  radialWipe: "radialWipe";
+  pixelate: "pixelate";
+  glitch: "glitch";
+  blinds: "blinds";
+  diamondReveal: "diamondReveal";
+  spin: "spin";
+  flip: "flip";
+  splitReveal: "splitReveal";
+  flash: "flash";
+  filmBurn: "filmBurn";
+  mosaic: "mosaic";
+  ripple: "ripple";
+  pageTurn: "pageTurn";
+  colorSplit: "colorSplit";
+}>;
+declare const zVideoEffectType: z.ZodEnum<{
+  hue: "hue";
+  saturation: "saturation";
+  blur: "blur";
+  brightness: "brightness";
+  contrast: "contrast";
+  temperature: "temperature";
+  tint: "tint";
+  sharpen: "sharpen";
+  vignette: "vignette";
+  grain: "grain";
+  shadow: "shadow";
+  glow: "glow";
+  "motion-blur": "motion-blur";
+  "radial-blur": "radial-blur";
+  "chromatic-aberration": "chromatic-aberration";
+  grayscale: "grayscale";
+  sepia: "sepia";
+  invert: "invert";
+  levels: "levels";
+  "hue-saturation": "hue-saturation";
+}>;
+declare const zAudioEffectType: z.ZodEnum<{
+  gain: "gain";
+  pan: "pan";
+  eq: "eq";
+  compressor: "compressor";
+  reverb: "reverb";
+  delay: "delay";
+  noiseReduction: "noiseReduction";
+  fadeIn: "fadeIn";
+  fadeOut: "fadeOut";
+}>;
+declare const zTextAnimationPreset: z.ZodEnum<{
+  none: "none";
+  blur: "blur";
+  glitch: "glitch";
+  flip: "flip";
+  typewriter: "typewriter";
+  fade: "fade";
+  "slide-up": "slide-up";
+  "slide-down": "slide-down";
+  "slide-left": "slide-left";
+  "slide-right": "slide-right";
+  scale: "scale";
+  bounce: "bounce";
+  rotate: "rotate";
+  pop: "pop";
+  split: "split";
+  "word-by-word": "word-by-word";
+  rise: "rise";
+  drop: "drop";
+  elastic: "elastic";
+  swing: "swing";
+  "zoom-blur": "zoom-blur";
+  cascade: "cascade";
+  wave: "wave";
+  shake: "shake";
+  rainbow: "rainbow";
+}>;
+declare const zCaptionAnimation: z.ZodEnum<{
+  none: "none";
+  typewriter: "typewriter";
+  bounce: "bounce";
+  "word-by-word": "word-by-word";
+  "word-highlight": "word-highlight";
+  karaoke: "karaoke";
+}>;
+declare const zGraphicAnimation: z.ZodEnum<{
+  none: "none";
+  fade: "fade";
+  "slide-up": "slide-up";
+  "slide-down": "slide-down";
+  "slide-left": "slide-left";
+  "slide-right": "slide-right";
+  scale: "scale";
+  bounce: "bounce";
+  rotate: "rotate";
+  pop: "pop";
+  elastic: "elastic";
+  draw: "draw";
+  "wipe-left": "wipe-left";
+  "wipe-right": "wipe-right";
+  "wipe-up": "wipe-up";
+  "wipe-down": "wipe-down";
+  "reveal-center": "reveal-center";
+  "reveal-edges": "reveal-edges";
+  "flip-horizontal": "flip-horizontal";
+  "flip-vertical": "flip-vertical";
+}>;
+declare const zEmphasisAnimation: z.ZodEnum<{
+  none: "none";
+  spin: "spin";
+  flash: "flash";
+  glow: "glow";
+  bounce: "bounce";
+  swing: "swing";
+  wave: "wave";
+  shake: "shake";
+  pulse: "pulse";
+  float: "float";
+  heartbeat: "heartbeat";
+  wobble: "wobble";
+  jello: "jello";
+  "rubber-band": "rubber-band";
+  tada: "tada";
+  vibrate: "vibrate";
+  flicker: "flicker";
+  breathe: "breathe";
+  tilt: "tilt";
+  "zoom-pulse": "zoom-pulse";
+  "focus-zoom": "focus-zoom";
+  "pan-left": "pan-left";
+  "pan-right": "pan-right";
+  "pan-up": "pan-up";
+  "pan-down": "pan-down";
+  "ken-burns": "ken-burns";
+}>;
+declare const zShapeType: z.ZodEnum<{
+  rectangle: "rectangle";
+  circle: "circle";
+  ellipse: "ellipse";
+  triangle: "triangle";
+  arrow: "arrow";
+  line: "line";
+  polygon: "polygon";
+  path: "path";
+  star: "star";
+}>;
+declare const zKeyframeProperty: z.ZodString;
+type TrackLayout = (typeof TRACK_LAYOUTS)[number];
+type TrackRole = (typeof TRACK_ROLES)[number];
+type FitMode = (typeof FIT_MODES)[number];
+type BlendMode = (typeof BLEND_MODES)[number];
+type Easing = (typeof EASINGS)[number];
+type TransitionType = (typeof TRANSITION_TYPES)[number];
+type VideoEffectType = (typeof VIDEO_EFFECT_TYPES)[number];
+type AudioEffectType = (typeof AUDIO_EFFECT_TYPES)[number];
+type TrackFlag = (typeof TRACK_FLAGS)[number];
+/**
+ * What the ingest service knows about an asset. The model never sees pixels;
+ * it edits against this, and the resolver turns `word:`/`shot:` references
+ * into seconds with it.
+ */
+interface AssetManifest {
+  readonly assets: Readonly<Record<string, AssetEntry>>;
+}
+interface AssetEntry {
+  readonly id: string;
+  readonly kind: "video" | "audio" | "image";
+  /** Seconds. Images report 0 and may be held for any duration. */
+  readonly duration: number;
+  readonly fps?: number;
+  readonly width?: number;
+  readonly height?: number;
+  readonly audio?: {
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly streams: number;
+  };
+  readonly transcript?: {
+    readonly words: readonly TranscriptWord[];
+  };
+  readonly shots?: readonly Shot[];
+  readonly silences?: readonly Silence[];
+  readonly waveform?: WaveformSummary;
+  /** Where the subject (a face, a person) sits in the picture, sampled over time; several boxes may share a `t`. */
+  readonly subjects?: readonly SubjectBox[];
+}
+/** A subject's box at source second `t`, as fractions of the source picture (0..1 from its top left). */
+interface SubjectBox {
+  readonly t: number;
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+interface TranscriptWord {
+  readonly i: number;
+  readonly text: string;
+  readonly start: number;
+  readonly end: number;
+  readonly speaker?: string;
+}
+interface Shot {
+  readonly i: number;
+  readonly start: number;
+  readonly end: number;
+}
+interface Silence {
+  readonly i: number;
+  readonly start: number;
+  readonly end: number;
+}
+interface WaveformSummary {
+  readonly binSeconds: number;
+  readonly peaks: readonly number[];
+  readonly rms: readonly number[];
+}
+declare const EMPTY_MANIFEST: AssetManifest;
+declare function assetIdOf(ref: string): string;
+declare function lookupAsset(manifest: AssetManifest, ref: string): AssetEntry | null;
+type ResolveErrorCode = "DANGLING_ANCHOR" |
+/** `at` names a moment the anchor does not play: trimmed out, or the anchor is not footage. */
+"INVALID_ANCHOR" |
+/** `at` on an anchor the first version cannot map: reversed, or with speed keys or freezes. */
+"UNSUPPORTED_ANCHOR" | "CYCLE" | "TRIM_PAST_SOURCE" | "UNKNOWN_REF" | "NOT_ADJACENT" | "INSUFFICIENT_HANDLES" | "NO_VISUAL_PARENT" | "DUPLICATE_ID" | "MISSING_ASSET" | "START_ON_SEQUENCE" | "MISSING_START" | "AMBIGUOUS_DURATION" | "INVALID_CHILD" | "INVALID_TIME_RANGE" | "UNKNOWN_TOKEN" | "UNKNOWN_STYLE" | "SCHEMA";
+interface ResolveError {
+  readonly code: ResolveErrorCode;
+  readonly id: string;
+  readonly prop?: string;
+  readonly message: string;
+}
+declare function isResolveError(value: unknown): value is ResolveError;
+type TimeRef = number | `word:${number}` | `word:${number}.end` | `shot:${number}` | `shot:${number}.end` | `silence:${number}` | `silence:${number}.end` | `marker:${string}`;
+type ParsedTimeRef = {
+  readonly kind: "seconds";
+  readonly value: number;
+} | {
+  readonly kind: "word" | "shot" | "silence";
+  readonly index: number;
+  readonly edge: "start" | "end";
+} | {
+  readonly kind: "marker";
+  readonly id: string;
+} | {
+  readonly kind: "invalid";
+  readonly reason: string;
+};
+declare function isTimeRefString(value: unknown): value is string;
+declare function parseTimeRef(ref: unknown): ParsedTimeRef;
+/**
+ * Turn a reference into seconds. Word, shot and silence references are source
+ * times on the asset; marker references are composition times.
+ */
+declare function resolveTimeRef(ref: unknown, asset: AssetEntry | null, markers: ReadonlyMap<string, number>, ctx: {
+  readonly id: string;
+  readonly prop: string;
+}): number | ResolveError;
+type Editable = "literal" | "generated" | "opaque";
+/** Prop keys under this prefix address a Layer's handles rather than the Layer's own props. */
+declare const INTERIOR_PREFIX = "interior.";
+/**
+ * One vocabulary element as collected from the React element tree, before
+ * schema parsing and before placement. `props` are the raw JSX props minus
+ * `children`.
+ */
+interface CollectedNode {
+  readonly id: string;
+  readonly kind: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly children: readonly CollectedNode[];
+  /** Text content for elements whose children are text (Title). */
+  readonly text?: string;
+  readonly parent: string | null;
+  readonly editable: Editable;
+  /** Props whose source value is an expression the editor cannot write (known only when a SourceIndex was supplied). */
+  readonly lockedProps: readonly string[];
+  /** Prop → `schema` key for props that read the file's props; a write to one rewrites `defaults`. */
+  readonly boundProps: Readonly<Record<string, string>>;
+  /** For helper output: which helper produced the node, under which parent, and the helper's nth use in the file. */
+  readonly origin?: {
+    readonly helper: string;
+    readonly callerId: string | null;
+    readonly callIndex: number;
+  };
+  /** A Layer's handles: the one component inside it and its props. The component's body stays opaque. */
+  readonly interior?: LayerInterior;
+}
+interface LayerInterior {
+  readonly component: string;
+  readonly props: Readonly<Record<string, unknown>>;
+}
+interface CollectedTree {
+  readonly root: CollectedNode;
+  readonly byId: ReadonlyMap<string, CollectedNode>;
+  readonly errors: readonly ResolveError[];
+}
+declare function walk(node: CollectedNode, visit: (node: CollectedNode, depth: number) => void, depth?: number): void;
+declare function findParentOf(tree: CollectedTree, id: string): CollectedNode | null;
+type Json = null | boolean | number | string | Json[] | {
+  [key: string]: Json;
+};
+/** One change recorded by an action. Patches address elements by id, never by position in the file. */
+type Patch = {
+  readonly op: "set";
+  readonly id: string;
+  readonly prop: string;
+  readonly value: Json | undefined;
+} | {
+  readonly op: "text";
+  readonly id: string;
+  readonly text: string;
+} | {
+  readonly op: "insert";
+  readonly id: string;
+  readonly parent: string;
+  readonly after: string | null;
+  readonly node: CollectedNode;
+} | {
+  readonly op: "remove";
+  readonly id: string;
+} | {
+  readonly op: "move";
+  readonly id: string;
+  readonly parent: string;
+  readonly after: string | null;
+} | {
+  readonly op: "bake";
+  readonly id: string;
+};
+type Presence = "present" | "inserted" | "removed";
+/** The reduced effect of every patch on one element. */
+interface NetPatch {
+  readonly id: string;
+  presence: Presence;
+  readonly props: Map<string, Json | undefined>;
+  text?: string;
+  place?: {
+    parent: string;
+    after: string | null;
+  };
+  node?: CollectedNode;
+  bake: boolean;
+}
+interface PatchLog {
+  readonly entries: readonly Patch[];
+  readonly net: ReadonlyMap<string, NetPatch>;
+  /** Increments on every append or truncate; resolve() memoises on it. */
+  readonly version: number;
+  append(patch: Patch): void;
+  /** Current length, for history entries to remember what they appended. */
+  mark(): number;
+  /** Drop every entry at or after `mark` and rebuild `net`. */
+  truncate(mark: number): void;
+  clear(): void;
+}
+/**
+ * The built-in themes and motion styles a file can name. A theme is a palette,
+ * fonts, a corner radius, a motion style and named presets per element kind;
+ * presets refer to the palette and fonts through tokens, so one set of presets
+ * serves every theme.
+ */
+declare const THEME_NAMES: readonly ["midnight", "paper", "neon", "pastel", "mono", "bold"];
+type ThemeName = (typeof THEME_NAMES)[number];
+declare const MOTION_NAMES: readonly ["none", "calm", "snappy", "bouncy", "editorial"];
+type MotionName = (typeof MOTION_NAMES)[number];
+/** The palette names every built-in theme fills. `onPrimary` is text drawn on a `primary` fill. */
+declare const PALETTE_KEYS: readonly ["primary", "secondary", "accent", "background", "surface", "text", "muted", "onPrimary"];
+declare const FONT_KEYS: readonly ["heading", "body", "mono"];
+interface MotionAnimation {
+  readonly type: string;
+  readonly duration: number;
+  readonly easing: string;
+}
+/** What a motion style fills where an element says nothing: its entrance, its exit, and a transition's type and length. */
+interface MotionStyle {
+  readonly enter?: MotionAnimation | undefined;
+  readonly exit?: MotionAnimation | undefined;
+  readonly transition?: {
+    readonly type?: string | undefined;
+    readonly duration?: number | undefined;
+  } | undefined;
+}
+type Presets = Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
+interface ThemeDefinition {
+  readonly palette: Readonly<Record<(typeof PALETTE_KEYS)[number], string>>;
+  readonly fonts: Readonly<Record<(typeof FONT_KEYS)[number], string>>;
+  readonly radius: number;
+  readonly motion: MotionName;
+  readonly styles: Presets;
+}
+declare const MOTIONS: Readonly<Record<MotionName, MotionStyle>>;
+declare const THEMES: Readonly<Record<ThemeName, ThemeDefinition>>;
+/** The theme tokens resolve against when a file declares none. Its motion and default presets apply only when declared. */
+declare const DEFAULT_THEME: ThemeName;
+/** A file's theme with its base theme merged in: what tokens, presets and motion defaults resolve against. */
+interface ResolvedTheme {
+  /** Whether the file declares a theme. Without one, tokens and named presets still resolve against the default theme; motion and `default` presets do not apply. */
+  readonly declared: boolean;
+  readonly base: string;
+  readonly palette: Readonly<Record<string, string>>;
+  readonly fonts: Readonly<Record<string, string>>;
+  readonly radius: number;
+  /** Null when the motion style fills nothing. */
+  readonly motion: MotionStyle | null;
+  readonly styles: Presets;
+  /** Every token by name, without the `$`. */
+  readonly tokens: Readonly<Record<string, string | number>>;
+}
+/** Where a themed prop's value came from: `$primary`, `style:h1`, `motion` or `theme`. */
+type ThemeOrigin = string;
+interface ThemeIssue {
+  readonly code: "UNKNOWN_TOKEN" | "UNKNOWN_STYLE";
+  readonly prop: string;
+  readonly message: string;
+}
+interface Themed {
+  readonly props: Record<string, unknown>;
+  /** Prop path (dot-separated) → where its value came from. Empty when nothing was themed. */
+  readonly from: Readonly<Record<string, ThemeOrigin>>;
+  readonly issues: readonly ThemeIssue[];
+}
+/** The theme a composition's raw `theme` prop describes. Memoised per object; an invalid theme falls back to its base (the schema reports why). */
+declare function resolveTheme(raw: unknown): ResolvedTheme;
+/** The value of `$name`, or undefined. */
+declare function themeToken(theme: ResolvedTheme, name: string): string | number | undefined;
+/**
+ * An element's raw props with its theme applied, before the schema parses them:
+ * the preset its `style` names (or the kind's `default` preset) fills the props
+ * the element leaves out, the motion style fills `enter`/`exit` (a transition's
+ * type and duration), and whole-string `$token` values become theme values. The
+ * element's own props always win. Returns the input object when nothing was themed.
+ */
+declare function applyTheme(kind: string, raw: Readonly<Record<string, unknown>>, theme: ResolvedTheme): Themed;
+interface Placement {
+  readonly id: string;
+  readonly kind: string;
+  readonly track: string | null;
+  readonly parent: string | null;
+  readonly children: readonly string[];
+  readonly start: number;
+  readonly end: number;
+  readonly duration: number;
+  readonly source?: {
+    readonly in: number;
+    readonly out: number;
+    readonly speed: number;
+    readonly asset: string;
+  };
+  /** Schema-parsed props with defaults applied, after patches. Raw props when the schema rejected them. */
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly editable: Editable;
+  readonly lockedProps: readonly string[];
+  /** Prop → `schema` key; editable, but the fold writes the value into `defaults` rather than the element. */
+  readonly boundProps: Readonly<Record<string, string>>;
+  readonly errors: readonly ResolveError[];
+  /** For transitions between siblings: the two clips. */
+  readonly between?: readonly [string, string];
+  /** A Layer's handles: the component inside it and its current props. */
+  readonly interior?: LayerInterior;
+  /** Props the theme supplied, by dot path: `$primary`, `style:h1`, `motion` or `theme`. Absent when none did. */
+  readonly themed?: Readonly<Record<string, ThemeOrigin>>;
+}
+interface ResolvedTrack {
+  readonly id: string;
+  readonly layout: TrackLayout;
+  readonly order: number;
+  readonly locked: boolean;
+  readonly hidden: boolean;
+  readonly muted: boolean;
+  readonly solo: boolean;
+  readonly role?: TrackRole;
+  readonly group?: string;
+  readonly items: readonly string[];
+}
+interface ResolvedState {
+  readonly composition: {
+    readonly id: string;
+    readonly fps: number;
+    readonly width: number;
+    readonly height: number;
+    readonly duration: number;
+  };
+  readonly tracks: readonly ResolvedTrack[];
+  readonly items: ReadonlyMap<string, Placement>;
+  readonly errors: readonly ResolveError[];
+  readonly tree: CollectedTree;
+  readonly manifest: AssetManifest;
+  readonly log: PatchLog | undefined;
+  /** The composition's theme, its base merged in; the default theme when the file declares none. */
+  readonly theme: ResolvedTheme;
+}
+/** Absolute placements for every element, computed from the tree, the manifests and the patch log. Memoised per log on its version. */
+declare function resolve(tree: CollectedTree, manifest: AssetManifest, log?: PatchLog): ResolvedState;
+/** Whether two placements would render and edit the same; used to hand back the previous object. */
+declare function samePlacement(a: Placement, b: Placement): boolean;
+type ActionErrorCode = "ELEMENT_NOT_FOUND" | "TRACK_LOCKED" | "LOCKED_PROP" | "OPAQUE_TARGET" | "INVALID_PARAMS" | "INVALID_TIME_RANGE" | "OUT_OF_BOUNDS" | "NOT_ADJACENT" | "INSUFFICIENT_HANDLES" | "CYCLE" | "DUPLICATE_ID" | "UNSUPPORTED_ON_LAYOUT" | "UNKNOWN_ACTION" | "NOT_IMPLEMENTED";
+interface ActionError {
+  readonly code: ActionErrorCode;
+  readonly message: string;
+  readonly path?: string;
+}
+interface ValidationResult {
+  readonly valid: boolean;
+  readonly errors: readonly ActionError[];
+}
+declare const ok: ValidationResult;
+declare function invalid(...errors: ActionError[]): ValidationResult;
+/** Where a new element goes. Sequence tracks take `after`; free tracks take `start`; overlays may anchor. */
+type PlacementSpec = {
+  readonly after: string | null;
+} | {
+  readonly start: number;
+} | {
+  readonly anchor: string;
+  readonly offset?: number;
+};
+/** A serialisable element to insert: raw JSX props, optional text, optional children. */
+interface NodeSpec {
+  readonly id: string;
+  readonly kind: string;
+  readonly props: Readonly<Record<string, Json | undefined>>;
+  readonly text?: string;
+  readonly children?: readonly NodeSpec[];
+}
+declare function nodeSpecOf(node: CollectedNode): NodeSpec;
+declare function nodeOfSpec(spec: NodeSpec, parent: string | null): CollectedNode;
+type Id = string;
+type Props = Readonly<Record<string, Json | undefined>>;
+interface CompositionActions {
+  "composition/updateSettings": {
+    fps?: number;
+    width?: number;
+    height?: number;
+    sampleRate?: number;
+    channels?: number;
+  };
+  "composition/setBackground": {
+    mode?: "color" | "blur";
+    color?: string;
+  };
+  /** The tweaks panel: rewrites the file's `defaults` literal. */
+  "composition/setProps": {
+    defaults: Readonly<Record<string, Json>>;
+  };
+  /** Swap the theme (or remove it with null); with `merge`, lay the given parts over the current theme instead. */
+  "composition/setTheme": {
+    theme: Readonly<Record<string, Json>> | null;
+    merge?: boolean;
+  };
+  /** One theme value: a palette colour, a font role or `radius`, by token name without the `$`. */
+  "theme/setToken": {
+    token: string;
+    value: string | number;
+  };
+  "batch/apply": {
+    actions: readonly ActionInput[];
+  };
+}
+interface TrackActions {
+  "track/add": {
+    trackId: Id;
+    position?: number;
+    layout?: TrackLayout;
+    role?: TrackRole;
+    name?: string;
+  };
+  "track/remove": {
+    trackId: Id;
+  };
+  "track/restore": {
+    trackId: Id;
+    node: NodeSpec;
+    position: number;
+  };
+  "track/duplicate": {
+    sourceTrackId: Id;
+    trackId: Id;
+    idMap: Readonly<Record<Id, Id>>;
+    position?: number;
+  };
+  "track/rename": {
+    trackId: Id;
+    name: string;
+  };
+  "track/reorder": {
+    trackId: Id;
+    position: number;
+  };
+  "track/setFlag": {
+    trackId: Id;
+    flag: TrackFlag;
+    value: boolean;
+  };
+  "track/setLayout": {
+    trackId: Id;
+    layout: TrackLayout;
+  };
+  "track/setGroup": {
+    trackId: Id;
+    group?: Id;
+  };
+  "track/consolidate": {
+    trackId: Id;
+  };
+  "track/restorePositions": {
+    trackId: Id;
+    positions: readonly {
+      id: Id;
+      start: number;
+    }[];
+  };
+}
+interface ClipActions {
+  "clip/add": {
+    id: Id;
+    trackId: Id;
+    src: string;
+    place: PlacementSpec;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: number;
+  };
+  /** An <Audio> (sound only: music, a voice-over), placed like a clip; `duration: "fill"` runs to the composition's end. */
+  "audio/add": {
+    id: Id;
+    trackId: Id;
+    src: string;
+    place: PlacementSpec;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: number | "fill";
+  };
+  "clip/remove": {
+    id: Id;
+  };
+  "clip/restore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+  };
+  "clip/rippleDelete": {
+    id: Id;
+  };
+  "clip/rippleRestore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+    affected: readonly {
+      id: Id;
+      start: number;
+    }[];
+  };
+  "clip/move": {
+    id: Id;
+    trackId?: Id;
+    place: PlacementSpec;
+  };
+  "clip/trim": {
+    id: Id;
+    edge: "in" | "out";
+    value: TimeRef;
+  };
+  "clip/split": {
+    id: Id;
+    at: number;
+    newId: Id;
+  };
+  "clip/merge": {
+    id: Id;
+    rightId: Id;
+    original: NodeSpec;
+  };
+  "clip/slip": {
+    id: Id;
+    delta: number;
+  };
+  "clip/slide": {
+    id: Id;
+    delta: number;
+  };
+  "clip/roll": {
+    leftId: Id;
+    rightId: Id;
+    delta: number;
+  };
+  "clip/trimToPlayhead": {
+    id: Id;
+    at: number;
+    edge: "in" | "out";
+  };
+  "clip/restoreTiming": {
+    id: Id;
+    in?: TimeRef;
+    out?: TimeRef;
+    duration?: Json;
+    start?: number;
+  };
+  "clip/closeGapBefore": {
+    id: Id;
+  };
+  "clip/setSpeed": {
+    id: Id;
+    speed: number;
+  };
+  "clip/setReverse": {
+    id: Id;
+    value: boolean;
+  };
+  "clip/setPitchCorrection": {
+    id: Id;
+    value: boolean;
+  };
+  "clip/setSmoothSlowMo": {
+    id: Id;
+    value: boolean;
+  };
+  "clip/setStabilization": {
+    id: Id;
+    value?: Json;
+  };
+  "clip/setChromaKey": {
+    id: Id;
+    value?: Json;
+  };
+  "clip/setBlend": {
+    id: Id;
+    mode?: string;
+    opacity?: number;
+  };
+  "clip/setEmphasis": {
+    id: Id;
+    value?: Json;
+  };
+  "clip/setFit": {
+    id: Id;
+    value?: string;
+  };
+  "clip/setSource": {
+    id: Id;
+    src: string;
+  };
+  "clip/setAnchor": {
+    id: Id;
+    anchor?: Id | "start";
+    offset?: number;
+  };
+}
+interface SpeedActions {
+  "speed/setKeys": {
+    id: Id;
+    keys: readonly NodeSpec[];
+    after?: Id | null;
+  };
+  "speed/setFreezes": {
+    id: Id;
+    freezes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface TransformActions {
+  "transform/update": {
+    id: Id;
+    transform: Readonly<Record<string, Json>>;
+  };
+}
+interface ChildStack<K extends string> {
+  add: {
+    id: Id;
+    childId: Id;
+    type: K;
+    params?: Readonly<Record<string, Json>>;
+    index?: number;
+  };
+  remove: {
+    id: Id;
+    childId: Id;
+  };
+  restore: {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  update: {
+    id: Id;
+    childId: Id;
+    params: Readonly<Record<string, Json>>;
+  };
+  toggle: {
+    id: Id;
+    childId: Id;
+    enabled: boolean;
+  };
+  setOrder: {
+    id: Id;
+    childIds: readonly Id[];
+  };
+  setStack: {
+    id: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface EffectActions {
+  "effect/add": ChildStack<string>["add"];
+  "effect/remove": ChildStack<string>["remove"];
+  "effect/restore": ChildStack<string>["restore"];
+  "effect/update": ChildStack<string>["update"];
+  "effect/toggle": ChildStack<string>["toggle"];
+  "effect/setOrder": ChildStack<string>["setOrder"];
+  "effect/setStack": ChildStack<string>["setStack"];
+  "audioEffect/add": ChildStack<string>["add"];
+  "audioEffect/remove": ChildStack<string>["remove"];
+  "audioEffect/restore": ChildStack<string>["restore"];
+  "audioEffect/update": ChildStack<string>["update"];
+  "audioEffect/toggle": ChildStack<string>["toggle"];
+  "audioEffect/setOrder": ChildStack<string>["setOrder"];
+  "audioEffect/setStack": ChildStack<string>["setStack"];
+  "colorGrade/set": {
+    id: Id;
+    grading?: Readonly<Record<string, Json>>;
+  };
+}
+interface KeyframeActions {
+  "keyframe/add": {
+    id: Id;
+    keyId: Id;
+    property: string;
+    at: number;
+    value: Json;
+    easing?: string;
+    handles?: Json;
+  };
+  "keyframe/remove": {
+    id: Id;
+    keyId: Id;
+  };
+  "keyframe/restore": {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "keyframe/update": {
+    id: Id;
+    keyId: Id;
+    value?: Json;
+    easing?: string;
+    handles?: Json;
+    roving?: boolean;
+  };
+  "keyframe/move": {
+    id: Id;
+    keyId: Id;
+    at: number;
+  };
+  "keyframe/setAll": {
+    id: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface TransitionActions {
+  "transition/add": {
+    transitionId: Id;
+    between: readonly [Id, Id] | {
+      on: Id;
+      edge: "in" | "out";
+    };
+    type: TransitionType;
+    duration: number;
+    params?: Readonly<Record<string, Json>>;
+  };
+  "transition/remove": {
+    transitionId: Id;
+  };
+  "transition/restore": {
+    transitionId: Id;
+    node: NodeSpec;
+    trackId: Id;
+    after: Id | null;
+  };
+  "transition/update": {
+    transitionId: Id;
+    type?: TransitionType;
+    duration?: number;
+    params?: Readonly<Record<string, Json>>;
+  };
+}
+interface AudioActions {
+  "audio/setVolume": {
+    id: Id;
+    volume: number;
+  };
+  "audio/setFade": {
+    id: Id;
+    in?: number;
+    out?: number;
+  };
+  "audio/setAutomation": {
+    id: Id;
+    lane: "volume" | "pan";
+    points: readonly (readonly [number, number])[];
+  };
+  "audio/setDuck": {
+    id: Id;
+    duck?: {
+      under: Id;
+      to: number;
+      attack?: number;
+      release?: number;
+    };
+  };
+}
+interface Overlay {
+  create: {
+    id: Id;
+    kind: string;
+    trackId: Id;
+    place: PlacementSpec;
+    props: Props;
+    text?: string;
+    children?: readonly NodeSpec[];
+    after?: Id | null;
+  };
+  update: {
+    id: Id;
+    props: Props;
+  };
+  remove: {
+    id: Id;
+  };
+}
+interface OverlayActions {
+  "text/create": Overlay["create"];
+  "text/update": Overlay["update"];
+  "text/remove": Overlay["remove"];
+  "text/setContent": {
+    id: Id;
+    text: string;
+  };
+  "shape/create": Overlay["create"];
+  "shape/update": Overlay["update"];
+  "shape/remove": Overlay["remove"];
+  "svg/create": Overlay["create"];
+  "svg/update": Overlay["update"];
+  "svg/remove": Overlay["remove"];
+  "sticker/create": Overlay["create"];
+  "sticker/update": Overlay["update"];
+  "sticker/remove": Overlay["remove"];
+  "graphic/create": Overlay["create"];
+  "graphic/update": Overlay["update"];
+  "graphic/remove": Overlay["remove"];
+  "adjustment/create": Overlay["create"];
+  "adjustment/update": Overlay["update"];
+  "adjustment/remove": Overlay["remove"];
+  "nested/create": Overlay["create"];
+  "nested/update": Overlay["update"];
+  "nested/remove": Overlay["remove"];
+  "nested/extract": {
+    id: Id;
+  };
+}
+interface CaptionActions {
+  "caption/import": {
+    captionsId: Id;
+    src?: string;
+    items?: readonly NodeSpec[];
+  };
+  "caption/add": {
+    captionsId: Id;
+    captionId: Id;
+    start: TimeRef;
+    end: TimeRef;
+    text: string;
+    words?: Json;
+  };
+  "caption/update": {
+    captionId: Id;
+    text?: string;
+    start?: TimeRef;
+    end?: TimeRef;
+    words?: Json;
+  };
+  "caption/remove": {
+    captionId: Id;
+  };
+  "caption/restore": {
+    captionsId: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "caption/setStyle": {
+    captionsId: Id;
+    style?: Readonly<Record<string, Json>>;
+  };
+  "caption/setAnimation": {
+    captionsId: Id;
+    animation: string;
+  };
+  "caption/setAll": {
+    captionsId: Id;
+    nodes: readonly NodeSpec[];
+    after?: Id | null;
+  };
+}
+interface MarkerActions {
+  "marker/add": {
+    markerId: Id;
+    at: number;
+    label?: string;
+    color?: string;
+  };
+  "marker/update": {
+    markerId: Id;
+    at?: number;
+    label?: string;
+    color?: string;
+  };
+  "marker/remove": {
+    markerId: Id;
+  };
+  "marker/restore": {
+    node: NodeSpec;
+    after: Id | null;
+  };
+}
+interface MaskActions {
+  "mask/create": {
+    id: Id;
+    parentId: Id;
+    props: Props;
+  };
+  "mask/update": {
+    id: Id;
+    props: Props;
+  };
+  "mask/remove": {
+    id: Id;
+  };
+  "mask/restore": {
+    id: Id;
+    parentId: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "mask/setPath": {
+    id: Id;
+    path: Json;
+  };
+}
+interface MulticamActions {
+  "multicam/create": {
+    id: Id;
+    trackId: Id;
+    place: PlacementSpec;
+    angles: readonly NodeSpec[];
+    sync?: number;
+  };
+  "multicam/remove": {
+    id: Id;
+  };
+  "multicam/restore": {
+    id: Id;
+    node: NodeSpec;
+    trackId: Id;
+    place: PlacementSpec;
+  };
+  "multicam/setActiveAngle": {
+    id: Id;
+    angle: Id;
+  };
+  "multicam/addCut": {
+    id: Id;
+    cutId: Id;
+    at: number;
+    angle: Id;
+  };
+  "multicam/moveCut": {
+    cutId: Id;
+    at: number;
+  };
+  "multicam/removeCut": {
+    cutId: Id;
+  };
+  "multicam/restoreCut": {
+    id: Id;
+    node: NodeSpec;
+    after: Id | null;
+  };
+  "multicam/flatten": {
+    id: Id;
+  };
+}
+interface LayerActions {
+  "layer/setTiming": {
+    id: Id;
+    duration?: Json;
+    anchor?: Id | "start";
+    offset?: number;
+    start?: number;
+  };
+  "layer/setProps": {
+    id: Id;
+    props: Readonly<Record<string, Json | undefined>>;
+  };
+  "layer/setTransform": {
+    id: Id;
+    transform: Readonly<Record<string, Json>>;
+  };
+}
+interface SourceActions {
+  "source/bake": {
+    id: Id;
+  };
+  "source/setProp": {
+    id: Id;
+    prop: string;
+    value: Json | undefined;
+  };
+  /** Several literal props at once; the inverse of every prop-writing action. */
+  "source/setProps": {
+    id: Id;
+    props: Readonly<Record<string, Json | undefined>>;
+  };
+}
+type ActionMap = CompositionActions & TrackActions & ClipActions & SpeedActions & TransformActions & EffectActions & KeyframeActions & TransitionActions & AudioActions & OverlayActions & CaptionActions & MarkerActions & MaskActions & MulticamActions & LayerActions & SourceActions;
+type ActionType = keyof ActionMap;
+interface Action<T extends ActionType = ActionType> {
+  readonly type: T;
+  readonly actionId: string;
+  readonly ts: number;
+  readonly params: ActionMap[T];
+}
+type ActionInput<T extends ActionType = ActionType> = {
+  readonly type: T;
+  readonly params: ActionMap[T];
+};
+type Namespace = ActionType extends `${infer N}/${string}` ? N : never;
+/** Rapid repeats of these on the same target collapse into one undo step (OpenReel's rule). */
+declare const AUTO_GROUP_TYPES: ReadonlySet<ActionType>;
+declare const TARGET_PARAM_KEYS: readonly ["id", "leftId", "trackId", "transitionId", "childId", "keyId", "captionId", "captionsId", "cutId", "markerId"];
+declare function targetIdOf(action: ActionInput): string | null;
+declare function describeAction(action: ActionInput): string;
+export { MotionStyle as $, MASK_EASINGS as $t, ValidationResult as A, zTextAnimationPreset as An, Silence as At, ResolvedTheme as B, BLEND_MODES as Bt, TransitionActions as C, zEasing as Cn, ResolveError as Ct, ActionErrorCode as D, zKeyframeProperty as Dn, AssetManifest as Dt, ActionError as E, zGraphicAnimation as En, AssetEntry as Et, Placement as F, lookupAsset as Ft, resolveTheme as G, EMPHASIS_ANIMATIONS as Gt, ThemeOrigin as H, CAPTION_ANIMATIONS as Ht, ResolvedState as I, ANIMATION_UNITS as It, FONT_KEYS as J, FitMode as Jt, themeToken as K, Easing as Kt, ResolvedTrack as L, AUDIO_EFFECT_TYPES as Lt, nodeOfSpec as M, zTrackRole as Mn, TranscriptWord as Mt, nodeSpecOf as N, zTransitionType as Nn, WaveformSummary as Nt, NodeSpec as O, zMaskEasing as On, EMPTY_MANIFEST as Ot, ok as P, zVideoEffectType as Pn, assetIdOf as Pt, MotionName as Q, KEYFRAME_PROPERTY_PATTERN as Qt, resolve as R, AUTOMATION_LANES as Rt, TransformActions as S, zCaptionAnimation as Sn, resolveTimeRef as St, targetIdOf as T, zFitMode as Tn, isResolveError as Tt, Themed as U, CAPTION_POSITIONS as Ut, ThemeIssue as V, BlendMode as Vt, applyTheme as W, EASINGS as Wt, MOTION_NAMES as X, INTERPOLATION_QUALITIES as Xt, MOTIONS as Y, GRAPHIC_ANIMATIONS as Yt, MotionAnimation as Z, KEYFRAME_PROPERTIES as Zt, OverlayActions as _, VIDEO_EFFECT_TYPES as _n, walk as _t, ActionType as a, TEXT_ALIGNS as an, ThemeName as at, TARGET_PARAM_KEYS as b, zAudioEffectType as bn, isTimeRefString as bt, ClipActions as c, TEXT_VALIGNS as cn, Patch as ct, KeyframeActions as d, TRACK_ROLES as dn, CollectedNode as dt, MASK_TYPES as en, PALETTE_KEYS as et, LayerActions as f, TRANSITION_TYPES as fn, CollectedTree as ft, Namespace as g, TransitionType as gn, findParentOf as gt, MulticamActions as h, TrackRole as hn, LayerInterior as ht, ActionMap as i, SVG_COLOR_MODES as in, ThemeDefinition as it, invalid as j, zTrackLayout as jn, SubjectBox as jt, PlacementSpec as k, zShapeType as kn, Shot as kt, CompositionActions as l, TRACK_FLAGS as ln, PatchLog as lt, MaskActions as m, TrackLayout as mn, INTERIOR_PREFIX as mt, Action as n, SHAPE_TYPES as nn, THEMES as nt, AudioActions as o, TEXT_ANIMATION_PRESETS as on, Json as ot, MarkerActions as p, TrackFlag as pn, Editable as pt, DEFAULT_THEME as q, FIT_MODES as qt, ActionInput as r, STABILIZE_CROP_MODES as rn, THEME_NAMES as rt, CaptionActions as s, TEXT_DECORATIONS as sn, NetPatch as st, AUTO_GROUP_TYPES as t, MATTE_CHANNELS as tn, Presets as tt, EffectActions as u, TRACK_LAYOUTS as un, Presence as ut, SourceActions as v, VideoEffectType as vn, ParsedTimeRef as vt, describeAction as w, zEmphasisAnimation as wn, ResolveErrorCode as wt, TrackActions as x, zBlendMode as xn, parseTimeRef as xt, SpeedActions as y, isKeyframeProperty as yn, TimeRef as yt, samePlacement as z, AudioEffectType as zt };