@vkontakte/videoplayer-core 2.0.103 → 2.0.104

package/{index.d.ts → types/player/types.d.ts}

@@ -1,15 +1,10 @@
-import { Seconds, VideoQuality, QualityLimits, ILogEntry, IValueObservable, IValueSubject, IObservable, Milliseconds, IError, Kbps, RecursivePartial, Byte, ExactVideoQuality, ValueSubject, Subject } from '@vkontakte/videoplayer-shared';
-export { ExactVideoQuality, IEmitter, IListener, ILogEntry, IObservable, IOperator, IRange, ISubscription, IUnsubscriber, IValue, IValueObservable, Observable, Subject, Subscription, ValueSubject, VideoQuality } from '@vkontakte/videoplayer-shared';
-
-declare const VERSION: string;
-
-type Pixel = number;
-
-interface StartEnd<Unit extends number> {
+import { IObservable, IValueObservable, IValueSubject, ILogEntry, Kbps, Milliseconds, Seconds, IRectangle, IError, QualityLimits, VideoQuality } from '@vkontakte/videoplayer-shared';
+import { Pixel } from '../utils/3d/types';
+export interface StartEnd<Unit extends number> {
     start: Unit;
     end: Unit;
 }
-interface IPlayer {
+export interface IPlayer {
     info: IPlayerInfo;
     events: IPlayerEvents;
     /**
@@ -80,7 +75,7 @@ interface IPlayer {
  * События, начинающиеся с `will...` случаются в начале совершения действия,
  * остальные - в момент окончания действия.
  */
-interface IPlayerEvents {
+export interface IPlayerEvents {
     /**
      * Плеер получил ссылку и начал полезную работу
      */
@@ -182,7 +177,7 @@ interface IPlayerEvents {
      */
     log$: IObservable<ILogEntry>;
 }
-interface IPlayerInfo {
+export interface IPlayerInfo {
     /**
      * Оптимистичный статут плеера. Так например, значение будет равно Playing сразу после вызова play().
      * Фактическое состояние лучше отслеживать по событиям (например, playing$)
@@ -375,19 +370,26 @@ interface IPlayerInfo {
      */
     currentAudioSegmentLength$: IValueSubject<number>;
 }
-declare enum PlaybackState {
+export declare enum PlaybackState {
     STOPPED = "stopped",
     READY = "ready",
     PLAYING = "playing",
     PAUSED = "paused"
 }
-interface IConfig {
+export interface IVolumeState {
+    /**
+     * range: [0;1]
+     */
+    volume: number;
+    muted: boolean;
+}
+export interface IConfig {
     container: string | HTMLElement;
     sources: ISources;
     meta?: IMetadata;
     failoverHosts?: string[];
 }
-interface ISources {
+export interface ISources {
     [VideoFormat.MPEG]?: IMpegSource;
     [VideoFormat.DASH_SEP]?: IDashURLSource;
     [VideoFormat.DASH_WEBM]?: IDashURLSource;
@@ -402,31 +404,31 @@ interface ISources {
     [VideoFormat.HLS_LIVE_CMAF]?: IHLSLiveSource;
     [VideoFormat.WEB_RTC_LIVE]?: URLSource;
 }
-interface IMetadata {
+export interface IMetadata {
     title?: string;
     subtitle?: string;
     videoId?: string;
 }
-type QualitySetSource = Partial<Record<VideoQuality, string>>;
-type URLSource = {
+export type QualitySetSource = Partial<Record<VideoQuality, string>>;
+export type URLSource = {
     type: 'url';
     url: string;
 };
-type RawSource = {
+export type RawSource = {
     type: 'raw';
     raw: string;
 };
-type URLSourceWithSeek = URLSource & Partial<{
+export type URLSourceWithSeek = URLSource & Partial<{
     maxSeekBackTime: Milliseconds;
 }>;
-type IMpegSource = QualitySetSource;
-type IDashURLSource = URLSource & {
+export type IMpegSource = QualitySetSource;
+export type IDashURLSource = URLSource & {
     compatibilityMode?: boolean;
 };
-type IDashSource = URLSource | RawSource;
-type IHLSSource = URLSource;
-type IHLSLiveSource = URLSourceWithSeek;
-declare enum VideoFormat {
+export type IDashSource = URLSource | RawSource;
+export type IHLSSource = URLSource;
+export type IHLSLiveSource = URLSourceWithSeek;
+export declare enum VideoFormat {
     MPEG = "MPEG",
     /** @deprecated Используйте DASH_SEP */
     DASH = "DASH_SEP",
@@ -452,7 +454,14 @@ declare enum VideoFormat {
     HLS_LIVE_CMAF = "HLS_LIVE_CMAF",
     WEB_RTC_LIVE = "WEB_RTC_LIVE"
 }
-interface IAudioTrack {
+export interface IVideoTrack {
+    id: string;
+    quality: VideoQuality;
+    bitrate?: Kbps;
+    size?: IRectangle;
+    fps?: number;
+}
+export interface IAudioTrack {
     id: string;
     bitrate?: Kbps;
 }
@@ -464,39 +473,57 @@ interface ITextTrackBase {
     url?: string;
     isAuto?: boolean;
 }
-interface IExternalTextTrack extends ITextTrackBase {
+export interface IExternalTextTrack extends ITextTrackBase {
     type: 'external';
     url: string;
 }
-interface IInternalTextTrack extends ITextTrackBase {
+export interface IInternalTextTrack extends ITextTrackBase {
     type: 'internal';
     url: string;
 }
-type ITextTrack = IExternalTextTrack | IInternalTextTrack;
-interface ICueSettings {
+export type ITextTrack = IExternalTextTrack | IInternalTextTrack;
+export interface ICueSettings {
     align?: 'left' | 'center' | 'right';
     position?: number | 'auto';
     size?: number;
     line?: number | 'auto';
 }
-declare enum ChromecastState {
+export declare enum VideoDestination {
+    SCREEN = "SCREEN",
+    CHROMECAST = "CHROMECAST"
+}
+export declare enum ChromecastState {
     NOT_AVAILABLE = "NOT_AVAILABLE",
     AVAILABLE = "AVAILABLE",
     CONNECTING = "CONNECTING",
     CONNECTED = "CONNECTED"
 }
-interface ISeekRequest {
+export interface ISeekRequest {
     from: Seconds;
     to: Seconds;
 }
-declare enum HttpConnectionType {
+export declare enum HttpConnectionType {
     HTTP1 = "http1",
     HTTP2 = "http2",
     QUIC = "quic"
 }
-type FpsByQuality = Partial<Record<VideoQuality, number>>;
-type PlaybackRate = number;
-declare enum Surface {
+export declare enum SeekOperationState {
+    None = "none",
+    Requested = "requested",
+    Applying = "applying"
+}
+type SeekStateNone = {
+    state: SeekOperationState.None;
+};
+type SeekStateNotNone = {
+    state: Exclude<SeekOperationState, SeekOperationState.None>;
+    position: Milliseconds;
+    forcePrecise: boolean;
+};
+export type SeekState = SeekStateNone | SeekStateNotNone;
+export type FpsByQuality = Partial<Record<VideoQuality, number>>;
+export type PlaybackRate = number;
+export declare enum Surface {
     NONE = "none",
     INLINE = "inline",
     FULLSCREEN = "fullscreen",
@@ -504,358 +531,4 @@ declare enum Surface {
     PIP = "pip",
     INVISIBLE = "invisible"
 }
-
-declare enum WebmCodecStrategy {
-    VP9 = "vp9",
-    AV1 = "av1",
-    NONE = "none",
-    SMOOTH = "smooth",
-    POWER_EFFICIENT = "power_efficient"
-}
-
-declare enum AndroidPreferredFormat {
-    DASH = "dash",
-    HLS = "hls",
-    MPEG = "mpeg",
-    DASH_ANY_MPEG = "dash_any_mpeg",
-    DASH_ANY_WEBM = "dash_any_webm",
-    DASH_SEP = "dash_sep"
-}
-
-type ITuningConfig = {
-    configName: string[];
-    throughputEstimator: {
-        type: 'TwoEma' | 'EmaAndMa';
-        emaAlphaSlow: number;
-        emaAlphaFast: number;
-        emaAlpha: number;
-        basisTrendChangeCount: number;
-        changeThreshold: number;
-        useBrowserEstimation: boolean;
-        rttPenaltyRequestSize: Byte;
-        streamMinSampleSize: Byte;
-        streamMinSampleTime: Milliseconds;
-        deviationDepth: number;
-        deviationFactor: number;
-        lowLatency: {
-            continuesByteSequenceInterval: Milliseconds;
-        };
-    };
-    autoTrackSelection: {
-        bitrateFactorAtEmptyBuffer: number;
-        bitrateFactorAtFullBuffer: number;
-        limitByContainer: boolean;
-        usePixelRatio: boolean;
-        containerSizeFactor: number;
-        lazyQualitySwitch: boolean;
-        minBufferToSwitchUp: number;
-        considerPlaybackRate: boolean;
-        trackCooldown: Milliseconds;
-        backgroundVideoQualityLimit: VideoQuality;
-        activeVideoAreaThreshold: number;
-    };
-    droppedFramesChecker: {
-        enabled: boolean;
-        percentLimit: number;
-        checkTime: number;
-        countLimit: number;
-        tickCountAfterQualityChange: number;
-        qualityUpWaitingTime: number;
-        minQualityBanLimit: ExactVideoQuality;
-    };
-    dash: {
-        /** @deprecated */
-        forwardBufferTarget: Milliseconds;
-        forwardBufferTargetAuto: Milliseconds;
-        forwardBufferTargetManual: Milliseconds;
-        forwardBufferTargetPreload: Milliseconds;
-        maxSegmentDurationLeftToSelectNextSegment: Milliseconds;
-        minSafeBufferThreshold: number;
-        bufferPruningSafeZone: Milliseconds;
-        segmentRequestSize: Byte;
-        representationSwitchForwardBufferGap: Milliseconds;
-        crashOnStallTimeout: Milliseconds;
-        enableSubSegmentBufferFeeding: boolean;
-        segmentTimelineTolerance: Milliseconds;
-        useFetchPriorityHints: boolean;
-    };
-    dashCmafLive: {
-        maxActiveLiveOffset: Milliseconds;
-        normalizedTargetMinBufferSize: Milliseconds;
-        normalizedLiveMinBufferSize: Milliseconds;
-        normalizedActualBufferOffset: Milliseconds;
-        offsetCalculationError: Milliseconds;
-        lowLatency: {
-            maxTargetOffset: Milliseconds;
-            maxTargetOffsetDeviation: Milliseconds;
-            playbackCatchupSpeedup: number;
-            isActive: boolean;
-            delayEstimator: {
-                emaAlpha: number;
-                changeThreshold: number;
-                deviationDepth: number;
-                deviationFactor: number;
-                extremumInterval: number;
-            };
-        };
-    };
-    downloadBackoff: {
-        bufferThreshold: Milliseconds;
-        start: Milliseconds;
-        factor: number;
-        max: Milliseconds;
-        random: number;
-    };
-    live: {
-        minBuffer: Milliseconds;
-        minBufferSegments: number;
-        lowLatencyMinBuffer: Milliseconds;
-        lowLatencyMinBufferSegments: number;
-        lowLatencyActiveLiveDelay: Milliseconds;
-        activeLiveDelay: Milliseconds;
-        isLiveCatchUpMode: boolean;
-        /**
-         * Максимальное общее время нахождения на паузе, при котором воспроизведение можно продолжить без перезагрузки потока.
-         * Время всех "пауз" суммируется до тех пор, пока не превысит этот лимит.
-         * В случае превышения лимита при продолжении воспроизведения поток будет перезапущен с пересчитанным `offset`.
-         */
-        maxPausedTime: number;
-    };
-    enableWakeLock: boolean;
-    enableTelemetryAtStart: boolean;
-    forceFormat: VideoFormat | undefined;
-    formatsToAvoid: VideoFormat[];
-    disableChromecast: boolean;
-    chromecastReceiverId: string | undefined;
-    /** @deprecated */
-    useWebmBigRequest: boolean;
-    webmCodec: WebmCodecStrategy;
-    androidPreferredFormat: AndroidPreferredFormat;
-    preferCMAF: boolean;
-    preferWebRTC: boolean;
-    bigRequestMinInitSize: Byte;
-    bigRequestMinDataSize: Byte;
-    stripRangeHeader: boolean;
-    flushShortLoopedBuffers: boolean;
-    insufficientBufferRuleMargin: Milliseconds;
-    dashSeekInSegmentDurationThreshold: Milliseconds;
-    dashSeekInSegmentAlwaysSeekDelta: Milliseconds;
-    endGapTolerance: Milliseconds;
-    stallIgnoreThreshold: Milliseconds;
-    gapWatchdogInterval: Milliseconds;
-    requestQuick: boolean;
-    useHlsJs: boolean;
-    useDashAbortPartiallyFedSegment: boolean;
-    useNativeHLSTextTracks: boolean;
-    useManagedMediaSource: boolean;
-    isAudioDisabled: boolean;
-    autoplayOnlyInActiveTab: boolean;
-    dynamicImportTimeout: Milliseconds;
-    maxPlaybackTransitionInterval: Milliseconds;
-    providerErrorLimit: number;
-    manifestRetryInterval: number;
-    manifestRetryMaxInterval: number;
-    manifestRetryMaxCount: number;
-    webrtc: {
-        connectionRetryMaxNumber: number;
-    };
-    spherical: {
-        enabled: boolean;
-        fov: {
-            x: number;
-            y: number;
-        };
-        orientation?: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        rotationSpeed: number;
-        maxYawAngle: number;
-        rotationSpeedCorrection: number;
-        degreeToPixelCorrection: number;
-        speedFadeTime: Milliseconds;
-        speedFadeThreshold: Milliseconds;
-    };
-};
-type IOptionalTuningConfig = RecursivePartial<ITuningConfig> & {
-    configName: ITuningConfig['configName'];
-};
-
-declare class Player implements IPlayer {
-    private subscription;
-    private domContainer;
-    private providerContainer?;
-    private chromecastInitializer;
-    private logger;
-    private abrLogger;
-    private config;
-    private tuning;
-    private throughputEstimator;
-    private isPlaybackStarted;
-    private initedAt;
-    private hasLiveOffsetByPaused;
-    private hasLiveOffsetByPausedTimer;
-    private desiredState;
-    info: {
-        playbackState$: ValueSubject<PlaybackState>;
-        position$: ValueSubject<number>;
-        duration$: ValueSubject<number>;
-        muted$: ValueSubject<boolean>;
-        volume$: ValueSubject<number>;
-        availableQualities$: ValueSubject<VideoQuality[]>;
-        availableQualitiesFps$: ValueSubject<Partial<Record<VideoQuality, number>>>;
-        availableAudioTracks$: ValueSubject<IAudioTrack[]>;
-        isAudioAvailable$: ValueSubject<boolean>;
-        currentQuality$: ValueSubject<VideoQuality | undefined>;
-        isAutoQualityEnabled$: ValueSubject<boolean>;
-        autoQualityLimitingAvailable$: ValueSubject<boolean>;
-        autoQualityLimits$: ValueSubject<QualityLimits>;
-        currentPlaybackRate$: ValueSubject<number>;
-        currentBuffer$: ValueSubject<StartEnd<number>>;
-        isBuffering$: ValueSubject<boolean>;
-        isStalled$: ValueSubject<boolean>;
-        isEnded$: ValueSubject<boolean>;
-        isLooped$: ValueSubject<boolean>;
-        isLive$: ValueSubject<boolean | undefined>;
-        canChangePlaybackSpeed$: ValueSubject<boolean | undefined>;
-        atLiveEdge$: ValueSubject<boolean | undefined>;
-        atLiveDurationEdge$: ValueSubject<boolean | undefined>;
-        liveTime$: ValueSubject<number | undefined>;
-        liveBufferTime$: ValueSubject<number | undefined>;
-        currentFormat$: ValueSubject<VideoFormat | undefined>;
-        availableTextTracks$: ValueSubject<ITextTrack[]>;
-        currentTextTrack$: ValueSubject<string | undefined>;
-        throughputEstimation$: ValueSubject<number | undefined>;
-        rttEstimation$: ValueSubject<number | undefined>;
-        videoBitrate$: ValueSubject<number | undefined>;
-        hostname$: ValueSubject<string | undefined>;
-        httpConnectionType$: ValueSubject<HttpConnectionType | undefined>;
-        httpConnectionReused$: ValueSubject<boolean | undefined>;
-        surface$: ValueSubject<Surface>;
-        chromecastState$: ValueSubject<ChromecastState>;
-        chromecastDeviceName$: ValueSubject<string | undefined>;
-        intrinsicVideoSize$: ValueSubject<{
-            width: number;
-            height: number;
-        } | undefined>;
-        availableSources$: ValueSubject<ISources | undefined>;
-        is3DVideo$: ValueSubject<boolean>;
-        currentVideoSegmentLength$: ValueSubject<number>;
-        currentAudioSegmentLength$: ValueSubject<number>;
-    };
-    events: {
-        inited$: Subject<void>;
-        ready$: Subject<void>;
-        started$: Subject<void>;
-        playing$: Subject<void>;
-        paused$: Subject<void>;
-        stopped$: Subject<void>;
-        willStart$: Subject<void>;
-        willResume$: Subject<void>;
-        willPause$: Subject<void>;
-        willStop$: Subject<void>;
-        willDestruct$: Subject<void>;
-        watchCoverageRecord$: Subject<StartEnd<number>>;
-        watchCoverageLive$: Subject<StartEnd<number>>;
-        managedError$: Subject<IError>;
-        fatalError$: Subject<IError>;
-        ended$: Subject<void>;
-        looped$: Subject<number>;
-        seeked$: Subject<void>;
-        willSeek$: Subject<ISeekRequest>;
-        firstBytes$: Subject<number>;
-        firstFrame$: Subject<number>;
-        canplay$: Subject<number>;
-        log$: Subject<ILogEntry>;
-    };
-    experimental: {
-        element$: ValueSubject<HTMLElement | undefined>;
-        tuningConfigName$: ValueSubject<string[]>;
-        enableDebugTelemetry$: ValueSubject<boolean>;
-        dumpTelemetry: (receiver: (value: Record<string, any>) => void) => void;
-    };
-    constructor(tuning?: IOptionalTuningConfig);
-    initVideo(config: IConfig): IPlayer;
-    destroy(): void;
-    prepare(): IPlayer;
-    play(): IPlayer;
-    pause(): IPlayer;
-    stop(): IPlayer;
-    seekTime(time: Seconds, forcePrecise?: boolean): IPlayer;
-    /**
-     * NOTE: Сейчас вызов `seekPercent` до получения `duration` не сработает.
-     * @param percent: number [0, 1];
-     */
-    seekPercent(percent: number): IPlayer;
-    setVolume(percent: number): IPlayer;
-    setMuted(isMuted: boolean): IPlayer;
-    setQuality(quality: VideoQuality): IPlayer;
-    setAutoQuality(enable: boolean): IPlayer;
-    setAutoQualityLimits(limits: QualityLimits): IPlayer;
-    setPlaybackRate(playbackRate: PlaybackRate): IPlayer;
-    setExternalTextTracks(tracks: Omit<IExternalTextTrack, 'type'>[]): IPlayer;
-    selectTextTrack(id: ITextTrack['id'] | undefined): IPlayer;
-    setTextTrackCueSettings(settings: ICueSettings): IPlayer;
-    setLooped(isLooped: boolean): IPlayer;
-    toggleChromecast(): void;
-    /**
-     * Starts 3D-camera constant rotation
-     * Base rotation speed is provided through the tuning config
-     *
-     * @param mx - camera X rotation speed multiplier
-     * @param my - camera Y rotation speed multiplier
-     *
-     * 1 - positive direction
-     * 0.5 - half speed in positive direction
-     * 0 - no rotation
-     * -1 negative direction
-     * -2 double speed in negative direction
-     *
-     * Limitations:
-     *    When camera reaches angles 180 or -180 in vertical direction it stops.
-     *    z-axis is frozen for now
-     *
-     * Set all zeroes to stop the camera rotation
-     *    startCameraManualRotation(0, 0);
-     */
-    startCameraManualRotation(mx: number, my: number): this;
-    /**
-     * Rotates 3d-camera to given angles relative to current position
-     */
-    stopCameraManualRotation(immediate?: boolean): this;
-    /**
-     * Rotates 3d-camera to given angles relative to current position
-     * using mouse deltas and scene fov
-     */
-    moveCameraFocusPX(dxpx: number, dypx: number): this;
-    /**
-     * "Holds" camera so that it can not perform movement without manual control
-     */
-    holdCamera(): this;
-    /**
-     * "Releases" the camera so that it can move using its internal logic
-     */
-    releaseCamera(): this;
-    getExactTime(): Seconds;
-    getAllLogs(): ILogEntry[];
-    private getScene3D;
-    private setIntrinsicVideoSize;
-    private initDesiredStateSubscriptions;
-    private initProviderContainerSubscription;
-    private initChromecastSubscription;
-    private initStartingVideoTrack;
-    private setStartingVideoTrack;
-    private initLogs;
-    private initDebugTelemetry;
-    private initWakeLock;
-    private setVideoTrackIdByQuality;
-    private getActiveLiveDelay;
-}
-
-/**
- * @deprecated
- */
-declare const SDK_VERSION: string;
-
-export { ChromecastState, HttpConnectionType, IConfig, ICueSettings, IDashSource, IDashURLSource, IExternalTextTrack, IHLSLiveSource, IHLSSource, IMpegSource, IOptionalTuningConfig, IPlayer, IPlayerEvents, IPlayerInfo, ISeekRequest, ISources, ITextTrack, PlaybackRate, PlaybackState, Player, RawSource, SDK_VERSION, Surface, URLSource, URLSourceWithSeek, VERSION, VideoFormat };
+export {};

package/types/player/utils/optimisticPosition.d.ts

@@ -0,0 +1,12 @@
+import type { SeekState } from '../../player/types';
+import { IObservable, IValueObservable, Seconds } from '@vkontakte/videoplayer-shared';
+import { IStateMachine } from '../../utils/StateMachine/types';
+interface IParams {
+    seekState: IStateMachine<SeekState>;
+    position$: IValueObservable<Seconds>;
+}
+/**
+ * Реализует оптимистичное изменение позиции при перемотке
+ */
+declare const _default: ({ seekState, position$ }: IParams) => IObservable<Seconds>;
+export default _default;

package/types/player/utils/selectContainer.d.ts

@@ -0,0 +1,3 @@
+import { IConfig } from '../../player/types';
+declare const _default: (config: IConfig) => HTMLElement;
+export default _default;

package/types/providers/ChromecastProvider/ChromecastInitializer/index.d.ts

@@ -0,0 +1,31 @@
+import { ISubject, IValueSubject, ILogger, IError } from '@vkontakte/videoplayer-shared';
+import { ChromecastState } from '../../../player/types';
+import { IChromecastConnection, IChromecastInitializer } from './types';
+interface IParams {
+    receiverApplicationId?: string;
+    isDisabled?: boolean;
+    dependencies: {
+        logger: ILogger;
+    };
+}
+export declare class ChromecastInitializer implements IChromecastInitializer {
+    connection$: IValueSubject<IChromecastConnection | undefined>;
+    castState$: IValueSubject<ChromecastState>;
+    errorEvent$: ISubject<IError>;
+    contentId?: string;
+    private realCastState$;
+    private subscription;
+    private log;
+    private params;
+    constructor(params: IParams);
+    connect(): void;
+    disconnect(): void;
+    stopMedia(): Promise<void>;
+    toggleConnection(): void;
+    setVolume(volume: number): void;
+    setMuted(muted: boolean): void;
+    destroy(): void;
+    private initListeners;
+    private initializeCastApi;
+}
+export {};

package/types/providers/ChromecastProvider/ChromecastInitializer/types.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="chromecast-caf-sender" />
+/// <reference types="chrome/chrome-cast" />
+import { IObservable, IValueObservable, IError } from '@vkontakte/videoplayer-shared';
+import { ChromecastState } from '../../../player/types';
+export interface IChromecastInitializer {
+    connect(): void;
+    disconnect(): void;
+    stopMedia(): Promise<void>;
+    toggleConnection(): void;
+    setVolume(volume: number): void;
+    setMuted(muted: boolean): void;
+    destroy(): void;
+    contentId?: string;
+    connection$: IValueObservable<IChromecastConnection | undefined>;
+    castState$: IValueObservable<ChromecastState>;
+    errorEvent$: IObservable<IError>;
+}
+export interface IChromecastConnection {
+    remotePlayer: cast.framework.RemotePlayer;
+    remotePlayerController: cast.framework.RemotePlayerController;
+    session: cast.framework.CastSession;
+    castDevice: chrome.cast.Receiver;
+}

package/types/providers/ChromecastProvider/index.d.ts

@@ -0,0 +1,33 @@
+import { IMetadata, ISources, VideoFormat } from '../../player/types';
+import { IChromecastConnection } from '../../providers/ChromecastProvider/ChromecastInitializer/types';
+import { IProvider, IProviderParams } from '../types';
+interface IParams extends IProviderParams<ISources> {
+    meta: IMetadata;
+    format: VideoFormat;
+    connection: IChromecastConnection;
+}
+export default class ChromecastProvider implements IProvider {
+    private subscription;
+    private loadMediaTimeoutSubscription;
+    private videoState;
+    private params;
+    private log;
+    constructor(params: IParams);
+    destroy(): void;
+    private subscribe;
+    private restoreSession;
+    private prepare;
+    private handleRemotePause;
+    private handleRemotePlay;
+    private handleRemoteReady;
+    private handleRemoteStop;
+    private handleRemoteVolumeChange;
+    private seek;
+    private stop;
+    private createMediaInfo;
+    private createLoadRequest;
+    private loadMedia;
+    private logRemoteEvent;
+    private syncPlayback;
+}
+export {};