@remotion/player 4.0.178 → 4.0.180

package/dist/esm/PlaybackrateControl.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Size } from './utils/use-element-size.js';
+export declare const Checkmark: () => import("react/jsx-runtime.js").JSX.Element;
+export declare const playerButtonStyle: React.CSSProperties;
+export declare const PlaybackrateControl: React.FC<{
+    playbackRates: number[];
+    canvasSize: Size;
+}>;

package/dist/esm/Player.d.ts

@@ -0,0 +1,56 @@
+import type { ComponentType } from 'react';
+import React from 'react';
+import type { CompProps } from 'remotion';
+import type { AnyZodObject } from 'zod';
+import type { PlayerRef } from './player-methods.js';
+import type { RenderFullscreenButton, RenderPlayPauseButton } from './PlayerControls.js';
+import type { PosterFillMode, RenderLoading, RenderPoster } from './PlayerUI.js';
+import type { PropsIfHasProps } from './utils/props-if-has-props.js';
+export type ErrorFallback = (info: {
+    error: Error;
+}) => React.ReactNode;
+export type PlayerProps<Schema extends AnyZodObject, Props> = {
+    durationInFrames: number;
+    compositionWidth: number;
+    compositionHeight: number;
+    fps: number;
+    showVolumeControls?: boolean;
+    controls?: boolean;
+    errorFallback?: ErrorFallback;
+    style?: React.CSSProperties;
+    loop?: boolean;
+    autoPlay?: boolean;
+    allowFullscreen?: boolean;
+    clickToPlay?: boolean;
+    doubleClickToFullscreen?: boolean;
+    spaceKeyToPlayOrPause?: boolean;
+    numberOfSharedAudioTags?: number;
+    playbackRate?: number;
+    renderLoading?: RenderLoading;
+    moveToBeginningWhenEnded?: boolean;
+    className?: string;
+    initialFrame?: number;
+    renderPoster?: RenderPoster;
+    showPosterWhenPaused?: boolean;
+    showPosterWhenEnded?: boolean;
+    showPosterWhenUnplayed?: boolean;
+    showPosterWhenBuffering?: boolean;
+    inFrame?: number | null;
+    outFrame?: number | null;
+    initiallyShowControls?: number | boolean;
+    renderPlayPauseButton?: RenderPlayPauseButton;
+    renderFullscreenButton?: RenderFullscreenButton;
+    alwaysShowControls?: boolean;
+    schema?: Schema;
+    initiallyMuted?: boolean;
+    showPlaybackRateControl?: boolean | number[];
+    posterFillMode?: PosterFillMode;
+    bufferStateDelayInMilliseconds?: number;
+    hideControlsWhenPointerDoesntMove?: boolean | number;
+} & CompProps<Props> & PropsIfHasProps<Schema, Props>;
+export declare const componentOrNullIfLazy: <Props>(props: CompProps<Props>) => ComponentType<Props> | null;
+/**
+ * @description A component which can be rendered in a regular React App (for example: Vite, Next.js) to display a Remotion video.
+ * @see [Documentation](https://www.remotion.dev/docs/player/player)
+ */
+export declare const Player: <Schema extends AnyZodObject, Props>(props: PlayerProps<Schema, Props> & React.RefAttributes<PlayerRef>) => React.ReactElement | null;

package/dist/esm/PlayerControls.d.ts

@@ -0,0 +1,47 @@
+import type { MouseEventHandler, ReactNode } from 'react';
+import React from 'react';
+import type { usePlayer } from './use-player.js';
+import type { Size } from './utils/use-element-size.js';
+export type RenderPlayPauseButton = (props: {
+    playing: boolean;
+    isBuffering: boolean;
+}) => ReactNode | null;
+export type RenderFullscreenButton = (props: {
+    isFullscreen: boolean;
+}) => ReactNode;
+declare global {
+    interface Document {
+        webkitFullscreenEnabled?: boolean;
+        webkitFullscreenElement?: Element;
+        webkitExitFullscreen?: Document['exitFullscreen'];
+    }
+    interface HTMLDivElement {
+        webkitRequestFullScreen: HTMLDivElement['requestFullscreen'];
+    }
+}
+export declare const Controls: React.FC<{
+    fps: number;
+    durationInFrames: number;
+    showVolumeControls: boolean;
+    player: ReturnType<typeof usePlayer>;
+    onFullscreenButtonClick: MouseEventHandler<HTMLButtonElement>;
+    isFullscreen: boolean;
+    allowFullscreen: boolean;
+    onExitFullscreenButtonClick: MouseEventHandler<HTMLButtonElement>;
+    spaceKeyToPlayOrPause: boolean;
+    onSeekEnd: () => void;
+    onSeekStart: () => void;
+    inFrame: number | null;
+    outFrame: number | null;
+    initiallyShowControls: number | boolean;
+    canvasSize: Size | null;
+    renderPlayPauseButton: RenderPlayPauseButton | null;
+    renderFullscreenButton: RenderFullscreenButton | null;
+    alwaysShowControls: boolean;
+    showPlaybackRateControl: boolean | number[];
+    containerRef: React.RefObject<HTMLDivElement>;
+    buffering: boolean;
+    hideControlsWhenPointerDoesntMove: boolean | number;
+    onPointerUp: React.PointerEventHandler<HTMLDivElement> | undefined;
+    onDoubleClick: MouseEventHandler<HTMLDivElement> | undefined;
+}>;

package/dist/esm/PlayerSeekBar.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare const PlayerSeekBar: React.FC<{
+    durationInFrames: number;
+    onSeekStart: () => void;
+    onSeekEnd: () => void;
+    inFrame: number | null;
+    outFrame: number | null;
+}>;

package/dist/esm/PlayerUI.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import type { PlayerRef } from './player-methods.js';
+import type { RenderFullscreenButton, RenderPlayPauseButton } from './PlayerControls.js';
+export type ErrorFallback = (info: {
+    error: Error;
+}) => React.ReactNode;
+export type RenderLoading = (canvas: {
+    height: number;
+    width: number;
+    isBuffering: boolean;
+}) => React.ReactNode;
+export type RenderPoster = RenderLoading;
+export type PosterFillMode = 'player-size' | 'composition-size';
+declare const _default: React.ForwardRefExoticComponent<{
+    controls: boolean;
+    loop: boolean;
+    autoPlay: boolean;
+    allowFullscreen: boolean;
+    inputProps: Record<string, unknown>;
+    showVolumeControls: boolean;
+    style?: React.CSSProperties | undefined;
+    clickToPlay: boolean;
+    doubleClickToFullscreen: boolean;
+    spaceKeyToPlayOrPause: boolean;
+    errorFallback: ErrorFallback;
+    playbackRate: number;
+    renderLoading: RenderLoading | undefined;
+    renderPoster: RenderLoading | undefined;
+    className: string | undefined;
+    moveToBeginningWhenEnded: boolean;
+    showPosterWhenPaused: boolean;
+    showPosterWhenEnded: boolean;
+    showPosterWhenUnplayed: boolean;
+    showPosterWhenBuffering: boolean;
+    inFrame: number | null;
+    outFrame: number | null;
+    initiallyShowControls: number | boolean;
+    renderPlayPauseButton: RenderPlayPauseButton | null;
+    renderFullscreen: RenderFullscreenButton | null;
+    alwaysShowControls: boolean;
+    showPlaybackRateControl: boolean | number[];
+    posterFillMode: PosterFillMode;
+    bufferStateDelayInMilliseconds: number;
+    hideControlsWhenPointerDoesntMove: number | boolean;
+} & React.RefAttributes<PlayerRef>>;
+export default _default;

package/dist/esm/SharedPlayerContext.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentType, LazyExoticComponent } from 'react';
+import React from 'react';
+import type { TimelineContextValue } from 'remotion';
+export declare const PLAYER_COMP_ID = "player-comp";
+export declare const SharedPlayerContexts: React.FC<{
+    children: React.ReactNode;
+    timelineContext: TimelineContextValue;
+    fps: number;
+    compositionWidth: number;
+    compositionHeight: number;
+    durationInFrames: number;
+    component: LazyExoticComponent<ComponentType<unknown>>;
+    numberOfSharedAudioTags: number;
+    initiallyMuted: boolean;
+}>;

package/dist/esm/Thumbnail.d.ts

@@ -0,0 +1,23 @@
+import type { CSSProperties } from 'react';
+import type { CompProps } from 'remotion';
+import type { AnyZodObject } from 'zod';
+import type { ThumbnailMethods } from './player-methods.js';
+import type { ErrorFallback, RenderLoading } from './PlayerUI.js';
+import type { PropsIfHasProps } from './utils/props-if-has-props.js';
+type ThumbnailProps<Schema extends AnyZodObject, Props extends Record<string, unknown>> = PropsIfHasProps<Schema, Props> & CompProps<Props> & {
+    frameToDisplay: number;
+    style?: CSSProperties;
+    durationInFrames: number;
+    compositionWidth: number;
+    compositionHeight: number;
+    fps: number;
+    errorFallback?: ErrorFallback;
+    renderLoading?: RenderLoading;
+    className?: string;
+};
+/**
+ * @description A component which can be rendered in a regular React App (for example: Next.js, Vite) to display a single frame of a video.
+ * @see [Documentation](https://www.remotion.dev/docs/player/thumbnail)
+ */
+export declare const Thumbnail: <Schema extends AnyZodObject, Props extends Record<string, unknown>>(props: ThumbnailProps<Schema, Props> & import("react").RefAttributes<ThumbnailMethods>) => React.ReactElement | null;
+export {};

package/dist/esm/ThumbnailUI.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ThumbnailMethods } from './player-methods.js';
+import type { ErrorFallback, RenderLoading } from './PlayerUI.js';
+declare const _default: React.ForwardRefExoticComponent<{
+    inputProps: Record<string, unknown>;
+    style?: React.CSSProperties | undefined;
+    errorFallback: ErrorFallback;
+    renderLoading: RenderLoading | undefined;
+    className: string | undefined;
+} & React.RefAttributes<ThumbnailMethods>>;
+export default _default;

package/dist/esm/calculate-next-frame.d.ts

@@ -0,0 +1,14 @@
+export declare const calculateNextFrame: ({ time, currentFrame: startFrame, playbackSpeed, fps, actualLastFrame, actualFirstFrame, framesAdvanced, shouldLoop, }: {
+    time: number;
+    currentFrame: number;
+    playbackSpeed: number;
+    fps: number;
+    actualFirstFrame: number;
+    actualLastFrame: number;
+    framesAdvanced: number;
+    shouldLoop: boolean;
+}) => {
+    nextFrame: number;
+    framesToAdvance: number;
+    hasEnded: boolean;
+};

package/dist/esm/calculate-scale.d.ts

@@ -0,0 +1,50 @@
+import type { PreviewSize, VideoConfig } from 'remotion';
+import type { Size } from './utils/use-element-size.js';
+type Layout = {
+    centerX: number;
+    centerY: number;
+    xCorrection: number;
+    yCorrection: number;
+    scale: number;
+};
+export declare const calculateCanvasTransformation: ({ previewSize, compositionWidth, compositionHeight, canvasSize, }: {
+    previewSize: PreviewSize['size'];
+    compositionWidth: number;
+    compositionHeight: number;
+    canvasSize: Size;
+}) => Layout;
+export declare const calculateOuterStyle: ({ config, style, canvasSize, }: {
+    config: VideoConfig | null;
+    style: React.CSSProperties | undefined;
+    canvasSize: Size | null;
+}) => React.CSSProperties;
+export declare const calculateContainerStyle: ({ config, canvasSize, layout, scale, }: {
+    config: VideoConfig | null;
+    canvasSize: Size | null;
+    layout: Layout | null;
+    scale: number;
+}) => React.CSSProperties;
+export declare const calculateOuter: ({ layout, scale, config, }: {
+    layout: Layout | null;
+    scale: number;
+    config: VideoConfig | null;
+}) => {
+    readonly width?: undefined;
+    readonly height?: undefined;
+    readonly display?: undefined;
+    readonly flexDirection?: undefined;
+    readonly position?: undefined;
+    readonly left?: undefined;
+    readonly top?: undefined;
+    readonly overflow?: undefined;
+} | {
+    readonly width: number;
+    readonly height: number;
+    readonly display: "flex";
+    readonly flexDirection: "column";
+    readonly position: "absolute";
+    readonly left: number;
+    readonly top: number;
+    readonly overflow: "hidden";
+};
+export {};

package/dist/esm/emitter-context.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { PlayerEmitter, ThumbnailEmitter } from './event-emitter.js';
+export declare const PlayerEventEmitterContext: React.Context<PlayerEmitter | undefined>;
+export declare const ThumbnailEmitterContext: React.Context<ThumbnailEmitter | undefined>;

package/dist/esm/error-boundary.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export declare class ErrorBoundary extends React.Component<{
+    onError: (error: Error) => void;
+    children: React.ReactNode;
+    errorFallback: (info: {
+        error: Error;
+    }) => React.ReactNode;
+}, {
+    hasError: Error | null;
+}> {
+    state: {
+        hasError: null;
+    };
+    static getDerivedStateFromError(error: Error): {
+        hasError: Error;
+    };
+    componentDidCatch(error: Error): void;
+    render(): string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | null | undefined;
+}

package/dist/esm/event-emitter.d.ts

@@ -0,0 +1,91 @@
+type SeekPayload = {
+    frame: number;
+};
+type ErrorPayload = {
+    error: Error;
+};
+type TimeUpdateEventPayload = {
+    frame: number;
+};
+type FrameUpdateEventPayload = {
+    frame: number;
+};
+type RateChangeEventPayload = {
+    playbackRate: number;
+};
+type ScaleChangeEventPayload = {
+    scale: number;
+};
+type VolumeChangeEventPayload = {
+    volume: number;
+};
+type FullscreenChangeEventPayload = {
+    isFullscreen: boolean;
+};
+type MuteChangeEventPayload = {
+    isMuted: boolean;
+};
+type WaitingEventPayload = {};
+type ResumeEventPayload = {};
+type PlayerStateEventMap = {
+    seeked: SeekPayload;
+    pause: undefined;
+    play: undefined;
+    ratechange: RateChangeEventPayload;
+    scalechange: ScaleChangeEventPayload;
+    volumechange: VolumeChangeEventPayload;
+    ended: undefined;
+    error: ErrorPayload;
+    timeupdate: TimeUpdateEventPayload;
+    frameupdate: FrameUpdateEventPayload;
+    fullscreenchange: FullscreenChangeEventPayload;
+    mutechange: MuteChangeEventPayload;
+    waiting: WaitingEventPayload;
+    resume: ResumeEventPayload;
+};
+type ThumbnailStateEventMap = {
+    error: ErrorPayload;
+    waiting: WaitingEventPayload;
+    resume: ResumeEventPayload;
+};
+export type PlayerEventTypes = keyof PlayerStateEventMap;
+export type ThumbnailEventTypes = keyof ThumbnailStateEventMap;
+export type CallbackListener<T extends PlayerEventTypes> = (data: {
+    detail: PlayerStateEventMap[T];
+}) => void;
+type PlayerListeners = {
+    [EventType in PlayerEventTypes]: CallbackListener<EventType>[];
+};
+type ThumbnailListeners = {
+    [EventType in ThumbnailEventTypes]: CallbackListener<EventType>[];
+};
+export declare class PlayerEmitter {
+    listeners: PlayerListeners;
+    addEventListener<Q extends PlayerEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends PlayerEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    private dispatchEvent;
+    dispatchSeek(frame: number): void;
+    dispatchVolumeChange(volume: number): void;
+    dispatchPause(): void;
+    dispatchPlay(): void;
+    dispatchEnded(): void;
+    dispatchRateChange(playbackRate: number): void;
+    dispatchScaleChange(scale: number): void;
+    dispatchError(error: Error): void;
+    dispatchTimeUpdate(event: TimeUpdateEventPayload): void;
+    dispatchFrameUpdate(event: FrameUpdateEventPayload): void;
+    dispatchFullscreenChange(event: FullscreenChangeEventPayload): void;
+    dispatchMuteChange(event: MuteChangeEventPayload): void;
+    dispatchWaiting(event: WaitingEventPayload): void;
+    dispatchResume(event: ResumeEventPayload): void;
+}
+export declare class ThumbnailEmitter {
+    listeners: ThumbnailListeners;
+    addEventListener<Q extends ThumbnailEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends ThumbnailEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    private dispatchEvent;
+    dispatchError(error: Error): void;
+    dispatchWaiting(event: WaitingEventPayload): void;
+    dispatchResume(event: ResumeEventPayload): void;
+}
+export {};

package/dist/esm/format-time.d.ts

@@ -0,0 +1 @@
+export declare const formatTime: (timeInSeconds: number) => string;

package/dist/esm/icons.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare const ICON_SIZE = 25;
+export declare const fullscreenIconSize = 16;
+export declare const PlayIcon: React.FC;
+export declare const PauseIcon: React.FC;
+export declare const FullscreenIcon: React.FC<{
+    isFullscreen: boolean;
+}>;
+export declare const VolumeOffIcon: React.FC;
+export declare const VolumeOnIcon: React.FC;

package/dist/esm/index.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="react" />
+import type { CallbackListener, PlayerEventTypes } from './event-emitter.js';
+import { PlayerEmitter } from './event-emitter.js';
+export { PlayerMethods, PlayerRef, ThumbnailMethods, ThumbnailRef, } from './player-methods.js';
+export { Player, PlayerProps } from './Player.js';
+export type { RenderFullscreenButton, RenderPlayPauseButton, } from './PlayerControls.js';
+export type { ErrorFallback, RenderLoading, RenderPoster } from './PlayerUI.js';
+export { Thumbnail } from './Thumbnail.js';
+export { Size } from './utils/use-element-size.js';
+export type { CallbackListener, PlayerEventTypes as EventTypes };
+export declare const PlayerInternals: {
+    PlayerEventEmitterContext: import("react").Context<PlayerEmitter | undefined>;
+    PlayerEmitter: typeof PlayerEmitter;
+    usePlayer: () => {
+        frameBack: (frames: number) => void;
+        frameForward: (frames: number) => void;
+        isLastFrame: boolean;
+        isFirstFrame: boolean;
+        emitter: PlayerEmitter;
+        playing: boolean;
+        play: (e?: import("react").SyntheticEvent<Element, Event> | undefined) => void;
+        pause: () => void;
+        pauseAndReturnToPlayStart: () => void;
+        seek: (newFrame: number) => void;
+        getCurrentFrame: () => number;
+        isPlaying: () => boolean;
+        hasPlayed: boolean;
+        isBuffering: () => boolean;
+        remotionInternal_currentFrameRef: import("react").MutableRefObject<number>;
+    };
+    usePlayback: ({ loop, playbackRate, moveToBeginningWhenEnded, inFrame, outFrame, frameRef, }: {
+        loop: boolean;
+        playbackRate: number;
+        moveToBeginningWhenEnded: boolean;
+        inFrame: number | null;
+        outFrame: number | null;
+        frameRef: import("react").MutableRefObject<number>;
+    }) => void;
+    useElementSize: (ref: import("react").RefObject<HTMLElement>, options: {
+        triggerOnWindowResize: boolean;
+        shouldApplyCssTransforms: boolean;
+    }) => import("./utils/use-element-size.js").Size | null;
+    calculateCanvasTransformation: ({ previewSize, compositionWidth, compositionHeight, canvasSize, }: {
+        previewSize: number | "auto";
+        compositionWidth: number;
+        compositionHeight: number;
+        canvasSize: import("./utils/use-element-size.js").Size;
+    }) => {
+        centerX: number;
+        centerY: number;
+        xCorrection: number;
+        yCorrection: number;
+        scale: number;
+    };
+    useHoverState: (ref: import("react").RefObject<HTMLDivElement>, hideControlsWhenPointerDoesntMove: number | boolean) => boolean;
+    updateAllElementsSizes: () => void;
+    PlayerEmitterProvider: import("react").FC<{
+        children: import("react").ReactNode;
+        currentPlaybackRate: number | null;
+    }>;
+    BufferingIndicator: import("react").FC<{
+        type: "player" | "studio";
+    }>;
+};

package/dist/esm/is-backgrounded.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useIsBackgrounded: () => import("react").MutableRefObject<boolean>;

package/dist/esm/player-css-classname.d.ts

@@ -0,0 +1 @@
+export declare const PLAYER_CSS_CLASSNAME = "__remotion-player";

package/dist/esm/player-methods.d.ts

@@ -0,0 +1,25 @@
+import type { SyntheticEvent } from 'react';
+import type { PlayerEmitter, ThumbnailEmitter } from './event-emitter.js';
+export type ThumbnailMethods = {
+    getContainerNode: () => HTMLDivElement | null;
+    getScale: () => number;
+};
+export type PlayerMethods = ThumbnailMethods & {
+    play: (e?: SyntheticEvent) => void;
+    pause: () => void;
+    toggle: (e?: SyntheticEvent) => void;
+    seekTo: (frame: number) => void;
+    getCurrentFrame: () => number;
+    requestFullscreen: () => void;
+    exitFullscreen: () => void;
+    isFullscreen: () => boolean;
+    setVolume: (num: number) => void;
+    getVolume: () => number;
+    isMuted: () => boolean;
+    isPlaying: () => boolean;
+    mute: () => void;
+    unmute: () => void;
+    pauseAndReturnToPlayStart: () => void;
+};
+export type ThumbnailRef = ThumbnailEmitter & ThumbnailMethods;
+export type PlayerRef = PlayerEmitter & PlayerMethods;

package/dist/esm/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/test-utils.d.ts

@@ -0,0 +1,6 @@
+import type { queries, RenderOptions } from '@testing-library/react';
+import type { FC, ReactElement } from 'react';
+declare const HelloWorld: FC;
+declare const customRender: (ui: ReactElement, options?: Omit<RenderOptions, 'queries'>) => import("@testing-library/react").RenderResult<typeof queries, HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { customRender as render, HelloWorld };

package/dist/esm/test/validate-in-out-frames.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/test/validate-prop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/use-buffer-state-emitter.d.ts

@@ -0,0 +1,2 @@
+import type { PlayerEmitter, ThumbnailEmitter } from './event-emitter.js';
+export declare const useBufferStateEmitter: (emitter: PlayerEmitter | ThumbnailEmitter) => void;

package/dist/esm/use-hover-state.d.ts

@@ -0,0 +1 @@
+export declare const useHoverState: (ref: React.RefObject<HTMLDivElement>, hideControlsWhenPointerDoesntMove: boolean | number) => boolean;

package/dist/esm/use-playback.d.ts

@@ -0,0 +1,8 @@
+export declare const usePlayback: ({ loop, playbackRate, moveToBeginningWhenEnded, inFrame, outFrame, frameRef, }: {
+    loop: boolean;
+    playbackRate: number;
+    moveToBeginningWhenEnded: boolean;
+    inFrame: number | null;
+    outFrame: number | null;
+    frameRef: React.MutableRefObject<number>;
+}) => void;

package/dist/esm/use-player.d.ts

@@ -0,0 +1,24 @@
+import type { SyntheticEvent } from 'react';
+import type { PlayerEmitter } from './event-emitter.js';
+type UsePlayerMethods = {
+    frameBack: (frames: number) => void;
+    frameForward: (frames: number) => void;
+    isLastFrame: boolean;
+    isFirstFrame: boolean;
+    emitter: PlayerEmitter;
+    playing: boolean;
+    play: (e?: SyntheticEvent) => void;
+    pause: () => void;
+    pauseAndReturnToPlayStart: () => void;
+    seek: (newFrame: number) => void;
+    getCurrentFrame: () => number;
+    isPlaying: () => boolean;
+    hasPlayed: boolean;
+    isBuffering: () => boolean;
+    /**
+     * @deprecated Remotion internal API
+     */
+    remotionInternal_currentFrameRef: React.MutableRefObject<number>;
+};
+export declare const usePlayer: () => UsePlayerMethods;
+export {};

package/dist/esm/use-thumbnail.d.ts

@@ -0,0 +1,6 @@
+import type { ThumbnailEmitter } from './event-emitter.js';
+type UseThumbnailMethods = {
+    emitter: ThumbnailEmitter;
+};
+export declare const useThumbnail: () => UseThumbnailMethods;
+export {};

package/dist/esm/use-video-controls-resize.d.ts

@@ -0,0 +1,11 @@
+type Info = {
+    maxTimeLabelWidth: number | null;
+    displayVerticalVolumeSlider: boolean;
+};
+export declare const X_SPACER = 10;
+export declare const X_PADDING = 12;
+export declare const useVideoControlsResize: ({ allowFullscreen: allowFullScreen, playerWidth, }: {
+    allowFullscreen: boolean;
+    playerWidth: number;
+}) => Info;
+export {};

package/dist/esm/utils/calculate-player-size.d.ts

@@ -0,0 +1,9 @@
+import type { StandardLonghandProperties } from 'csstype';
+import type { Size } from './use-element-size.js';
+export declare const calculatePlayerSize: ({ currentSize, width, height, compositionWidth, compositionHeight, }: {
+    currentSize: Size | null;
+    width: StandardLonghandProperties['width'] | undefined;
+    height: StandardLonghandProperties['height'] | undefined;
+    compositionWidth: number;
+    compositionHeight: number;
+}) => React.CSSProperties;

package/dist/esm/utils/cancellable-promise.d.ts

@@ -0,0 +1,5 @@
+export type CancellablePromise = {
+    promise: Promise<unknown>;
+    cancel: () => void;
+};
+export declare const cancellablePromise: (promise: Promise<unknown>) => CancellablePromise;

package/dist/esm/utils/delay.d.ts

@@ -0,0 +1 @@
+export declare const delay: (n: number) => Promise<unknown>;

package/dist/esm/utils/is-node.d.ts

@@ -0,0 +1 @@
+export declare const IS_NODE: boolean;

package/dist/esm/utils/props-if-has-props.d.ts

@@ -0,0 +1,10 @@
+import type { AnyZodObject, z } from 'zod';
+export type PropsIfHasProps<Schema extends AnyZodObject, Props> = AnyZodObject extends Schema ? {} extends Props ? {
+    inputProps?: z.input<Schema> & Props;
+} : {
+    inputProps: Props;
+} : {} extends Props ? {
+    inputProps: z.input<Schema>;
+} : {
+    inputProps: z.input<Schema> & Props;
+};

package/dist/esm/utils/use-cancellable-promises.d.ts

@@ -0,0 +1,7 @@
+import type { CancellablePromise } from './cancellable-promise.js';
+declare const useCancellablePromises: () => {
+    appendPendingPromise: (promise: CancellablePromise) => void;
+    removePendingPromise: (promise: CancellablePromise) => void;
+    clearPendingPromises: () => void[];
+};
+export { useCancellablePromises };

package/dist/esm/utils/use-click-prevention-on-double-click.d.ts

@@ -0,0 +1,3 @@
+import type { SyntheticEvent } from 'react';
+declare const useClickPreventionOnDoubleClick: (onClick: (e: SyntheticEvent) => void, onDoubleClick: () => void, doubleClickToFullscreen: boolean) => [(e: SyntheticEvent) => void, () => void];
+export { useClickPreventionOnDoubleClick };