@vkontakte/videoplayer-core 2.0.148-dev.f4244a7e.0 → 2.0.149-dev.a444d83a.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/videoplayer-core",
-  "version": "2.0.148-dev.f4244a7e.0",
+  "version": "2.0.149-dev.a444d83a.0",
   "author": "vk.com",
   "description": "Videoplayer core library based on the vk.com platform",
   "homepage": "https://vk.com",
@@ -54,6 +54,6 @@
     "**/*.d.ts"
   ],
   "dependencies": {
-    "@vkontakte/videoplayer-shared": "1.0.76-dev.f4244a7e.0"
+    "@vkontakte/videoplayer-shared": "1.0.78-dev.a444d83a.0"
   }
 }

package/types/player/Player.d.ts

@@ -44,6 +44,7 @@ export default class Player implements IPlayer {
         isAudioAvailable$: ValueSubject<boolean>;
         currentPlaybackRate$: ValueSubject<number>;
         currentBuffer$: ValueSubject<StartEnd<number>>;
+        currentNativeBuffer$: ValueSubject<StartEnd<number>>;
         isBuffering$: ValueSubject<boolean>;
         isStalled$: ValueSubject<boolean>;
         isEnded$: ValueSubject<boolean>;

package/types/player/types.d.ts

@@ -317,11 +317,17 @@ export interface IPlayerInfo {
      */
     currentPlaybackRate$: IValueObservable<PlaybackRate>;
     /**
-     * Текущий буффер (тот, который содержит текущую позицию воспроизведения)
+     * Текущий буффер плеера (тот, который содержит текущую позицию воспроизведения)
      *
      * default value: `undefined`
      */
     currentBuffer$: IValueObservable<StartEnd<Seconds> | undefined>;
+    /**
+     * Текущий браузерный буффер (тот, который содержит текущую позицию воспроизведения)
+     *
+     * default value: `undefined`
+     */
+    currentNativeBuffer$: IValueObservable<StartEnd<Seconds> | undefined>;
     /**
      * Статус буферизации видео. true если буфер пустой и воспроизведение прервано
      * В отличии от isStalled показывает и буферизации на старте и после перемотки

package/types/providers/ChromecastPresentationApiProvider/ChromecastPresentationApiConnector.d.ts

@@ -0,0 +1,124 @@
+import { IError, ILogger, ISubject, IValueSubject } from '@vkontakte/videoplayer-shared';
+interface IParams {
+    appId: string;
+    logger: ILogger;
+}
+export declare class ChromecastPresentationApiConnector {
+    protected readonly params: IParams;
+    private readonly clientId;
+    private readonly capabilities;
+    private readonly presentationRequest$;
+    private readonly log;
+    private readonly sessionId$;
+    private readonly broadcastChannel;
+    private readonly subscription;
+    private subscriptionEvents;
+    private isDestroyed;
+    private sequenceNumber;
+    readonly presentationAvailable$: IValueSubject<boolean>;
+    readonly presentationConnection$: IValueSubject<PresentationConnection | null>;
+    readonly message$: IValueSubject<PresentationConnectionMessages | null>;
+    readonly friendlyName$: IValueSubject<string | null>;
+    readonly errorEvent$: ISubject<IError>;
+    constructor(params: IParams);
+    destroy(): void;
+    /**
+     * в случае перехвата соединения другим плеером важно не останавливать медийку,
+     * иначе прервется кастинг у того плеера, который его запустил
+     */
+    disconnect(withStopMedia?: boolean): void;
+    /**
+     * нужно вызывать перед `disconnect`, потому что если хромкаст был инициализирован на чужом соединении
+     * (те успешно сработал `presentationRequest.reconnect('auto-join')`), то `presentationConnection.close()`
+     * не отключит медийку на девайсе, если до этого оно не стояло на `PAUSE` или `STOP` (сделал через `STOP`,
+     * в итоге, для обратной совместимости с обвязкой для гуглового сдк)
+     */
+    stopMedia(): void;
+    /**
+     * @param reconnect включает попытку восстановить соединение через `.reconnect('auto-join')`
+     */
+    private reinitPresentation;
+    /** должен быть инициализирован с user-input'ом */
+    connect(): Promise<void>;
+    private subscribe;
+    private send;
+    sendV2Message(message: object): void;
+    private safeSend;
+    private handleMessage;
+    private createCastUrl;
+    private getSequenceNumber;
+    private resetSequenceNumber;
+    private getClientId;
+    private resetSubscriptionEvents;
+    private handleConnection;
+}
+declare global {
+    interface Window {
+        __vk_player_chromecast_id?: string;
+    }
+    interface Navigator {
+        presentation: {
+            defaultRequest: PresentationRequest | null;
+        };
+    }
+    type PresentationUrls = string | string[];
+    type PresentationConnectionState = 'connecting' | 'connected' | 'closed' | 'terminated';
+    class PresentationRequest extends EventTarget {
+        constructor(presentationUrls: PresentationUrls | undefined);
+        start(): Promise<PresentationConnection>;
+        reconnect(presentationId: string): Promise<PresentationConnection>;
+        getAvailability(): Promise<PresentationAvailability>;
+        onconnectionavailable: ((this: PresentationRequest, ev: PresentationConnectionAvailableEvent) => void) | null;
+    }
+    class PresentationConnection extends EventTarget {
+        readonly id: string;
+        readonly state: PresentationConnectionState;
+        onclose: ((this: PresentationConnection, ev: PresentationConnectionCloseEvent) => void) | null;
+        onconnect: ((this: PresentationConnection) => void) | null;
+        onmessage: ((this: PresentationConnection, ev: PresentationConnectionMessageEvent) => void) | null;
+        onterminate: ((this: PresentationConnection) => void) | null;
+        send: (data: string) => void;
+        terminate: () => void;
+        close: () => void;
+    }
+    interface PresentationAvailability extends EventTarget {
+        value: boolean;
+        onchange: ((this: PresentationAvailability, ev: Event) => void) | null;
+    }
+    interface PresentationConnectionAvailableEvent extends Event {
+        readonly connection: PresentationConnection;
+    }
+    interface PresentationConnectionCloseEvent extends Event {
+        readonly reason: 'closed' | 'error';
+    }
+    interface PresentationConnectionMessageEvent extends Event {
+        readonly data: string;
+    }
+}
+interface PresentationConnectionMessage {
+    clientId: string;
+    timeoutMillis: number;
+}
+interface PresentationConnectionMessageReceiverAction extends PresentationConnectionMessage {
+    type: 'receiver_action';
+    message: {
+        action: 'cast' | 'stop';
+        receiver: chrome.cast.Receiver;
+    };
+}
+interface PresentationConnectionMessageSession extends PresentationConnectionMessage {
+    type: 'new_session' | 'update_session';
+    message: chrome.cast.Session;
+}
+interface PresentationConnectionMessageV2Message extends PresentationConnectionMessage {
+    type: 'v2_message';
+    message: PresentationConnectionMessageV2MessageMessage;
+}
+interface PresentationConnectionMessageV2MessageMessage {
+    type: 'MEDIA_STATUS';
+    requestId: number;
+    sessionId: string;
+    status: chrome.cast.media.Media[];
+}
+export type PresentationConnectionMessages = PresentationConnectionMessageReceiverAction | PresentationConnectionMessageSession | PresentationConnectionMessageV2Message;
+export {};

package/types/providers/ChromecastPresentationApiProvider/ChromecastPresentationApiInitializer.d.ts

@@ -0,0 +1,25 @@
+import { ChromecastState } from '../../player/types';
+import { IError, IValueSubject, ISubject } from '@vkontakte/videoplayer-shared';
+import { IChromecastConnection } from '../ChromecastProvider/ChromecastInitializer/types';
+import { ChromecastPresentationApiConnector } from './ChromecastPresentationApiConnector';
+import { IChromecastPresentationApiInitializer } from './types';
+import { IParams } from '../ChromecastProvider/ChromecastInitializer/types';
+export declare class ChromecastPresentationApiInitializer implements IChromecastPresentationApiInitializer {
+    private readonly subscription;
+    private readonly log;
+    contentId?: string | undefined;
+    readonly connection$: IValueSubject<IChromecastConnection | undefined>;
+    readonly castState$: IValueSubject<ChromecastState>;
+    readonly errorEvent$: ISubject<IError>;
+    readonly chromecastConnector: ChromecastPresentationApiConnector | undefined;
+    static isSupported(): boolean;
+    constructor(params: IParams);
+    private subscribe;
+    connect(): void;
+    disconnect(): void;
+    stopMedia(): Promise<void>;
+    toggleConnection(): void;
+    setVolume(_volume: number): void;
+    setMuted(_muted: boolean): void;
+    destroy(): void;
+}

package/types/providers/ChromecastPresentationApiProvider/ChromecastPresentationApiProvider.d.ts

@@ -0,0 +1,36 @@
+import { IProvider } from '../types';
+import { IParams } from './types';
+export declare class ChromecastPresentationApiProvider implements IProvider {
+    private readonly subscription;
+    private readonly log;
+    private readonly params;
+    private readonly sessionId$;
+    private readonly mediaSessionId$;
+    private readonly contentId$;
+    private readonly progressTicker;
+    private readonly isMobile;
+    private readonly mobileVolumeState;
+    private media;
+    private lastRequestedVolume;
+    constructor(params: IParams);
+    private subscribe;
+    private handleMessage;
+    /**
+     * ключевая проблема хромкаста - синхронизировать состояния плеера, потому что
+     * устройством может управлять не только текущая вкладка браузера, но и любая
+     * другая как вкладка, так и устройство. поэтому мы считаем, что если доехали
+     * до этапа инициализации провадера, то форсим именно нашу медийку с нашим уникальным
+     * айдишником.
+     */
+    private loadMedia;
+    private stop;
+    private play;
+    private pause;
+    private seek;
+    private setVolume;
+    private syncPlaybackState;
+    private syncPlayback;
+    private syncMediaState;
+    private syncVolumeState;
+    destroy(): void;
+}

package/types/providers/ChromecastPresentationApiProvider/ProgressTicker.d.ts

@@ -0,0 +1,11 @@
+import { IParams } from './types';
+export declare class ProgressTicker {
+    private readonly params;
+    private interval;
+    private startVideoPosition;
+    private startTs;
+    constructor(params: Pick<IParams, 'output'>);
+    start(from?: number): void;
+    pause(): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,3 @@
+export { ChromecastPresentationApiProvider } from './ChromecastPresentationApiProvider';
+export { ChromecastPresentationApiConnector } from './ChromecastPresentationApiConnector';
+export { ChromecastPresentationApiInitializer } from './ChromecastPresentationApiInitializer';

package/types/providers/ChromecastPresentationApiProvider/types.d.ts

@@ -0,0 +1,49 @@
+import { IChromecastInitializer } from '../ChromecastProvider/ChromecastInitializer/types';
+import type { IParams as IParamsChromecastProvider } from '../ChromecastProvider/types';
+import { ChromecastPresentationApiConnector } from './ChromecastPresentationApiConnector';
+export declare enum ProviderState {
+    STOPPED = "stopped",
+    READY = "ready",
+    PLAYING = "playing",
+    PAUSED = "paused"
+}
+export declare enum PlayerState {
+    IDLE = "IDLE",
+    PLAYING = "PLAYING",
+    PAUSED = "PAUSED",
+    BUFFERING = "BUFFERING"
+}
+export interface IChromecastPresentationApiInitializer extends IChromecastInitializer {
+    chromecastConnector?: ChromecastPresentationApiConnector;
+}
+export interface IParams extends Omit<IParamsChromecastProvider, 'connection'> {
+    chromecastConnector: ChromecastPresentationApiConnector;
+}
+/**
+ * @see https://developers.google.com/cast/docs/reference/chrome/chrome.cast#.DefaultActionPolicy
+ */
+export declare enum DefaultActionPolicy {
+    CREATE_SESSION = "create_session",
+    CAST_THIS_TAB = "cast_this_tab"
+}
+/**
+ * @see https://developers.google.com/cast/docs/reference/chrome/chrome.cast#.AutoJoinPolicy
+ */
+export declare enum AutoJoinPolicy {
+    CUSTOM_CONTROLLER_SCOPED = "custom_controller_scoped",
+    TAB_AND_ORIGIN_SCOPED = "tab_and_origin_scoped",
+    ORIGIN_SCOPED = "origin_scoped",
+    PAGE_SCOPED = "page_scoped"
+}
+/**
+ * @see https://developers.google.com/cast/docs/reference/chrome/chrome.cast.media#.IdleReason
+ */
+export declare enum IdleReason {
+    CANCELLED = "CANCELLED",
+    INTERRUPTED = "INTERRUPTED",
+    FINISHED = "FINISHED",
+    ERROR = "ERROR"
+}
+export declare enum BroadcastChannelEventName {
+    Connection = "connection"
+}

package/types/providers/ChromecastPresentationApiProvider/utils.d.ts

@@ -0,0 +1,4 @@
+import { IChromecastConnection } from '../ChromecastProvider/ChromecastInitializer/types';
+export declare const createFakeChromecastConnection: (friendlyName: string) => IChromecastConnection;
+/** скопировал из сдк гугла */
+export declare const createId: () => string;

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

@@ -1,13 +1,6 @@
-import { ISubject, IValueSubject, ILogger, IError } from '@vkontakte/videoplayer-shared';
+import { ISubject, IValueSubject, IError } from '@vkontakte/videoplayer-shared';
 import { ChromecastState } from '../../../player/types';
-import { IChromecastConnection, IChromecastInitializer } from './types';
-interface IParams {
-    receiverApplicationId?: string;
-    isDisabled?: boolean;
-    dependencies: {
-        logger: ILogger;
-    };
-}
+import { IChromecastConnection, IChromecastInitializer, IParams } from './types';
 export declare class ChromecastInitializer implements IChromecastInitializer {
     readonly connection$: IValueSubject<IChromecastConnection | undefined>;
     readonly castState$: IValueSubject<ChromecastState>;
@@ -29,4 +22,3 @@ export declare class ChromecastInitializer implements IChromecastInitializer {
     private initListeners;
     private initializeCastApi;
 }
-export {};

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

@@ -1,4 +1,4 @@
-import { IObservable, IValueObservable, IError } from '@vkontakte/videoplayer-shared';
+import { IObservable, IValueObservable, IError, ILogger } from '@vkontakte/videoplayer-shared';
 import { ChromecastState } from '../../../player/types';
 export interface IChromecastInitializer {
     connect(): void;
@@ -19,3 +19,10 @@ export interface IChromecastConnection {
     session: cast.framework.CastSession;
     castDevice: chrome.cast.Receiver;
 }
+export interface IParams {
+    receiverApplicationId?: string;
+    isDisabled?: boolean;
+    dependencies: {
+        logger: ILogger;
+    };
+}

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

@@ -1,11 +1,5 @@
-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;
-}
+import { IProvider } from '../types';
+import { IParams } from './types';
 export default class ChromecastProvider implements IProvider {
     private subscription;
     private loadMediaTimeoutSubscription;
@@ -24,10 +18,8 @@ export default class ChromecastProvider implements IProvider {
     private handleRemoteVolumeChange;
     private seek;
     private stop;
-    private createMediaInfo;
     private createLoadRequest;
     private loadMedia;
     private logRemoteEvent;
     private syncPlayback;
 }
-export {};

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

@@ -0,0 +1,8 @@
+import { IMetadata, ISources, VideoFormat } from '../../player/types';
+import { IProviderParams } from '../types';
+import { IChromecastConnection } from './ChromecastInitializer/types';
+export interface IParams extends IProviderParams<ISources> {
+    meta: IMetadata;
+    format: VideoFormat;
+    connection: IChromecastConnection;
+}

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

@@ -0,0 +1,2 @@
+import { IParams } from './types';
+export declare const createMediaInfo: (params: Pick<IParams, "meta" | "format" | "output" | "source">) => chrome.cast.media.MediaInfo;

package/types/providers/DashLiveProvider/utils/LiveDashPlayer.d.ts

@@ -20,6 +20,7 @@ interface IParams {
         manifestRetryInterval: number;
         manifestRetryMaxInterval: number;
         manifestRetryMaxCount: number;
+        useInvalidBufferFix: boolean;
     };
     logger: (...args: any[]) => void;
 }

package/types/providers/DashProvider/lib/fetcher.d.ts

@@ -40,7 +40,6 @@ export declare class Fetcher {
     private tracer;
     manifestRequested$: ISubject<void>;
     firstBytesManifest$: ISubject<void>;
-    manifestReceived$: ISubject<void>;
     firstBytesRequested$: ISubject<void>;
     firstBytesReceived$: ISubject<void>;
     lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;

package/types/providers/DashProvider/lib/sourceBufferTaskQueue.d.ts

@@ -7,7 +7,8 @@ declare class SourceBufferTaskQueue {
     private currentTask;
     private destroyed;
     private abortRequested;
-    constructor(buffer: SourceBuffer);
+    private isAbortFixEnabled;
+    constructor(buffer: SourceBuffer, isAbortFixEnabled?: boolean);
     append(data: BufferSource, signal?: AbortSignal): Promise<boolean>;
     remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
     abort(init?: BufferSource): Promise<boolean>;

package/types/providers/DashProviderNew/lib/fetcher.d.ts

@@ -39,7 +39,6 @@ export declare class Fetcher {
     private tracer;
     manifestRequested$: ISubject<void>;
     firstBytesManifest$: ISubject<void>;
-    manifestReceived$: ISubject<void>;
     firstBytesRequested$: ISubject<void>;
     firstBytesReceived$: ISubject<void>;
     lastConnectionType$: IValueSubject<HttpConnectionType | undefined>;

package/types/providers/DashProviderNew/lib/sourceBufferTaskQueue.d.ts

@@ -7,7 +7,8 @@ declare class SourceBufferTaskQueue {
     private currentTask;
     private destroyed;
     private abortRequested;
-    constructor(buffer: SourceBuffer);
+    private isAbortFixEnabled;
+    constructor(buffer: SourceBuffer, isAbortFixEnabled?: boolean);
     append(data: BufferSource, signal?: AbortSignal): Promise<boolean>;
     remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
     abort(init?: BufferSource): Promise<boolean>;

package/types/providers/DashProviderVirtual/baseDashProvider.d.ts

@@ -0,0 +1,61 @@
+import { IAudioTrack, IDashURLSource, IHLSSource, IInternalTextTrack, IVideoTrack, VideoCodec } from '../../player/types';
+import { IProviderSubscriptionInfo, ProviderState } from './lib/types';
+import { CommonInit, Representation, Stream } from '../../providers/utils/parsers/types';
+import { IProvider, IProviderParams } from '../../providers/types';
+import { IObservableVideo } from '../../providers/utils/HTMLVideoElement/observable';
+import { TrackHistory } from '../../utils/autoSelectTrack';
+import { IStateMachine } from '../../utils/StateMachine/types';
+import { ISubscription, ITracer, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Scene3D } from '../../utils/3d/Scene3D';
+import DroppedFramesManager from '../../providers/utils/HTMLVideoElement/DroppedFramesManager';
+import TextTrackManager from '../../providers/utils/HTMLVideoElement/TextTrackManager';
+import StallsManager from '../../providers/utils/StallsManager';
+import { ElementSizeManager } from './lib/ElementSizeManager';
+import { BasePlayer } from '../../providers/DashProviderVirtual/lib/player/basePlayer';
+type IParams = IProviderParams<IDashURLSource> & {
+    sourceHls?: IHLSSource;
+    forceVideoCodec?: VideoCodec;
+};
+export default abstract class BaseDashProvider implements IProvider {
+    scene3D: Scene3D | undefined;
+    protected subscription: ISubscription;
+    protected videoState: IStateMachine<ProviderState>;
+    protected video: HTMLVideoElement;
+    protected observableVideo: IObservableVideo | null;
+    protected player: BasePlayer;
+    protected params: IParams;
+    protected tracer: ITracer;
+    protected textTracksManager: TextTrackManager;
+    protected droppedFramesManager: DroppedFramesManager;
+    protected stallsManager: StallsManager;
+    protected elementSizeManager: ElementSizeManager;
+    protected videoTracksMap: Map<IVideoTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected audioTracksMap: Map<IAudioTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected textTracksMap: Map<IInternalTextTrack, {
+        stream: Stream;
+        representation: Representation;
+    }>;
+    protected videoStreamsMap: Map<Stream, IVideoTrack[]>;
+    protected audioStreamsMap: Map<Stream, IAudioTrack[]>;
+    protected videoTrackSwitchHistory: TrackHistory<IVideoTrack>;
+    protected audioTrackSwitchHistory: TrackHistory<import("../../player/types").IBaseTrack>;
+    constructor(params: IParams);
+    protected abstract seek(position: Milliseconds, forcePrecise: boolean): void;
+    protected abstract getPlayer(): BasePlayer;
+    protected getProviderSubscriptionInfo(): IProviderSubscriptionInfo;
+    protected subscribe(): void;
+    protected selectVideoAudioRepresentations(): [Representation, Representation | undefined] | undefined;
+    protected prepare(manifestOffset?: number): void;
+    protected syncPlayback: () => undefined;
+    protected init3DScene: (init: CommonInit) => void;
+    protected destroy3DScene: () => void;
+    protected playIfAllowed(): void;
+    destroy(): void;
+}
+export {};

package/types/providers/DashProviderVirtual/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const DASH_LIVE_UPDATE_INTERVAL_MS = 1000;
+export declare const DASH_STALL_UPDATE_INTERVAL_MS = 50;
+export declare const DASH_LIVE_STALL_REINIT_INTERVAL_MS = 2000;

package/types/providers/DashProviderVirtual/dashCmafLiveProvider.d.ts

@@ -0,0 +1,10 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import { IParams } from './lib/types';
+import BaseDashProvider from './baseDashProvider';
+import { LivePlayer } from '../../providers/DashProviderVirtual/lib/player/livePlayer';
+export default class DashCmafLiveProvider extends BaseDashProvider {
+    constructor(params: IParams);
+    protected getPlayer(): LivePlayer;
+    protected subscribe(): void;
+    protected seek(position: Milliseconds): void;
+}

package/types/providers/DashProviderVirtual/dashProvider.d.ts

@@ -0,0 +1,8 @@
+import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import BaseDashProvider from './baseDashProvider';
+import { Player } from '../../providers/DashProviderVirtual/lib/player/player';
+export default class DashProvider extends BaseDashProvider {
+    protected subscribe(): void;
+    protected getPlayer(): Player;
+    protected seek(position: Milliseconds, forcePrecise: boolean): void;
+}

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

@@ -0,0 +1,2 @@
+export { default as DashProvider } from './dashProvider';
+export { default as DashCmafLiveProvider } from './dashCmafLiveProvider';

package/types/providers/DashProviderVirtual/lib/ElementSizeManager.d.ts

@@ -0,0 +1,19 @@
+import { IObservableVideo } from '../../../providers/utils/HTMLVideoElement/observable';
+import { IListener, IRectangle, ISubscription, ValueSubject } from '@vkontakte/videoplayer-shared';
+interface ConnectParams {
+    video: HTMLVideoElement;
+    observableVideo: IObservableVideo;
+}
+export declare class ElementSizeManager {
+    private readonly subscription;
+    private readonly pipSize$;
+    private readonly videoSize$;
+    private readonly elementSize$;
+    private pictureInPictureWindowRemoveEventListener;
+    connect({ observableVideo, video }: ConnectParams): void;
+    getValue(): IRectangle<number> | undefined;
+    subscribe(listener: IListener<IRectangle<number> | undefined>, error?: IListener<Error | unknown>): ISubscription;
+    getObservable(): ValueSubject<IRectangle<number> | undefined>;
+    destroy(): void;
+}
+export {};

package/types/providers/DashProviderVirtual/lib/LiveTextManager.d.ts

@@ -0,0 +1,23 @@
+import { IValueSubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+import { Manifest, Stream, TextRepresentation } from '../../../providers/utils/parsers/types';
+import { Dependencies } from '../../../providers/DashProviderVirtual/lib/buffer/types';
+export declare class LiveTextManager {
+    currentRepresentation$: IValueSubject<TextRepresentation | null>;
+    private readonly maxRepresentations;
+    private representationsCursor;
+    private representations;
+    private readonly getCurrentPosition;
+    private currentSegment;
+    constructor(streams: Stream[], deps: Pick<Dependencies, 'getCurrentPosition'>);
+    updateLive(manifest: Manifest | null): void;
+    seekLive(streams?: Stream[]): void;
+    maintain(currentPosition?: Milliseconds | undefined): void;
+    destroy(): void;
+    /**
+     * @todo support multi-streams
+     * @see https://jira.mvk.com/browse/VP-2420
+     */
+    private processStreams;
+    static isSupported(streams?: Stream[]): boolean;
+    private static filterRepresentations;
+}

package/types/providers/DashProviderVirtual/lib/buffer/nativeBufferManager.d.ts

@@ -0,0 +1,19 @@
+import { IError, IRange, ISubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+export declare class NativeBufferManager {
+    error$: ISubject<IError>;
+    private mediaSource;
+    private sourceBuffer;
+    private sourceBufferTaskQueue;
+    private subscription;
+    constructor(mediaSource: MediaSource);
+    init(mime: string, codecs: string): void;
+    addInitSegment(initView: BufferSource, signal?: AbortSignal): Promise<boolean>;
+    append(segmentView: BufferSource, signal?: AbortSignal): Promise<boolean>;
+    remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
+    clear(signal?: AbortSignal): Promise<boolean>;
+    warmUpMediaSource(): void;
+    getBufferState(): IRange<Milliseconds>[] | null;
+    getForwardBufferDuration(currentPosition: Milliseconds | undefined): Milliseconds;
+    abortBuffer(init: ArrayBuffer | undefined): Promise<boolean>;
+    destroy(): void;
+}

package/types/providers/DashProviderVirtual/lib/buffer/sourceBufferTaskQueue.d.ts

@@ -0,0 +1,19 @@
+import { Byte, IError, ISubject, Milliseconds } from '@vkontakte/videoplayer-shared';
+declare class SourceBufferTaskQueue {
+    bufferFull$: ISubject<Byte>;
+    error$: ISubject<IError>;
+    private buffer;
+    private queue;
+    private currentTask;
+    private destroyed;
+    private abortRequested;
+    constructor(buffer: SourceBuffer);
+    append(data: BufferSource, signal?: AbortSignal): Promise<boolean>;
+    remove(from: Milliseconds, to: Milliseconds, signal?: AbortSignal): Promise<boolean>;
+    abort(init?: BufferSource): Promise<boolean>;
+    destroy(): void;
+    private completeTask;
+    private pull;
+    private execute;
+}
+export default SourceBufferTaskQueue;