@hanifhan1f/vidstack 1.12.13

package/types/providers/hls/provider.d.ts

@@ -0,0 +1,64 @@
+import { type Dispose } from 'maverick.js';
+import type { Src } from '../../core/api/src-types';
+import type { MediaProviderAdapter } from '../types';
+import { VideoProvider } from '../video/provider';
+import type { HLSInstanceCallback, HLSLibrary } from './types';
+/**
+ * The HLS provider introduces support for HLS streaming via the popular `hls.js`
+ * library. HLS streaming is either [supported natively](https://caniuse.com/?search=hls) (generally
+ * on iOS), or in environments that [support the Media Stream API](https://caniuse.com/?search=mediastream).
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/providers/hls}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video}
+ * @see {@link https://github.com/video-dev/hls.js/blob/master/docs/API.md}
+ * @example
+ * ```html
+ * <media-player
+ *   src="https://files.vidstack.io/hls/index.m3u8"
+ *   poster="https://files.vidstack.io/poster.png"
+ * >
+ *   <media-provider></media-provider>
+ * </media-player>
+ * ```
+ */
+export declare class HLSProvider extends VideoProvider implements MediaProviderAdapter {
+    #private;
+    protected $$PROVIDER_TYPE: string;
+    /**
+     * The `hls.js` constructor.
+     */
+    get ctor(): typeof import("hls.js").default | null;
+    /**
+     * The current `hls.js` instance.
+     */
+    get instance(): import("hls.js").default | null;
+    /**
+     * Whether `hls.js` is supported in this environment.
+     */
+    static supported: boolean;
+    get type(): string;
+    get canLiveSync(): boolean;
+    /**
+     * The `hls.js` configuration object.
+     *
+     * @see {@link https://github.com/video-dev/hls.js/blob/master/docs/API.md#fine-tuning}
+     */
+    get config(): Partial<import("hls.js").HlsConfig>;
+    set config(config: Partial<import("hls.js").HlsConfig>);
+    /**
+     * The `hls.js` constructor (supports dynamic imports) or a URL of where it can be found.
+     *
+     * @defaultValue `https://cdn.jsdelivr.net/npm/hls.js@^1.0.0/dist/hls.min.js`
+     */
+    get library(): HLSLibrary;
+    set library(library: HLSLibrary);
+    preconnect(): void;
+    setup(): void;
+    loadSource(src: Src, preload?: HTMLMediaElement['preload']): Promise<void>;
+    /**
+     * The given callback is invoked when a new `hls.js` instance is created and right before it's
+     * attached to media.
+     */
+    onInstance(callback: HLSInstanceCallback): Dispose;
+    destroy(): void;
+}

package/types/providers/hls/types.d.ts

@@ -0,0 +1,9 @@
+import type * as HLS from 'hls.js';
+import type { HLSProviderEvents } from './events';
+export { type HLSProviderEvents };
+export type HLSConstructor = typeof HLS.default;
+export type HLSConstructorLoader = () => Promise<{
+    default: HLSConstructor;
+} | undefined>;
+export type HLSLibrary = HLSConstructor | HLSConstructorLoader | string | undefined;
+export type HLSInstanceCallback = (hls: HLS.default) => void;

package/types/providers/html/audio/audio-context.d.ts

@@ -0,0 +1,6 @@
+export declare function getOrCreateAudioCtx(): AudioContext;
+export declare function createGainNode(): GainNode;
+export declare function createElementSource(el: HTMLMediaElement, gainNode?: GainNode): MediaElementAudioSourceNode;
+export declare function destroyGainNode(node: GainNode): void;
+export declare function destroyElementSource(src: MediaElementAudioSourceNode): void;
+export declare function freeAudioCtxWhenAllResourcesFreed(): void;

package/types/providers/html/audio/audio-gain.d.ts

@@ -0,0 +1,10 @@
+import type { AudioGainAdapter } from '../../types';
+export declare class AudioGain implements AudioGainAdapter {
+    #private;
+    get currentGain(): number | null;
+    get supported(): boolean;
+    constructor(media: HTMLMediaElement, onChange: (gain: number | null) => void);
+    setGain(gain: number): void;
+    removeGain(): void;
+    destroy(): void;
+}

package/types/providers/html/html/342/200/223media-events.d.ts

@@ -0,0 +1,6 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { HTMLMediaProvider } from './provider';
+export declare class HTMLMediaEvents {
+    #private;
+    constructor(provider: HTMLMediaProvider, ctx: MediaContext);
+}

package/types/providers/html/native-audio-tracks.d.ts

@@ -0,0 +1,6 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { HTMLMediaProvider } from './provider';
+export declare class NativeAudioTracks {
+    #private;
+    constructor(provider: HTMLMediaProvider, ctx: MediaContext);
+}

package/types/providers/html/provider.d.ts

@@ -0,0 +1,34 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { HTMLMediaSrc, Src } from '../../core/api/src-types';
+import type { MediaProviderAdapter } from '../types';
+import { AudioGain } from './audio/audio-gain';
+/**
+ * This HTML media provider adapts the underlying media element such as `<audio>` or `<video>` to
+ * satisfy the media provider interface.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement}
+ */
+export declare class HTMLMediaProvider implements MediaProviderAdapter {
+    #private;
+    readonly media: HTMLMediaElement;
+    protected readonly ctx: MediaContext;
+    readonly scope: import("maverick.js").Scope;
+    currentSrc: Src<HTMLMediaSrc> | null;
+    readonly audioGain: AudioGain;
+    constructor(media: HTMLMediaElement, ctx: MediaContext);
+    setup(): void;
+    get type(): string;
+    setPlaybackRate(rate: number): void;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    setMuted(muted: boolean): void;
+    setVolume(volume: number): void;
+    setCurrentTime(time: number): void;
+    setPlaysInline(inline: boolean): void;
+    loadSource({ src, type }: Src, preload?: HTMLMediaElement['preload']): Promise<void>;
+    /**
+     * Append source so it works when requesting AirPlay since hls.js will remove it.
+     */
+    protected appendSource(src: Src<string>, defaultType?: string): void;
+    protected removeSource(): void;
+}

package/types/providers/html/remote-playback.d.ts

@@ -0,0 +1,18 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { MediaRemotePlaybackAdapter } from '../types';
+export declare abstract class HTMLRemotePlaybackAdapter implements MediaRemotePlaybackAdapter {
+    #private;
+    protected abstract readonly type: 'airplay' | 'google-cast';
+    protected abstract readonly canPrompt: boolean;
+    get supported(): boolean;
+    constructor(media: HTMLMediaElement, ctx: MediaContext);
+    prompt(): Promise<void>;
+}
+export declare class HTMLAirPlayAdapter extends HTMLRemotePlaybackAdapter {
+    type: "airplay";
+    get canPrompt(): boolean;
+}
+export declare class HTMLGoogleCastAdapter extends HTMLRemotePlaybackAdapter {
+    type: "google-cast";
+    get canPrompt(): boolean;
+}

package/types/providers/type-check.d.ts

@@ -0,0 +1,28 @@
+import type { AudioProvider } from './audio/provider';
+import type { DASHProvider } from './dash/provider';
+import type { GoogleCastProvider } from './google-cast/provider';
+import type { HLSProvider } from './hls/provider';
+import type { VideoProvider } from './video/provider';
+import type { VimeoProvider } from './vimeo/provider';
+import type { YouTubeProvider } from './youtube/provider';
+/** @see {@link https://www.vidstack.io/docs/player/providers/audio} */
+export declare function isAudioProvider(provider: any): provider is AudioProvider;
+/** @see {@link https://www.vidstack.io/docs/player/providers/video} */
+export declare function isVideoProvider(provider: any): provider is VideoProvider;
+/** @see {@link https://www.vidstack.io/docs/player/providers/hls} */
+export declare function isHLSProvider(provider: any): provider is HLSProvider;
+export declare function isDASHProvider(provider: any): provider is DASHProvider;
+/** @see {@link https://www.vidstack.io/docs/player/providers/youtube} */
+export declare function isYouTubeProvider(provider: any): provider is YouTubeProvider;
+/** @see {@link https://www.vidstack.io/docs/player/providers/vimeo} */
+export declare function isVimeoProvider(provider: any): provider is VimeoProvider;
+/** @see {@link https://www.vidstack.io/docs/player/providers/google-cast} */
+export declare function isGoogleCastProvider(provider: any): provider is GoogleCastProvider;
+/** @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLAudioElement} */
+export declare function isHTMLAudioElement(element: unknown): element is HTMLAudioElement;
+/** @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement} */
+export declare function isHTMLVideoElement(element: unknown): element is HTMLVideoElement;
+/** @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement} */
+export declare function isHTMLMediaElement(element: unknown): element is HTMLMediaElement;
+/** @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement} */
+export declare function isHTMLIFrameElement(element: unknown): element is HTMLIFrameElement;

package/types/providers/types.d.ts

@@ -0,0 +1,95 @@
+import type { Scope } from 'maverick.js';
+import type { MediaContext } from '../core/api/media-context';
+import type { MediaState } from '../core/api/player-state';
+import type { Src } from '../core/api/src-types';
+import type { MediaType } from '../core/api/types';
+import type { FullscreenAdapter } from '../foundation/fullscreen/controller';
+import type { AudioProvider } from './audio/provider';
+import type { DASHProvider } from './dash/provider';
+import type { GoogleCastProvider } from './google-cast/provider';
+import type { HLSProvider } from './hls/provider';
+import type { VideoProvider } from './video/provider';
+import type { VimeoProvider } from './vimeo/provider';
+import type { YouTubeProvider } from './youtube/provider';
+export type AnyMediaProvider = ({
+    type: 'audio';
+} & AudioProvider) | ({
+    type: 'video';
+} & VideoProvider) | ({
+    type: 'hls';
+} & HLSProvider) | ({
+    type: 'dash';
+} & DASHProvider) | ({
+    type: 'youtube';
+} & YouTubeProvider) | ({
+    type: 'vimeo';
+} & VimeoProvider) | ({
+    type: 'google-cast';
+} & GoogleCastProvider);
+export interface MediaProviderLoader<Provider extends MediaProviderAdapter = MediaProviderAdapter> {
+    readonly name: string;
+    target: HTMLElement | null;
+    canPlay(src: Src): boolean;
+    mediaType(src?: Src): MediaType;
+    preconnect?(ctx: MediaContext): void;
+    load(ctx: MediaContext): Promise<Provider>;
+    loadPoster?(src: Src, ctx: MediaContext, abort: AbortController): Promise<string | null>;
+}
+export interface MediaProviderAdapter {
+    readonly scope: Scope;
+    readonly type: string;
+    readonly currentSrc: Src | null;
+    readonly audioGain?: AudioGainAdapter;
+    readonly fullscreen?: MediaFullscreenAdapter;
+    readonly pictureInPicture?: MediaPictureInPictureAdapter;
+    readonly airPlay?: MediaRemotePlaybackAdapter;
+    readonly canLiveSync?: boolean;
+    preconnect?(): void;
+    setup(): void;
+    destroy?(): void;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    setMuted(muted: boolean): void;
+    setCurrentTime(time: number): void;
+    setVolume(volume: number): void;
+    setPlaysInline?(inline: boolean): void;
+    setPlaybackRate?(rate: number): void;
+    loadSource(src: Src, preload: MediaState['preload']): Promise<void>;
+}
+export interface AudioGainAdapter {
+    readonly supported: boolean;
+    readonly currentGain: number | null;
+    setGain(gain: number): void;
+    removeGain(): void;
+}
+export interface MediaRemotePlaybackAdapter {
+    /**
+     * Whether requesting playback is supported.
+     */
+    readonly supported: boolean;
+    /**
+     * Request remote playback.
+     */
+    prompt(options?: unknown): Promise<void>;
+}
+export interface MediaFullscreenAdapter extends FullscreenAdapter {
+}
+export interface MediaPictureInPictureAdapter {
+    /**
+     * Whether picture-in-picture mode is active.
+     */
+    readonly active: boolean;
+    /**
+     * Whether picture-in-picture mode is supported. This does not mean that the operation is
+     * guaranteed to be successful, only that it can be attempted.
+     */
+    readonly supported: boolean;
+    /**
+     * Request to display the current provider in picture-in-picture mode.
+     */
+    enter(): Promise<void | PictureInPictureWindow>;
+    /**
+     * Request to display the current provider in inline by exiting picture-in-picture mode.
+     */
+    exit(): Promise<void>;
+}

package/types/providers/video/loader.d.ts

@@ -0,0 +1,12 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { Src } from '../../core/api/src-types';
+import type { MediaType } from '../../core/api/types';
+import type { MediaProviderLoader } from '../types';
+import type { VideoProvider } from './provider';
+export declare class VideoProviderLoader implements MediaProviderLoader<VideoProvider> {
+    readonly name: string;
+    target: HTMLVideoElement;
+    canPlay(src: Src): boolean;
+    mediaType(): MediaType;
+    load(ctx: MediaContext): Promise<VideoProvider>;
+}

package/types/providers/video/native-hls-text-tracks.d.ts

@@ -0,0 +1,9 @@
+import type { MediaContext } from '../../core/api/media-context';
+/**
+ * This is used to discover text tracks that were found by the native playback engine. For example,
+ * Safari will load text tracks that were embedded in the HLS playlist.
+ */
+export declare class NativeHLSTextTracks {
+    #private;
+    constructor(video: HTMLVideoElement, ctx: MediaContext);
+}

package/types/providers/video/picture-in-picture.d.ts

@@ -0,0 +1,16 @@
+import type { MediaContext } from '../../core/api/media-context';
+import type { MediaPictureInPictureAdapter } from '../types';
+declare global {
+    interface GlobalEventHandlersEventMap {
+        enterpictureinpicture: Event;
+        leavepictureinpicture: Event;
+    }
+}
+export declare class VideoPictureInPicture implements MediaPictureInPictureAdapter {
+    #private;
+    constructor(video: HTMLVideoElement, media: MediaContext);
+    get active(): boolean;
+    get supported(): boolean;
+    enter(): Promise<PictureInPictureWindow>;
+    exit(): Promise<void>;
+}

package/types/providers/video/presentation/events.d.ts

@@ -0,0 +1,11 @@
+import type { DOMEvent } from 'maverick.js/std';
+export type VideoPresentationEvents = {
+    'video-presentation-change': VideoPresentationChangeEvent;
+};
+/**
+ * Fired when the video presentation mode changes. Only available in Safari.
+ *
+ * @detail mode
+ */
+export interface VideoPresentationChangeEvent extends DOMEvent<WebKitPresentationMode> {
+}

package/types/providers/video/presentation/video-presentation.d.ts

@@ -0,0 +1,30 @@
+import type { MediaContext } from '../../../core/api/media-context';
+import type { MediaFullscreenAdapter, MediaPictureInPictureAdapter } from '../../types';
+declare global {
+    interface GlobalEventHandlersEventMap {
+        webkitpresentationmodechanged: Event;
+    }
+}
+export declare class VideoPresentation {
+    #private;
+    get mode(): WebKitPresentationMode;
+    constructor(video: HTMLVideoElement, media: MediaContext);
+    get supported(): boolean;
+    setPresentationMode(mode: WebKitPresentationMode): Promise<void>;
+}
+export declare class FullscreenPresentationAdapter implements MediaFullscreenAdapter {
+    #private;
+    get active(): boolean;
+    get supported(): boolean;
+    constructor(presentation: VideoPresentation);
+    enter(): Promise<void>;
+    exit(): Promise<void>;
+}
+export declare class PIPPresentationAdapter implements MediaPictureInPictureAdapter {
+    #private;
+    get active(): boolean;
+    get supported(): boolean;
+    constructor(presentation: VideoPresentation);
+    enter(): Promise<void>;
+    exit(): Promise<void>;
+}

package/types/providers/video/provider.d.ts

@@ -0,0 +1,34 @@
+import type { MediaContext } from '../../core/api/media-context';
+import { HTMLMediaProvider } from '../html/provider';
+import type { MediaFullscreenAdapter, MediaPictureInPictureAdapter, MediaProviderAdapter, MediaRemotePlaybackAdapter } from '../types';
+/**
+ * The video provider adapts the `<video>` element to enable loading videos via the HTML Media
+ * Element API.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/providers/video}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/video}
+ * @example
+ * ```html
+ * <media-player
+ *   src="https://files.vidstack.io/720p.mp4"
+ *   poster="https://files.vidstack.io/poster.png"
+ * >
+ *   <media-provider></media-provider>
+ * </media-player>
+ * ```
+ */
+export declare class VideoProvider extends HTMLMediaProvider implements MediaProviderAdapter {
+    protected $$PROVIDER_TYPE: string;
+    get type(): string;
+    airPlay?: MediaRemotePlaybackAdapter;
+    fullscreen?: MediaFullscreenAdapter;
+    pictureInPicture?: MediaPictureInPictureAdapter;
+    constructor(video: HTMLVideoElement, ctx: MediaContext);
+    setup(): void;
+    /**
+     * The native HTML `<video>` element.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement}
+     */
+    get video(): HTMLVideoElement;
+}

package/types/providers/vimeo/embed/command.d.ts

@@ -0,0 +1,81 @@
+import type { VimeoEvent } from './event';
+import type { VimeoChapter, VimeoQuality, VimeoTextTrack } from './misc';
+/**
+ * @see https://github.com/vimeo/player.js#methods
+ */
+export type VimeoCommand = 'addEventListener' | 'disableTextTrack' | 'enableTextTrack' | 'exitFullscreen' | 'exitPictureInPicture' | 'getBuffered' | 'getCuePoints' | 'getChapters' | 'getCurrentTime' | 'getDuration' | 'getFullscreen' | 'getMuted' | 'getPictureInPicture' | 'getPlayed' | 'getQualities' | 'getQuality' | 'getSeekable' | 'getSeeking' | 'getTextTracks' | 'getVideoTitle' | '_hideOverlay' | 'pause' | 'play' | 'requestFullscreen' | 'requestPictureInPicture' | 'seekTo' | 'setMuted' | 'setPlaybackRate' | 'setQuality' | 'setVolume' | '_showOverlay' | 'destroy' | 'loadVideo' | 'unload';
+export interface VimeoCommandArg {
+    play: void;
+    pause: void;
+    setMuted: boolean;
+    setVolume: number;
+    getDuration: void;
+    getChapters: void;
+    getCurrentTime: void;
+    seekTo: number;
+    setPlaybackRate: number;
+    addEventListener: VimeoEvent;
+    getCuePoints: void;
+    getVideoTitle: string;
+    getTextTracks: void;
+    enableTextTrack: {
+        language: string;
+        kind: string;
+    };
+    disableTextTrack: string;
+    setQuality: string;
+    _showOverlay: void;
+    _hideOverlay: void;
+    getBuffered: void;
+    requestFullscreen: void;
+    exitFullscreen: void;
+    requestPictureInPicture: void;
+    exitPictureInPicture: void;
+    getQuality: void;
+    getQualities: void;
+    getPlayed: void;
+    getSeekable: void;
+    getSeeking: void;
+    getFullscreen: void;
+    getMuted: void;
+    getPictureInPicture: void;
+    destroy: void;
+    loadVideo: number;
+    unload: void;
+}
+export interface VimeoCommandData {
+    play: void;
+    pause: void;
+    setMuted: boolean;
+    setVolume: void;
+    getDuration: number;
+    getChapters: VimeoChapter[];
+    getCurrentTime: number;
+    seekTo: void;
+    setPlaybackRate: void;
+    addEventListener: void;
+    getCuePoints: void;
+    getVideoTitle: string;
+    getTextTracks: VimeoTextTrack[];
+    enableTextTrack: void;
+    disableTextTrack: void;
+    setQuality: void;
+    _showOverlay: void;
+    _hideOverlay: void;
+    getBuffered: number;
+    requestFullscreen: void;
+    exitFullscreen: void;
+    requestPictureInPicture: void;
+    exitPictureInPicture: void;
+    getQuality: string;
+    getQualities: VimeoQuality[];
+    getPlayed: number[];
+    getSeekable: number[];
+    getSeeking: boolean;
+    getFullscreen: boolean;
+    getMuted: boolean;
+    getPictureInPicture: boolean;
+    destroy: void;
+    loadVideo: void;
+    unload: void;
+}

package/types/providers/vimeo/embed/event.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @see {@link https://github.com/vimeo/player.js#events}
+ */
+export declare const trackedVimeoEvents: VimeoEvent[];
+export type VimeoEvent = 'bufferend' | 'bufferstart' | 'cuechange' | 'durationchange' | 'ended' | 'enterpictureinpicture' | 'error' | 'fullscreenchange' | 'leavepictureinpicture' | 'loaded' | 'loadeddata' | 'loadedmetadata' | 'loadProgress' | 'loadstart' | 'pause' | 'play' | 'playbackratechange' | 'playProgress' | 'progress' | 'qualitychange' | 'ready' | 'seek' | 'seeked' | 'seeking' | 'texttrackchange' | 'volumechange' | 'waiting' | 'timeupdate';
+export interface VimeoProgressPayload {
+    seconds: number;
+    percent: number;
+    duration: number;
+}
+export interface VimeoPlayPayload {
+    seconds: number;
+    percent: number;
+    duration: number;
+}
+export interface VimeoErrorPayload {
+    name: string;
+    message: string;
+    method?: string;
+}
+export interface VimeoEventPayload {
+    play: VimeoPlayPayload;
+    pause: void;
+    ready: void;
+    playProgress: VimeoProgressPayload;
+    loadProgress: VimeoProgressPayload;
+    bufferstart: void;
+    bufferend: void;
+    loaded: {
+        id: number;
+    };
+    ended: void;
+    seeking: void;
+    seek: void;
+    seeked: void;
+    cuechange: void;
+    fullscreenchange: {
+        fullscreen: boolean;
+    };
+    volumechange: {
+        volume: number;
+    };
+    durationchange: {
+        duration: number;
+    };
+    playbackratechange: {
+        playbackRate: number;
+    };
+    texttrackchange: void;
+    error: any;
+    loadeddata: any;
+    loadstart: any;
+    loadedmetadata: any;
+    enterpictureinpicture: void;
+    leavepictureinpicture: void;
+    qualitychange: any;
+    waiting: void;
+}

package/types/providers/vimeo/embed/message.d.ts

@@ -0,0 +1,8 @@
+import type { VimeoCommand } from './command';
+import type { VimeoEventPayload } from './event';
+export interface VimeoMessage {
+    data?: any;
+    value?: any;
+    method?: VimeoCommand;
+    event?: keyof VimeoEventPayload;
+}

package/types/providers/vimeo/embed/misc.d.ts

@@ -0,0 +1,52 @@
+export interface VimeoVideoInfo {
+    title: string;
+    poster: string;
+    duration: number;
+    pro: boolean;
+}
+export interface VimeoChapter {
+    startTime: number;
+    title: string;
+    index: number;
+}
+export interface VimeoTextTrack {
+    label: string;
+    language: string;
+    kind: 'captions' | 'subtitles';
+    mode: 'showing' | 'disabled';
+}
+export interface VimeoTextCue {
+    html: string;
+    kind: 'captions' | 'subtitles';
+    label: string;
+    language: string;
+    text: string;
+}
+export interface VimeoQuality {
+    id: string;
+    label: string;
+    active: boolean;
+}
+export interface VimeoOEmbedData {
+    account_type: 'basic' | 'pro' | 'business';
+    author_name: string;
+    author_url: string;
+    description: string;
+    duration: number;
+    height: number;
+    html: string;
+    is_plus: '0' | '1';
+    provider_name: string;
+    provider_url: string;
+    thumbnail_height: number;
+    thumbnail_url_with_play_button: string;
+    thumbnail_url: string;
+    thumbnail_width: number;
+    title: string;
+    type: 'audio' | 'video';
+    upload_date: string;
+    uri: string;
+    version: string;
+    video_id: number;
+    width: number;
+}