@pixerate/editor 0.85.0 → 0.87.0

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

@@ -268,6 +268,13 @@ interface VideoMediaClip extends VideoClipBase {
     in?: number;
     /** Playback speed (default 1): it uses `duration × speed` of the source. */
     speed?: number;
+    /**
+     * A speed ramp: keys mapping clip time to source time after the in point (`v` ms from `in`), so
+     * a key's slope is the speed there, a flat stretch is a freeze frame and eased keys ramp between
+     * speeds. Never runs backwards. Before the first key and after the last the picture holds. Takes
+     * the place of `speed` (see `videoSpeedRampKeys` for building one from speeds).
+     */
+    timeRemap?: VideoKeyframes;
     /** Gain (1 = unchanged, default 1), or keyframes. */
     volume?: VideoAnimatable;
     /** Silences this clip. */
@@ -344,6 +351,7 @@ declare function parseVideoAnimatable(v: unknown, path: string, range?: {
     optional?: boolean;
 }): VideoAnimatable | undefined;
 declare function parseVideoTransform(v: unknown, path: string): VideoTransform | undefined;
+declare function parseVideoTimeRemap(v: unknown, speed: unknown, path: string): VideoKeyframes | 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;
@@ -635,6 +643,18 @@ type VideoEdit = ({
     clip: string;
     property: VideoKeyframeProperty;
     keys: VideoKey[] | null;
+}
+/**
+ * A speed ramp: keys mapping clip time to source ms after the in point (see `timeRemap`), or
+ * null to play at normal speed from where the ramp started. `duration` sets the clip's new length
+ * (default: unchanged); `ripple` moves later material with the change.
+ */
+ | {
+    op: 'set_time_remap';
+    clip: string;
+    keys: VideoKey[] | null;
+    duration?: number;
+    ripple?: boolean;
 } | {
     op: 'close_gaps';
     track: string;
@@ -1018,6 +1038,223 @@ declare function videoGradeSvgDefs(grade: VideoGrade | undefined): {
 /** 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[];
 
+/**
+ * Colour scopes: a histogram, a luma waveform and a vectorscope, worked out from a frame's pixels,
+ * plus exposure and clipping figures. Pure functions on RGBA pixels as `ImageData` holds them, so
+ * the same numbers come from a preview canvas, a decoded export frame or a test.
+ *
+ * Luma and chroma use the Rec. 709 weights on the gamma-encoded values (Y′, Cb, Cr), as broadcast
+ * scopes do: luma 0 is black and 1 white; Cb and Cr run from −0.5 to 0.5.
+ */
+/** RGBA pixels, 4 values (0–255) a pixel, rows top to bottom: an `ImageData` fits. */
+interface VideoPixels {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}
+type VideoScopeKind = 'histogram' | 'waveform' | 'vectorscope';
+declare const VIDEO_SCOPE_KINDS: readonly ["histogram", "waveform", "vectorscope"];
+/** Rec. 709 luma of gamma-encoded RGB (each 0–1). */
+declare const videoLuma: (r: number, g: number, b: number) => number;
+/** Rec. 709 chroma (Cb, Cr), each −0.5 to 0.5, of gamma-encoded RGB (each 0–1). */
+declare function videoChroma(r: number, g: number, b: number): [number, number];
+interface VideoScopeOptions {
+    /**
+     * Read at most about this many pixels, evenly spaced (default 262 144, a 512 × 512 picture), so
+     * a large frame costs no more than a small one. Counts are of the pixels read.
+     */
+    maxPixels?: number;
+}
+/** How many pixels fall in each of `bins` equal steps of red, green, blue and luma (bin 0 is darkest). */
+interface VideoHistogram {
+    bins: number;
+    r: number[];
+    g: number[];
+    b: number[];
+    luma: number[];
+    /** Pixels counted. */
+    total: number;
+}
+declare function videoHistogram(pixels: VideoPixels, options?: VideoScopeOptions & {
+    bins?: number;
+}): VideoHistogram;
+/**
+ * A luma waveform: the picture split into `columns` vertical strips, left to right, each counting
+ * its pixels at each of `levels` luma steps. `data[column * levels + level]`; level 0 is black.
+ */
+interface VideoWaveform {
+    columns: number;
+    levels: number;
+    data: Uint32Array;
+    /** The largest count, for scaling a drawing. */
+    peak: number;
+}
+declare function videoLumaWaveform(pixels: VideoPixels, options?: VideoScopeOptions & {
+    columns?: number;
+    levels?: number;
+}): VideoWaveform;
+/**
+ * A vectorscope: pixels counted on a `size` × `size` grid by chroma, Cb across (left −0.5, right
+ * +0.5) and Cr up (top +0.5). The centre is grey; the further out, the more saturated; the angle
+ * is the hue. `data[row * size + column]`.
+ */
+interface VideoVectorscope {
+    size: number;
+    data: Uint32Array;
+    peak: number;
+}
+/** Where chroma (Cb, Cr) falls on a vectorscope of `size` pixels, as `[column, row]`. */
+declare const videoVectorscopePoint: (cb: number, cr: number, size: number) => [number, number];
+declare function videoVectorscope(pixels: VideoPixels, options?: VideoScopeOptions & {
+    size?: number;
+}): VideoVectorscope;
+/** Exposure and colour figures for a frame (see `videoExposureStats`). Luma and levels run 0–1. */
+interface VideoExposureStats {
+    /** Pixels read. */
+    pixels: number;
+    luma: {
+        mean: number;
+        median: number;
+        min: number;
+        max: number;
+        p1: number;
+        p99: number;
+    };
+    /** Share (0–1) of pixels crushed to black (luma at or below `shadowLevel`) or blown to white (at or above `highlightLevel`). */
+    clipped: {
+        shadows: number;
+        highlights: number;
+        r: number;
+        g: number;
+        b: number;
+    };
+    /** Mean and highest chroma, 0 (grey) to 1 (a full primary). */
+    saturation: {
+        mean: number;
+        max: number;
+    };
+    /** The mean colour as `#rrggbb`: far from grey means a colour cast. */
+    average: string;
+}
+interface VideoExposureOptions extends VideoScopeOptions {
+    /** Luma (0–1) at or below which a pixel counts as crushed (default 0.02). */
+    shadowLevel?: number;
+    /** Luma or channel (0–1) at or above which a pixel counts as blown (default 0.98). */
+    highlightLevel?: number;
+}
+declare function videoExposureStats(pixels: VideoPixels, options?: VideoExposureOptions): VideoExposureStats;
+/** What a scope reading says in words: exposure, clipping and colour cast worth fixing. */
+declare function videoExposureNotes(stats: VideoExposureStats): string[];
+/** A compact reading of a frame for agents: exposure figures, notes, and coarse histogram, waveform and vectorscope summaries. */
+interface VideoScopeSummary {
+    stats: VideoExposureStats;
+    notes: string[];
+    /** Share of pixels (0–1) in each of `bins` equal luma and channel steps, darkest first. */
+    histogram: {
+        bins: number;
+        luma: number[];
+        r: number[];
+        g: number[];
+        b: number[];
+    };
+    /** The picture in vertical strips, left to right: each strip's luma spread (0–1). */
+    waveform: {
+        start: number;
+        end: number;
+        min: number;
+        median: number;
+        max: number;
+    }[];
+    /** The chroma of the most saturated tenth of the picture: its main hue (degrees on the vectorscope, red ≈ 103°) and strength (0–1). */
+    vectorscope: {
+        hue: number | null;
+        strength: number;
+        spread: number;
+    };
+}
+/** Vectorscope angle (degrees, anticlockwise from +Cb) of chroma. */
+declare const videoVectorscopeAngle: (cb: number, cr: number) => number;
+declare function summarizeVideoScopes(pixels: VideoPixels, options?: VideoExposureOptions & {
+    bins?: number;
+    columns?: number;
+}): VideoScopeSummary;
+/** Where the six 75% colour-bar targets sit on a vectorscope: name, Cb and Cr. */
+declare const VIDEO_VECTORSCOPE_TARGETS: readonly {
+    name: string;
+    rgb: [number, number, number];
+    cb: number;
+    cr: number;
+}[];
+/** RGBA pixels of a drawn scope, ready for `new ImageData(data, width, height)`. */
+interface VideoScopeImage {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray<ArrayBuffer>;
+}
+/** A histogram drawn `width` × `height`: red, green and blue added together, with luma as a white outline. */
+declare function videoHistogramImage(h: VideoHistogram, width?: number, height?: number): VideoScopeImage;
+/** A luma waveform drawn `width` × `height`: white at the top, black at the bottom, lines at each quarter. */
+declare function videoWaveformImage(w: VideoWaveform, width?: number, height?: number): VideoScopeImage;
+/** A vectorscope drawn `size` × `size`, with its outer circle, the skin-tone line and the colour-bar targets. */
+declare function videoVectorscopeImage(v: VideoVectorscope, size?: number): VideoScopeImage;
+/** One scope of a frame drawn `width` × `height` (a vectorscope is square: the smaller side). */
+declare function videoScopeImage(kind: VideoScopeKind, pixels: VideoPixels, width?: number, height?: number, options?: VideoScopeOptions): VideoScopeImage;
+/** A frame the preview drew: when, whether every picture in it had loaded, and its pixels. */
+interface VideoPreviewSnapshot {
+    time: number;
+    /** False while a picture is still loading or seeking (the frame shows a placeholder or a stale picture). */
+    complete: boolean;
+    pixels: VideoPixels;
+}
+/**
+ * Where a preview's pixels can be read, for scopes and agents: a `VideoPreviewEngine` attaches its
+ * canvas and says each time it draws. `VideoEditorController.previewPixels` is one, so a preview,
+ * a scopes panel and the agent tools of one editor find each other without wiring.
+ */
+declare class VideoPreviewPixels {
+    private reader;
+    private drawnAt;
+    private readonly listeners;
+    /** Gives the canvas to read (the latest preview wins). Returns a function that takes it away again. */
+    attach(reader: () => VideoPreviewSnapshot | null): () => void;
+    /** Whether a preview is attached. */
+    get attached(): boolean;
+    /** The preview drew the frame at `time`; `complete` is false while a picture was missing or stale. */
+    drawn(time: number, complete: boolean): void;
+    /** The last frame drawn, with its pixels; `null` without a preview. Throws when the canvas cannot be read. */
+    read(): VideoPreviewSnapshot | null;
+    /** Called after each frame the preview draws. */
+    subscribe(listener: () => void): () => void;
+    /**
+     * The frame at `time` once it is complete: now, if the last frame drawn was it, else the next
+     * complete drawing of it. Fails after `timeout` ms (default 5000).
+     */
+    next(time: number, timeout?: number): Promise<VideoPreviewSnapshot>;
+    private emit;
+}
+/** What a scopes panel shows for the preview's latest frame (see `readVideoScopesPanel`). */
+type VideoScopesPanelReading = {
+    ok: true;
+    time: number;
+    complete: boolean;
+    images: Partial<Record<VideoScopeKind, VideoScopeImage>>;
+    stats: VideoExposureStats;
+    notes: string[];
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * The preview's latest frame as a scopes panel draws it: an image per scope `kinds`, each
+ * `width` × `height` (vectorscopes square), and the exposure figures. Reads at most `maxPixels`
+ * (default 65 536) so it keeps up with playback. Says why when there is nothing to show.
+ */
+declare function readVideoScopesPanel(feed: VideoPreviewPixels, kinds?: readonly VideoScopeKind[], options?: {
+    width?: number;
+    height?: number;
+    maxPixels?: number;
+}): VideoScopesPanelReading;
+
 /** Default length of an entrance or exit animation (ms). */
 declare const VIDEO_CLIP_ANIMATION_DURATION = 500;
 declare const PROPS: readonly ["opacity", "x", "y", "scale"];
@@ -1123,6 +1360,55 @@ 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;
 
+/**
+ * Speed ramps and freeze frames: a media clip's `timeRemap` keys map clip time to source time after
+ * its in point. The slope between two keys is the speed there; equal values are a freeze; an eased
+ * segment changes speed smoothly. These helpers read and build them.
+ */
+/** Where in the source (ms) a media clip is at clip time `clipTime`, through its speed or its ramp. */
+declare function videoClipSourceTime(clip: VideoMediaClip, clipTime: number): number;
+/** The speed a media clip plays at at clip time `clipTime` (0 in a freeze), measured over a millisecond. */
+declare function videoClipSpeedAt(clip: VideoClip, clipTime: number): number;
+/** One stretch of a ramp: `duration` ms of the clip at `speed`, or easing from `speed` to `toSpeed`. 0 is a freeze. */
+interface VideoSpeedSegment {
+    duration: number;
+    speed: number;
+    /** Ramp smoothly to this speed by the end of the stretch (default: stay at `speed`). */
+    toSpeed?: number;
+}
+/**
+ * Remap keys for stretches of speed, from the clip's start: steady stretches are linear segments,
+ * ramps a cubic-bezier ease that changes the speed evenly from one to the other (the source moves
+ * the average of the two speeds over the stretch). Returns the keys and the source the clip plays.
+ */
+declare function videoSpeedRampKeys(segments: readonly VideoSpeedSegment[]): {
+    keys: VideoKey[];
+    duration: number;
+    source: number;
+};
+/**
+ * Checks remap keys: in time order and never going back in the source, eased segments included
+ * (each is sampled, so a curve that overshoots and would play backwards is caught). Throws a
+ * readable error.
+ */
+declare function checkVideoTimeRemap(remap: VideoKeyframes, path?: string): void;
+/** The stretch of source (ms, from the in point) a ramp plays: from its first key's value to its last's. */
+declare function videoTimeRemapSpan(remap: VideoKeyframes): {
+    from: number;
+    to: number;
+};
+/** Clip time and source time pairs tracing a ramp as straight lines (eased stretches sampled every `step` ms), with freezes marked. */
+declare function videoTimeRemapBreakpoints(remap: VideoKeyframes, step: number): {
+    t: number;
+    v: number;
+}[];
+/** The edit that plays a media clip through stretches of speed from the moment it shows at its start (see `videoSpeedRampKeys`). */
+declare function videoSpeedRampEdit(clip: VideoMediaClip, segments: readonly VideoSpeedSegment[], ripple?: boolean): VideoEdit;
+/** The edit that holds the frame a media clip shows at clip time `at` for `duration` ms, then plays on (the clip gets longer). */
+declare function videoFreezeFrameEdit(clip: VideoMediaClip, at: number, duration: number, ripple?: boolean): VideoEdit;
+/** A slow-motion ramp preset for a clip of `duration` ms: normal speed for half of it, a 500 ms glide down to 0.3×, then 1.5 s at 0.3×. */
+declare const videoSlowMotionRamp: (duration: number) => VideoSpeedSegment[];
+
 /** Radius of an iris `progress` (0–1) open: from nothing to the frame's corners. */
 declare const videoIrisRadius: (frame: {
     width: number;
@@ -1285,6 +1571,8 @@ interface VideoPreviewSource {
         playing: boolean;
     };
     subscribe(listener: () => void): () => void;
+    /** Where to publish the drawn pixels (a controller has one), for scopes and agents. */
+    previewPixels?: VideoPreviewPixels;
 }
 /** The parts of a media element the preview drives (so tests can pass fakes). */
 interface VideoPreviewMedia {
@@ -1294,6 +1582,8 @@ interface VideoPreviewMedia {
     volume: number;
     muted: boolean;
     paused: boolean;
+    /** True while a seek is under way (the element still shows the old frame). */
+    seeking?: boolean;
     readyState: number;
     preload: string;
     play(): Promise<void> | void;
@@ -1325,6 +1615,11 @@ interface VideoPreviewOptions {
      * it. Default: a hidden `<svg>` added to `document.body`. `null` leaves white balance out.
      */
     defineSvgFilter?: ((id: string, markup: string) => void) | null;
+    /**
+     * Where to publish the canvas's pixels after each frame, for scopes and the `get_video_scopes`
+     * tool (default: the source's `previewPixels`). `null` publishes nothing.
+     */
+    pixels?: VideoPreviewPixels | null;
 }
 /**
  * Plays a project in the browser: keeps one `<video>` or `<audio>` element per playing clip in step
@@ -1344,12 +1639,18 @@ declare class VideoPreviewEngine {
     private destroyed;
     private filterHost;
     private readonly filters;
+    private readonly detachPixels;
+    private readonly pixelsTarget;
+    private drawn;
+    private complete;
     constructor(source: VideoPreviewSource, canvas: {
         width: number;
         height: number;
         clientWidth?: number;
         getContext?: (id: '2d') => unknown;
     }, options?: VideoPreviewOptions);
+    /** The canvas's pixels and the frame they show, or `null` when its context cannot be read. */
+    readPixels(): VideoPreviewSnapshot | null;
     private createMedia;
     private image;
     private entry;
@@ -1418,6 +1719,8 @@ declare class VideoEditorController {
     readonly player: AnimationPlayer;
     /** Sound levels per asset, loaded on demand for waveforms and agents. */
     readonly audioPeaks: VideoAudioPeaksCache;
+    /** The pixels the preview last drew, for scopes and `get_video_scopes` (a `VideoPreviewEngine` fills it). */
+    readonly previewPixels: VideoPreviewPixels;
     private project;
     private issues;
     private selection;
@@ -1518,6 +1821,14 @@ interface VideoEditorToolProviderOptions {
         data: string;
         mimeType: string;
     };
+    /**
+     * The rendered pixels of the frame at `time` (ms), for `get_video_scopes` (e.g. a frame decoded
+     * by ffmpeg on a server). Default: what the editor's `<VideoPreview>` draws, through
+     * `controller.previewPixels`, seeking it there and back when `time` is not the playhead.
+     */
+    framePixels?: (time: number) => VideoPixels | null | Promise<VideoPixels | null>;
+    /** How long `get_video_scopes` waits for the preview to finish drawing a frame (ms, default 5000). */
+    framePixelsTimeout?: number;
 }
 /** A project as agents see it: settings, assets, and each track's clips in order with their times. */
 declare function describeVideoProject(project: VideoProject): {
@@ -1554,6 +1865,7 @@ declare function describeVideoProject(project: VideoProject): {
             asset: string;
             in?: number;
             speed?: number;
+            timeRemap?: VideoKeyframes;
             volume?: VideoAnimatable;
             muted?: boolean;
             fadeInCurve?: VideoFadeCurve;
@@ -1771,4 +2083,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_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 };
+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_SCOPE_KINDS, VIDEO_TIME_EPSILON, VIDEO_TRANSFORM_PROPERTIES, VIDEO_TRANSITION_LABELS, VIDEO_TRANSITION_TYPES, VIDEO_VECTORSCOPE_TARGETS, 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 VideoExposureOptions, type VideoExposureStats, type VideoFadeCurve, type VideoFfmpegExport, type VideoFfmpegOptions, type VideoFit, type VideoFrame, type VideoGap, type VideoGrade, type VideoGradeControl, type VideoGradePreset, type VideoGradeStep, type VideoHistogram, 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 VideoPixels, type VideoPlacementMode, VideoPreviewEngine, type VideoPreviewImage, type VideoPreviewMedia, type VideoPreviewOptions, VideoPreviewPixels, type VideoPreviewSnapshot, type VideoPreviewSource, type VideoProject, type VideoRect, type VideoRulerTick, type VideoScopeImage, type VideoScopeKind, type VideoScopeOptions, type VideoScopeSummary, type VideoScopesPanelReading, type VideoSilenceOptions, type VideoSnapOptions, type VideoSpeedSegment, type VideoSvgOptions, type VideoTextClip, type VideoTimelineWord, type VideoTrack, type VideoTrackKind, type VideoTranscriptRange, type VideoTranscriptWord, type VideoTransform, type VideoTransition, type VideoTransitionType, type VideoVectorscope, type VideoWaveform, type VideoWaveformMode, type VideoWipeDirection, allVideoClipIds, applyVideoEdits, applyVideoGrade, buildVideoAudioPeaks, checkVideoProject, checkVideoTimeRemap, 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, parseVideoTimeRemap, parseVideoTrack, parseVideoTranscript, parseVideoTranscriptWords, parseVideoTransform, parseVideoTransition, placeVideoRect, planVideoClipDrag, probeVideoMedia, readVideoScopesPanel, removeVideoKey, retimeVideoAnimatable, setVideoKey, snapToVideoFrame, snapVideoTime, sortVideoKeys, sortedVideoClips, splitVideoAnimatable, summarizeVideoScopes, toVideoEdl, toVideoFfmpeg, toVideoLoudnessMeasure, videoAssetDropEdit, videoAssetHasSound, videoAssetKindOf, videoAssetMap, videoAudioLevels, videoAudioPeakRange, videoAudioPeakSpans, videoAudioPeaksDuration, videoChroma, videoClipAfter, videoClipAnimated, videoClipAnimationProperties, videoClipAnimationSpans, videoClipBefore, videoClipEnd, videoClipHandles, videoClipKeyframes, videoClipLabel, videoClipOverhang, videoClipShowsWaveform, videoClipSoundGain, videoClipSourceRange, videoClipSourceTime, videoClipSpeed, videoClipSpeedAt, videoClipTint, videoClipWaveform, videoClipWaveformPath, videoClipsAt, videoContactSheetSvg, videoDragLabel, videoDropTracks, videoEaseBezier, videoEaseProgress, videoExposureNotes, videoExposureStats, videoFadeCurveGain, videoFrameAt, videoFrameDuration, videoFrameToSvg, videoFrames, videoFreezeFrameEdit, videoGradeCssFilter, videoGradeFfmpegFilters, videoGradeGainsFilterId, videoGradePreset, videoGradeStepMatrix, videoGradeStepSvgValues, videoGradeSteps, videoGradeSvgDefs, videoGradeSvgFilter, videoHistogram, videoHistogramImage, videoHourFrames, videoIrisRadius, videoIssueKey, videoKeyframeBreakpoints, videoKeyframeFfmpegExpr, videoKeyframeRows, videoKeyframeToggleEdit, videoKeyframeValueEdit, videoKeysOf, videoLuma, videoLumaWaveform, videoOverlap, videoPeakDb, videoProjectDuration, videoProjectSvg, videoRemoveRangesEdits, videoRulerTicks, videoScopeImage, videoSlowMotionRamp, videoSnapPoints, videoSpeedRampEdit, videoSpeedRampKeys, videoTextStyle, videoTimeRemapBreakpoints, videoTimeRemapSpan, videoTimecodeFrames, videoTimelineTranscript, videoTitleFrame, videoTrackSyncLocked, videoTranscriptEdit, videoTranscriptTrack, videoTransformAt, videoTransitionAudioCurve, videoTransitionEase, videoTransitionHasDirection, videoValueAt, videoVectorscope, videoVectorscopeAngle, videoVectorscopeImage, videoVectorscopePoint, videoWaveformImage, videoWaveformPath, videoWipeRect, videoWordAt, videoWordsRange };