@pixerate/editor 0.123.0 → 0.124.1

package/dist/{export-Dv0-ZVrV.d.cts → export-BdfY_lH0.d.ts}

@@ -1,3 +1,5 @@
+import { d as EffectValue, v as EffectsSlot, f as EffectPixels, E as EffectProvider, e as EffectDescription } from './helpers-DX2_7L5t.js';
+
 /**
  * Keyframes for a clip's opacity, volume and transform. A property is either a plain number or
  * `{ keys }`: values at clip-relative times (ms from the clip's start), each with the easing of the
@@ -165,9 +167,37 @@ declare const VIDEO_FITS: readonly ["contain", "cover", "fill", "none"];
  * - `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.
+ * - `effect`: a transition effect from the editor's effects provider (`VideoTransition.effect`).
+ */
+type VideoTransitionType = 'crossfade' | 'dip' | 'wipe' | 'push' | 'slide' | 'iris' | 'effect';
+declare const VIDEO_TRANSITION_TYPES: readonly ["crossfade", "dip", "wipe", "push", "slide", "iris", "effect"];
+/**
+ * Values of a provider effect's controls (see `@pixerate/editor/effects`): plain values, or
+ * keyframes (clip-relative ms) for numeric controls.
  */
-type VideoTransitionType = 'crossfade' | 'dip' | 'wipe' | 'push' | 'slide' | 'iris';
-declare const VIDEO_TRANSITION_TYPES: readonly ["crossfade", "dip", "wipe", "push", "slide", "iris"];
+type VideoEffectValues = Record<string, EffectValue | VideoKeyframes>;
+/** A provider effect used by a transition or an effect clip. Kept in the project even without a provider. */
+interface VideoEffectRef {
+    /** The provider's effect id. */
+    effect: string;
+    /** The provider it was applied with (its `id`). */
+    provider?: string;
+    /** The effect's name when it was applied, shown where no provider can draw it. */
+    name?: string;
+    values?: VideoEffectValues;
+}
+/**
+ * A provider effect on a clip's picture (see `VideoClipBase.effects`). Effects run in order on the
+ * picture as it comes from the source, before the clip's grade, placement, opacity and blend.
+ */
+interface VideoClipEffect extends VideoEffectRef {
+    /** Unique within the clip (e.g. `fx1`). */
+    id: string;
+    /** Default true. */
+    enabled?: boolean;
+    /** How much of the effect's result shows over its input, 0–1 (default 1), or keyframes. */
+    opacity?: VideoAnimatable;
+}
 type VideoWipeDirection = 'left' | 'right' | 'up' | 'down';
 declare const VIDEO_WIPE_DIRECTIONS: readonly ["left", "right", "up", "down"];
 /**
@@ -183,6 +213,8 @@ interface VideoTransition {
     color?: string;
     /** For wipe, push and slide: the way the edge or picture travels (default right: in from the left). */
     direction?: VideoWipeDirection;
+    /** For effect: the provider's transition effect and its values (plain values only). */
+    effect?: VideoEffectRef;
     /**
      * 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
@@ -267,6 +299,8 @@ interface VideoClipBase {
     fadeOut?: number;
     /** Transition from the clip before (see `VideoTransition`). */
     transition?: VideoTransition;
+    /** Provider effects on the picture, applied in order (see `VideoClipEffect`). */
+    effects?: VideoClipEffect[];
 }
 /**
  * The shape of a sound fade, the same curves ffmpeg's `afade` draws, so previews and exports agree.
@@ -344,7 +378,14 @@ interface VideoSequenceClip extends VideoClipBase {
     /** Shape of the sound's fade out (default linear). */
     fadeOutCurve?: VideoFadeCurve;
 }
-type VideoClip = VideoMediaClip | VideoTextClip | VideoColorClip | VideoSequenceClip;
+/**
+ * A picture drawn by a provider effect (a generator, title or overlay), filling the frame. Without
+ * a provider it shows as a placeholder and keeps its effect id and values.
+ */
+interface VideoEffectClip extends VideoClipBase, VideoEffectRef {
+    type: 'effect';
+}
+type VideoClip = VideoMediaClip | VideoTextClip | VideoColorClip | VideoSequenceClip | VideoEffectClip;
 type VideoClipType = VideoClip['type'];
 /**
  * How a clip is placed where others already are: `refuse` an overlap (the default), `overwrite`
@@ -353,7 +394,7 @@ type VideoClipType = VideoClip['type'];
  */
 type VideoPlacementMode = 'refuse' | 'overwrite' | 'insert';
 declare const VIDEO_PLACEMENT_MODES: readonly ["refuse", "overwrite", "insert"];
-declare const VIDEO_CLIP_TYPES: readonly ["media", "text", "color", "sequence"];
+declare const VIDEO_CLIP_TYPES: readonly ["media", "text", "color", "sequence", "effect"];
 interface VideoMarker {
     id: string;
     time: number;
@@ -389,6 +430,338 @@ interface VideoProject {
     markers?: VideoMarker[];
 }
 
+/** A rectangle in frame pixels. */
+interface VideoRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** One picture in a frame, in draw order (first is at the back). */
+interface VideoLayer {
+    /**
+     * The clip it comes from, or `transition:<clip>` for a dip's colour. Inside a compound clip it is
+     * the path of clip ids from the project's own track (`compound/inner`), so the same sequence
+     * played twice gives distinct layers.
+     */
+    clip: string;
+    /** The track it is on (inside a compound: the sequence's track). */
+    track: string;
+    type: VideoClip['type'];
+    /** For media: the asset, its kind and `src`, and the moment of the source to show (ms). */
+    asset?: string;
+    assetKind?: VideoAsset['kind'];
+    src?: string;
+    /** For media: the moment of the source to show (ms); for a compound: the moment of its sequence. */
+    sourceTime?: number;
+    /** For a compound: the sequence it plays. */
+    sequence?: string;
+    /**
+     * For a compound: the sequence's frame at `sourceTime`, back to front in the sequence's own frame
+     * (the project's size, transparent where nothing covers it). They are drawn together as one
+     * picture, which this layer's rect, rotation, opacity, blend, grade, wipe and iris then apply to.
+     */
+    layers?: VideoLayer[];
+    /** 0–1, after fades and transitions. */
+    opacity: number;
+    /** Where the fitted picture sits before rotation (its centre is the rotation centre). */
+    rect: VideoRect;
+    /** Degrees clockwise about the rect's centre. */
+    rotation: number;
+    /** For a wipe: the part shown is the `progress` (0–1) of the rect from the edge opposite `direction`. */
+    wipe?: {
+        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;
+        color: string;
+        fontSize: number;
+        fontFamily: string;
+        fontWeight: number;
+        background?: string;
+    };
+    /** For colour clips and dips. */
+    color?: string;
+    /** How it mixes with the layers beneath (absent = normal). */
+    blend?: VideoBlendMode;
+    /** Colour correction (absent = none). */
+    grade?: VideoGrade;
+    /** The clip's enabled provider effects, in order, with values at this moment (see `VideoClipEffect`). */
+    effects?: VideoLayerEffect[];
+    /** For an effect clip: the provider effect drawing the picture, at `time` ms into the clip. */
+    generator?: {
+        effect: string;
+        name?: string;
+        values: Record<string, EffectValue>;
+        time: number;
+    };
+    /**
+     * For a clip coming in through an effect transition: the provider transition from the outgoing
+     * clip's layer (`from`, drawn in its place) to this one, `progress` (0–1) and `time` ms through it.
+     */
+    transitionEffect?: {
+        effect: string;
+        name?: string;
+        values: Record<string, EffectValue>;
+        progress: number;
+        time: number;
+        from: VideoLayer | null;
+    };
+}
+/** One provider effect on a layer at a moment. */
+interface VideoLayerEffect {
+    /** The effect's id within its clip. */
+    id: string;
+    effect: string;
+    name?: string;
+    /** 0–1 after keyframes. */
+    opacity: number;
+    values: Record<string, EffectValue>;
+    /** Ms into the clip. */
+    time: number;
+}
+/** Effect values at clip-relative `clipTime` (ms): keyframed numbers resolved. */
+declare function videoEffectValuesAt(values: VideoEffectValues | undefined, clipTime: number): Record<string, EffectValue>;
+/** One sound playing at a moment. */
+interface VideoAudioSource {
+    /** The clip it comes from (inside a compound: the path of clip ids, `compound/inner`). */
+    clip: string;
+    /** The track it is on (inside a compound: the sequence's track). */
+    track: string;
+    asset: string;
+    src: string;
+    /** The moment of the source playing (ms). */
+    sourceTime: number;
+    /** Gain after clip and track volume, fades and transitions, and those of any compound it plays in (0 = silent). */
+    gain: number;
+    speed: number;
+}
+interface VideoFrame {
+    time: number;
+    width: number;
+    height: number;
+    background: string;
+    layers: VideoLayer[];
+    audio: VideoAudioSource[];
+}
+/** A transform's values at clip-relative time `clipTime` (ms), keyframes resolved and defaults filled in. */
+declare function videoTransformAt(transform: VideoClip['transform'], clipTime?: number): {
+    x: number;
+    y: number;
+    scale: number;
+    rotation: number;
+};
+/** Places a picture of `size` in the frame by `fit`, then the clip's transform at clip-relative `clipTime` (ms). */
+declare function placeVideoRect(frame: {
+    width: number;
+    height: number;
+}, size: {
+    width: number;
+    height: number;
+}, fit?: VideoFit, transform?: VideoClip['transform'], clipTime?: number): VideoRect;
+/** A title's text and style with the defaults filled in. */
+declare function videoTextStyle(clip: VideoTextClip): NonNullable<VideoLayer['text']>;
+/**
+ * A frame holding only one title, fully opaque on a transparent background, placed as the preview
+ * places it: draw it with `drawVideoFrame` and save the canvas as a PNG to give the ffmpeg export
+ * titles without `drawtext` (`VideoFfmpegOptions.titleImage`). Fades and opacity are left to the export.
+ * A keyframed transform is placed as it is at `clipTime` (the export passes titles with keyframed
+ * 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;
+/**
+ * A media or compound clip's own gain at clip time `clipTime` (ms): its volume (or volume keyframes) times its
+ * shaped fades. Leaves out track volume and transitions, which depend on the timeline around it.
+ */
+declare function videoClipSoundGain(clip: VideoClip, clipTime: number): number;
+/**
+ * What plays at `time` (ms): the pictures to draw, back to front, with their placement, opacity
+ * and the moment of source each shows, and the sounds with their gain. A pure function of the
+ * project and the time, so previews, exporters and agents all agree on every frame. A compound
+ * clip is one layer holding its sequence's frame (`layers`), and its sounds are mixed in with the
+ * compound's volume, fades and transitions.
+ */
+declare function videoFrameAt(project: VideoProject, time: number): VideoFrame;
+/**
+ * Layers as drawn without an effects provider: an effect transition becomes a crossfade (the
+ * outgoing layer, then this one faded up by the progress). Clip effects are left on the layers,
+ * where they are simply not drawn.
+ */
+declare function videoLayersWithoutTransitionEffects(layers: readonly VideoLayer[]): VideoLayer[];
+/**
+ * Every layer of a frame that draws a picture of its own, compounds opened up (each compound's
+ * layers in place of it), back to front. Hosts use it to find the media a frame needs.
+ */
+declare function videoFrameLeafLayers(layers: readonly VideoLayer[]): VideoLayer[];
+
+/**
+ * Provider effects in the video editor (see `@pixerate/editor/effects`): the per-frame cache of
+ * rendered effect pictures the preview and frame-exact exports draw from, and helpers to find the
+ * effects a project uses.
+ *
+ * Effects render asynchronously. The canvas drawing (`drawVideoFrame`) is synchronous, so it asks
+ * the engine for a picture by key: a cached one is drawn at once, and a missing one is requested
+ * and the layer drawn without its effects meanwhile (the frame counts as incomplete). When the
+ * render lands, subscribers redraw. `renderVideoFrameExact` repeats this until every effect of the
+ * frame is in, which is what exports use.
+ */
+
+/** Where a project uses a provider effect. */
+interface VideoEffectUse {
+    /** The clip it is on (for a transition: the clip it leads into). */
+    clip: string;
+    /** `clip`: in the clip's effect stack (`instance` is its id); `transition`: an effect transition; `generator`: an effect clip. */
+    kind: 'clip' | 'transition' | 'generator';
+    instance?: string;
+    effect: string;
+    name?: string;
+    provider?: string;
+    enabled: boolean;
+}
+/** Every provider effect in a project, sequences included, in track and clip order. */
+declare function videoProjectEffects(project: VideoProject): VideoEffectUse[];
+/** The provider effects of one clip: its effect clip picture, its transition and its effect stack. */
+declare function videoClipEffectUses(clip: VideoClip): VideoEffectUse[];
+/** True when drawing the layers needs an effects provider. */
+declare const videoLayersUseEffects: (layers: readonly VideoLayer[]) => boolean;
+/** The start of the frame `time` falls in (ms), on the project's frame grid. Effects render once per frame. */
+declare const videoEffectFrameTime: (time: number, fps: number) => number;
+/** What to render for one layer. */
+type VideoEffectJob = 
+/** A clip's effect stack over its unprocessed picture. */
+{
+    kind: 'stack';
+    input: EffectPixels;
+    effects: readonly VideoLayerEffect[];
+}
+/** An effect clip: the generator at `time`, then the clip's effect stack. */
+ | {
+    kind: 'generator';
+    width: number;
+    height: number;
+    effect: string;
+    values: Record<string, EffectValue>;
+    time: number;
+    effects: readonly VideoLayerEffect[];
+}
+/** An effect transition between two whole-frame pictures. */
+ | {
+    kind: 'transition';
+    effect: string;
+    values: Record<string, EffectValue>;
+    progress: number;
+    time: number;
+    from: EffectPixels;
+    to: EffectPixels;
+};
+/**
+ * The cache key of a layer's processed picture at a canvas size: everything that changes the
+ * picture before placement (its content, the moment of source, the effects and their values),
+ * not where it is placed. A transition's key covers both of its pictures, placement included.
+ */
+declare function videoEffectLayerKey(layer: VideoLayer, width: number, height: number): string;
+/** `a` mixed towards `b` by `k` (0–1), as a new picture. */
+declare function mixEffectPixels(a: EffectPixels, b: EffectPixels, k: number): EffectPixels;
+/** `top` laid over `base` (straight alpha, source-over) at `opacity`, as a new picture. */
+declare function overEffectPixels(base: EffectPixels, top: EffectPixels, opacity?: number): EffectPixels;
+interface VideoEffectsEngineOptions {
+    /** The provider slot to follow (a controller passes its own). Default: a new one. */
+    slot?: EffectsSlot;
+    /** Rendered pictures kept (default 120, a few seconds of one layer). */
+    maxEntries?: number;
+    /** Live renderers kept (default 4): GPU providers hold a graphics context each (see `EffectRendererPool`). */
+    maxRenderers?: number;
+    /**
+     * Turns rendered pixels into something `drawImage` takes. Default: an `OffscreenCanvas` (or a
+     * `<canvas>`) holding them; `null` where neither exists.
+     */
+    toImage?: (pixels: EffectPixels) => CanvasImageSource | null;
+}
+/**
+ * Renders and caches provider effect pictures for one editor. It follows the editor's provider
+ * slot: with no provider it renders nothing (`available` is false), and a new provider clears the
+ * cache and disposes the old renderers.
+ */
+declare class VideoEffectsEngine {
+    readonly slot: EffectsSlot;
+    private readonly cache;
+    private readonly pending;
+    private readonly failures;
+    private readonly pool;
+    private readonly descriptions;
+    private readonly listeners;
+    private readonly maxEntries;
+    private readonly toImage;
+    private generation;
+    private readonly detach;
+    constructor(options?: VideoEffectsEngineOptions);
+    get provider(): EffectProvider | null;
+    /** True when a provider is registered, so effects can be drawn. */
+    get available(): boolean;
+    /** The drawable picture for `key`, or `undefined` when it is not rendered (yet). */
+    get(key: string): CanvasImageSource | null | undefined;
+    /** The rendered pixels for `key`. */
+    pixels(key: string): EffectPixels | undefined;
+    /** Why the render for `key` failed, if it did (it is not retried until the cache is cleared). */
+    failure(key: string): Error | undefined;
+    /** Every failure so far, newest last. */
+    failuresList(): {
+        key: string;
+        error: Error;
+    }[];
+    /** Whether `key` is being rendered. */
+    isPending(key: string): boolean;
+    /**
+     * Starts rendering `job` into `key` unless it is cached, pending or failed. Returns true while
+     * the picture is on its way (so the frame is waiting for it).
+     */
+    request(key: string, job: VideoEffectJob): boolean;
+    /** Resolves when nothing is being rendered. */
+    idle(): Promise<void>;
+    /** Renders a job now, without the cache. Rejects with the provider's error. */
+    run(job: VideoEffectJob): Promise<EffectPixels>;
+    private stack;
+    /** The provider's description of an effect, fetched once. */
+    describe(provider: EffectProvider, id: string): Promise<EffectDescription>;
+    /** Renders through the pool: a few live renderers, one render at a time on each. */
+    private render;
+    /** Forgets every picture and failure and disposes the renderers (e.g. after the provider changes). */
+    reset(): void;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    destroy(): void;
+}
+/** Which uses each place accepts. */
+declare const VIDEO_EFFECT_PLACES: {
+    /** A clip's effect stack: filters change the picture, overlays draw over it. */
+    readonly clip: readonly ["filter", "overlay"];
+    readonly transition: readonly ["transition"];
+    /** An effect clip's picture. */
+    readonly generator: readonly ["generator", "title", "overlay"];
+};
+type VideoEffectPlace = keyof typeof VIDEO_EFFECT_PLACES;
+/** Refuses an effect that cannot go in `place`, with what to use instead. */
+declare function checkVideoEffectPlace(d: EffectDescription, place: VideoEffectPlace): void;
+/**
+ * Checks values (plain, or keyframes for numeric controls when `keyframes`) against an effect's
+ * controls and returns them over `base` (default the effect's defaults). Throws
+ * `EffectControlError` naming every bad control.
+ */
+declare function checkVideoEffectValues(d: EffectDescription, values: VideoEffectValues | undefined, options?: {
+    base?: VideoEffectValues;
+    keyframes?: boolean;
+}): VideoEffectValues;
+
 interface VideoEdlOptions {
     /** Track to export (default: the bottom video track, V1 in most NLEs). */
     track?: string;
@@ -433,7 +806,21 @@ interface VideoFfmpegOptions {
     }) => string;
     /** Normalise the mix's loudness with ffmpeg's `loudnorm` (EBU R128). */
     loudness?: VideoLoudnessTarget;
+    /**
+     * The picture as frames the host rendered, instead of ffmpeg's filters: one per frame of the
+     * project's frame grid from 0, each the project's size rounded up to even numbers, drawn with
+     * `renderVideoFrameExact` (the preview's own drawing, provider effects included). `input` is an
+     * image sequence pattern (`frames/%06d.png`, format `image2`, the default) or raw RGBA on a
+     * pipe (`pipe:0`, format `rawvideo`). The sound is still mixed by ffmpeg. Projects that use
+     * provider effects need this: ffmpeg cannot draw them, so without it the export is refused.
+     */
+    frames?: {
+        input: string;
+        format?: 'image2' | 'rawvideo';
+    };
 }
+/** The provider effects in a project's video tracks that ffmpeg's filters cannot draw. */
+declare function videoFfmpegUnsupportedEffects(project: VideoProject): VideoEffectUse[];
 /** A loudness to normalise the mix to (`loudnorm`'s I, TP and LRA). */
 interface VideoLoudnessTarget {
     /** Integrated loudness, in LUFS (default -14, as streaming services play; -16 for podcasts, -23 for EBU R128 broadcast). */
@@ -498,4 +885,4 @@ declare function toVideoFfmpeg(project: VideoProject, options?: VideoFfmpegOptio
  */
 declare function toVideoLoudnessMeasure(project: VideoProject, options?: Pick<VideoFfmpegOptions, 'resolve' | 'loudness'>): VideoFfmpegExport;
 
-export { removeVideoKey as $, type VideoFfmpegExport as A, type VideoEdlOptions as B, type VideoAssetKind as C, type VideoClipAnimationEffect as D, type VideoTransitionType as E, VIDEO_BLEND_MODES as F, VIDEO_CLIP_ANIMATION_EFFECTS as G, VIDEO_CLIP_TYPES as H, VIDEO_EASE_NAMES as I, VIDEO_FADE_CURVES as J, VIDEO_FITS as K, VIDEO_KEYFRAME_LIMITS as L, VIDEO_KEYFRAME_PROPERTIES as M, VIDEO_PLACEMENT_MODES as N, VIDEO_TRANSFORM_PROPERTIES as O, VIDEO_TRANSITION_TYPES as P, VIDEO_WIPE_DIRECTIONS as Q, type VideoClipType as R, type VideoColorClip as S, type VideoEase as T, type VideoLoudnessMeasurement as U, type VideoProject as V, type VideoLoudnessTarget as W, type VideoSequenceClip as X, ffmpegFilterValue as Y, isVideoKeyframes as Z, parseVideoLoudnessMeasurement as _, type VideoAnimatable as a, retimeVideoAnimatable as a0, setVideoKey as a1, sortVideoKeys as a2, splitVideoAnimatable as a3, toVideoEdl as a4, toVideoFfmpeg as a5, toVideoLoudnessMeasure as a6, videoEaseBezier as a7, videoEaseProgress as a8, videoKeyframeBreakpoints as a9, videoKeyframeFfmpegExpr as aa, videoShellQuote as ab, videoTransitionAudioCurve as ac, videoValueAt as ad, type VideoAsset as b, type VideoAssetProxy as c, type VideoClip as d, type VideoClipAnimation as e, type VideoGrade as f, type VideoGradeLut as g, type VideoKeyframes as h, type VideoMarker as i, type VideoSequence as j, type VideoTrack as k, type VideoTranscriptWord as l, type VideoTransform as m, type VideoTransition as n, type VideoTrackKind as o, type VideoPlacementMode as p, type VideoKeyframeProperty as q, type VideoKey as r, type VideoWipeDirection as s, type VideoBlendMode as t, type VideoFit as u, videoKeysOf as v, type VideoFadeCurve as w, type VideoTextClip as x, type VideoMediaClip as y, type VideoFfmpegOptions as z };
+export { type VideoColorClip as $, type VideoRect as A, type VideoEffectPlace as B, type VideoFfmpegOptions as C, type VideoFfmpegExport as D, type VideoEdlOptions as E, type VideoFadeCurve as F, type VideoFit as G, type VideoBlendMode as H, type VideoAssetKind as I, type VideoClipAnimationEffect as J, type VideoTransitionType as K, VIDEO_BLEND_MODES as L, VIDEO_CLIP_ANIMATION_EFFECTS as M, VIDEO_CLIP_TYPES as N, VIDEO_EASE_NAMES as O, VIDEO_EFFECT_PLACES as P, VIDEO_FADE_CURVES as Q, VIDEO_FITS as R, VIDEO_KEYFRAME_LIMITS as S, VIDEO_KEYFRAME_PROPERTIES as T, VIDEO_PLACEMENT_MODES as U, type VideoProject as V, VIDEO_TRANSFORM_PROPERTIES as W, VIDEO_TRANSITION_TYPES as X, VIDEO_WIPE_DIRECTIONS as Y, type VideoAudioSource as Z, type VideoClipType as _, type VideoAnimatable as a, type VideoEase as a0, type VideoEffectClip as a1, type VideoEffectJob as a2, type VideoEffectUse as a3, type VideoEffectsEngineOptions as a4, type VideoLayerEffect as a5, type VideoLoudnessMeasurement as a6, type VideoLoudnessTarget as a7, type VideoSequenceClip as a8, type VideoTextClip as a9, videoFrameAt as aA, videoFrameLeafLayers as aB, videoKeyframeBreakpoints as aC, videoKeyframeFfmpegExpr as aD, videoLayersUseEffects as aE, videoLayersWithoutTransitionEffects as aF, videoProjectEffects as aG, videoShellQuote as aH, videoTextStyle as aI, videoTitleFrame as aJ, videoTransformAt as aK, videoTransitionAudioCurve as aL, videoTransitionEase as aM, videoValueAt as aN, type VideoWipeDirection as aa, checkVideoEffectPlace as ab, checkVideoEffectValues as ac, ffmpegFilterValue as ad, isVideoKeyframes as ae, mixEffectPixels as af, overEffectPixels as ag, parseVideoLoudnessMeasurement as ah, placeVideoRect as ai, removeVideoKey as aj, retimeVideoAnimatable as ak, setVideoKey as al, sortVideoKeys as am, splitVideoAnimatable as an, toVideoEdl as ao, toVideoFfmpeg as ap, toVideoLoudnessMeasure as aq, videoClipEffectUses as ar, videoClipSoundGain as as, videoEaseBezier as at, videoEaseProgress as au, videoEffectFrameTime as av, videoEffectLayerKey as aw, videoEffectValuesAt as ax, videoFadeCurveGain as ay, videoFfmpegUnsupportedEffects as az, type VideoAsset as b, type VideoAssetProxy as c, type VideoClip as d, type VideoClipAnimation as e, type VideoClipEffect as f, type VideoEffectRef as g, type VideoEffectValues as h, type VideoGrade as i, type VideoGradeLut as j, type VideoKeyframes as k, type VideoMarker as l, type VideoSequence as m, type VideoTrack as n, type VideoTranscriptWord as o, type VideoTransform as p, type VideoTransition as q, type VideoTrackKind as r, type VideoPlacementMode as s, type VideoKeyframeProperty as t, type VideoKey as u, videoKeysOf as v, type VideoMediaClip as w, VideoEffectsEngine as x, type VideoLayer as y, type VideoFrame as z };