@pixerate/editor 0.83.0 → 0.85.0

package/dist/video-editor/index.d.cts

@@ -92,6 +92,12 @@ declare function videoKeyframeFfmpegExpr(prop: VideoAnimatable | undefined, time
  */
 
 type VideoAssetKind = 'video' | 'audio' | 'image';
+/** A spoken word in an asset's transcript, timed in the source (ms). */
+interface VideoTranscriptWord {
+    word: string;
+    start: number;
+    end: number;
+}
 /** A piece of source media. The project refers to it by id; `src` is whatever the host can load. */
 interface VideoAsset {
     id: string;
@@ -108,6 +114,8 @@ interface VideoAsset {
     hasAudio?: boolean;
     /** A still to show for a video where its frames cannot be drawn (SVG renders, thumbnails). */
     poster?: string;
+    /** What is said in it, word by word, timed in the source (see `parseVideoTranscript`). */
+    transcript?: VideoTranscriptWord[];
 }
 type VideoTrackKind = 'video' | 'audio';
 interface VideoTrack {
@@ -142,8 +150,16 @@ interface VideoTransform {
 /** How a picture is fitted to the frame before its transform: like CSS `object-fit`. */
 type VideoFit = 'contain' | 'cover' | 'fill' | 'none';
 declare const VIDEO_FITS: readonly ["contain", "cover", "fill", "none"];
-type VideoTransitionType = 'crossfade' | 'dip' | 'wipe';
-declare const VIDEO_TRANSITION_TYPES: readonly ["crossfade", "dip", "wipe"];
+/**
+ * - `crossfade`: this clip fades up over the one before.
+ * - `dip`: down into a colour and up out of it.
+ * - `wipe`: an edge travels across, revealing this clip.
+ * - `push`: this clip slides in, pushing the one before out.
+ * - `slide`: this clip slides in over the one before, which stays put.
+ * - `iris`: a circle opens from the centre, revealing this clip.
+ */
+type VideoTransitionType = 'crossfade' | 'dip' | 'wipe' | 'push' | 'slide' | 'iris';
+declare const VIDEO_TRANSITION_TYPES: readonly ["crossfade", "dip", "wipe", "push", "slide", "iris"];
 type VideoWipeDirection = 'left' | 'right' | 'up' | 'down';
 declare const VIDEO_WIPE_DIRECTIONS: readonly ["left", "right", "up", "down"];
 /**
@@ -157,8 +173,54 @@ interface VideoTransition {
     duration: number;
     /** For dip: the colour passed through (default black). */
     color?: string;
-    /** For wipe: the way the edge travels (default right, revealing from the left). */
+    /** For wipe, push and slide: the way the edge or picture travels (default right: in from the left). */
     direction?: VideoWipeDirection;
+    /**
+     * Shape of the sound's fades through the transition (see `VideoFadeCurve`). Default
+     * `equal-power` for crossfades and wipes, where two sounds overlap and a linear mix dips in
+     * loudness halfway; `linear` for dips, where one sound fades out before the other fades in.
+     */
+    audioCurve?: VideoFadeCurve;
+}
+/** The curve a transition's sound fades follow (its `audioCurve`, else the default for its type). */
+declare const videoTransitionAudioCurve: (t: VideoTransition) => VideoFadeCurve;
+/**
+ * How a clip's picture mixes with what is beneath it, as in CSS `mix-blend-mode` (`add` sums the
+ * colours, `plus-lighter` in CSS). These are the modes the canvas preview, SVG frames and ffmpeg's
+ * `blend` filter all share.
+ */
+type VideoBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'add';
+declare const VIDEO_BLEND_MODES: readonly ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "add"];
+/**
+ * Colour correction for a clip's picture (see `VIDEO_GRADE_CONTROLS` for ranges). Applied in a fixed
+ * order: exposure, contrast, saturation, hue, then white balance (temperature and tint).
+ */
+interface VideoGrade {
+    /** Stops: +1 doubles every channel (default 0). */
+    exposure?: number;
+    /** -1 (flat grey) to 1 (twice as steep), around mid grey (default 0). */
+    contrast?: number;
+    /** -1 (black and white) to 1 (twice as saturated); default 0. */
+    saturation?: number;
+    /** Hue rotation in degrees (default 0). */
+    hue?: number;
+    /** -1 (cool) to 1 (warm); default 0. */
+    temperature?: number;
+    /** -1 (green) to 1 (magenta); default 0. */
+    tint?: number;
+}
+/**
+ * How a clip enters or leaves: `fade`; `rise` (up into place) or `drop` (down into place);
+ * `slide-left` / `slide-right` (in moving that way); `zoom` (grows into place); `pop` (grows past its
+ * size and settles). Each also fades. An exit plays the same movement backwards.
+ */
+type VideoClipAnimationEffect = 'fade' | 'rise' | 'drop' | 'slide-left' | 'slide-right' | 'zoom' | 'pop';
+declare const VIDEO_CLIP_ANIMATION_EFFECTS: readonly ["fade", "rise", "drop", "slide-left", "slide-right", "zoom", "pop"];
+/** An entrance or exit animation (see `VideoClipAnimationEffect`). */
+interface VideoClipAnimation {
+    effect: VideoClipAnimationEffect;
+    /** Length (ms, default 500). */
+    duration?: number;
 }
 interface VideoClipBase {
     id: string;
@@ -172,6 +234,14 @@ interface VideoClipBase {
     transform?: VideoTransform;
     /** Default contain. */
     fit?: VideoFit;
+    /** How the picture mixes with what is beneath it (default normal). */
+    blend?: VideoBlendMode;
+    /** Colour correction of the picture. */
+    grade?: VideoGrade;
+    /** How the picture enters, from the clip's start (on top of any fade in). */
+    animateIn?: VideoClipAnimation;
+    /** How the picture leaves, up to the clip's end. */
+    animateOut?: VideoClipAnimation;
     /** Fade in from nothing over this long (ms), pictures and sound. */
     fadeIn?: number;
     /** Fade out over this long (ms). */
@@ -274,7 +344,10 @@ declare function parseVideoAnimatable(v: unknown, path: string, range?: {
     optional?: boolean;
 }): VideoAnimatable | undefined;
 declare function parseVideoTransform(v: unknown, path: string): VideoTransform | undefined;
+declare function parseVideoClipAnimation(v: unknown, path: string): VideoClipAnimation | undefined;
+declare function parseVideoGrade(v: unknown, path: string): VideoGrade | undefined;
 declare function parseVideoTransition(v: unknown, path: string): VideoTransition | undefined;
+declare function parseVideoTranscriptWords(v: unknown, path: string): VideoTranscriptWord[] | undefined;
 declare function parseVideoAsset(v: unknown, path?: string): VideoAsset;
 declare function parseVideoClip(v: unknown, path?: string): VideoClip;
 declare function parseVideoTrack(v: unknown, path?: string): VideoTrack;
@@ -410,7 +483,7 @@ declare function videoClipKeyframes(clip: VideoClip): {
     keys: ReturnType<typeof videoKeysOf>;
 }[];
 type VideoIssueSeverity = 'error' | 'warning' | 'note';
-declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "keyframes-outside-clip", "unknown-duration", "unused-asset", "marker-past-end", "empty"];
+declare const VIDEO_ISSUE_CODES: readonly ["missing-asset", "wrong-track", "overlap", "source-overrun", "transition-without-cut", "transition-too-long", "transition-handles", "fades-too-long", "animations-too-long", "animation-keyed", "keyframes-outside-clip", "unknown-duration", "unused-asset", "marker-past-end", "empty"];
 type VideoIssueCode = (typeof VIDEO_ISSUE_CODES)[number];
 interface VideoIssue {
     code: VideoIssueCode;
@@ -653,6 +726,10 @@ interface VideoLayer {
         direction: VideoWipeDirection;
         progress: number;
     };
+    /** For an iris: only a circle on the frame's centre shows, its radius `progress` (0–1) of the way to the frame's corners. */
+    iris?: {
+        progress: number;
+    };
     /** For text: what to draw. */
     text?: {
         text: string;
@@ -664,6 +741,10 @@ interface VideoLayer {
     };
     /** For colour clips and dips. */
     color?: string;
+    /** How it mixes with the layers beneath (absent = normal). */
+    blend?: VideoBlendMode;
+    /** Colour correction (absent = none). */
+    grade?: VideoGrade;
 }
 /** One sound playing at a moment. */
 interface VideoAudioSource {
@@ -710,6 +791,8 @@ declare function videoTextStyle(clip: VideoTextClip): NonNullable<VideoLayer['te
  * transforms without them, and moves the image itself).
  */
 declare function videoTitleFrame(project: VideoProject, clip: VideoTextClip, clipTime?: number): VideoFrame;
+/** How far a push or slide has moved at `progress` (0–1): eased in and out, (1 − cos πp) / 2. */
+declare const videoTransitionEase: (progress: number) => number;
 /** Gain of a fade shape `x` of the way up (0–1); a fade out uses the time left, so it mirrors the fade in. */
 declare function videoFadeCurveGain(curve: VideoFadeCurve | undefined, x: number): number;
 /**
@@ -828,6 +911,223 @@ declare class VideoAudioPeaksCache {
     private emit;
 }
 
+/**
+ * Colour correction as a fixed series of colour-matrix steps on gamma-encoded sRGB, each clamped
+ * to 0–1, in the same order everywhere: exposure, contrast, saturation, hue, then white balance.
+ * Every step is one the browser has (CSS `brightness`, `contrast`, `saturate`, `hue-rotate`; white
+ * balance as an SVG `feColorMatrix`) and ffmpeg has (`lutrgb`, `colorchannelmixer`), with the same
+ * formulas, so the preview, SVG frames and the export agree.
+ */
+/** One slider of a grade: its range, default and step, for schemas, inspectors and clamping. */
+interface VideoGradeControl {
+    key: keyof VideoGrade;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    /** What the number means, for tool descriptions. */
+    description: string;
+}
+declare const VIDEO_GRADE_CONTROLS: readonly VideoGradeControl[];
+/** Named looks. Apply them at a strength with `videoGradePreset`. */
+declare const VIDEO_GRADE_PRESETS: {
+    readonly warm: {
+        readonly temperature: 0.4;
+        readonly saturation: 0.1;
+    };
+    readonly cool: {
+        readonly temperature: -0.4;
+        readonly tint: -0.05;
+    };
+    readonly punchy: {
+        readonly contrast: 0.25;
+        readonly saturation: 0.3;
+    };
+    readonly faded: {
+        readonly exposure: 0.15;
+        readonly contrast: -0.3;
+        readonly saturation: -0.3;
+    };
+    readonly 'black-and-white': {
+        readonly saturation: -1;
+        readonly contrast: 0.15;
+    };
+    readonly 'bleach-bypass': {
+        readonly saturation: -0.6;
+        readonly contrast: 0.4;
+    };
+    readonly 'day-for-night': {
+        readonly exposure: -1.5;
+        readonly saturation: -0.4;
+        readonly temperature: -0.6;
+    };
+};
+type VideoGradePreset = keyof typeof VIDEO_GRADE_PRESETS;
+declare const VIDEO_GRADE_PRESET_NAMES: VideoGradePreset[];
+/** A grade with every value clamped to its range and zero values left out; `undefined` when nothing is left. */
+declare function normalizeVideoGrade(grade: VideoGrade | undefined): VideoGrade | undefined;
+/** A preset at `amount` (0–1, default 1) of its strength. */
+declare function videoGradePreset(name: VideoGradePreset, amount?: number): VideoGrade | undefined;
+/** One step of a grade. */
+type VideoGradeStep = {
+    kind: 'brightness';
+    amount: number;
+} | {
+    kind: 'contrast';
+    amount: number;
+} | {
+    kind: 'saturate';
+    amount: number;
+} | {
+    kind: 'hue-rotate';
+    degrees: number;
+} | {
+    kind: 'gains';
+    r: number;
+    g: number;
+    b: number;
+};
+/** The steps a grade applies, in order, leaving out those that change nothing. */
+declare function videoGradeSteps(grade: VideoGrade | undefined): VideoGradeStep[];
+/**
+ * A step as a 3 × 4 matrix (rows r, g, b; columns r, g, b, offset), with the coefficients the CSS
+ * Filter Effects spec gives for `saturate` and `hue-rotate`.
+ */
+declare function videoGradeStepMatrix(step: VideoGradeStep): number[][];
+/** An RGB colour (0–255 each) through a grade, as the preview and export draw it. */
+declare function applyVideoGrade(grade: VideoGrade | undefined, rgb: readonly [number, number, number]): [number, number, number];
+/** The `values` of an SVG `feColorMatrix type="matrix"` for a step. */
+declare function videoGradeStepSvgValues(step: VideoGradeStep): string;
+/** An SVG `<filter>` applying a grade, steps in order (each clamps, as CSS filters do). */
+declare function videoGradeSvgFilter(id: string, grade: VideoGrade | undefined): string;
+/** Id of the SVG filter for a white-balance step: the same gains always get the same id. */
+declare const videoGradeGainsFilterId: (step: Extract<VideoGradeStep, {
+    kind: "gains";
+}>) => string;
+/**
+ * A grade as a CSS / canvas `filter`: CSS functions for every step, and `url(#id)` for white balance,
+ * which CSS has no function for (see `videoGradeGainsFilterId`; the host puts that filter in the page).
+ * `''` when the grade changes nothing.
+ */
+declare function videoGradeCssFilter(grade: VideoGrade | undefined): string;
+/** The white-balance SVG filters a grade's CSS filter refers to, as `{ id, markup }`. */
+declare function videoGradeSvgDefs(grade: VideoGrade | undefined): {
+    id: string;
+    markup: string;
+}[];
+/** A grade as ffmpeg filters on RGB, in order: `lutrgb` for exposure and contrast, `colorchannelmixer` for the rest. */
+declare function videoGradeFfmpegFilters(grade: VideoGrade | undefined): string[];
+
+/** Default length of an entrance or exit animation (ms). */
+declare const VIDEO_CLIP_ANIMATION_DURATION = 500;
+declare const PROPS: readonly ["opacity", "x", "y", "scale"];
+type Prop = (typeof PROPS)[number];
+/** The properties an animation moves (each also fades: opacity is always one). */
+declare function videoClipAnimationProperties(animation: VideoClipAnimation): Prop[];
+/** Entrance and exit lengths (ms), shortened in proportion when together they are longer than the clip. */
+declare function videoClipAnimationSpans(clip: VideoClip): {
+    in: number;
+    out: number;
+};
+/**
+ * The clip with its entrance and exit animations written out as keyframes on opacity, x, y and
+ * scale, so previews, SVG frames and the ffmpeg export all play them the same way. A property the
+ * clip already keys itself is left alone (`checkVideoProject` notes it). Returns the clip unchanged
+ * when it has no animations.
+ */
+declare function videoClipAnimated(clip: VideoClip, project: Pick<VideoProject, 'width' | 'height'>): VideoClip;
+
+/**
+ * A transcript from text a speech-to-text service or captioning tool wrote: Whisper-style JSON
+ * (`{ segments: [{ words: [{ word, start, end }] }] }` or `{ words: [...] }`, times in seconds, or a
+ * plain `[{ word, start, end }]` array in ms), SubRip (`.srt`) or WebVTT. Captions have no word
+ * timings, so their words are spread evenly across each cue (`approximate: true`). Throws when it
+ * finds no words.
+ */
+declare function parseVideoTranscript(input: string | unknown): {
+    words: VideoTranscriptWord[];
+    approximate: boolean;
+};
+/** A word where it plays on the timeline. */
+interface VideoTimelineWord {
+    word: string;
+    /** Timeline times (ms). */
+    start: number;
+    end: number;
+    /** The clip that plays it. */
+    clip: string;
+    track: string;
+    /** Its index in the asset's transcript. */
+    index: number;
+}
+/**
+ * The track whose words make the timeline transcript: `track` if given, else the first audio track
+ * with a transcribed clip, else the first video track with one. `null` when nothing is transcribed.
+ */
+declare function videoTranscriptTrack(project: VideoProject, track?: string): string | null;
+/**
+ * The words the timeline plays on one track, in order: each transcribed media clip's words whose
+ * middle falls inside the stretch of source it plays, moved to timeline time through its in point
+ * and speed and clamped to the clip.
+ */
+declare function videoTimelineTranscript(project: VideoProject, options?: {
+    track?: string;
+}): VideoTimelineWord[];
+/** A stretch of the timeline (ms) and the words in it. */
+interface VideoTranscriptRange {
+    from: number;
+    to: number;
+    text: string;
+}
+/** A word as compared: lower case, without surrounding punctuation. */
+declare const normalizeVideoWord: (word: string) => string;
+/** Every place a phrase is said (case and punctuation ignored), as timeline ranges. */
+declare function findVideoTranscriptText(words: readonly VideoTimelineWord[], query: string): VideoTranscriptRange[];
+/** Filler words and phrases removed by default. "like" and "so" are left out: too often meant. */
+declare const VIDEO_DEFAULT_FILLERS: readonly ["um", "umm", "uh", "uhh", "uhm", "erm", "er", "ah", "hmm", "mm", "you know", "i mean"];
+/** Fillers in the transcript, longest phrase first ("you know" before "you"), as timeline ranges. */
+declare function findVideoFillers(words: readonly VideoTimelineWord[], fillers?: readonly string[]): VideoTranscriptRange[];
+interface VideoPauseOptions {
+    /** Shortest gap between words that counts as a pause (ms, default 700). */
+    min?: number;
+    /** Silence to keep next to each word so speech does not sound clipped (ms, default 150). */
+    keep?: number;
+    /** Frame rate to snap the cut inward to (default: none). */
+    fps?: number;
+}
+/** Gaps between consecutive words on the same clip longer than `min`, less `keep` either side, as timeline ranges. */
+declare function findVideoTranscriptPauses(words: readonly VideoTimelineWord[], options?: VideoPauseOptions): VideoTranscriptRange[];
+/** Ranges sorted and merged where they touch or overlap. */
+declare function mergeVideoRanges(ranges: readonly {
+    from: number;
+    to: number;
+}[]): {
+    from: number;
+    to: number;
+}[];
+/**
+ * The edits that cut ranges out of the timeline and close them up: one `extract_range` per merged
+ * range, last first, so earlier ranges keep their times. Apply them together as one undo step.
+ */
+declare function videoRemoveRangesEdits(ranges: readonly {
+    from: number;
+    to: number;
+}[], tracks?: string[]): VideoEdit[];
+/** The timeline stretch from word `a` to word `b` (either order), for deleting a selection of words. */
+declare function videoWordsRange(words: readonly VideoTimelineWord[], a: number, b: number): {
+    from: number;
+    to: number;
+};
+/** The edit that attaches a transcript file's text to an asset (see `parseVideoTranscript`). Throws a readable error for text it cannot read. */
+declare function videoTranscriptEdit(assetId: string, text: string): VideoEdit;
+/** The word playing at a timeline time, as its index in `words`, or -1. */
+declare function videoWordAt(words: readonly VideoTimelineWord[], time: number): number;
+
+/** Radius of an iris `progress` (0–1) open: from nothing to the frame's corners. */
+declare const videoIrisRadius: (frame: {
+    width: number;
+    height: number;
+}, progress: number) => number;
 /** The part of a rect a wipe shows. */
 declare function videoWipeRect(rect: VideoRect, wipe: NonNullable<VideoLayer['wipe']>): VideoRect;
 interface VideoSvgOptions {
@@ -849,8 +1149,10 @@ declare function videoContactSheetSvg(project: VideoProject, times: readonly num
     width?: number;
 }): string;
 /** The subset of `CanvasRenderingContext2D` `drawVideoFrame` uses (so tests and workers can pass their own). */
-type VideoCanvasContext = Pick<CanvasRenderingContext2D, 'save' | 'restore' | 'fillRect' | 'drawImage' | 'translate' | 'rotate' | 'beginPath' | 'rect' | 'clip' | 'fillText' | 'measureText' | 'setTransform'> & {
+type VideoCanvasContext = Pick<CanvasRenderingContext2D, 'save' | 'restore' | 'fillRect' | 'drawImage' | 'translate' | 'rotate' | 'beginPath' | 'rect' | 'arc' | 'clip' | 'fillText' | 'measureText' | 'setTransform'> & {
     globalAlpha: number;
+    globalCompositeOperation: GlobalCompositeOperation;
+    filter?: string;
     fillStyle: string | CanvasGradient | CanvasPattern;
     font: string;
     textAlign: CanvasTextAlign;
@@ -862,9 +1164,13 @@ type VideoCanvasContext = Pick<CanvasRenderingContext2D, 'save' | 'restore' | 'f
 /**
  * Draws a frame on a 2D canvas scaled by `scale` (canvas pixels per frame pixel). `sourceFor`
  * returns what to draw for a media layer (a `<video>` seeked to `layer.sourceTime`, an `<img>`,
- * an `ImageBitmap`…) or `null` for a placeholder box.
+ * an `ImageBitmap`…) or `null` for a placeholder box. Grades become the context's `filter`; white
+ * balance there refers to an SVG filter, which `options.defineSvgFilter` is given to put in the page
+ * (without it, white balance is left out of the canvas).
  */
-declare function drawVideoFrame(ctx: VideoCanvasContext, frame: VideoFrame, sourceFor: (layer: VideoLayer) => CanvasImageSource | null, scale?: number): void;
+declare function drawVideoFrame(ctx: VideoCanvasContext, frame: VideoFrame, sourceFor: (layer: VideoLayer) => CanvasImageSource | null, scale?: number, options?: {
+    defineSvgFilter?: (id: string, markup: string) => void;
+}): void;
 
 interface VideoEdlOptions {
     /** Track to export (default: the bottom video track, V1 in most NLEs). */
@@ -1014,6 +1320,11 @@ interface VideoPreviewOptions {
     context?: VideoCanvasContext | null;
     /** Called after each frame is drawn. */
     onFrame?: (frame: VideoFrame) => void;
+    /**
+     * Puts an SVG filter (white balance in a grade) where the canvas's `filter: url(#id)` can find
+     * it. Default: a hidden `<svg>` added to `document.body`. `null` leaves white balance out.
+     */
+    defineSvgFilter?: ((id: string, markup: string) => void) | null;
 }
 /**
  * Plays a project in the browser: keeps one `<video>` or `<audio>` element per playing clip in step
@@ -1031,6 +1342,8 @@ declare class VideoPreviewEngine {
     private readonly unsubscribe;
     private scheduled;
     private destroyed;
+    private filterHost;
+    private readonly filters;
     constructor(source: VideoPreviewSource, canvas: {
         width: number;
         height: number;
@@ -1046,6 +1359,7 @@ declare class VideoPreviewEngine {
     private redraw;
     private sourceFor;
     private draw;
+    private readonly defineSvgFilter;
     /** Stops following the editor and releases every media element. */
     destroy(): void;
 }
@@ -1207,7 +1521,28 @@ interface VideoEditorToolProviderOptions {
 }
 /** A project as agents see it: settings, assets, and each track's clips in order with their times. */
 declare function describeVideoProject(project: VideoProject): {
-    assets: VideoAsset[];
+    assets: ({
+        id: string;
+        kind: VideoAssetKind;
+        src: string;
+        name?: string;
+        duration?: number;
+        width?: number;
+        height?: number;
+        hasAudio?: boolean;
+        poster?: string;
+    } | {
+        transcriptWords: number;
+        id: string;
+        kind: VideoAssetKind;
+        src: string;
+        name?: string;
+        duration?: number;
+        width?: number;
+        height?: number;
+        hasAudio?: boolean;
+        poster?: string;
+    })[];
     tracks: {
         clips: ({
             source?: {
@@ -1230,6 +1565,10 @@ declare function describeVideoProject(project: VideoProject): {
             opacity?: VideoAnimatable;
             transform?: VideoTransform;
             fit?: VideoFit;
+            blend?: VideoBlendMode;
+            grade?: VideoGrade;
+            animateIn?: VideoClipAnimation;
+            animateOut?: VideoClipAnimation;
             fadeIn?: number;
             fadeOut?: number;
             transition?: VideoTransition;
@@ -1253,6 +1592,10 @@ declare function describeVideoProject(project: VideoProject): {
             opacity?: VideoAnimatable;
             transform?: VideoTransform;
             fit?: VideoFit;
+            blend?: VideoBlendMode;
+            grade?: VideoGrade;
+            animateIn?: VideoClipAnimation;
+            animateOut?: VideoClipAnimation;
             fadeIn?: number;
             fadeOut?: number;
             transition?: VideoTransition;
@@ -1271,6 +1614,10 @@ declare function describeVideoProject(project: VideoProject): {
             opacity?: VideoAnimatable;
             transform?: VideoTransform;
             fit?: VideoFit;
+            blend?: VideoBlendMode;
+            grade?: VideoGrade;
+            animateIn?: VideoClipAnimation;
+            animateOut?: VideoClipAnimation;
             fadeIn?: number;
             fadeOut?: number;
             transition?: VideoTransition;
@@ -1319,6 +1666,14 @@ declare function videoRulerTicks(duration: number, pxPerSecond: number, fps: num
 type VideoWaveformMode = 'audio' | 'all' | 'none';
 /** Whether a timeline in `mode` draws a waveform in this clip. */
 declare function videoClipShowsWaveform(clip: VideoClip, asset: VideoAsset | undefined, mode?: VideoWaveformMode): asset is VideoAsset;
+/** Names for the entrance and exit animations, for menus. */
+declare const VIDEO_CLIP_ANIMATION_LABELS: Readonly<Record<VideoClipAnimationEffect, string>>;
+/** Names for the transitions, for menus. */
+declare const VIDEO_TRANSITION_LABELS: Readonly<Record<VideoTransitionType, string>>;
+/** Whether a transition type takes a `direction`. */
+declare const videoTransitionHasDirection: (type: VideoTransitionType) => boolean;
+/** Names for the blend modes, for menus. */
+declare const VIDEO_BLEND_MODE_LABELS: Readonly<Record<VideoBlendMode, string>>;
 /** Names for the sound fade curves, for menus. */
 declare const VIDEO_FADE_CURVE_LABELS: Readonly<Record<VideoFadeCurve, string>>;
 declare function videoClipTint(clip: VideoClip, asset?: VideoAsset): string;
@@ -1416,4 +1771,4 @@ declare function videoKeyframeValueEdit(project: VideoProject, clipId: string, p
  */
 declare function videoKeyframeToggleEdit(project: VideoProject, clipId: string, property: VideoKeyframeProperty, time: number): VideoEdit | null;
 
-export { type CreateVideoProjectOptions, type NewVideoClip, VIDEO_CLIP_TYPES, VIDEO_DEFAULT_STILL_DURATION, VIDEO_DEFAULT_TITLE_DURATION, VIDEO_EASE_NAMES, VIDEO_EDIT_OPS, VIDEO_FADE_CURVES, VIDEO_FADE_CURVE_LABELS, VIDEO_FITS, VIDEO_ISSUE_CODES, VIDEO_KEYFRAME_LIMITS, VIDEO_KEYFRAME_PROPERTIES, VIDEO_PEAK_BLOCK, VIDEO_PLACEMENT_MODES, VIDEO_TIME_EPSILON, VIDEO_TRANSFORM_PROPERTIES, VIDEO_TRANSITION_TYPES, VIDEO_WIPE_DIRECTIONS, type VideoAnimatable, type VideoAsset, type VideoAssetKind, type VideoAudioLevel, type VideoAudioPeaks, VideoAudioPeaksCache, type VideoAudioPeaksLoader, type VideoAudioSource, type VideoCanvasContext, type VideoClip, type VideoClipDragInput, type VideoClipDragMode, type VideoClipDragPlan, type VideoClipLocation, type VideoClipType, type VideoColorClip, type VideoEase, type VideoEdit, type VideoEditOp, type VideoEditOutcome, type VideoEditResult, VideoEditorController, type VideoEditorOptions, type VideoEditorState, type VideoEditorToolProviderOptions, type VideoEdlOptions, type VideoFadeCurve, type VideoFfmpegExport, type VideoFfmpegOptions, type VideoFit, type VideoFrame, type VideoGap, type VideoIssue, type VideoIssueCode, type VideoIssueSeverity, type VideoKey, type VideoKeyframeProperty, type VideoKeyframeRow, type VideoKeyframes, type VideoLayer, type VideoLoudnessMeasurement, type VideoLoudnessTarget, type VideoMarker, type VideoMediaClip, type VideoMediaProbe, type VideoPlacementMode, VideoPreviewEngine, type VideoPreviewImage, type VideoPreviewMedia, type VideoPreviewOptions, type VideoPreviewSource, type VideoProject, type VideoRect, type VideoRulerTick, type VideoSilenceOptions, type VideoSnapOptions, type VideoSvgOptions, type VideoTextClip, type VideoTrack, type VideoTrackKind, type VideoTransform, type VideoTransition, type VideoTransitionType, type VideoWaveformMode, type VideoWipeDirection, allVideoClipIds, applyVideoEdits, buildVideoAudioPeaks, checkVideoProject, createVideoEditorToolProvider, createVideoProject, decodeVideoAudioPeaks, describeVideoProject, drawVideoFrame, ffmpegFilterValue, findVideoAudioSilences, findVideoClip, findVideoGaps, formatVideoSeconds, formatVideoTimecode, formatVideoTimecodeFrames, isVideoDropFrameRate, isVideoKeyframes, nextFreeVideoSlot, parseVideoAnimatable, parseVideoAsset, parseVideoClip, parseVideoKeyframes, parseVideoLoudnessMeasurement, parseVideoMarker, parseVideoProject, parseVideoTrack, parseVideoTransform, parseVideoTransition, placeVideoRect, planVideoClipDrag, probeVideoMedia, removeVideoKey, retimeVideoAnimatable, setVideoKey, snapToVideoFrame, snapVideoTime, sortVideoKeys, sortedVideoClips, splitVideoAnimatable, toVideoEdl, toVideoFfmpeg, toVideoLoudnessMeasure, videoAssetDropEdit, videoAssetHasSound, videoAssetKindOf, videoAssetMap, videoAudioLevels, videoAudioPeakRange, videoAudioPeakSpans, videoAudioPeaksDuration, videoClipAfter, videoClipBefore, videoClipEnd, videoClipHandles, videoClipKeyframes, videoClipLabel, videoClipOverhang, videoClipShowsWaveform, videoClipSoundGain, videoClipSourceRange, videoClipSpeed, videoClipTint, videoClipWaveform, videoClipWaveformPath, videoClipsAt, videoContactSheetSvg, videoDragLabel, videoDropTracks, videoEaseBezier, videoEaseProgress, videoFadeCurveGain, videoFrameAt, videoFrameDuration, videoFrameToSvg, videoFrames, videoHourFrames, videoIssueKey, videoKeyframeBreakpoints, videoKeyframeFfmpegExpr, videoKeyframeRows, videoKeyframeToggleEdit, videoKeyframeValueEdit, videoKeysOf, videoOverlap, videoPeakDb, videoProjectDuration, videoProjectSvg, videoRulerTicks, videoSnapPoints, videoTextStyle, videoTimecodeFrames, videoTitleFrame, videoTrackSyncLocked, videoTransformAt, videoValueAt, videoWaveformPath, videoWipeRect };
+export { type CreateVideoProjectOptions, type NewVideoClip, VIDEO_BLEND_MODES, VIDEO_BLEND_MODE_LABELS, VIDEO_CLIP_ANIMATION_DURATION, VIDEO_CLIP_ANIMATION_EFFECTS, VIDEO_CLIP_ANIMATION_LABELS, VIDEO_CLIP_TYPES, VIDEO_DEFAULT_FILLERS, VIDEO_DEFAULT_STILL_DURATION, VIDEO_DEFAULT_TITLE_DURATION, VIDEO_EASE_NAMES, VIDEO_EDIT_OPS, VIDEO_FADE_CURVES, VIDEO_FADE_CURVE_LABELS, VIDEO_FITS, VIDEO_GRADE_CONTROLS, VIDEO_GRADE_PRESETS, VIDEO_GRADE_PRESET_NAMES, VIDEO_ISSUE_CODES, VIDEO_KEYFRAME_LIMITS, VIDEO_KEYFRAME_PROPERTIES, VIDEO_PEAK_BLOCK, VIDEO_PLACEMENT_MODES, VIDEO_TIME_EPSILON, VIDEO_TRANSFORM_PROPERTIES, VIDEO_TRANSITION_LABELS, VIDEO_TRANSITION_TYPES, VIDEO_WIPE_DIRECTIONS, type VideoAnimatable, type VideoAsset, type VideoAssetKind, type VideoAudioLevel, type VideoAudioPeaks, VideoAudioPeaksCache, type VideoAudioPeaksLoader, type VideoAudioSource, type VideoBlendMode, type VideoCanvasContext, type VideoClip, type VideoClipAnimation, type VideoClipAnimationEffect, type VideoClipDragInput, type VideoClipDragMode, type VideoClipDragPlan, type VideoClipLocation, type VideoClipType, type VideoColorClip, type VideoEase, type VideoEdit, type VideoEditOp, type VideoEditOutcome, type VideoEditResult, VideoEditorController, type VideoEditorOptions, type VideoEditorState, type VideoEditorToolProviderOptions, type VideoEdlOptions, type VideoFadeCurve, type VideoFfmpegExport, type VideoFfmpegOptions, type VideoFit, type VideoFrame, type VideoGap, type VideoGrade, type VideoGradeControl, type VideoGradePreset, type VideoGradeStep, type VideoIssue, type VideoIssueCode, type VideoIssueSeverity, type VideoKey, type VideoKeyframeProperty, type VideoKeyframeRow, type VideoKeyframes, type VideoLayer, type VideoLoudnessMeasurement, type VideoLoudnessTarget, type VideoMarker, type VideoMediaClip, type VideoMediaProbe, type VideoPauseOptions, type VideoPlacementMode, VideoPreviewEngine, type VideoPreviewImage, type VideoPreviewMedia, type VideoPreviewOptions, type VideoPreviewSource, type VideoProject, type VideoRect, type VideoRulerTick, type VideoSilenceOptions, type VideoSnapOptions, type VideoSvgOptions, type VideoTextClip, type VideoTimelineWord, type VideoTrack, type VideoTrackKind, type VideoTranscriptRange, type VideoTranscriptWord, type VideoTransform, type VideoTransition, type VideoTransitionType, type VideoWaveformMode, type VideoWipeDirection, allVideoClipIds, applyVideoEdits, applyVideoGrade, buildVideoAudioPeaks, checkVideoProject, createVideoEditorToolProvider, createVideoProject, decodeVideoAudioPeaks, describeVideoProject, drawVideoFrame, ffmpegFilterValue, findVideoAudioSilences, findVideoClip, findVideoFillers, findVideoGaps, findVideoTranscriptPauses, findVideoTranscriptText, formatVideoSeconds, formatVideoTimecode, formatVideoTimecodeFrames, isVideoDropFrameRate, isVideoKeyframes, mergeVideoRanges, nextFreeVideoSlot, normalizeVideoGrade, normalizeVideoWord, parseVideoAnimatable, parseVideoAsset, parseVideoClip, parseVideoClipAnimation, parseVideoGrade, parseVideoKeyframes, parseVideoLoudnessMeasurement, parseVideoMarker, parseVideoProject, parseVideoTrack, parseVideoTranscript, parseVideoTranscriptWords, parseVideoTransform, parseVideoTransition, placeVideoRect, planVideoClipDrag, probeVideoMedia, removeVideoKey, retimeVideoAnimatable, setVideoKey, snapToVideoFrame, snapVideoTime, sortVideoKeys, sortedVideoClips, splitVideoAnimatable, toVideoEdl, toVideoFfmpeg, toVideoLoudnessMeasure, videoAssetDropEdit, videoAssetHasSound, videoAssetKindOf, videoAssetMap, videoAudioLevels, videoAudioPeakRange, videoAudioPeakSpans, videoAudioPeaksDuration, videoClipAfter, videoClipAnimated, videoClipAnimationProperties, videoClipAnimationSpans, videoClipBefore, videoClipEnd, videoClipHandles, videoClipKeyframes, videoClipLabel, videoClipOverhang, videoClipShowsWaveform, videoClipSoundGain, videoClipSourceRange, videoClipSpeed, videoClipTint, videoClipWaveform, videoClipWaveformPath, videoClipsAt, videoContactSheetSvg, videoDragLabel, videoDropTracks, videoEaseBezier, videoEaseProgress, videoFadeCurveGain, videoFrameAt, videoFrameDuration, videoFrameToSvg, videoFrames, videoGradeCssFilter, videoGradeFfmpegFilters, videoGradeGainsFilterId, videoGradePreset, videoGradeStepMatrix, videoGradeStepSvgValues, videoGradeSteps, videoGradeSvgDefs, videoGradeSvgFilter, videoHourFrames, videoIrisRadius, videoIssueKey, videoKeyframeBreakpoints, videoKeyframeFfmpegExpr, videoKeyframeRows, videoKeyframeToggleEdit, videoKeyframeValueEdit, videoKeysOf, videoOverlap, videoPeakDb, videoProjectDuration, videoProjectSvg, videoRemoveRangesEdits, videoRulerTicks, videoSnapPoints, videoTextStyle, videoTimecodeFrames, videoTimelineTranscript, videoTitleFrame, videoTrackSyncLocked, videoTranscriptEdit, videoTranscriptTrack, videoTransformAt, videoTransitionAudioCurve, videoTransitionEase, videoTransitionHasDirection, videoValueAt, videoWaveformPath, videoWipeRect, videoWordAt, videoWordsRange };