remotion/dist/cjs/internals.d.ts

Make videos programmatically

import type { ScheduleAudioNodeResult } from './audio/shared-audio-tags.js';
import { type ScheduleAudioNodeOptions } from './audio/shared-audio-tags.js';
import type { RemotionAudioContextState } from './audio/use-audio-context.js';
import { type CompProps } from './Composition.js';
import type { TCompMetadata, TComposition, TRenderAsset, TSequence } from './CompositionManager.js';
import type { CompositionManagerContext } from './CompositionManagerContext.js';
import * as CSSUtils from './default-css.js';
import type { SerializedJSONWithCustomFields } from './input-props-serialization.js';
import type { LoggingContextValue } from './log-level-context.js';
import type { NonceHistory } from './nonce.js';
import type { RemotionEnvironment } from './remotion-environment-context.js';
import { type SequenceFieldSchema, type SequenceSchema, type VisibleFieldSchema } from './sequence-field-schema.js';
import type { OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters } from './sequence-node-path.js';
import { OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext } from './sequence-node-path.js';
import type { ResolvedStackLocation } from './sequence-stack-traces.js';
import type { CannotUpdateSequenceReason } from './SequenceManager.js';
import { type CanUpdateEffectPropsResponse, type CanUpdateEffectPropsResponseFalse, type CanUpdateEffectPropsResponseTrue, type CanUpdateSequencePropsResponse, type CanUpdateSequencePropsResponseFalse, type CanUpdateSequencePropsResponseTrue, type SequenceNodePath, type SequencePropsSubscriptionKey } from './SequenceManager.js';
import * as TimelinePosition from './timeline-position-state.js';
import { type PlaybackRateContextValue, type SetTimelineContextValue, type TimelineContextValue } from './TimelineContext.js';
import { truthy } from './truthy.js';
import type { CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusTrue, GetCodeValues, GetDragOverrides, GetEffectCodeValues, GetEffectDragOverrides } from './use-schema.js';
import { type CanUpdateSequencePropStatus, type CodeValues, type DragOverrides, type EffectDragOverrides } from './use-schema.js';
import type { MediaVolumeContextValue, SetMediaVolumeContextValue } from './volume-position-state.js';
import type { WatchRemotionStaticFilesPayload } from './watch-static-file.js';
import { useRemotionContexts } from './wrap-remotion-context.js';
export type { EffectChainState } from './effects/run-effect-chain.js';
export declare const Internals: {
    readonly MaxMediaCacheSizeContext: import("react").Context<number | null>;
    readonly useUnsafeVideoConfig: () => import("./video-config.js").VideoConfig | null;
    readonly useFrameForVolumeProp: (behavior: import("./audio/use-audio-frame.js").LoopVolumeCurveBehavior) => number;
    readonly useTimelinePosition: () => number;
    readonly useAbsoluteTimelinePosition: () => number;
    readonly evaluateVolume: ({ frame, volume, mediaVolume, }: {
        frame: number;
        volume: import("./volume-prop.js").VolumeProp | undefined;
        mediaVolume: number;
    }) => number;
    readonly getAbsoluteSrc: (relativeSrc: string) => string;
    readonly getAssetDisplayName: (filename: string) => string;
    readonly Timeline: typeof TimelinePosition;
    readonly validateMediaTrimProps: ({ startFrom, endAt, trimBefore, trimAfter, }: {
        startFrom: number | undefined;
        endAt: number | undefined;
        trimBefore: number | undefined;
        trimAfter: number | undefined;
    }) => void;
    readonly validateMediaProps: (props: {
        volume: import("./volume-prop.js").VolumeProp | undefined;
        playbackRate: number | undefined;
        preservePitch?: boolean | undefined;
    }, component: "Html5Video" | "Html5Audio" | "Audio" | "Video") => void;
    readonly resolveTrimProps: ({ startFrom, endAt, trimBefore, trimAfter, }: {
        startFrom: number | undefined;
        endAt: number | undefined;
        trimBefore: number | undefined;
        trimAfter: number | undefined;
    }) => {
        trimBeforeValue: number | undefined;
        trimAfterValue: number | undefined;
    };
    readonly VideoForPreview: import("react").ForwardRefExoticComponent<Omit<import("./video/props.js").NativeVideoProps & {
        name?: string;
        volume?: import("./volume-prop.js").VolumeProp;
        playbackRate?: number;
        preservePitch?: boolean;
        acceptableTimeShiftInSeconds?: number;
        allowAmplificationDuringRender?: boolean;
        useWebAudioApi?: boolean;
        toneFrequency?: number;
        pauseWhenBuffering?: boolean;
        showInTimeline?: boolean;
        delayRenderTimeoutInMilliseconds?: number;
        loopVolumeCurveBehavior?: import("./audio/use-audio-frame.js").LoopVolumeCurveBehavior;
        delayRenderRetries?: number;
        onError?: (err: Error) => void;
        onAutoPlayError?: null | (() => void);
        audioStreamIndex?: number;
    } & {
        readonly onlyWarnForMediaSeekingError: boolean;
        readonly onDuration: (src: string, durationInSeconds: number) => void;
        readonly pauseWhenBuffering: boolean;
        readonly _remotionInternalNativeLoopPassed: boolean;
        readonly _remotionInternalStack: string | null;
        readonly showInTimeline: boolean;
        readonly onVideoFrame: null | import("./index.js").OnVideoFrame;
        readonly crossOrigin?: "" | "anonymous" | "use-credentials";
    }, "ref"> & import("react").RefAttributes<HTMLVideoElement>>;
    readonly CompositionManager: import("react").Context<CompositionManagerContext>;
    readonly CompositionSetters: import("react").Context<import("./CompositionManagerContext.js").CompositionManagerSetters>;
    readonly VisualModeCodeValuesContext: import("react").Context<import("./SequenceManager.js").VisualModeCodeValues>;
    readonly VisualModeDragOverridesContext: import("react").Context<import("./SequenceManager.js").VisualModeDragOverrides>;
    readonly VisualModeSettersContext: import("react").Context<import("./SequenceManager.js").VisualModeSetters>;
    readonly SequenceManager: import("react").Context<import("./SequenceManager.js").SequenceManagerContext>;
    readonly SequenceStackTracesUpdateContext: import("react").Context<import("./sequence-stack-traces.js").UpdateResolvedStackTraceFn>;
    readonly wrapInSchema: <S extends SequenceSchema, Props extends object>(Component: React.ComponentType<Props & {
        readonly _experimentalControls: import("./CompositionManager.js").SequenceControls | undefined;
    }>, schema: S) => React.ComponentType<Props>;
    readonly sequenceSchema: {
        readonly hidden: import("./sequence-field-schema.js").BooleanFieldSchema;
        readonly layout: {
            readonly type: "enum";
            readonly default: "absolute-fill";
            readonly description: "Layout";
            readonly variants: {
                readonly 'absolute-fill': {
                    readonly premountFor: {
                        readonly type: "number";
                        readonly default: 0;
                        readonly description: "Premount For";
                        readonly min: 0;
                        readonly step: 1;
                    };
                    readonly postmountFor: {
                        readonly type: "hidden";
                    };
                    readonly styleWhilePremounted: {
                        readonly type: "hidden";
                    };
                    readonly styleWhilePostmounted: {
                        readonly type: "hidden";
                    };
                    readonly 'style.translate': {
                        readonly type: "translate";
                        readonly step: 1;
                        readonly default: "0px 0px";
                        readonly description: "Offset";
                    };
                    readonly 'style.scale': {
                        readonly type: "number";
                        readonly min: 0.05;
                        readonly max: 100;
                        readonly step: 0.01;
                        readonly default: 1;
                        readonly description: "Scale";
                    };
                    readonly 'style.rotate': {
                        readonly type: "rotation";
                        readonly step: 1;
                        readonly default: "0deg";
                        readonly description: "Rotation";
                    };
                    readonly 'style.opacity': {
                        readonly type: "number";
                        readonly min: 0;
                        readonly max: 1;
                        readonly step: 0.01;
                        readonly default: 1;
                        readonly description: "Opacity";
                    };
                };
                readonly none: {};
            };
        };
    };
    readonly sequenceStyleSchema: {
        readonly premountFor: {
            readonly type: "number";
            readonly default: 0;
            readonly description: "Premount For";
            readonly min: 0;
            readonly step: 1;
        };
        readonly postmountFor: {
            readonly type: "hidden";
        };
        readonly styleWhilePremounted: {
            readonly type: "hidden";
        };
        readonly styleWhilePostmounted: {
            readonly type: "hidden";
        };
        readonly 'style.translate': {
            readonly type: "translate";
            readonly step: 1;
            readonly default: "0px 0px";
            readonly description: "Offset";
        };
        readonly 'style.scale': {
            readonly type: "number";
            readonly min: 0.05;
            readonly max: 100;
            readonly step: 0.01;
            readonly default: 1;
            readonly description: "Scale";
        };
        readonly 'style.rotate': {
            readonly type: "rotation";
            readonly step: 1;
            readonly default: "0deg";
            readonly description: "Rotation";
        };
        readonly 'style.opacity': {
            readonly type: "number";
            readonly min: 0;
            readonly max: 1;
            readonly step: 0.01;
            readonly default: 1;
            readonly description: "Opacity";
        };
    };
    readonly sequenceVisualStyleSchema: {
        readonly 'style.translate': {
            readonly type: "translate";
            readonly step: 1;
            readonly default: "0px 0px";
            readonly description: "Offset";
        };
        readonly 'style.scale': {
            readonly type: "number";
            readonly min: 0.05;
            readonly max: 100;
            readonly step: 0.01;
            readonly default: 1;
            readonly description: "Scale";
        };
        readonly 'style.rotate': {
            readonly type: "rotation";
            readonly step: 1;
            readonly default: "0deg";
            readonly description: "Rotation";
        };
        readonly 'style.opacity': {
            readonly type: "number";
            readonly min: 0;
            readonly max: 1;
            readonly step: 0.01;
            readonly default: 1;
            readonly description: "Opacity";
        };
    };
    readonly sequencePremountSchema: {
        readonly premountFor: {
            readonly type: "number";
            readonly default: 0;
            readonly description: "Premount For";
            readonly min: 0;
            readonly step: 1;
        };
        readonly postmountFor: {
            readonly type: "hidden";
        };
        readonly styleWhilePremounted: {
            readonly type: "hidden";
        };
        readonly styleWhilePostmounted: {
            readonly type: "hidden";
        };
    };
    readonly flattenActiveSchema: (schema: SequenceSchema, resolve: import("./flatten-schema.js").ResolveValue) => SequenceSchema;
    readonly getFlatSchemaWithAllKeys: (schema: SequenceSchema) => SequenceSchema;
    readonly RemotionRootContexts: import("react").FC<{
        readonly children: React.ReactNode;
        readonly numberOfAudioTags: number;
        readonly logLevel: import("./log.js").LogLevel;
        readonly audioLatencyHint: AudioContextLatencyCategory;
        readonly videoEnabled: boolean;
        readonly audioEnabled: boolean;
        readonly frameState: Record<string, number> | null;
    }>;
    readonly CompositionManagerProvider: ({ children, onlyRenderComposition, currentCompositionMetadata, initialCompositions, initialCanvasContent, }: {
        readonly children: React.ReactNode;
        readonly onlyRenderComposition: string | null;
        readonly currentCompositionMetadata: import("./CompositionManagerContext.js").BaseMetadata | null;
        readonly initialCompositions: import("./CompositionManager.js").AnyComposition[];
        readonly initialCanvasContent: import("./CompositionManagerContext.js").CanvasContent | null;
    }) => import("react/jsx-runtime.js").JSX.Element;
    readonly useVideo: () => (import("./video-config.js").VideoConfig & {
        component: import("react").LazyExoticComponent<import("react").ComponentType<Record<string, unknown>>> | import("react").ComponentType<Record<string, unknown>>;
    }) | null;
    readonly getRoot: () => import("react").FC<{}> | null;
    readonly useMediaVolumeState: () => readonly [number, (u: number) => void];
    readonly useMediaMutedState: () => readonly [boolean, (u: React.SetStateAction<boolean>) => void];
    readonly useMediaInTimeline: ({ volume, mediaVolume, src, mediaType, playbackRate, displayName, id, getStack, showInTimeline, premountDisplay, postmountDisplay, loopDisplay, documentationLink, }: {
        volume: import("./volume-prop.js").VolumeProp | undefined;
        mediaVolume: number;
        src: string | undefined;
        mediaType: "audio" | "video";
        playbackRate: number;
        displayName: string | null;
        id: string;
        getStack: () => string | null;
        showInTimeline: boolean;
        premountDisplay: number | null;
        postmountDisplay: number | null;
        loopDisplay: import("./CompositionManager.js").LoopDisplay | undefined;
        documentationLink: string | null;
    }) => void;
    readonly useLazyComponent: <Props>({ compProps, componentName, noSuspense, }: {
        compProps: CompProps<Props>;
        componentName: string;
        noSuspense: boolean;
    }) => (import("react").ExoticComponent<Props | (import("react").PropsWithoutRef<Props> & import("react").RefAttributes<import("react").Component<Props, any, any>>)> & {
        readonly _result: import("react").ComponentType<Props>;
    }) | import("react").ComponentType<Props>;
    readonly truthy: typeof truthy;
    readonly SequenceContext: import("react").Context<import("./SequenceContext.js").SequenceContextType | null>;
    readonly PremountContext: import("react").Context<import("./PremountContext.js").PremountContextValue>;
    readonly useRemotionContexts: typeof useRemotionContexts;
    readonly RemotionContextProvider: (props: import("./wrap-remotion-context.js").RemotionContextProviderProps) => import("react/jsx-runtime.js").JSX.Element;
    readonly CSSUtils: typeof CSSUtils;
    readonly setupEnvVariables: () => void;
    readonly MediaVolumeContext: import("react").Context<MediaVolumeContextValue>;
    readonly SetMediaVolumeContext: import("react").Context<SetMediaVolumeContextValue>;
    readonly getRemotionEnvironment: () => RemotionEnvironment;
    readonly SharedAudioContext: import("react").Context<{
        audioContext: AudioContext | null;
        getAudioContextState: () => RemotionAudioContextState | null;
        gainNode: GainNode | null;
        audioSyncAnchor: {
            value: number;
        };
        audioSyncAnchorEmitter: import("./audio/shared-audio-tags.js").AudioSyncAnchorEmitter;
        scheduleAudioNode: (options: ScheduleAudioNodeOptions) => ScheduleAudioNodeResult;
        resume: () => Promise<void>;
        suspend: () => Promise<void>;
        getIsResumingAudioContext: () => Promise<void> | null;
        unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
    } | null>;
    readonly SharedAudioContextProvider: import("react").FC<{
        readonly children: React.ReactNode;
        readonly audioLatencyHint: AudioContextLatencyCategory;
        readonly audioEnabled: boolean;
    }>;
    readonly SharedAudioTagsContext: import("react").Context<{
        registerAudio: (options: {
            aud: import("react").AudioHTMLAttributes<HTMLAudioElement>;
            audioId: string;
            premounting: boolean;
            postmounting: boolean;
        }) => {
            id: number;
            props: import("react").AudioHTMLAttributes<HTMLAudioElement>;
            el: React.RefObject<HTMLAudioElement | null>;
            audioId: string;
            mediaElementSourceNode: import("./audio/shared-element-source-node.js").SharedElementSourceNode | null;
            premounting: boolean;
            postmounting: boolean;
            audioMounted: boolean;
            cleanupOnMediaTagUnmount: () => void;
        };
        unregisterAudio: (id: number) => void;
        updateAudio: (options: {
            id: number;
            aud: import("react").AudioHTMLAttributes<HTMLAudioElement>;
            audioId: string;
            premounting: boolean;
            postmounting: boolean;
        }) => void;
        playAllAudios: () => void;
        numberOfAudioTags: number;
    } | null>;
    readonly SharedAudioTagsContextProvider: import("react").FC<{
        readonly numberOfAudioTags: number;
        readonly children: React.ReactNode;
    }>;
    readonly invalidCompositionErrorMessage: string;
    readonly calculateMediaDuration: ({ trimAfter, mediaDurationInFrames, playbackRate, trimBefore, }: {
        mediaDurationInFrames: number;
        playbackRate: number;
        trimBefore: number | undefined;
        trimAfter: number | undefined;
    }) => number;
    readonly isCompositionIdValid: (id: string) => RegExpMatchArray | null;
    readonly getPreviewDomElement: () => HTMLElement | null;
    readonly compositionsRef: import("react").RefObject<{
        getCompositions: () => import("./CompositionManager.js").AnyComposition[];
    } | null>;
    readonly portalNode: () => HTMLElement;
    readonly waitForRoot: (fn: (comp: React.FC) => void) => (() => void);
    readonly SetTimelineContext: import("react").Context<SetTimelineContextValue>;
    readonly CanUseRemotionHooksProvider: import("react").FC<{
        readonly children: React.ReactNode;
    }>;
    readonly CanUseRemotionHooks: import("react").Context<boolean>;
    readonly PrefetchProvider: import("react").FC<{
        readonly children: React.ReactNode;
    }>;
    readonly DurationsContextProvider: import("react").FC<{
        readonly children: React.ReactNode;
    }>;
    readonly IsPlayerContextProvider: import("react").FC<{
        children?: import("react").ReactNode | undefined;
    }>;
    readonly useIsPlayer: () => boolean;
    readonly EditorPropsProvider: import("react").FC<{
        readonly children: React.ReactNode;
    }>;
    readonly EditorPropsContext: import("react").Context<import("./EditorProps.js").EditorPropsContextType>;
    readonly usePreload: (src: string) => string;
    readonly NonceContext: import("react").Context<import("./nonce.js").TNonceContext>;
    readonly resolveVideoConfig: ({ calculateMetadata, signal, defaultProps, inputProps: originalProps, compositionId, compositionDurationInFrames, compositionFps, compositionHeight, compositionWidth, }: {
        compositionId: string;
        compositionWidth: number | null;
        compositionHeight: number | null;
        compositionFps: number | null;
        compositionDurationInFrames: number | null;
        calculateMetadata: import("./Composition.js").CalculateMetadataFunction<import("./props-if-has-props.js").InferProps<import("./any-zod-type.js").AnyZodObject, Record<string, unknown>>> | null;
        signal: AbortSignal;
        defaultProps: Record<string, unknown>;
        inputProps: Record<string, unknown>;
    }) => import("./video-config.js").VideoConfig | Promise<import("./video-config.js").VideoConfig>;
    readonly resolveVideoConfigOrCatch: (params: {
        compositionId: string;
        compositionWidth: number | null;
        compositionHeight: number | null;
        compositionFps: number | null;
        compositionDurationInFrames: number | null;
        calculateMetadata: import("./Composition.js").CalculateMetadataFunction<import("./props-if-has-props.js").InferProps<import("./any-zod-type.js").AnyZodObject, Record<string, unknown>>> | null;
        signal: AbortSignal;
        defaultProps: Record<string, unknown>;
        inputProps: Record<string, unknown>;
    }) => {
        type: "success";
        result: import("./video-config.js").VideoConfig | Promise<import("./video-config.js").VideoConfig>;
    } | {
        type: "error";
        error: Error;
    };
    readonly ResolveCompositionContext: import("react").Context<{
        [x: string]: ({
            type: "loading";
        } | {
            type: "success";
            result: import("./video-config.js").VideoConfig;
        } | {
            type: "success-and-refreshing";
            result: import("./video-config.js").VideoConfig;
        } | {
            type: "error";
            error: Error;
        }) | undefined;
    } | null>;
    readonly useResolvedVideoConfig: (preferredCompositionId: string | null) => ({
        type: "loading";
    } | {
        type: "success";
        result: import("./video-config.js").VideoConfig;
    } | {
        type: "success-and-refreshing";
        result: import("./video-config.js").VideoConfig;
    } | {
        type: "error";
        error: Error;
    }) | null;
    readonly resolveCompositionsRef: import("react").RefObject<{
        setCurrentRenderModalComposition: (compositionId: string | null) => void;
        reloadCurrentlySelectedComposition: () => void;
    } | null>;
    readonly REMOTION_STUDIO_CONTAINER_ELEMENT: "__remotion-studio-container";
    readonly RenderAssetManager: import("react").Context<import("./RenderAssetManager.js").RenderAssetManagerContext>;
    readonly persistCurrentFrame: (time: {
        [x: string]: number;
    }) => void;
    readonly usePlaybackRate: () => PlaybackRateContextValue;
    readonly useTimelineContext: () => TimelineContextValue;
    readonly useTimelineSetFrame: () => ((u: React.SetStateAction<Record<string, number>>) => void);
    readonly isIosSafari: () => boolean;
    readonly WATCH_REMOTION_STATIC_FILES: "remotion_staticFilesChanged";
    readonly addSequenceStackTraces: (component: unknown) => void;
    readonly useMediaStartsAt: () => number;
    readonly BufferingProvider: import("react").FC<{
        readonly children: React.ReactNode;
    }>;
    readonly BufferingContextReact: import("react").Context<{
        addBlock: (block: {
            id: string;
        }) => {
            unblock: () => void;
        };
        listenForBuffering: (callback: () => void) => {
            remove: () => void;
        };
        listenForResume: (callback: () => void) => {
            remove: () => void;
        };
        buffering: React.MutableRefObject<boolean>;
    } | null>;
    readonly getComponentsToAddStacksTo: () => unknown[];
    readonly CurrentScaleContext: import("react").Context<import("./use-current-scale.js").CurrentScaleContextType | null>;
    readonly PreviewSizeContext: import("react").Context<import("./use-current-scale.js").PreviewSizeCtx>;
    readonly calculateScale: ({ canvasSize, compositionHeight, compositionWidth, previewSize, }: {
        previewSize: import("./use-current-scale.js").PreviewSize["size"];
        compositionWidth: number;
        compositionHeight: number;
        canvasSize: {
            width: number;
            height: number;
        };
    }) => number;
    readonly validateRenderAsset: (artifact: TRenderAsset) => void;
    readonly Log: {
        trace: (options: {
            logLevel: import("./log.js").LogLevel;
            tag: string | null;
        }, message?: any, ...optionalParams: any[]) => void;
        verbose: (options: {
            logLevel: import("./log.js").LogLevel;
            tag: string | null;
        }, message?: any, ...optionalParams: any[]) => void;
        info: (options: {
            logLevel: import("./log.js").LogLevel;
            tag: string | null;
        }, message?: any, ...optionalParams: any[]) => void;
        warn: (options: {
            logLevel: import("./log.js").LogLevel;
            tag: string | null;
        }, message?: any, ...optionalParams: any[]) => void;
        error: (options: {
            logLevel: import("./log.js").LogLevel;
            tag: string | null;
        }, message?: any, ...optionalParams: any[]) => void;
    };
    readonly LogLevelContext: import("react").Context<LoggingContextValue>;
    readonly useLogLevel: () => import("./log.js").LogLevel;
    readonly playbackLogging: ({ logLevel, tag, message, mountTime, }: {
        logLevel: import("./log.js").LogLevel;
        tag: string;
        message: string;
        mountTime: number | null;
    }) => void;
    readonly timeValueRef: import("react").RefObject<{
        goToFrame: () => void;
        seek: (newFrame: number) => void;
        play: (e?: import("react").SyntheticEvent | PointerEvent) => void;
        pause: () => void;
        toggle: (e?: import("react").SyntheticEvent | PointerEvent) => void;
    } | null>;
    readonly compositionSelectorRef: import("react").RefObject<{
        expandComposition: (compName: string) => void;
        selectComposition: (compName: string) => void;
        toggleFolder: (folderName: string, parentName: string | null) => void;
    } | null>;
    readonly RemotionEnvironmentContext: import("react").Context<RemotionEnvironment | null>;
    readonly warnAboutTooHighVolume: (volume: number) => void;
    readonly AudioForPreview: import("react").ForwardRefExoticComponent<Omit<import("./audio/props.js").NativeAudioProps & {
        name?: string;
        volume?: import("./volume-prop.js").VolumeProp;
        playbackRate?: number;
        preservePitch?: boolean;
        acceptableTimeShiftInSeconds?: number;
        allowAmplificationDuringRender?: boolean;
        _remotionInternalNeedsDurationCalculation?: boolean;
        _remotionInternalNativeLoopPassed?: boolean;
        toneFrequency?: number;
        useWebAudioApi?: boolean;
        pauseWhenBuffering?: boolean;
        showInTimeline?: boolean;
        delayRenderTimeoutInMilliseconds?: number;
        delayRenderRetries?: number;
        loopVolumeCurveBehavior?: import("./audio/use-audio-frame.js").LoopVolumeCurveBehavior;
        onError?: (err: Error) => void;
        audioStreamIndex?: number;
    } & {
        readonly shouldPreMountAudioTags: boolean;
        readonly onDuration: (src: string, durationInSeconds: number) => void;
        readonly pauseWhenBuffering: boolean;
        readonly _remotionInternalNativeLoopPassed: boolean;
        readonly _remotionInternalStack: string | null;
        readonly showInTimeline: boolean;
        readonly stack?: string | undefined;
        readonly onNativeError: React.ReactEventHandler<HTMLAudioElement>;
    }, "ref"> & import("react").RefAttributes<HTMLAudioElement>>;
    readonly OBJECTFIT_CONTAIN_CLASS_NAME: "__remotion_objectfitcontain";
    readonly InnerOffthreadVideo: import("react").FC<import("./video/props.js").AllOffthreadVideoProps>;
    readonly useBasicMediaInTimeline: ({ volume, mediaVolume, mediaType, src, displayName, trimBefore, trimAfter, playbackRate, sequenceDurationInFrames, mediaStartsAt, loop, }: {
        volume: import("./volume-prop.js").VolumeProp | undefined;
        mediaVolume: number;
        mediaType: "audio" | "video" | "image";
        src: string | undefined;
        displayName: string | null;
        trimBefore: number | undefined;
        trimAfter: number | undefined;
        playbackRate: number;
        sequenceDurationInFrames: number;
        mediaStartsAt: number;
        loop: boolean;
    }) => {
        volumes: string | number;
        duration: number;
        doesVolumeChange: boolean;
        nonce: import("./nonce.js").NonceHistoryContext;
        rootId: string;
        finalDisplayName: string;
        startMediaFrom: number;
        src: string;
        playbackRate: number;
    };
    readonly getInputPropsOverride: () => Record<string, unknown> | null;
    readonly setInputPropsOverride: (override: Record<string, unknown> | null) => void;
    readonly useVideoEnabled: () => boolean;
    readonly useAudioEnabled: () => boolean;
    readonly useIsPlayerBuffering: (bufferManager: {
        addBlock: (block: {
            id: string;
        }) => {
            unblock: () => void;
        };
        listenForBuffering: (callback: () => void) => {
            remove: () => void;
        };
        listenForResume: (callback: () => void) => {
            remove: () => void;
        };
        buffering: React.MutableRefObject<boolean>;
    }) => boolean;
    readonly TimelinePosition: typeof TimelinePosition;
    readonly DelayRenderContextType: import("react").Context<import("./delay-render.js").DelayRenderScope | null>;
    readonly TimelineContext: import("react").Context<TimelineContextValue | null>;
    readonly PlaybackRateContext: import("react").Context<PlaybackRateContextValue | null>;
    readonly AbsoluteTimeContext: import("react").Context<TimelineContextValue | null>;
    readonly RenderAssetManagerProvider: import("react").FC<{
        children: React.ReactNode;
        collectAssets: null | React.RefObject<import("./RenderAssetManager.js").CollectAssetsRef | null>;
    }>;
    readonly getEffectiveVisualModeValue: ({ codeValue, dragOverrideValue, defaultValue, shouldResortToDefaultValueIfUndefined, }: {
        codeValue: CanUpdateSequencePropStatusTrue;
        dragOverrideValue: unknown;
        defaultValue: unknown;
        shouldResortToDefaultValueIfUndefined: boolean;
    }) => unknown;
    readonly CompositionRenderErrorContext: import("react").Context<import("./composition-render-error-context.js").CompositionRenderErrorContextType>;
    readonly useEffectChainState: () => {
        get: (width: number, height: number) => import("./effects/run-effect-chain.js").EffectChainState | null;
    };
    readonly runEffectChain: ({ state, source, effects, output, width, height, }: import("./effects/run-effect-chain.js").RunEffectChainOptions) => Promise<boolean>;
    readonly useMemoizedEffects: ({ effects, overrideId, }: {
        effects: readonly import("./index.js").EffectDescriptor<unknown>[];
        readonly overrideId: string | null;
    }) => import("./index.js").EffectDefinitionAndStack<unknown>[];
    readonly useMemoizedEffectDefinitions: (effects: readonly import("./index.js").EffectDescriptor<unknown>[]) => readonly import("./index.js").EffectDefinition<unknown>[];
    readonly createEffect: <P, S>(definition: import("./index.js").EffectDefinition<P, S>) => import("./index.js").EffectFactory<P>;
    readonly createWebGLContextError: (effectName: string) => Error;
    readonly createWebGL2ContextError: (effectName: string) => Error;
    readonly computeEffectiveSchemaValuesDotNotation: ({ schema, currentValue, overrideValues, propStatus, }: {
        schema: SequenceSchema;
        currentValue: Record<string, unknown>;
        overrideValues: Record<string, unknown>;
        propStatus: Record<string, CanUpdateSequencePropStatus> | undefined;
    }) => {
        merged: Record<string, unknown>;
        propsToDelete: Set<string>;
    };
    readonly OverrideIdsToNodePathsGettersContext: import("react").Context<OverrideToNodePathGetters>;
    readonly OverrideIdsToNodePathsSettersContext: import("react").Context<OverrideToNodeSetters>;
    readonly findPropsToDelete: ({ schema, key, value, }: {
        schema: SequenceSchema;
        key: string;
        value: unknown;
    }) => string[];
    readonly makeSequencePropsSubscriptionKey: (key: SequencePropsSubscriptionKey) => string;
    readonly getCodeValuesCtx: (codeValues: CodeValues, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
    readonly getEffectCodeValuesCtx: ({ codeValues, nodePath, effectIndex, }: {
        codeValues: CodeValues;
        nodePath: SequencePropsSubscriptionKey;
        effectIndex: number;
    }) => {
        type: "cannot-update-sequence";
        reason: CannotUpdateSequenceReason;
    } | {
        type: "cannot-update-effect";
        reason: import("./SequenceManager.js").CannotUpdateEffectReason;
    } | {
        type: "can-update-effect";
        props: Record<string, CanUpdateSequencePropStatus>;
    };
    readonly hiddenField: SequenceFieldSchema;
};
export type { CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateEffectPropsResponseFalse, CanUpdateEffectPropsResponseTrue, CanUpdateSequencePropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusTrue, CodeValues, CompositionManagerContext, CompProps, DragOverrides, EffectDragOverrides, GetCodeValues, GetDragOverrides, GetEffectCodeValues, GetEffectDragOverrides, LoggingContextValue, MediaVolumeContextValue, NonceHistory, OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext, OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters, PlaybackRateContextValue, RemotionEnvironment, ResolvedStackLocation, ScheduleAudioNodeOptions, ScheduleAudioNodeResult, SequenceFieldSchema, SequenceNodePath, SequencePropsSubscriptionKey, SequenceSchema, SerializedJSONWithCustomFields, SetMediaVolumeContextValue, SetTimelineContextValue, TCompMetadata, TComposition, TimelineContextValue, TRenderAsset, TSequence, VisibleFieldSchema, WatchRemotionStaticFilesPayload, RemotionAudioContextState, };