@hanifhan1f/vidstack 1.12.13

package/types/core/api/src-types.d.ts

@@ -0,0 +1,50 @@
+import type { SetRequired } from 'type-fest';
+export type MediaSrc = string | AudioSrc | VideoSrc | HLSSrc | DASHSrc | YouTubeSrc | VimeoSrc;
+export type MediaSrcObject = MediaStream | MediaSource | Blob;
+export type HTMLMediaSrc = string | MediaSrcObject;
+export interface Src<T = unknown> {
+    src: T;
+    type: string;
+}
+export interface AudioSrc extends AudioSrcMeta {
+    src: HTMLMediaSrc;
+    type: AudioMimeType;
+}
+export type AudioMimeType = 'audio/mpeg' | 'audio/ogg' | 'audio/3gp' | 'audio/mp3' | 'audio/webm' | 'audio/flac' | 'audio/object';
+export interface AudioSrcMeta {
+    id?: string;
+    bitrate?: number;
+    channels?: number;
+}
+export interface VideoSrc extends VideoSrcMeta {
+    src: HTMLMediaSrc;
+    type: VideoMimeType;
+}
+export type VideoMimeType = 'video/mp4' | 'video/webm' | 'video/3gp' | 'video/ogg' | 'video/avi' | 'video/mpeg' | 'video/object';
+export interface VideoSrcMeta {
+    id?: string;
+    width?: number;
+    height?: number;
+    bitrate?: number;
+    framerate?: number;
+    codec?: string;
+}
+export interface HLSSrc {
+    src: string;
+    type: HLSMimeType;
+}
+export type HLSMimeType = 'application/vnd.apple.mpegurl' | 'audio/mpegurl' | 'audio/x-mpegurl' | 'application/x-mpegurl' | 'video/x-mpegurl' | 'video/mpegurl' | 'application/mpegurl';
+export interface DASHSrc {
+    src: string;
+    type: DASHMimeType;
+}
+export type DASHMimeType = 'application/dash+xml';
+export interface YouTubeSrc {
+    src: string;
+    type: 'video/youtube';
+}
+export interface VimeoSrc {
+    src: string;
+    type: 'video/vimeo';
+}
+export declare function isVideoQualitySrc(src: Src): src is SetRequired<VideoSrc, 'width' | 'height'>;

package/types/core/api/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The current media type.
+ */
+export type MediaType = 'unknown' | 'audio' | 'video';
+/**
+ * The current media stream type.
+ */
+export type MediaStreamType = 'unknown' | 'on-demand' | 'live' | 'live:dvr' | 'll-live' | 'll-live:dvr';
+export type MediaCrossOrigin = '' | 'anonymous' | 'use-credentials';
+export type RemotePlaybackType = 'airplay' | 'google-cast' | 'none';
+export interface RemotePlaybackInfo {
+    deviceName?: string;
+}
+/**
+ * Indicates the current view type which determines how the media will be presented.
+ */
+export type MediaViewType = 'unknown' | 'audio' | 'video';
+/**
+ * Indicates the type of strategy that should be used to initiate the loading process.
+ *
+ * @docs {@see https://www.vidstack.io/docs/player/core-concepts/loading#load-strategies}
+ */
+export type MediaLoadingStrategy = 'eager' | 'idle' | 'visible' | 'custom' | 'play';
+/**
+ * Indicates the type of strategy that should be used to initiate the poster loading process.
+ *
+ * @docs {@see https://www.vidstack.io/docs/player/core-concepts/loading#load-strategies}
+ */
+export type MediaPosterLoadingStrategy = 'eager' | 'idle' | 'visible' | 'custom';
+/**
+ * A number which represents the general type of error that occurred.
+ *
+ * - *Abort Error Code (1):* The fetching of the associated resource was aborted by the user's
+ * request.
+ *
+ * - *Network Error Code (2):* Some kind of network error occurred which prevented the media from
+ * being successfully fetched, despite having previously been available.
+ *
+ * - *Decode Error Code (3):* Despite having previously been determined to be usable, an error
+ * occurred while trying to decode the media resource, resulting in an error.
+ *
+ * - *Invalid Resource Error Code (4):* The associated resource or media provider object (such as
+ * a `MediaStream`) has been found to be unsuitable.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaError
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MediaError/code
+ */
+export type MediaErrorCode = 1 | 2 | 3 | 4;
+export interface MediaErrorDetail {
+    message: string;
+    code?: MediaErrorCode;
+    error?: Error;
+    mediaError?: MediaError;
+}

package/types/core/controls.d.ts

@@ -0,0 +1,43 @@
+import { MediaPlayerController } from './api/player-controller';
+export declare class MediaControls extends MediaPlayerController {
+    #private;
+    /**
+     * The default amount of delay in milliseconds while media playback is progressing without user
+     * activity to indicate an idle state (i.e., hide controls).
+     *
+     * @defaultValue 2000
+     */
+    defaultDelay: number;
+    /**
+     * Whether controls can hide after a delay in user interaction. If this is false, controls will
+     * not hide and be user controlled.
+     */
+    get canIdle(): boolean;
+    set canIdle(canIdle: boolean);
+    /**
+     * Whether controls visibility should be toggled when the mouse enters and leaves the player
+     * container.
+     *
+     * @defaultValue false
+     */
+    get hideOnMouseLeave(): boolean;
+    set hideOnMouseLeave(hide: boolean);
+    /**
+     * Whether media controls are currently visible.
+     */
+    get showing(): boolean;
+    /**
+     * Show controls.
+     */
+    show(delay?: number, trigger?: Event): void;
+    /**
+     * Hide controls.
+     */
+    hide(delay?: number, trigger?: Event): void;
+    /**
+     * Whether all idle tracking on controls should be paused until resumed again.
+     */
+    pause(trigger?: Event): void;
+    resume(trigger?: Event): void;
+    protected onConnect(): void;
+}

package/types/core/font/font-options.d.ts

@@ -0,0 +1,42 @@
+import { type WriteSignal } from 'maverick.js';
+import type { DefaultLayoutTranslations } from '../../components/layouts/default/translations';
+export declare const FONT_COLOR_OPTION: FontOption;
+export declare const FONT_FAMILY_OPTION: FontOption;
+export declare const FONT_SIZE_OPTION: FontSliderOption;
+export declare const FONT_OPACITY_OPTION: FontSliderOption;
+export declare const FONT_TEXT_SHADOW_OPTION: FontOption;
+export declare const FONT_DEFAULTS: {
+    readonly fontFamily: "pro-sans";
+    readonly fontSize: "100%";
+    readonly textColor: "#ffffff";
+    readonly textOpacity: "100%";
+    readonly textShadow: "none";
+    readonly textBg: "#000000";
+    readonly textBgOpacity: "100%";
+    readonly displayBg: "#000000";
+    readonly displayBgOpacity: "0%";
+};
+export declare const FONT_SIGNALS: Record<"fontFamily" | "fontSize" | "textColor" | "textOpacity" | "textShadow" | "textBg" | "textBgOpacity" | "displayBg" | "displayBgOpacity", WriteSignal<string>>;
+export type FontSignal = keyof typeof FONT_DEFAULTS;
+export declare function onFontReset(): void;
+export interface FontRadioOption {
+    type: 'radio';
+    values: string[] | Record<string, string>;
+}
+export interface FontSliderOption {
+    type: 'slider';
+    min: number;
+    max: number;
+    step: number;
+    upIcon: unknown;
+    downIcon: unknown;
+}
+export interface FontColorOption {
+    type: 'color';
+}
+export type FontOption = FontRadioOption | FontSliderOption | FontColorOption;
+export interface DefaultFontSettingProps {
+    label: keyof DefaultLayoutTranslations;
+    type: FontSignal;
+    option: FontOption;
+}

package/types/core/font/font-vars.d.ts

@@ -0,0 +1 @@
+export declare function updateFontCssVars(): void;

package/types/core/keyboard/aria-shortcuts.d.ts

@@ -0,0 +1,6 @@
+import { ViewController } from 'maverick.js';
+export declare class ARIAKeyShortcuts extends ViewController {
+    #private;
+    constructor(shortcut: string);
+    protected onAttach(el: HTMLElement): void;
+}

package/types/core/keyboard/controller.d.ts

@@ -0,0 +1,9 @@
+import type { MediaContext } from '../api/media-context';
+import { MediaPlayerController } from '../api/player-controller';
+import type { MediaKeyShortcuts } from './types';
+export declare const MEDIA_KEY_SHORTCUTS: MediaKeyShortcuts;
+export declare class MediaKeyboardController extends MediaPlayerController {
+    #private;
+    constructor(media: MediaContext);
+    protected onConnect(): void;
+}

package/types/core/keyboard/types.d.ts

@@ -0,0 +1,33 @@
+import type { MediaPlayer } from '../../components/player';
+import type { MediaRemoteControl } from '../state/remote-control';
+export type MediaKeyTarget = 'document' | 'player';
+export interface MediaKeyShortcuts {
+    [keys: string]: MediaKeyShortcut | undefined;
+    togglePaused?: MediaKeyShortcut;
+    toggleMuted?: MediaKeyShortcut;
+    toggleFullscreen?: MediaKeyShortcut;
+    togglePictureInPicture?: MediaKeyShortcut;
+    toggleCaptions?: MediaKeyShortcut;
+    seekBackward?: MediaKeyShortcut;
+    seekForward?: MediaKeyShortcut;
+    speedUp?: MediaKeyShortcut;
+    slowDown?: MediaKeyShortcut;
+    volumeUp?: MediaKeyShortcut;
+    volumeDown?: MediaKeyShortcut;
+}
+export type MediaKeyShortcut = MediaKeysCallback | string | string[] | null;
+export interface MediaKeysCallback {
+    keys: string | string[];
+    /** @deprecated - use `onKeyUp` or `onKeyDown` */
+    callback?(event: KeyboardEvent, remote: MediaRemoteControl): void;
+    onKeyUp?(context: {
+        event: KeyboardEvent;
+        player: MediaPlayer;
+        remote: MediaRemoteControl;
+    }): void;
+    onKeyDown?(context: {
+        event: KeyboardEvent;
+        player: MediaPlayer;
+        remote: MediaRemoteControl;
+    }): void;
+}

package/types/core/quality/events.d.ts

@@ -0,0 +1,43 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { ListReadonlyChangeEvent } from '../../foundation/list/list';
+import type { VideoQuality, VideoQualityList } from './video-quality';
+export interface VideoQualityListEvents {
+    add: VideoQualityAddEvent;
+    remove: VideoQualityRemoveEvent;
+    change: VideoQualityChangeEvent;
+    'auto-change': VideoQualityAutoChangeEvent;
+    'readonly-change': ListReadonlyChangeEvent;
+}
+export interface VideoQualityListEvent<T> extends DOMEvent<T> {
+    target: VideoQualityList;
+}
+/**
+ * Fired when a video quality has been added to the list.
+ *
+ * @detail newQuality
+ */
+export interface VideoQualityAddEvent extends VideoQualityListEvent<VideoQuality> {
+}
+/**
+ * Fired when a video quality has been removed from the list.
+ *
+ * @detail removedQuality
+ */
+export interface VideoQualityRemoveEvent extends VideoQualityListEvent<VideoQuality> {
+}
+/**
+ * Fired when the selected video quality has changed.
+ *
+ * @detail change
+ */
+export interface VideoQualityChangeEvent extends VideoQualityListEvent<VideoQualityChangeEventDetail> {
+}
+export interface VideoQualityChangeEventDetail {
+    prev: VideoQuality | null;
+    current: VideoQuality;
+}
+/**
+ * Fired when auto quality selection is enabled or disabled.
+ */
+export interface VideoQualityAutoChangeEvent extends VideoQualityListEvent<boolean> {
+}

package/types/core/quality/symbols.d.ts

@@ -0,0 +1,6 @@
+export declare const SET_AUTO: unique symbol, ENABLE_AUTO: unique symbol;
+/** @internal */
+export declare const QualitySymbol: {
+    readonly setAuto: typeof SET_AUTO;
+    readonly enableAuto: typeof ENABLE_AUTO;
+};

package/types/core/quality/utils.d.ts

@@ -0,0 +1,2 @@
+import type { VideoQuality } from './video-quality';
+export declare function sortVideoQualities(qualities: VideoQuality[], desc?: boolean): VideoQuality[];

package/types/core/quality/video-quality.d.ts

@@ -0,0 +1,52 @@
+import { SelectList, type SelectListItem } from '../../foundation/list/select-list';
+import { ListSymbol } from '../../foundation/list/symbols';
+import type { VideoQualityListEvents } from './events';
+import { QualitySymbol } from './symbols';
+/**
+ * @see {@link https://vidstack.io/docs/player/core-concepts/video-quality#quality-list}
+ */
+export declare class VideoQualityList extends SelectList<VideoQuality, VideoQualityListEvents> {
+    #private;
+    /**
+     * Configures quality switching:
+     *
+     * - `current`: Trigger an immediate quality level switch. This will abort the current fragment
+     * request if any, flush the whole buffer, and fetch fragment matching with current position
+     * and requested quality level.
+     *
+     * - `next`: Trigger a quality level switch for next fragment. This could eventually flush
+     * already buffered next fragment.
+     *
+     * - `load`: Set quality level for next loaded fragment.
+     *
+     * @see {@link https://www.vidstack.io/docs/player/api/video-quality#switch}
+     * @see {@link https://github.com/video-dev/hls.js/blob/master/docs/API.md#quality-switch-control-api}
+     */
+    switch: 'current' | 'next' | 'load';
+    /**
+     * Whether automatic quality selection is enabled.
+     */
+    get auto(): boolean;
+    /** @internal */
+    [QualitySymbol.enableAuto]?: (trigger?: Event) => void;
+    /** @internal */
+    protected [ListSymbol.onUserSelect](): void;
+    /** @internal */
+    protected [ListSymbol.onReset](trigger?: Event): void;
+    /**
+     * Request automatic quality selection (if supported). This will be a no-op if the list is
+     * `readonly` as that already implies auto-selection.
+     */
+    autoSelect(trigger?: Event): void;
+    getBySrc(src: unknown): VideoQuality | undefined;
+    /** @internal */
+    [QualitySymbol.setAuto](auto: boolean, trigger?: Event): void;
+}
+export interface VideoQuality extends SelectListItem {
+    readonly id: string;
+    readonly src?: unknown;
+    readonly width: number;
+    readonly height: number;
+    readonly bitrate: number | null;
+    readonly codec: string | null;
+}

package/types/core/state/media-events-logger.d.ts

@@ -0,0 +1,7 @@
+import { type MediaContext } from '../api/media-context';
+import { MediaPlayerController } from '../api/player-controller';
+export declare class MediaEventsLogger extends MediaPlayerController {
+    #private;
+    constructor(media: MediaContext);
+    protected onConnect(el: HTMLElement): void;
+}

package/types/core/state/media-load-controller.d.ts

@@ -0,0 +1,6 @@
+import { MediaPlayerController } from '../api/player-controller';
+export declare class MediaLoadController extends MediaPlayerController {
+    #private;
+    constructor(type: 'load' | 'posterLoad', callback: () => void);
+    onAttach(el: HTMLElement): Promise<void>;
+}

package/types/core/state/media-player-delegate.d.ts

@@ -0,0 +1,13 @@
+import { type InferEventDetail } from 'maverick.js/std';
+import type { MediaContext } from '../api/media-context';
+import type { MediaEvents } from '../api/media-events';
+export declare class MediaPlayerDelegate {
+    #private;
+    constructor(handle: (event: Event) => void, media: MediaContext);
+    notify<Type extends keyof MediaEvents>(type: Type, ...init: InferEventDetail<MediaEvents[Type]> extends void | undefined | never ? [detail?: never, trigger?: Event] : [detail: InferEventDetail<MediaEvents[Type]>, trigger?: Event]): void;
+    ready(info?: {
+        duration: number;
+        seekable: TimeRanges;
+        buffered: TimeRanges;
+    }, trigger?: Event): Promise<void>;
+}

package/types/core/state/media-request-manager.d.ts

@@ -0,0 +1,71 @@
+import { Queue } from '../../foundation/queue/queue';
+import type { MediaContext } from '../api/media-context';
+import * as RE from '../api/media-request-events';
+import { MediaPlayerController } from '../api/player-controller';
+import { MediaControls } from '../controls';
+import type { MediaStateManager } from './media-state-manager';
+/**
+ * This class is responsible for listening to media request events and calling the appropriate
+ * actions on the current media provider. Do note, actions are queued until a media provider
+ * has connected.
+ */
+export declare class MediaRequestManager extends MediaPlayerController implements MediaRequestHandler {
+    #private;
+    readonly controls: MediaControls;
+    constructor(stateMgr: MediaStateManager, request: MediaRequestContext, media: MediaContext);
+    protected onAttach(): void;
+    protected onConnect(el: HTMLElement): void;
+    protected onDestroy(): void;
+    play(trigger?: Event): Promise<void>;
+    pause(trigger?: Event): Promise<void>;
+    setAudioGain(gain: number, trigger?: Event): void;
+    seekToLiveEdge(trigger?: Event): void;
+    enterFullscreen(target?: RE.MediaFullscreenRequestTarget, trigger?: Event): Promise<void>;
+    exitFullscreen(target?: RE.MediaFullscreenRequestTarget, trigger?: Event): Promise<void>;
+    enterPictureInPicture(trigger?: Event): Promise<void | PictureInPictureWindow>;
+    exitPictureInPicture(trigger?: Event): Promise<void>;
+    ['media-airplay-request'](event: RE.MediaAirPlayRequestEvent): Promise<void>;
+    requestAirPlay(trigger?: Event): Promise<void>;
+    ['media-google-cast-request'](event: RE.MediaGoogleCastRequestEvent): Promise<void>;
+    requestGoogleCast(trigger?: Event): Promise<void>;
+    ['media-clip-start-change-request'](event: RE.MediaClipStartChangeRequestEvent): void;
+    ['media-clip-end-change-request'](event: RE.MediaClipEndChangeRequestEvent): void;
+    ['media-duration-change-request'](event: RE.MediaDurationChangeRequestEvent): void;
+    ['media-audio-track-change-request'](event: RE.MediaAudioTrackChangeRequestEvent): void;
+    ['media-enter-fullscreen-request'](event: RE.MediaEnterFullscreenRequestEvent): Promise<void>;
+    ['media-exit-fullscreen-request'](event: RE.MediaExitFullscreenRequestEvent): Promise<void>;
+    ['media-orientation-lock-request'](event: RE.MediaOrientationLockRequestEvent): Promise<void>;
+    ['media-orientation-unlock-request'](event: RE.MediaOrientationUnlockRequestEvent): Promise<void>;
+    ['media-enter-pip-request'](event: RE.MediaEnterPIPRequestEvent): Promise<void>;
+    ['media-exit-pip-request'](event: RE.MediaExitPIPRequestEvent): Promise<void>;
+    ['media-live-edge-request'](event: RE.MediaLiveEdgeRequestEvent): void;
+    ['media-loop-request'](event: RE.MediaLoopRequestEvent): Promise<void>;
+    ['media-user-loop-change-request'](event: RE.MediaUserLoopChangeRequestEvent): void;
+    ['media-pause-request'](event: RE.MediaPauseRequestEvent): Promise<void>;
+    ['media-play-request'](event: RE.MediaPlayRequestEvent): Promise<void>;
+    ['media-rate-change-request'](event: RE.MediaRateChangeRequestEvent): void;
+    ['media-audio-gain-change-request'](event: RE.MediaAudioGainChangeRequestEvent): void;
+    ['media-quality-change-request'](event: RE.MediaQualityChangeRequestEvent): void;
+    ['media-pause-controls-request'](event: RE.MediaPauseControlsRequestEvent): void;
+    ['media-resume-controls-request'](event: RE.MediaResumeControlsRequestEvent): void;
+    ['media-seek-request'](event: RE.MediaSeekRequestEvent): void;
+    ['media-seeking-request'](event: RE.MediaSeekingRequestEvent): void;
+    ['media-start-loading'](event: RE.MediaStartLoadingRequestEvent): void;
+    ['media-poster-start-loading'](event: RE.MediaPosterStartLoadingRequestEvent): void;
+    ['media-text-track-change-request'](event: RE.MediaTextTrackChangeRequestEvent): void;
+    ['media-mute-request'](event: RE.MediaMuteRequestEvent): void;
+    ['media-unmute-request'](event: RE.MediaUnmuteRequestEvent): void;
+    ['media-volume-change-request'](event: RE.MediaVolumeChangeRequestEvent): void;
+}
+export declare class MediaRequestContext {
+    seeking: boolean;
+    looping: boolean;
+    replaying: boolean;
+    queue: Queue<MediaRequestQueueItems>;
+}
+export type MediaRequestQueueItems = {
+    [P in keyof RE.MediaRequestEvents]: Event;
+};
+export type MediaRequestHandler = {
+    [Type in keyof RE.MediaRequestEvents]: (event: RE.MediaRequestEvents[Type]) => unknown;
+};

package/types/core/state/media-state-manager.d.ts

@@ -0,0 +1,59 @@
+import type { MediaContext } from '../api/media-context';
+import * as ME from '../api/media-events';
+import { MediaPlayerController } from '../api/player-controller';
+import type { MediaRequestContext } from './media-request-manager';
+/**
+ * This class is responsible for listening to and normalizing media events, updating the media
+ * state context, and satisfying media requests.
+ */
+export declare class MediaStateManager extends MediaPlayerController {
+    #private;
+    constructor(request: MediaRequestContext, media: MediaContext);
+    protected onAttach(el: HTMLElement): void;
+    protected onConnect(el: HTMLElement): void;
+    protected onDestroy(): void;
+    handle(event: Event): void;
+    ['provider-change'](event: ME.MediaProviderChangeEvent): void;
+    ['provider-loader-change'](event: ME.MediaProviderLoaderChangeEvent): void;
+    ['auto-play'](event: ME.MediaAutoPlayEvent): void;
+    ['auto-play-fail'](event: ME.MediaAutoPlayFailEvent): void;
+    ['can-load'](event: ME.MediaCanLoadEvent): void;
+    ['can-load-poster'](event: ME.MediaCanLoadEvent): void;
+    ['media-type-change'](event: ME.MediaTypeChangeEvent): void;
+    ['stream-type-change'](event: ME.MediaStreamTypeChangeEvent): void;
+    ['rate-change'](event: ME.MediaRateChangeEvent): void;
+    ['remote-playback-change'](event: ME.MediaRemotePlaybackChangeEvent): void;
+    ['sources-change'](event: ME.MediaSourcesChangeEvent): void;
+    ['source-change'](event: ME.MediaSourceChangeEvent): void;
+    ['abort'](event: ME.MediaAbortEvent): void;
+    ['load-start'](event: ME.MediaLoadStartEvent): void;
+    ['error'](event: ME.MediaErrorEvent): void;
+    ['loaded-metadata'](event: ME.MediaLoadedMetadataEvent): void;
+    ['loaded-data'](event: ME.MediaLoadedDataEvent): void;
+    ['can-play'](event: ME.MediaCanPlayEvent): void;
+    ['can-play-through'](event: ME.MediaCanPlayThroughEvent): void;
+    ['duration-change'](event: ME.MediaDurationChangeEvent): void;
+    ['progress'](event: ME.MediaProgressEvent): void;
+    ['play'](event: ME.MediaPlayEvent): void;
+    ['play-fail'](event: ME.MediaPlayFailEvent): void;
+    ['playing'](event: ME.MediaPlayingEvent): void;
+    ['started'](event: Event): void;
+    ['pause'](event: ME.MediaPauseEvent): void;
+    ['time-change'](event: ME.MediaTimeChangeEvent): void;
+    ['audio-gain-change'](event: ME.MediaAudioGainChangeEvent): void;
+    ['volume-change'](event: ME.MediaVolumeChangeEvent): void;
+    ['seeking']: ((event: ME.MediaSeekingEvent) => void) & {
+        cancel: () => void;
+        flush: () => void;
+    };
+    ['seeked'](event: ME.MediaSeekedEvent): void;
+    ['waiting'](event: ME.MediaWaitingEvent): void;
+    ['end'](event: Event): void;
+    ['fullscreen-change'](event: ME.MediaFullscreenChangeEvent): void;
+    ['fullscreen-error'](event: ME.MediaFullscreenErrorEvent): void;
+    ['orientation-change'](event: ME.MediaOrientationChangeEvent): void;
+    ['picture-in-picture-change'](event: ME.MediaPIPChangeEvent): void;
+    ['picture-in-picture-error'](event: ME.MediaPIPErrorEvent): void;
+    ['title-change'](event: ME.MediaPosterChangeEvent): void;
+    ['poster-change'](event: ME.MediaPosterChangeEvent): void;
+}

package/types/core/state/media-state-sync.d.ts

@@ -0,0 +1,8 @@
+import { MediaPlayerController } from '../api/player-controller';
+/**
+ * Sync player props with internal store and dispatch change events.
+ */
+export declare class MediaStateSync extends MediaPlayerController {
+    #private;
+    protected onSetup(): void;
+}

package/types/core/state/media-storage.d.ts

@@ -0,0 +1,74 @@
+import type { MaybeStopEffect } from 'maverick.js';
+import type { Src } from '../api/src-types';
+export interface MediaStorage {
+    getVolume(): Promise<number | null>;
+    setVolume?(volume: number): Promise<void>;
+    getMuted(): Promise<boolean | null>;
+    setMuted?(muted: boolean): Promise<void>;
+    getTime(): Promise<number | null>;
+    setTime?(time: number, ended?: boolean): Promise<void>;
+    getLang(): Promise<string | null>;
+    setLang?(lang: string | null): Promise<void>;
+    getCaptions(): Promise<boolean | null>;
+    setCaptions?(captions: boolean): Promise<void>;
+    getPlaybackRate(): Promise<number | null>;
+    setPlaybackRate?(rate: number): Promise<void>;
+    getVideoQuality(): Promise<SerializedVideoQuality | null>;
+    setVideoQuality?(quality: SerializedVideoQuality | null): Promise<void>;
+    getAudioGain(): Promise<number | null>;
+    setAudioGain?(gain: number | null): Promise<void>;
+    /**
+     * Called when media is ready for playback and new data can be loaded.
+     */
+    onLoad?(src: Src): void | Promise<void>;
+    /**
+     * Called when the `mediaId` has changed. This method can return a function to be called
+     * before the next change.
+     *
+     * - The `mediaId` is computed from the current source and clip times. It will be `null` if
+     * there is no source.
+     *
+     * - The `playerId` is the string provided to the player `storage` prop (if set), or the `id`
+     *   set on the player element, otherwise `undefined`.
+     */
+    onChange?(src: Src, mediaId: string | null, playerId?: string): MaybeStopEffect;
+    /**
+     * Called when storage is being destroyed either because the `storage` property on the player
+     * has changed, or the player is being destroyed.
+     */
+    onDestroy?(): void;
+}
+export interface SerializedVideoQuality {
+    id: string;
+    width: number;
+    height: number;
+    bitrate?: number | null;
+}
+export declare class LocalMediaStorage implements MediaStorage {
+    #private;
+    protected playerId: string;
+    protected mediaId: string | null;
+    getVolume(): Promise<number | null>;
+    setVolume(volume: number): Promise<void>;
+    getMuted(): Promise<boolean | null>;
+    setMuted(muted: boolean): Promise<void>;
+    getTime(): Promise<number | null>;
+    setTime(time: number, ended: boolean): Promise<void>;
+    getLang(): Promise<string | null>;
+    setLang(lang: string | null): Promise<void>;
+    getCaptions(): Promise<boolean | null>;
+    setCaptions(enabled: boolean): Promise<void>;
+    getPlaybackRate(): Promise<number | null>;
+    setPlaybackRate(rate: any): Promise<void>;
+    getAudioGain(): Promise<number | null>;
+    setAudioGain(gain: number | null): Promise<void>;
+    getVideoQuality(): Promise<SerializedVideoQuality | null>;
+    setVideoQuality(quality: SerializedVideoQuality | null): Promise<void>;
+    onChange(src: Src, mediaId: string | null, playerId?: string): void;
+    protected save(): void;
+    protected saveTimeThrottled: (() => void) & {
+        cancel: () => void;
+        flush: () => void;
+    };
+    private saveTime;
+}

package/types/core/state/navigator-media-session.d.ts

@@ -0,0 +1,5 @@
+import { MediaPlayerController } from '../api/player-controller';
+export declare class NavigatorMediaSession extends MediaPlayerController {
+    #private;
+    protected onConnect(): void;
+}