@pixerate/editor 0.89.0 → 0.91.0

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

@@ -98,6 +98,15 @@ interface VideoTranscriptWord {
     start: number;
     end: number;
 }
+/** A smaller copy of an asset's media for the preview (see `VideoAsset.proxies`). */
+interface VideoAssetProxy {
+    /** Its size as a fraction of the original (0.5 = half width and height). */
+    scale: number;
+    /** What the preview loads instead of the original. */
+    src: string;
+    width?: number;
+    height?: number;
+}
 /** A piece of source media. The project refers to it by id; `src` is whatever the host can load. */
 interface VideoAsset {
     id: string;
@@ -116,6 +125,12 @@ interface VideoAsset {
     poster?: string;
     /** What is said in it, word by word, timed in the source (see `parseVideoTranscript`). */
     transcript?: VideoTranscriptWord[];
+    /**
+     * Smaller copies of a video for smooth editing (see `videoProxyFfmpeg`). The preview plays the
+     * one its preview scale picks; exports and EDLs always use `src`. A proxy must have the same
+     * length and timing as the original.
+     */
+    proxies?: VideoAssetProxy[];
 }
 type VideoTrackKind = 'video' | 'audio';
 interface VideoTrack {
@@ -369,6 +384,7 @@ declare function parseVideoGradeLut(v: unknown, path: string): VideoGradeLut | u
 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 parseVideoAssetProxies(v: unknown, path: string): VideoAssetProxy[] | undefined;
 declare function parseVideoClip(v: unknown, path?: string): VideoClip;
 declare function parseVideoTrack(v: unknown, path?: string): VideoTrack;
 declare function parseVideoMarker(v: unknown, path?: string): VideoMarker;
@@ -1671,6 +1687,8 @@ interface VideoFfmpegExport {
 }
 /** Escapes a value for a filter option inside a filtergraph (option level, then graph level). */
 declare const ffmpegFilterValue: (s: string) => string;
+/** Quotes an argument for a POSIX shell when it needs it. */
+declare const videoShellQuote: (s: string) => string;
 /**
  * The project as an ffmpeg command: each clip an input trimmed to what it plays (plus transition
  * overlap), scaled and placed as `videoFrameAt` places it, faded, and overlaid on a background in
@@ -1686,18 +1704,250 @@ declare function toVideoFfmpeg(project: VideoProject, options?: VideoFfmpegOptio
  */
 declare function toVideoLoudnessMeasure(project: VideoProject, options?: Pick<VideoFfmpegOptions, 'resolve' | 'loudness'>): VideoFfmpegExport;
 
+/**
+ * How large a picture the preview plays: `full` (the original), a fraction (0.5 = half size, using
+ * the smallest proxy at least that large), or `auto` (what the preview canvas shows).
+ */
+type VideoPreviewScale = 'auto' | 'full' | number;
+/** The scales a preview-scale control offers, besides `auto` and `full`. */
+declare const VIDEO_PROXY_SCALES: readonly [0.5, 0.25];
+/** The proxy the preview plays at `scale` (0–1]: the smallest at least that large, else `null` (play the original). */
+declare function videoAssetProxy(asset: Pick<VideoAsset, 'proxies'> | undefined, scale: number): VideoAssetProxy | null;
+/** The `src` the preview plays for an asset at `scale`: a proxy's, or the original's. */
+declare const videoPreviewSrc: (asset: VideoAsset | undefined, scale: number, fallback?: string) => string;
+/** A preview scale as a fraction: `full` is 1, `auto` is `shown` (the canvas's resolution, at most 1). */
+declare function resolveVideoPreviewScale(scale: VideoPreviewScale | undefined, shown: number): number;
+interface VideoProxyOptions {
+    /** Size of the proxy as a fraction of the original (default 0.5). */
+    scale?: number;
+    /** Output file (default: the source's name with `.proxy-50.mp4`, for scale 0.5). */
+    output?: string;
+    /** The path or URL ffmpeg should open (default the asset's `src`). */
+    resolve?: (asset: VideoAsset) => string;
+    /** Frames between keyframes (default 12): short, so seeking and scrubbing decode little. */
+    gop?: number;
+    /** x264 quality (default 28: small files; proxies are for editing, not viewing). */
+    crf?: number;
+}
+/** A proxy's file name next to `src`: `clip.mov` at 0.5 → `clip.proxy-50.mp4`. */
+declare function videoProxyName(src: string, scale?: number): string;
+/** An ffmpeg command making an asset's proxy, and the proxy entry to add once it exists. */
+interface VideoProxyCommand {
+    asset: string;
+    args: string[];
+    /** One shell line. */
+    command: string;
+    /** The entry for `VideoAsset.proxies` (its `src` is the output; map it to a URL the preview can load if needed). */
+    proxy: VideoAssetProxy;
+}
+/**
+ * The ffmpeg command for a proxy of a video asset: scaled to `scale` (even sizes), H.264 with a
+ * short keyframe interval (`gop`) and no B-frames so seeking is cheap, `fastdecode`, the sound
+ * kept as AAC, and `faststart` so a browser can play it while it loads.
+ */
+declare function videoProxyFfmpeg(asset: VideoAsset, options?: VideoProxyOptions): VideoProxyCommand;
+/** Commands for every video asset (or those listed) without a proxy at `scale`. */
+declare function videoProxyPlan(project: VideoProject, options?: VideoProxyOptions & {
+    assets?: readonly string[];
+    output?: never;
+}): VideoProxyCommand[];
+/** The choices a preview-size control offers, with labels: `value` round-trips through `parseVideoPreviewScale`. */
+declare const VIDEO_PREVIEW_SCALE_OPTIONS: readonly {
+    value: string;
+    label: string;
+    scale: VideoPreviewScale;
+}[];
+/** A preview-size control's value back as a scale (`auto` for anything unknown). */
+declare const parseVideoPreviewScale: (value: string) => VideoPreviewScale;
+/** Whether any asset has proxies (so a preview-size control is worth showing). */
+declare const videoProjectHasProxies: (project: VideoProject) => boolean;
+
+/**
+ * A cache of decoded source frames for the preview, with prefetch ahead of the playhead, after the
+ * way Blender's sequencer caches strips: scrubbing and stepping show cached frames at once instead
+ * of waiting for a `<video>` to seek. It is host-side and optional: give a `VideoFrameCache` to the
+ * controller (`frameCache`) or the preview engine.
+ *
+ * Frames are keyed by the file the preview plays (the asset's `src`, or the proxy it picks) and the
+ * source frame, not by clip: every clip of an asset shares them, and edits never invalidate them.
+ * Eviction removes the frames furthest from the playhead, counting frames behind it (against the
+ * play direction) as further, and never touches the prefetch window.
+ */
+
+/** The source frame showing at a source time (ms) on an `fps` grid: a frame shows from its start. */
+declare const videoSourceFrame: (sourceTime: number, fps: number) => number;
+/** The middle of a source frame (ms): where a decoder should seek, away from the frame's edges. */
+declare const videoSourceFrameTime: (frame: number, fps: number) => number;
+/** A cache key: the file and the source frame. */
+declare const videoFrameCacheKey: (src: string, frame: number) => string;
+/** A frame the preview will need: the file, the source frame and when on the timeline it shows. */
+interface VideoFrameRequest {
+    key: string;
+    src: string;
+    frame: number;
+    /** Where to seek in the source (ms): the middle of the frame. */
+    sourceTime: number;
+    /** When it shows on the timeline (ms). */
+    time: number;
+}
+/** The video layers' source frames at timeline `time`, as the preview would play them. */
+declare function videoFrameRequestsAt(project: VideoProject, time: number, srcFor?: (layer: VideoLayer) => string | undefined): VideoFrameRequest[];
+/**
+ * The frames to have ready from `time` over the next `window` ms (backwards with `direction` -1),
+ * a frame apart, nearest first, each key once.
+ */
+declare function planVideoPrefetch(project: VideoProject, time: number, options?: {
+    window?: number;
+    direction?: 1 | -1;
+    srcFor?: (layer: VideoLayer) => string | undefined;
+}): VideoFrameRequest[];
+/** A cached frame's bookkeeping for eviction. */
+interface VideoCacheEntryInfo {
+    key: string;
+    /** When it last showed (or will show) on the timeline (ms). */
+    time: number;
+    bytes: number;
+}
+/**
+ * Which entries to drop to get under `maxBytes`: never those in the prefetch window
+ * (`protect`), then the furthest from the playhead first, with frames behind it (against
+ * `direction`) counted `behind` times as far (default 2), so the way you are going is kept.
+ */
+declare function videoCacheEvictions(entries: readonly VideoCacheEntryInfo[], options: {
+    playhead: number;
+    maxBytes: number;
+    direction?: 1 | -1;
+    behind?: number;
+    protect?: ReadonlySet<string>;
+}): string[];
+/** A decoded frame: anything `drawImage` takes, with its size (`close` is called when it is evicted). */
+interface VideoDecodedFrame {
+    image: CanvasImageSource & {
+        close?: () => void;
+    };
+    width: number;
+    height: number;
+}
+/** Decodes the frame of `src` at a source time (ms). */
+type VideoFrameDecoder = (src: string, sourceTime: number) => Promise<VideoDecodedFrame>;
+interface VideoFrameCacheOptions {
+    /** How frames are decoded for prefetch (default in a browser: `createVideoElementDecoder()`; elsewhere none, so only frames the preview hands over are kept). */
+    decode?: VideoFrameDecoder | null;
+    /** Memory budget in bytes (4 a pixel; default 512 MB). */
+    maxBytes?: number;
+    /** How far ahead of the playhead to prefetch (ms, default 2000; 0 turns prefetch off). */
+    prefetch?: number;
+    /** How much further frames behind the playhead count when evicting (default 2). */
+    behind?: number;
+    /** Frames decoded at once (default 2). */
+    concurrency?: number;
+    /** Copies a ready media element's current picture (default `createImageBitmap`), to keep frames the preview has shown. */
+    capture?: (source: CanvasImageSource) => Promise<VideoDecodedFrame | null>;
+}
+/** The cache's state, for a status line and agents. */
+interface VideoFrameCacheStats {
+    frames: number;
+    bytes: number;
+    maxBytes: number;
+    hits: number;
+    misses: number;
+    /** Frames being decoded or waiting to be. */
+    pending: number;
+    prefetch: number;
+}
+/**
+ * Decoded source frames for the preview, filled ahead of the playhead and evicted by distance from
+ * it (see the module notes). `VideoPreviewEngine` calls `update` as the playhead moves, draws hits
+ * from `get` while paused or while an element seeks, and hands over frames it has shown.
+ */
+declare class VideoFrameCache {
+    private readonly options;
+    private readonly entries;
+    private readonly inFlight;
+    private queue;
+    private protect;
+    private readonly listeners;
+    private playhead;
+    private direction;
+    private hits;
+    private misses;
+    private bytes;
+    private generation;
+    private destroyed;
+    private srcFor;
+    readonly maxBytes: number;
+    readonly prefetch: number;
+    private readonly decode;
+    constructor(options?: VideoFrameCacheOptions);
+    /** The cached frame of `src` showing at a source time (ms), on the project's `fps` grid. Counts a hit or a miss. */
+    get(src: string, sourceTime: number, fps: number): CanvasImageSource | undefined;
+    /** Whether a frame is cached, without counting it. */
+    has(src: string, sourceTime: number, fps: number): boolean;
+    /** Keeps a decoded frame (replacing any with the same key), then evicts to the budget. */
+    put(request: Pick<VideoFrameRequest, 'key' | 'time'>, frame: VideoDecodedFrame): void;
+    /** Keeps what a ready media element shows now as the frame of `src` at `sourceTime` (async; does nothing if it is cached). */
+    capture(src: string, sourceTime: number, fps: number, time: number, source: CanvasImageSource): void;
+    /**
+     * Follows the playhead: protects the prefetch window, evicts to the budget, and queues the
+     * window's missing frames for decoding (nearest first). `srcFor` gives the file a layer plays.
+     */
+    update(project: VideoProject, time: number, options?: {
+        playing?: boolean;
+        direction?: 1 | -1;
+        srcFor?: (layer: VideoLayer) => string | undefined;
+    }): void;
+    /**
+     * The stretches of the timeline whose video frames are all cached, between `from` and `to` (ms),
+     * for the files the preview last played (its `srcFor`, e.g. proxies) unless `srcFor` is given.
+     * `step` (ms, at least a frame) samples more coarsely.
+     */
+    cachedRanges(project: VideoProject, options?: {
+        from?: number;
+        to?: number;
+        srcFor?: (layer: VideoLayer) => string | undefined;
+        step?: number;
+    }): {
+        start: number;
+        end: number;
+    }[];
+    stats(): VideoFrameCacheStats;
+    /** Called when frames arrive or leave. */
+    subscribe(listener: () => void): () => void;
+    /** Drops every frame (closing them) and the queue. */
+    clear(): void;
+    /** Clears and stops decoding for good. */
+    destroy(): void;
+    private pump;
+    private evict;
+    private drop;
+    private emit;
+}
+/**
+ * A browser decoder for prefetch: one hidden, muted `<video>` per file, seeking to each requested
+ * time in turn and copying the picture with `createImageBitmap` once it is presented
+ * (`requestVideoFrameCallback` where the browser has it, else `seeked`). Media from another origin
+ * needs CORS, as for scopes.
+ */
+declare function createVideoElementDecoder(options?: {
+    createVideo?: () => HTMLVideoElement;
+    timeout?: number;
+}): VideoFrameDecoder;
+
 /** What a preview follows: a `VideoEditorController` fits. */
 interface VideoPreviewSource {
     getState(): {
         project: VideoProject;
         time: number;
         playing: boolean;
+        previewScale?: VideoPreviewScale;
     };
     subscribe(listener: () => void): () => void;
     /** Where to publish the drawn pixels (a controller has one), for scopes and agents. */
     previewPixels?: VideoPreviewPixels;
     /** Where grades' LUTs load from (a controller has one). */
     luts?: VideoLutCache;
+    /** Decoded source frames with prefetch (a controller has one when the host gives it). */
+    frameCache?: VideoFrameCache | null;
 }
 /** The parts of a media element the preview drives (so tests can pass fakes). */
 interface VideoPreviewMedia {
@@ -1726,6 +1976,8 @@ interface VideoPreviewImage {
 interface VideoPreviewOptions {
     /** Canvas pixels per frame pixel (default: fits the canvas's displayed width at the device pixel ratio, at most 1). */
     resolution?: number;
+    /** How large a picture to play, overriding the source's `previewScale` (see `VideoPreviewScale`). */
+    previewScale?: VideoPreviewScale;
     /** How far (ms) a playing element may drift from the timeline before it is re-seeked (default 200). */
     tolerance?: number;
     /** Makes media and image elements (default `document.createElement`). */
@@ -1745,6 +1997,11 @@ interface VideoPreviewOptions {
      * tool (default: the source's `previewPixels`). `null` publishes nothing.
      */
     pixels?: VideoPreviewPixels | null;
+    /**
+     * Decoded source frames to draw while paused, scrubbing or waiting for a seek, prefetched ahead
+     * of the playhead (default: the source's `frameCache`; `null` uses none).
+     */
+    frameCache?: VideoFrameCache | null;
     /** Where grades' LUTs load from (default: the source's `luts`). Without one, LUTs are left out. */
     luts?: VideoLutCache | null;
     /**
@@ -1776,6 +2033,11 @@ declare class VideoPreviewEngine {
     private drawn;
     private complete;
     private readonly lutCache;
+    private readonly frameCache;
+    private readonly unsubscribeFrames;
+    private srcFor;
+    private playing;
+    private fps;
     private readonly unsubscribeLuts;
     private scratchCanvas;
     constructor(source: VideoPreviewSource, canvas: {
@@ -1794,6 +2056,8 @@ declare class VideoPreviewEngine {
     update(): void;
     private redraw;
     private sourceFor;
+    /** Canvas pixels per frame pixel: the option, else the displayed width at the device pixel ratio (at most 1). */
+    private resolutionFor;
     private draw;
     /** A grade's LUT once loaded; while it loads (or if it fails) the frame is drawn without it and counts as incomplete. */
     private readonly lutFor;
@@ -1820,6 +2084,13 @@ interface VideoEditorOptions {
     audioPeaks?: VideoAudioPeaksCache | VideoAudioPeaksLoader;
     /** Where grades' LUT files (`.cube`) come from: a shared cache, or a loader (default: `fetch` each `src`). */
     luts?: VideoLutCache | VideoLutLoader;
+    /** How large a picture the preview plays (default `auto`: a proxy as large as the canvas shows, if the asset has one). */
+    previewScale?: VideoPreviewScale;
+    /**
+     * Decoded source frames with prefetch for the preview (see `VideoFrameCache`): scrubbing and
+     * stepping then show cached frames at once. Host-side and optional (default none).
+     */
+    frameCache?: VideoFrameCache;
 }
 /** A snapshot of the editor. The same object is returned until something changes. */
 interface VideoEditorState {
@@ -1843,6 +2114,8 @@ interface VideoEditorState {
     canRedo: boolean;
     undoLabel: string;
     redoLabel: string;
+    /** How large a picture the preview plays: `auto`, `full` or a fraction that picks a proxy. */
+    previewScale: VideoPreviewScale;
     /** Bumped on every change. */
     revision: number;
 }
@@ -1863,10 +2136,13 @@ declare class VideoEditorController {
     readonly previewPixels: VideoPreviewPixels;
     /** Grades' LUTs, loaded on demand for the preview, SVG frames and agents. */
     readonly luts: VideoLutCache;
+    /** The host's frame cache, if it gave one (the preview fills and reads it). */
+    readonly frameCache: VideoFrameCache | null;
     private project;
     private issues;
     private selection;
     private readOnly;
+    private previewScale;
     private error;
     private revision;
     private applying;
@@ -1901,6 +2177,12 @@ declare class VideoEditorController {
         clearHistory?: boolean;
     }): VideoEditResult;
     setReadOnly(readOnly: boolean): void;
+    /**
+     * Sets how large a picture the preview plays: `full` (the originals), a fraction such as 0.5
+     * (the smallest proxy at least that large, else the original) or `auto` (as large as the canvas
+     * shows). A view setting, not part of the project: no undo step.
+     */
+    setPreviewScale(scale: VideoPreviewScale): void;
     /** Selects clips (unknown ids are dropped). `add` toggles them into the current selection. */
     select(clips: readonly string[] | null, options?: {
         add?: boolean;
@@ -1984,6 +2266,7 @@ declare function describeVideoProject(project: VideoProject): {
         height?: number;
         hasAudio?: boolean;
         poster?: string;
+        proxies?: VideoAssetProxy[];
     } | {
         transcriptWords: number;
         id: string;
@@ -1995,6 +2278,7 @@ declare function describeVideoProject(project: VideoProject): {
         height?: number;
         hasAudio?: boolean;
         poster?: string;
+        proxies?: VideoAssetProxy[];
     })[];
     tracks: {
         clips: ({
@@ -2230,4 +2514,4 @@ declare function videoKeyframeToggleEdit(project: VideoProject, clipId: string,
  */
 declare function videoLutEdits(project: VideoProject, clips: readonly string[], lut: VideoGradeLut | null): VideoEdit[];
 
-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_LUT_MAX_SIZE, 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 VideoDrawOptions, 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 VideoGradeLut, type VideoGradePreset, type VideoGradeSetting, 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 VideoLut, VideoLutCache, type VideoLutLoader, type VideoLutSvgApproximation, 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 VideoScratchCanvas, 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, applyVideoLut, applyVideoLutToPixels, buildVideoAudioPeaks, checkVideoProject, checkVideoTimeRemap, createVideoEditorToolProvider, createVideoProject, decodeVideoAudioPeaks, describeVideoProject, drawVideoFrame, ffmpegFilterValue, findVideoAudioSilences, findVideoClip, findVideoFillers, findVideoGaps, findVideoTranscriptPauses, findVideoTranscriptText, formatVideoSeconds, formatVideoTimecode, formatVideoTimecodeFrames, isVideoDropFrameRate, isVideoKeyframes, mergeVideoRanges, nextFreeVideoSlot, normalizeVideoGrade, normalizeVideoGradeLut, normalizeVideoWord, parseVideoAnimatable, parseVideoAsset, parseVideoClip, parseVideoClipAnimation, parseVideoCubeLut, parseVideoGrade, parseVideoGradeLut, 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, videoGradeLook, videoGradePreset, videoGradeStepMatrix, videoGradeStepSvgValues, videoGradeSteps, videoGradeSvgDefs, videoGradeSvgFilter, videoHistogram, videoHistogramImage, videoHourFrames, videoIrisRadius, videoIssueKey, videoKeyframeBreakpoints, videoKeyframeFfmpegExpr, videoKeyframeRows, videoKeyframeToggleEdit, videoKeyframeValueEdit, videoKeysOf, videoLuma, videoLumaWaveform, videoLutEdits, videoLutFromFunction, videoLutSvgApproximation, videoLutSvgPrimitives, videoLutToCube, 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 };
+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_LUT_MAX_SIZE, VIDEO_PEAK_BLOCK, VIDEO_PLACEMENT_MODES, VIDEO_PREVIEW_SCALE_OPTIONS, VIDEO_PROXY_SCALES, 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 VideoAssetProxy, type VideoAudioLevel, type VideoAudioPeaks, VideoAudioPeaksCache, type VideoAudioPeaksLoader, type VideoAudioSource, type VideoBlendMode, type VideoCacheEntryInfo, type VideoCanvasContext, type VideoClip, type VideoClipAnimation, type VideoClipAnimationEffect, type VideoClipDragInput, type VideoClipDragMode, type VideoClipDragPlan, type VideoClipLocation, type VideoClipType, type VideoColorClip, type VideoDecodedFrame, type VideoDrawOptions, 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, VideoFrameCache, type VideoFrameCacheOptions, type VideoFrameCacheStats, type VideoFrameDecoder, type VideoFrameRequest, type VideoGap, type VideoGrade, type VideoGradeControl, type VideoGradeLut, type VideoGradePreset, type VideoGradeSetting, 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 VideoLut, VideoLutCache, type VideoLutLoader, type VideoLutSvgApproximation, type VideoMarker, type VideoMediaClip, type VideoMediaProbe, type VideoPauseOptions, type VideoPixels, type VideoPlacementMode, VideoPreviewEngine, type VideoPreviewImage, type VideoPreviewMedia, type VideoPreviewOptions, VideoPreviewPixels, type VideoPreviewScale, type VideoPreviewSnapshot, type VideoPreviewSource, type VideoProject, type VideoProxyCommand, type VideoProxyOptions, type VideoRect, type VideoRulerTick, type VideoScopeImage, type VideoScopeKind, type VideoScopeOptions, type VideoScopeSummary, type VideoScopesPanelReading, type VideoScratchCanvas, 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, applyVideoLut, applyVideoLutToPixels, buildVideoAudioPeaks, checkVideoProject, checkVideoTimeRemap, createVideoEditorToolProvider, createVideoElementDecoder, createVideoProject, decodeVideoAudioPeaks, describeVideoProject, drawVideoFrame, ffmpegFilterValue, findVideoAudioSilences, findVideoClip, findVideoFillers, findVideoGaps, findVideoTranscriptPauses, findVideoTranscriptText, formatVideoSeconds, formatVideoTimecode, formatVideoTimecodeFrames, isVideoDropFrameRate, isVideoKeyframes, mergeVideoRanges, nextFreeVideoSlot, normalizeVideoGrade, normalizeVideoGradeLut, normalizeVideoWord, parseVideoAnimatable, parseVideoAsset, parseVideoAssetProxies, parseVideoClip, parseVideoClipAnimation, parseVideoCubeLut, parseVideoGrade, parseVideoGradeLut, parseVideoKeyframes, parseVideoLoudnessMeasurement, parseVideoMarker, parseVideoPreviewScale, parseVideoProject, parseVideoTimeRemap, parseVideoTrack, parseVideoTranscript, parseVideoTranscriptWords, parseVideoTransform, parseVideoTransition, placeVideoRect, planVideoClipDrag, planVideoPrefetch, probeVideoMedia, readVideoScopesPanel, removeVideoKey, resolveVideoPreviewScale, retimeVideoAnimatable, setVideoKey, snapToVideoFrame, snapVideoTime, sortVideoKeys, sortedVideoClips, splitVideoAnimatable, summarizeVideoScopes, toVideoEdl, toVideoFfmpeg, toVideoLoudnessMeasure, videoAssetDropEdit, videoAssetHasSound, videoAssetKindOf, videoAssetMap, videoAssetProxy, videoAudioLevels, videoAudioPeakRange, videoAudioPeakSpans, videoAudioPeaksDuration, videoCacheEvictions, 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, videoFrameCacheKey, videoFrameDuration, videoFrameRequestsAt, videoFrameToSvg, videoFrames, videoFreezeFrameEdit, videoGradeCssFilter, videoGradeFfmpegFilters, videoGradeGainsFilterId, videoGradeLook, videoGradePreset, videoGradeStepMatrix, videoGradeStepSvgValues, videoGradeSteps, videoGradeSvgDefs, videoGradeSvgFilter, videoHistogram, videoHistogramImage, videoHourFrames, videoIrisRadius, videoIssueKey, videoKeyframeBreakpoints, videoKeyframeFfmpegExpr, videoKeyframeRows, videoKeyframeToggleEdit, videoKeyframeValueEdit, videoKeysOf, videoLuma, videoLumaWaveform, videoLutEdits, videoLutFromFunction, videoLutSvgApproximation, videoLutSvgPrimitives, videoLutToCube, videoOverlap, videoPeakDb, videoPreviewSrc, videoProjectDuration, videoProjectHasProxies, videoProjectSvg, videoProxyFfmpeg, videoProxyName, videoProxyPlan, videoRemoveRangesEdits, videoRulerTicks, videoScopeImage, videoShellQuote, videoSlowMotionRamp, videoSnapPoints, videoSourceFrame, videoSourceFrameTime, 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 };