Class Engine

Main SDK entrypoint for project editing, playback, serialization, and export.

The engine coordinates the display, timeline, library, storage, subtitles, rendering, and media-processing subsystems behind a single singleton instance.

Properties

customClipTypes

customClipTypes: Map<string, CustomClipConstructor<CustomClip>> = ...

`Readonly`events

events: EventEmitter

`Static` `Readonly`currentVersion

currentVersion: string = __APP_VERSION__

`Static`projectVersion

projectVersion: string = ...

Methods

callStaticCustomClipMethod

callStaticCustomClipMethod(
    typeEnum: string,
    methodName: string,
    ...args: any[],
): any
Invokes a static method on a previously registered custom clip type.
Parameters
- typeEnum: string
  Registered custom clip type to target.
- methodName: string
  Static method name to invoke.
- ...args: any[]
  Arguments forwarded to the static method.
Returns any
The value returned by the static method.

cancelExport

cancelExport(): Promise<void>
Cancels the active export, if one is currently running.

Returns Promise<void>
A promise that resolves after cancellation has been propagated to the renderer.

clearAllCustomData

clearAllCustomData(): void
Removes all custom metadata entries from the engine.

Returns void
Nothing.

createCustomClipInstance

createCustomClipInstance<T extends CustomClip = CustomClip>(
typeEnum: string,
...args: any[],
): T
Creates an instance of a registered custom clip type.
Type Parameters
- T extends CustomClip = CustomClip
Parameters
- typeEnum: string
  Registered custom clip type to instantiate.
- ...args: any[]
  Arguments forwarded to the custom clip constructor.
Returns T
The created custom clip instance.

destroy

destroy(everything?: boolean): Promise<void>
Destroys the current engine state and releases runtime resources.
Parameters
- Optionaleverything: boolean
  When true, also destroys long-lived singletons such as display, renderer, FFmpeg, and font registry, and clears the engine singleton reference.
Returns Promise<void>
A promise that resolves after teardown finishes.

export

export(payload?: ExportOptions): Promise<null | ExportResult>
Exports the current project using the supplied export settings.
Parameters
- Optionalpayload: ExportOptions
  Export configuration describing output type, time range, resolution scale, and audio format.
Returns Promise<null | ExportResult>
A promise that resolves to the exported artifact, or null when no file is produced.

exportAudioRange

exportAudioRange(payload: AudioRangeExportOptions): Promise<null | ExportResult>
Exports an audio-only mix for the requested timeline range.
Parameters
- payload: AudioRangeExportOptions
  Audio export configuration, including the exported range and optional clip filtering.
Returns Promise<null | ExportResult>
A promise that resolves to the exported audio artifact, or null when no file is produced.

getAllCustomData

getAllCustomData(): undefined | Map<string, unknown>
Returns a copy of the engine's custom metadata.

Returns undefined | Map<string, unknown>
A new metadata map, or undefined when no custom metadata has been set.

getBackgroundTimer

getBackgroundTimer(): BackgroundTimer
Returns the background timer used for deferred work while the page is inactive.

Returns BackgroundTimer
The engine background timer.

getClipById

getClipById(clipId: string): undefined | Clip<Sprite, ClipStyle<Sprite>>
Looks up a clip by its timeline identifier.
Parameters
- clipId: string
  Clip identifier to resolve.
Returns undefined | Clip<Sprite, ClipStyle<Sprite>>
The matching clip, or undefined if no clip exists for that ID.

getClipsIdsForPoint

getClipsIdsForPoint(x: number, y: number): null
Returns the IDs of clips intersecting the supplied canvas coordinates.

This method is currently a placeholder and always returns null.
Parameters
- x: number
  Horizontal coordinate in canvas space.
- y: number
  Vertical coordinate in canvas space.
Returns null
null.

getCustomData

getCustomData(key: string): unknown
Reads a custom metadata value previously stored on the engine.
Parameters
- key: string
  Metadata key to read.
Returns unknown
The stored value, or undefined if the key is not present.

getDataHashFunction

getDataHashFunction(): undefined | ((data: Uint8Array) => Promise<string>)
Returns the custom media hash function configured during initialization.

Returns undefined | ((data: Uint8Array) => Promise<string>)
The custom hash function, or undefined when the default behavior is used.

getDisplay

getDisplay(): Display
Returns the display controller used to render the project canvas.

Returns Display
The engine display.

getFFmpeg

getFFmpeg(): FFmpeg
Returns the low-level FFmpeg instance used by the SDK.

Returns FFmpeg
The initialized FFmpeg bridge.

getFontRegistry

getFontRegistry(): FontRegistry
Returns the font registry used by text and HTML clips.

Returns FontRegistry
The font registry.

getFrameAsBase64Image

getFrameAsBase64Image(
    time?: number,
    mimeType?: "image/jpeg" | "image/webp" | "image/png",
    quality?: number,
): Promise<string>
Captures a rendered frame as a base64-encoded image.

If time is provided, the timeline is temporarily seeked before capture and then restored.
Parameters
- Optionaltime: number
  Optional timeline time, in seconds, to capture.
- mimeType: "image/jpeg" | "image/webp" | "image/png" = "image/png"
  Image MIME type used for encoding.
- quality: number = 0.92
  Encoder quality passed to PIXI extraction for lossy formats.
Returns Promise<string>
A promise that resolves to a base64 image string, or an empty string when no renderer is available.

getLibrary

getLibrary(): Library
Returns the library that owns imported media, effects, filters, transitions, and subtitles.

Returns Library
The project library.

getProjectId

getProjectId(): string
Returns the identifier of the active project.

Returns string
The current project ID.

getRenderer

getRenderer(): PixiRenderer
Returns the renderer currently backing the engine display.

Returns PixiRenderer
The active PIXI renderer wrapper.

getRendererStage

getRendererStage(): null | Container<DisplayObject>
Returns the root PIXI stage used for rendering.

Returns null | Container<DisplayObject>
The renderer stage.

getSettings

getSettings(): Settings
Returns the project settings currently applied by the engine.

Returns Settings
The active settings instance.

getStorageController

getStorageController(): StorageController
Returns the storage controller responsible for project persistence.

Returns StorageController
The storage controller.

getSubtitlesManager

getSubtitlesManager(): SubtitlesManager
Returns the subtitles manager used for subtitle track styling and playback.

Returns SubtitlesManager
The subtitles manager.

getTimeline

getTimeline(): Timeline
Returns the timeline managed by the engine.

Returns Timeline
The project timeline.

getTranscoder

getTranscoder(): null | ITranscodeProvider
Returns the optional transcode provider configured for this engine.

Returns null | ITranscodeProvider
The transcode provider, or null when transcoding is not configured.

getUndoManager

getUndoManager(): UndoManager
Returns the undo manager associated with the engine.

Returns UndoManager
The undo manager.

hasCustomClipType

hasCustomClipType(typeEnum: string): boolean
Checks whether a custom clip type has been registered.
Parameters
- typeEnum: string
  Clip type identifier to test.
Returns boolean
true if the custom clip type exists; otherwise false.

hasCustomData

hasCustomData(key: string): boolean
Checks whether a custom metadata entry exists.
Parameters
- key: string
  Metadata key to check.
Returns boolean
true if the key exists; otherwise false.

hasInstance

hasInstance(): boolean
Indicates whether the engine singleton has already been created.

Returns boolean
true if an engine instance already exists; otherwise false.

init

init(options: EngineOptions): Promise<void>
Initializes the engine and all configured subsystems.

This sets up display, FFmpeg, storage, library state, timeline state, licensing, and optional transcoding support.
Parameters
- options: EngineOptions
  Engine startup configuration.
Returns Promise<void>
A promise that resolves after initialization has completed.

isInitialized

isInitialized(): boolean
Indicates whether init() has completed successfully for this engine instance.

Returns boolean
true if the engine has been initialized; otherwise false.

isReady

isReady(): boolean
Indicates whether the engine is ready for playback, editing, and rendering work.

Returns boolean
true if initialization has completed and the engine is ready; otherwise false.

isRendering

isRendering(): boolean
Indicates whether preview rendering or export rendering is currently running.

Returns boolean
true while render work is in progress; otherwise false.

isSafeToSerialize

isSafeToSerialize(): boolean
Indicates whether the current engine state can be serialized safely.

Returns boolean
true when the engine is ready and the library is not processing background work; otherwise false.

pause

pause(): Promise<void>
Pauses timeline playback without discarding the current playhead position.

Returns Promise<void>
A promise that resolves after playback has paused.

play

play(): Promise<void>
Starts timeline playback.

Returns Promise<void>
A promise that resolves after playback has started.

registerCustomClip

registerCustomClip<T extends CustomClip = CustomClip>(
classType: CustomClipConstructor<T>,
typeEnum: string,
): void
Registers a custom clip constructor under a clip type identifier.
Type Parameters
- T extends CustomClip = CustomClip
Parameters
- classType: CustomClipConstructor<T>
  Constructor used to create clip instances of the custom type.
- typeEnum: string
  Clip type identifier associated with the constructor.
Returns void
Nothing.

reset

reset(): Promise<void>
Replaces the current project with a fresh empty project.

Returns Promise<void>
A promise that resolves after the reset project has been deserialized.

seek

seek(value: number): Promise<void>
Moves the timeline playhead to the requested time.
Parameters
- value: number
  Target timeline time, in seconds.
Returns Promise<void>
A promise that resolves after seeking has completed.

serialize

serialize(): {
    createdAt?: number;
    customData?: [string, unknown][];
    display: { backgroundColor: string; height: number; width: number };
    library: {
        customData?: [string, unknown][];
        effects: {
            autoFit?: boolean;
            blendMode?: NORMAL | ADD | SCREEN | MULTIPLY;
            fragmentSrc: string;
            id: string;
            inputTextures?: {
                mipmap?: OFF | ON;
                name: string;
                scaleMode?: NEAREST | LINEAR;
                url: string;
                wrapMode?: CLAMP | REPEAT | MIRRORED_REPEAT;
            }[];
            name: string;
            noTransform?: boolean;
            padding?: number;
            properties: {
                defaultValue: Required<any>;
                description?: string;
                initOnly?: boolean;
                label?: string;
                max?: number | number[];
                min?: number | number[];
                name: string;
                step?: number | number[];
                type: PropertyDescriptionTypeEnum;
            }[];
            provider: string;
        }[];
        filters: { id: string; lutUrl: string; name: string; provider: string }[];
        media: {
            customData?: [string, unknown][];
            filename: string;
            hash?: string;
            id: string;
            mimeType?: string;
            name?: string;
            permanentUrl?: string;
            placeholderClipIds?: string[];
            type: string;
        }[];
        subtitles: {
            duration: number;
            id: string;
            language: string;
            textBlocks: {
                duration: number;
                text: string;
                time: number;
                wordTimings?: number[];
            }[];
        }[];
        transitions: {
            id: string;
            inputTextures?: {
                mipmap?: OFF
                | ON;
                name: string;
                scaleMode?: NEAREST | LINEAR;
                url: string;
                wrapMode?: CLAMP | REPEAT | MIRRORED_REPEAT;
            }[];
            name: string;
            properties: {
                defaultValue: Required<any>;
                description?: string;
                initOnly?: boolean;
                label?: string;
                max?: number | number[];
                min?: number | number[];
                name: string;
                step?: number | number[];
                type: PropertyDescriptionTypeEnum;
            }[];
            provider: string;
            transitionSrc: string;
        }[];
    };
    projectId?: string;
    settings?: {
        clipAudioMonoChannelsWeight: number[];
        clipAudioMonoMixType: MonoMixType;
        clipAudioSampleForceMono: boolean;
        clipAudioSampleRate: number;
        clipAudioSeekThreshold: number;
        clipAudioStoreSamples: boolean;
        clipVideoDynamicLoad: boolean;
        clipVideoDynamicLoadTime: number;
        clipVideoFilmstripInterval: number;
        clipVideoFilmstripKeyframesOnly: boolean;
        clipVideoFilmstripMaxFrames: number;
        clipVideoFilmstripMaxHeight: number;
        clipVideoFilmstripMaxWidth: number;
        clipVideoFilmstripMaxWorkers: number;
        clipVideoSeekThreshold: number;
        clipVideoStoreFilmstrip: boolean;
        clipVideoStoreSamples: boolean;
        decoderPreferredAcceleration: PreferredAcceleration;
        decoderUseSeparateWorker: boolean;
        decoderUseSubImage: boolean;
        decoderUseWebCodecs: boolean;
        encoderBitrate: number;
        encoderBitrateMode: BitrateMode;
        encoderCodec: VideoCodec;
        encoderCrf: number;
        encoderDeadline: number;
        encoderForcedCodecRFCString: string;
        encoderKeyframeInterval: number;
        encoderPerformanceMode: PerformanceMode;
        encoderPreferredAcceleration: PreferredAcceleration;
        encoderUseAlpha: boolean;
        encoderUseWebCodecs: boolean;
        m3u8MaxResolution: [number, number];
        mediaHashAlgorithm: HashAlgorithmEnum;
        renderAudioUseWorker: boolean;
        renderCancelFailTimeout: number;
        renderChunkedOutputMaxSize: number;
        renderMaxQueueSize: number;
        renderShowPreview: boolean;
        renderThrottleFactor: number;
        renderUseChunkedOutput: boolean;
        renderVideoUseDirectFrames: boolean;
        subtitlesAutoWrapOnResize: boolean;
        subtitlesScaleOnResize: boolean;
        useInternalTranscoder: boolean;
        viewAutoLayoutOnResize: AutoLayoutMode;
    };
    subtitlesManager?: {
        highlightAnimation: HighlightAnimationEnum;
        highlightAnimationSpeed: number;
        highlightEnabled: boolean;
        highlightTextStyle: {
            backgroundColor: string;
            backgroundCornerRadius: number;
            backgroundPadding: number;
            color: string;
            dropShadow: boolean;
            dropShadowAlpha: number;
            dropShadowAngle: number;
            dropShadowBlur: number;
            dropShadowColor: string;
            dropShadowDistance: number;
            fontFamily: string;
            fontSize: number;
            fontStyle: "normal"
            | "italic"
            | "oblique";
            fontWeight:
                | "normal"
                | "bold"
                | "bolder"
                | "lighter"
                | "100"
                | "200"
                | "300"
                | "400"
                | "500"
                | "600"
                | "700"
                | "800"
                | "900";
            letterSpacing: number;
            padding: number;
            strokeColor: string;
            strokeThickness: number;
        };
        mainTextStyle: {
            backgroundColor: string;
            backgroundCornerRadius: number;
            backgroundPadding: number;
            color: string;
            dropShadow: boolean;
            dropShadowAlpha: number;
            dropShadowAngle: number;
            dropShadowBlur: number;
            dropShadowColor: string;
            dropShadowDistance: number;
            fontFamily: string;
            fontSize: number;
            fontStyle: "normal"
            | "italic"
            | "oblique";
            fontWeight:
                | "normal"
                | "bold"
                | "bolder"
                | "lighter"
                | "100"
                | "200"
                | "300"
                | "400"
                | "500"
                | "600"
                | "700"
                | "800"
                | "900";
            leading: number;
            letterSpacing: number;
            lineHeight: number;
            padding: number;
            strokeColor: string;
            strokeThickness: number;
            wordWrap: boolean;
            wordWrapWidth: number;
        };
        position?: [number, number];
        scale: number;
        textMode: "partial" | "full";
    };
    timeline: {
        customData?: [string, unknown][];
        fitDuration: number;
        fps: number;
        layers: {
            clips: any[];
            customData?: [string, unknown][];
            id: string;
            muted?: boolean;
            name?: string;
            transitions: {
                endClipId: string;
                id: string;
                inDuration: number;
                outDuration: number;
                properties: [string, any][];
                provider: string;
                startClipId: string;
                transitionId: string;
            }[];
            visible?: boolean;
            volume?: number;
        }[];
        startTime: number;
        volume: number;
    };
    version?: string;
}
Serializes the current project into a schema-validated plain object.

Returns {
    createdAt?: number;
    customData?: [string, unknown][];
    display: { backgroundColor: string; height: number; width: number };
    library: {
        customData?: [string, unknown][];
        effects: {
            autoFit?: boolean;
            blendMode?: NORMAL | ADD | SCREEN | MULTIPLY;
            fragmentSrc: string;
            id: string;
            inputTextures?: {
                mipmap?: OFF | ON;
                name: string;
                scaleMode?: NEAREST | LINEAR;
                url: string;
                wrapMode?: CLAMP | REPEAT | MIRRORED_REPEAT;
            }[];
            name: string;
            noTransform?: boolean;
            padding?: number;
            properties: {
                defaultValue: Required<any>;
                description?: string;
                initOnly?: boolean;
                label?: string;
                max?: number | number[];
                min?: number | number[];
                name: string;
                step?: number | number[];
                type: PropertyDescriptionTypeEnum;
            }[];
            provider: string;
        }[];
        filters: { id: string; lutUrl: string; name: string; provider: string }[];
        media: {
            customData?: [string, unknown][];
            filename: string;
            hash?: string;
            id: string;
            mimeType?: string;
            name?: string;
            permanentUrl?: string;
            placeholderClipIds?: string[];
            type: string;
        }[];
        subtitles: {
            duration: number;
            id: string;
            language: string;
            textBlocks: {
                duration: number;
                text: string;
                time: number;
                wordTimings?: number[];
            }[];
        }[];
        transitions: {
            id: string;
            inputTextures?: {
                mipmap?: OFF
                | ON;
                name: string;
                scaleMode?: NEAREST | LINEAR;
                url: string;
                wrapMode?: CLAMP | REPEAT | MIRRORED_REPEAT;
            }[];
            name: string;
            properties: {
                defaultValue: Required<any>;
                description?: string;
                initOnly?: boolean;
                label?: string;
                max?: number | number[];
                min?: number | number[];
                name: string;
                step?: number | number[];
                type: PropertyDescriptionTypeEnum;
            }[];
            provider: string;
            transitionSrc: string;
        }[];
    };
    projectId?: string;
    settings?: {
        clipAudioMonoChannelsWeight: number[];
        clipAudioMonoMixType: MonoMixType;
        clipAudioSampleForceMono: boolean;
        clipAudioSampleRate: number;
        clipAudioSeekThreshold: number;
        clipAudioStoreSamples: boolean;
        clipVideoDynamicLoad: boolean;
        clipVideoDynamicLoadTime: number;
        clipVideoFilmstripInterval: number;
        clipVideoFilmstripKeyframesOnly: boolean;
        clipVideoFilmstripMaxFrames: number;
        clipVideoFilmstripMaxHeight: number;
        clipVideoFilmstripMaxWidth: number;
        clipVideoFilmstripMaxWorkers: number;
        clipVideoSeekThreshold: number;
        clipVideoStoreFilmstrip: boolean;
        clipVideoStoreSamples: boolean;
        decoderPreferredAcceleration: PreferredAcceleration;
        decoderUseSeparateWorker: boolean;
        decoderUseSubImage: boolean;
        decoderUseWebCodecs: boolean;
        encoderBitrate: number;
        encoderBitrateMode: BitrateMode;
        encoderCodec: VideoCodec;
        encoderCrf: number;
        encoderDeadline: number;
        encoderForcedCodecRFCString: string;
        encoderKeyframeInterval: number;
        encoderPerformanceMode: PerformanceMode;
        encoderPreferredAcceleration: PreferredAcceleration;
        encoderUseAlpha: boolean;
        encoderUseWebCodecs: boolean;
        m3u8MaxResolution: [number, number];
        mediaHashAlgorithm: HashAlgorithmEnum;
        renderAudioUseWorker: boolean;
        renderCancelFailTimeout: number;
        renderChunkedOutputMaxSize: number;
        renderMaxQueueSize: number;
        renderShowPreview: boolean;
        renderThrottleFactor: number;
        renderUseChunkedOutput: boolean;
        renderVideoUseDirectFrames: boolean;
        subtitlesAutoWrapOnResize: boolean;
        subtitlesScaleOnResize: boolean;
        useInternalTranscoder: boolean;
        viewAutoLayoutOnResize: AutoLayoutMode;
    };
    subtitlesManager?: {
        highlightAnimation: HighlightAnimationEnum;
        highlightAnimationSpeed: number;
        highlightEnabled: boolean;
        highlightTextStyle: {
            backgroundColor: string;
            backgroundCornerRadius: number;
            backgroundPadding: number;
            color: string;
            dropShadow: boolean;
            dropShadowAlpha: number;
            dropShadowAngle: number;
            dropShadowBlur: number;
            dropShadowColor: string;
            dropShadowDistance: number;
            fontFamily: string;
            fontSize: number;
            fontStyle: "normal"
            | "italic"
            | "oblique";
            fontWeight:
                | "normal"
                | "bold"
                | "bolder"
                | "lighter"
                | "100"
                | "200"
                | "300"
                | "400"
                | "500"
                | "600"
                | "700"
                | "800"
                | "900";
            letterSpacing: number;
            padding: number;
            strokeColor: string;
            strokeThickness: number;
        };
        mainTextStyle: {
            backgroundColor: string;
            backgroundCornerRadius: number;
            backgroundPadding: number;
            color: string;
            dropShadow: boolean;
            dropShadowAlpha: number;
            dropShadowAngle: number;
            dropShadowBlur: number;
            dropShadowColor: string;
            dropShadowDistance: number;
            fontFamily: string;
            fontSize: number;
            fontStyle: "normal"
            | "italic"
            | "oblique";
            fontWeight:
                | "normal"
                | "bold"
                | "bolder"
                | "lighter"
                | "100"
                | "200"
                | "300"
                | "400"
                | "500"
                | "600"
                | "700"
                | "800"
                | "900";
            leading: number;
            letterSpacing: number;
            lineHeight: number;
            padding: number;
            strokeColor: string;
            strokeThickness: number;
            wordWrap: boolean;
            wordWrapWidth: number;
        };
        position?: [number, number];
        scale: number;
        textMode: "partial" | "full";
    };
    timeline: {
        customData?: [string, unknown][];
        fitDuration: number;
        fps: number;
        layers: {
            clips: any[];
            customData?: [string, unknown][];
            id: string;
            muted?: boolean;
            name?: string;
            transitions: {
                endClipId: string;
                id: string;
                inDuration: number;
                outDuration: number;
                properties: [string, any][];
                provider: string;
                startClipId: string;
                transitionId: string;
            }[];
            visible?: boolean;
            volume?: number;
        }[];
        startTime: number;
        volume: number;
    };
    version?: string;
}
The serialized engine payload.

setAllCustomData

setAllCustomData(data: Map<string, unknown>): void
Replaces all custom metadata entries with the supplied map.
Parameters
- data: Map<string, unknown>
  Metadata map to store.
Returns void
Nothing.

setCustomData

setCustomData(key: string, value: unknown, overwrite?: boolean): boolean
Stores custom metadata on the engine instance.
Parameters
- key: string
  Metadata key to write.
- value: unknown
  Metadata value to store.
- overwrite: boolean = true
  When false, existing values are preserved and the write is rejected.
Returns boolean
true if the value was stored; otherwise false.

setProjectId

setProjectId(id: string): Promise<void>
Replaces the active project identifier and reinitializes storage for the new project.
Parameters
- id: string
  Project identifier to assign.
Returns Promise<void>
A promise that resolves after storage has been rebound to the new project ID.

setSubtitles

setSubtitles(subtitlesId: string, offset: number): void
Activates a subtitles track on the timeline.
Parameters
- subtitlesId: string
  Subtitle track identifier to apply.
- offset: number
  Time offset, in seconds, used when synchronizing the subtitles track.
Returns void
Nothing.

shouldSplitAudio

shouldSplitAudio(): boolean
Indicates whether imported media should have audio separated for the current platform.

Returns boolean
true when audio splitting should be enabled; otherwise false.

stop

stop(): Promise<void>
Stops timeline playback.

Returns Promise<void>
A promise that resolves after playback has stopped.

`Static`deserialize

deserialize(data: object): Promise<undefined | void | Engine>
Restores engine state from a serialized project payload.

If another deserialization is already in progress, the latest payload is queued and processed after the active deserialization finishes.
Parameters
- data: object
  Serialized engine payload to load.
Returns Promise<undefined | void | Engine>
A promise that resolves to the engine instance once deserialization finishes.

`Static`getInstance

getInstance(): Engine
Returns Engine

`Static`getSDKVersion

getSDKVersion(): string
Returns the SDK version bundled into the current build.

Returns string
The current SDK version string.

Class Engine

Index

Properties

Methods

Properties

customClipTypes

Readonlyevents

Static ReadonlycurrentVersion

StaticprojectVersion

Methods

callStaticCustomClipMethod

Parameters

Returns any

cancelExport

Returns Promise<void>

clearAllCustomData

Returns void

createCustomClipInstance

Type Parameters

Parameters

Returns T

destroy

Parameters

Returns Promise<void>

export

Parameters

Returns Promise<null | ExportResult>

exportAudioRange

Parameters

Returns Promise<null | ExportResult>

getAllCustomData

Returns undefined | Map<string, unknown>

getBackgroundTimer

Returns BackgroundTimer

getClipById

Parameters

Returns undefined | Clip<Sprite, ClipStyle<Sprite>>

getClipsIdsForPoint

Parameters

Returns null

getCustomData

Parameters

Returns unknown

getDataHashFunction

Returns undefined | ((data: Uint8Array) => Promise<string>)

getDisplay

Returns Display

getFFmpeg

Returns FFmpeg

getFontRegistry

Returns FontRegistry

getFrameAsBase64Image

Parameters

Returns Promise<string>

getLibrary

Returns Library

getProjectId

Returns string

getRenderer

Returns PixiRenderer

getRendererStage

Returns null | Container<DisplayObject>

getSettings

Returns Settings

getStorageController

Returns StorageController

getSubtitlesManager

Returns SubtitlesManager

getTimeline

Returns Timeline

getTranscoder

Returns null | ITranscodeProvider

getUndoManager

Returns UndoManager

hasCustomClipType

Parameters

Returns boolean

hasCustomData

Parameters

Returns boolean

`Readonly`events

`Static` `Readonly`currentVersion

`Static`projectVersion

`Static`deserialize

`Static`getInstance

`Static`getSDKVersion