@vkontakte/videoplayer-core 2.0.154-dev.6d21d9b3.0 → 2.0.154-dev.784f4859.0

package/types/providers/types.d.ts

@@ -1,113 +1,112 @@
-import { ITuningConfig } from '../utils/tuningConfig';
-import { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IRange, IError, QualityLimits, IWarning, IComponentLogger, ITracer, IRectangle } from '@vkontakte/videoplayer-shared';
-import { IChromecastInitializer } from '../providers/ChromecastProvider/ChromecastInitializer/types';
-import { HttpConnectionType, HttpConnectionMetrics, HttpDownloadMetrics, VideoCodec, AudioCodec, IAudioStream, IAudioTrack, ICueSettings, ISources, IVideoStream, SeekState } from '../player/types';
-import { IExternalTextTrack, IInternalTextTrack, ITextTrack, IVideoTrack, IVolumeState, PlaybackState, PlaybackRate } from '../player/types';
-import { IStateMachine } from '../utils/StateMachine/types';
-import ThroughputEstimator from '../utils/ThroughputEstimator';
-import { Scene3D } from '../utils/3d/Scene3D';
-import { Vector2D } from '../utils/3d/types';
+import type { ITuningConfig } from "../utils/tuningConfig";
+import type { ILogger, ISubject, IValueSubject, Milliseconds, Seconds, IRange, IError, QualityLimits, IWarning, IComponentLogger, ITracer, IRectangle } from "@vkontakte/videoplayer-shared";
+import type { IChromecastInitializer } from "./ChromecastProvider/ChromecastInitializer/types";
+import type { HttpConnectionType, HttpConnectionMetrics, HttpDownloadMetrics, VideoCodec, AudioCodec, IAudioStream, IAudioTrack, ICueSettings, ISources, IVideoStream, SeekState } from "../player/types";
+import type { IExternalTextTrack, IInternalTextTrack, ITextTrack, IVideoTrack, IVolumeState, PlaybackState, PlaybackRate } from "../player/types";
+import type { IStateMachine } from "../utils/StateMachine/types";
+import type ThroughputEstimator from "../utils/ThroughputEstimator";
+import type { Scene3D } from "../utils/3d/Scene3D";
+import type { Vector2D } from "../utils/3d/types";
 export interface IProvider {
-    scene3D?: Scene3D;
-    destroy(): void;
+	scene3D?: Scene3D;
+	destroy(): void;
 }
 export interface IProviderDependencies {
-    dependencies: {
-        throughputEstimator: ThroughputEstimator;
-        chromecastInitializer: IChromecastInitializer;
-        logger: ILogger;
-        tracer: ITracer;
-        abrLogger: IComponentLogger;
-    };
+	dependencies: {
+		throughputEstimator: ThroughputEstimator;
+		chromecastInitializer: IChromecastInitializer;
+		logger: ILogger;
+		tracer: ITracer;
+		abrLogger: IComponentLogger;
+	};
 }
 export interface IProviderParams<TSourceType> extends IProviderDependencies {
-    container: HTMLElement;
-    source: TSourceType;
-    desiredState: IDesiredState;
-    output: IProviderOutput;
-    tuning: ITuningConfig;
-    panelSize?: IRectangle;
-    skipVideoElVolumeSync: boolean;
+	container: HTMLElement;
+	source: TSourceType;
+	desiredState: IDesiredState;
+	output: IProviderOutput;
+	tuning: ITuningConfig;
+	panelSize?: IRectangle;
 }
 export interface IDesiredState {
-    playbackState: IStateMachine<PlaybackState>;
-    seekState: IStateMachine<SeekState>;
-    volume: IStateMachine<IVolumeState>;
-    playbackRate: IStateMachine<PlaybackRate>;
-    isLooped: IStateMachine<boolean>;
-    isLowLatency: IStateMachine<boolean>;
-    videoStream: IStateMachine<IVideoStream | undefined>;
-    videoTrack: IStateMachine<IVideoTrack | undefined>;
-    audioStream: IStateMachine<IAudioStream | undefined>;
-    autoVideoTrackSwitching: IStateMachine<boolean>;
-    autoVideoTrackLimits: IStateMachine<QualityLimits>;
-    externalTextTracks: IStateMachine<IExternalTextTrack[]>;
-    internalTextTracks: IStateMachine<IInternalTextTrack[]>;
-    currentTextTrack: IStateMachine<ITextTrack['id'] | undefined>;
-    textTrackCuesSettings: IStateMachine<ICueSettings>;
-    cameraOrientation: IStateMachine<Vector2D>;
+	playbackState: IStateMachine<PlaybackState>;
+	seekState: IStateMachine<SeekState>;
+	volume: IStateMachine<IVolumeState>;
+	playbackRate: IStateMachine<PlaybackRate>;
+	isLooped: IStateMachine<boolean>;
+	isLowLatency: IStateMachine<boolean>;
+	videoStream: IStateMachine<IVideoStream | undefined>;
+	videoTrack: IStateMachine<IVideoTrack | undefined>;
+	audioStream: IStateMachine<IAudioStream | undefined>;
+	autoVideoTrackSwitching: IStateMachine<boolean>;
+	autoVideoTrackLimits: IStateMachine<QualityLimits>;
+	externalTextTracks: IStateMachine<IExternalTextTrack[]>;
+	internalTextTracks: IStateMachine<IInternalTextTrack[]>;
+	currentTextTrack: IStateMachine<ITextTrack["id"] | undefined>;
+	textTrackCuesSettings: IStateMachine<ICueSettings>;
+	cameraOrientation: IStateMachine<Vector2D>;
 }
 export interface IProviderOutput {
-    position$: IValueSubject<Seconds>;
-    duration$: IValueSubject<Seconds>;
-    volume$: IValueSubject<IVolumeState>;
-    currentVideoSegmentLength$: IValueSubject<number>;
-    currentAudioSegmentLength$: IValueSubject<number>;
-    availableVideoStreams$: IValueSubject<IVideoStream[]>;
-    currentVideoStream$: IValueSubject<IVideoStream | undefined>;
-    availableVideoTracks$: IValueSubject<IVideoTrack[]>;
-    currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
-    availableVideoCodecs$: IValueSubject<VideoCodec[]>;
-    availableAudioStreams$: IValueSubject<IAudioStream[]>;
-    currentAudioStream$: IValueSubject<IAudioStream | undefined>;
-    availableAudioTracks$: IValueSubject<IAudioTrack[]>;
-    availableAudioCodecs$: IValueSubject<AudioCodec[]>;
-    availableTextTracks$: IValueSubject<ITextTrack[]>;
-    currentTextTrack$: IValueSubject<ITextTrack['id'] | undefined>;
-    isAudioAvailable$: IValueSubject<boolean>;
-    autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
-    autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
-    canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
-    currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
-    currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
-    isBuffering$: IValueSubject<boolean>;
-    isLive$: IValueSubject<boolean | undefined>;
-    isLiveEnded$: IValueSubject<boolean | null>;
-    canPlayLiveTailBuffer$: IValueSubject<boolean>;
-    isLowLatency$: IValueSubject<boolean | undefined>;
-    liveTime$: IValueSubject<Milliseconds | undefined>;
-    liveBufferTime$: IValueSubject<Seconds | undefined>;
-    liveLatency$: IValueSubject<Milliseconds | undefined>;
-    hostname$: IValueSubject<string | undefined>;
-    httpConnectionType$: IValueSubject<HttpConnectionType | undefined>;
-    httpConnectionReused$: IValueSubject<boolean | undefined>;
-    httpConnectionMetrics$: IValueSubject<HttpConnectionMetrics | undefined>;
-    httpDownloadMetrics$: IValueSubject<HttpDownloadMetrics | undefined>;
-    element$: IValueSubject<HTMLVideoElement | undefined>;
-    elementVisible$: IValueSubject<boolean>;
-    availableSources$: IValueSubject<ISources | undefined>;
-    willSeekEvent$: ISubject<void>;
-    seekedEvent$: ISubject<void>;
-    error$: ISubject<IError>;
-    fetcherRecoverableError$: ISubject<IError>;
-    fetcherError$: ISubject<IError>;
-    warning$: ISubject<IWarning>;
-    endedEvent$: ISubject<void>;
-    loopedEvent$: ISubject<Seconds>;
-    manifestRequested$: ISubject<void>;
-    firstBytesManifest$: ISubject<void>;
-    manifestReceived$: ISubject<void>;
-    firstBytesRequested$: ISubject<void>;
-    firstBytesReceived$: ISubject<void>;
-    firstBytesEvent$: ISubject<Milliseconds | void>;
-    loadedMetadataEvent$: ISubject<void>;
-    firstFrameEvent$: ISubject<void>;
-    soundProhibitedEvent$: ISubject<void>;
-    canplay$: ISubject<void>;
-    severeStallOccurred$: ISubject<boolean>;
-    is3DVideo$: ISubject<boolean>;
-    inPiP$: IValueSubject<boolean>;
-    inFullscreen$: IValueSubject<boolean>;
-    playbackState$: IValueSubject<PlaybackState | string>;
-    getCurrentTime$: IValueSubject<(() => number) | null>;
+	position$: IValueSubject<Seconds>;
+	duration$: IValueSubject<Seconds>;
+	volume$: IValueSubject<IVolumeState>;
+	currentVideoSegmentLength$: IValueSubject<number>;
+	currentAudioSegmentLength$: IValueSubject<number>;
+	availableVideoStreams$: IValueSubject<IVideoStream[]>;
+	currentVideoStream$: IValueSubject<IVideoStream | undefined>;
+	availableVideoTracks$: IValueSubject<IVideoTrack[]>;
+	currentVideoTrack$: IValueSubject<IVideoTrack | undefined>;
+	availableVideoCodecs$: IValueSubject<VideoCodec[]>;
+	availableAudioStreams$: IValueSubject<IAudioStream[]>;
+	currentAudioStream$: IValueSubject<IAudioStream | undefined>;
+	availableAudioTracks$: IValueSubject<IAudioTrack[]>;
+	availableAudioCodecs$: IValueSubject<AudioCodec[]>;
+	availableTextTracks$: IValueSubject<ITextTrack[]>;
+	currentTextTrack$: IValueSubject<ITextTrack["id"] | undefined>;
+	isAudioAvailable$: IValueSubject<boolean>;
+	autoVideoTrackLimits$: IValueSubject<QualityLimits | undefined>;
+	autoVideoTrackLimitingAvailable$: IValueSubject<boolean>;
+	canChangePlaybackSpeed$: IValueSubject<boolean | undefined>;
+	currentBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	currentNativeBuffer$: IValueSubject<IRange<Seconds> | undefined>;
+	isBuffering$: IValueSubject<boolean>;
+	isLive$: IValueSubject<boolean | undefined>;
+	isLiveEnded$: IValueSubject<boolean | null>;
+	canPlayLiveTailBuffer$: IValueSubject<boolean>;
+	isLowLatency$: IValueSubject<boolean | undefined>;
+	liveTime$: IValueSubject<Milliseconds | undefined>;
+	liveBufferTime$: IValueSubject<Seconds | undefined>;
+	liveLatency$: IValueSubject<Milliseconds | undefined>;
+	hostname$: IValueSubject<string | undefined>;
+	httpConnectionType$: IValueSubject<HttpConnectionType | undefined>;
+	httpConnectionReused$: IValueSubject<boolean | undefined>;
+	httpConnectionMetrics$: IValueSubject<HttpConnectionMetrics | undefined>;
+	httpDownloadMetrics$: IValueSubject<HttpDownloadMetrics | undefined>;
+	element$: IValueSubject<HTMLVideoElement | undefined>;
+	elementVisible$: IValueSubject<boolean>;
+	availableSources$: IValueSubject<ISources | undefined>;
+	willSeekEvent$: ISubject<void>;
+	seekedEvent$: ISubject<void>;
+	error$: ISubject<IError>;
+	fetcherRecoverableError$: ISubject<IError>;
+	fetcherError$: ISubject<IError>;
+	warning$: ISubject<IWarning>;
+	endedEvent$: ISubject<void>;
+	loopedEvent$: ISubject<Seconds>;
+	manifestRequested$: ISubject<void>;
+	firstBytesManifest$: ISubject<void>;
+	manifestReceived$: ISubject<void>;
+	firstBytesRequested$: ISubject<void>;
+	firstBytesReceived$: ISubject<void>;
+	firstBytesEvent$: ISubject<Milliseconds | void>;
+	loadedMetadataEvent$: ISubject<void>;
+	firstFrameEvent$: ISubject<void>;
+	soundProhibitedEvent$: ISubject<void>;
+	canplay$: ISubject<void>;
+	severeStallOccurred$: ISubject<boolean>;
+	is3DVideo$: ISubject<boolean>;
+	inPiP$: IValueSubject<boolean>;
+	inFullscreen$: IValueSubject<boolean>;
+	playbackState$: IValueSubject<PlaybackState | string>;
+	getCurrentTime$: IValueSubject<(() => number) | null>;
 }

package/types/providers/utils/HTMLVideoElement/DroppedFramesManager.d.ts

@@ -1,44 +1,45 @@
-import { type ExactVideoQuality, ILogger, IObservable, Subject } from '@vkontakte/videoplayer-shared';
-import { ITuningConfig } from '../../../utils/tuningConfig';
-import { IVideoTrack } from '../../../player/types';
-import { IStateMachine } from '../../../utils/StateMachine/types';
+import type { ILogger, IObservable } from "@vkontakte/videoplayer-shared";
+import { type ExactVideoQuality, Subject } from "@vkontakte/videoplayer-shared";
+import type { ITuningConfig } from "../../../utils/tuningConfig";
+import type { IVideoTrack } from "../../../player/types";
+import type { IStateMachine } from "../../../utils/StateMachine/types";
 interface IConnectData {
-    logger: ILogger;
-    video: HTMLVideoElement;
-    tracks: IVideoTrack[];
-    droppedFramesChecker: ITuningConfig['droppedFramesChecker'];
-    isAuto: IStateMachine<boolean>;
-    playing$: IObservable<undefined>;
-    pause$: IObservable<undefined>;
+	logger: ILogger;
+	video: HTMLVideoElement;
+	tracks: IVideoTrack[];
+	droppedFramesChecker: ITuningConfig["droppedFramesChecker"];
+	isAuto: IStateMachine<boolean>;
+	playing$: IObservable<undefined>;
+	pause$: IObservable<undefined>;
 }
 declare class DroppedFramesManager {
-    onDroopedVideoFramesLimit$: Subject<void>;
-    private subscription;
-    private log;
-    private video;
-    private droppedFramesChecker;
-    private isAuto;
-    private playing;
-    private tracks;
-    private forceChecker$;
-    private isForceCheckCounter;
-    private prevTotalVideoFrames;
-    private prevDroppedVideoFrames;
-    private currentTimer;
-    private limitCounts;
-    private currentQuality;
-    private maxQualityLimit;
-    connect(data: IConnectData): void;
-    destroy(): void;
-    get droppedVideoMaxQualityLimit(): ExactVideoQuality | undefined;
-    private subscribe;
-    private handleChangeVideoQuality;
-    private onChangeQuality;
-    private checkDroppedFrames;
-    private onDroopedVideoFramesLimitTrigger;
-    private getMaxQualityLimit;
-    private get isEnabled();
-    private get isDroppedFramesCheckerSupport();
-    private savePrevFrameCounts;
+	onDroopedVideoFramesLimit$: Subject<void>;
+	private subscription;
+	private log;
+	private video;
+	private droppedFramesChecker;
+	private isAuto;
+	private playing;
+	private tracks;
+	private forceChecker$;
+	private isForceCheckCounter;
+	private prevTotalVideoFrames;
+	private prevDroppedVideoFrames;
+	private currentTimer;
+	private limitCounts;
+	private currentQuality;
+	private maxQualityLimit;
+	connect(data: IConnectData): void;
+	destroy(): void;
+	get droppedVideoMaxQualityLimit(): ExactVideoQuality | undefined;
+	private subscribe;
+	private handleChangeVideoQuality;
+	private onChangeQuality;
+	private checkDroppedFrames;
+	private onDroopedVideoFramesLimitTrigger;
+	private getMaxQualityLimit;
+	private get isEnabled();
+	private get isDroppedFramesCheckerSupport();
+	private savePrevFrameCounts;
 }
 export default DroppedFramesManager;

package/types/providers/utils/HTMLVideoElement/TextTrackManager.d.ts

@@ -1,32 +1,32 @@
-import { IExternalTextTrack, IInternalTextTrack, ITextTrack } from '../../../player/types';
-import { IDesiredState, IProviderOutput } from '../../../providers/types';
+import type { IExternalTextTrack, IInternalTextTrack, ITextTrack } from "../../../player/types";
+import type { IDesiredState, IProviderOutput } from "../../types";
 /**
- * TODO: сейчас externalTextTracks и internalTextTracks записываются в availableTextTracks отсюда
- * нужно будет выпилить этот класс за исключением этой логики,
- * когда перестанет быть необходима поддержка браузерных субтитров
- */
+* TODO: сейчас externalTextTracks и internalTextTracks записываются в availableTextTracks отсюда
+* нужно будет выпилить этот класс за исключением этой логики,
+* когда перестанет быть необходима поддержка браузерных субтитров
+*/
 declare class TextTrackManager {
-    private available$;
-    private current$;
-    private error$;
-    private video;
-    private cueSettings;
-    private subscription;
-    private externalTracks;
-    private internalTracks;
-    private baseURL?;
-    constructor(baseURL?: string);
-    connect(video: HTMLVideoElement, desiredState: Pick<IDesiredState, 'externalTextTracks' | 'internalTextTracks' | 'currentTextTrack' | 'textTrackCuesSettings'>, providerOutput: Pick<IProviderOutput, 'availableTextTracks$' | 'currentTextTrack$' | 'error$'>): void;
-    private subscribe;
-    private applyCueSettings;
-    private htmlTextTracksAsArray;
-    private htmlTextTrackToITextTrack;
-    private static isHealthyTrack;
-    setExternal(tracks: IExternalTextTrack[]): void;
-    setInternal(tracks: IInternalTextTrack[]): void;
-    select(selectedId: ITextTrack['id'] | undefined): void;
-    destroy(): void;
-    private attach;
-    private detach;
+	private available$;
+	private current$;
+	private error$;
+	private video;
+	private cueSettings;
+	private subscription;
+	private externalTracks;
+	private internalTracks;
+	private baseURL?;
+	constructor(baseURL?: string);
+	connect(video: HTMLVideoElement, desiredState: Pick<IDesiredState, "externalTextTracks" | "internalTextTracks" | "currentTextTrack" | "textTrackCuesSettings">, providerOutput: Pick<IProviderOutput, "availableTextTracks$" | "currentTextTrack$" | "error$">): void;
+	private subscribe;
+	private applyCueSettings;
+	private htmlTextTracksAsArray;
+	private htmlTextTrackToITextTrack;
+	private static isHealthyTrack;
+	setExternal(tracks: IExternalTextTrack[]): void;
+	setInternal(tracks: IInternalTextTrack[]): void;
+	select(selectedId: ITextTrack["id"] | undefined): void;
+	destroy(): void;
+	private attach;
+	private detach;
 }
 export default TextTrackManager;

package/types/providers/utils/HTMLVideoElement/forcePlay.d.ts

@@ -1,8 +1,8 @@
 /**
- * Пытаемся запустить видео обходя ошибку `NotAllowedError` путём включения `mute`.
- * @param {HTMLVideoElement} video - видеообъект
- * @param {Function} soundNotAllowedCallback - колбэк, который вызовется если нам не разрешили играть со звуком
- * @return {Promise}<boolean> - получилось начать воспроизведение
- */
+* Пытаемся запустить видео обходя ошибку `NotAllowedError` путём включения `mute`.
+* @param {HTMLVideoElement} video - видеообъект
+* @param {Function} soundNotAllowedCallback - колбэк, который вызовется если нам не разрешили играть со звуком
+* @return {Promise}<boolean> - получилось начать воспроизведение
+*/
 declare const _default: (video: HTMLVideoElement, soundNotAllowedCallback?: () => void) => Promise<boolean>;
 export default _default;

package/types/providers/utils/HTMLVideoElement/observable.d.ts

@@ -1,28 +1,28 @@
-import { Seconds, IRange, IObservable, IError, IValueObservable } from '@vkontakte/videoplayer-shared';
-import { IVolumeState, PlaybackRate } from '../../../player/types';
+import type { Seconds, IRange, IObservable, IError, IValueObservable } from "@vkontakte/videoplayer-shared";
+import type { IVolumeState, PlaybackRate } from "../../../player/types";
 export interface IObservableVideo {
-    playing$: IObservable<undefined>;
-    pause$: IObservable<undefined>;
-    canplay$: IObservable<undefined>;
-    ended$: IObservable<undefined>;
-    looped$: IObservable<Seconds>;
-    error$: IObservable<IError>;
-    seeked$: IObservable<undefined>;
-    seeking$: IObservable<undefined>;
-    progress$: IObservable<undefined>;
-    timeUpdate$: IObservable<Seconds>;
-    durationChange$: IObservable<Seconds>;
-    loadStart$: IObservable<void>;
-    loadedMetadata$: IObservable<undefined>;
-    loadedData$: IObservable<undefined>;
-    isBuffering$: IObservable<boolean>;
-    currentBuffer$: IObservable<IRange<Seconds>>;
-    volumeState$: IObservable<IVolumeState>;
-    playbackRateState$: IObservable<PlaybackRate>;
-    inPiP$: IValueObservable<boolean>;
-    inFullscreen$: IValueObservable<boolean>;
-    enterPip$: IObservable<PictureInPictureEvent>;
-    leavePip$: IObservable<PictureInPictureEvent>;
-    destroy: () => void;
+	playing$: IObservable<undefined>;
+	pause$: IObservable<undefined>;
+	canplay$: IObservable<undefined>;
+	ended$: IObservable<undefined>;
+	looped$: IObservable<Seconds>;
+	error$: IObservable<IError>;
+	seeked$: IObservable<undefined>;
+	seeking$: IObservable<undefined>;
+	progress$: IObservable<undefined>;
+	timeUpdate$: IObservable<Seconds>;
+	durationChange$: IObservable<Seconds>;
+	loadStart$: IObservable<void>;
+	loadedMetadata$: IObservable<undefined>;
+	loadedData$: IObservable<undefined>;
+	isBuffering$: IObservable<boolean>;
+	currentBuffer$: IObservable<IRange<Seconds>>;
+	volumeState$: IObservable<IVolumeState>;
+	playbackRateState$: IObservable<PlaybackRate>;
+	inPiP$: IValueObservable<boolean>;
+	inFullscreen$: IValueObservable<boolean>;
+	enterPip$: IObservable<PictureInPictureEvent>;
+	leavePip$: IObservable<PictureInPictureEvent>;
+	destroy: () => void;
 }
 export declare const observe: (video: HTMLVideoElement) => IObservableVideo;

package/types/providers/utils/HTMLVideoElement/pool.d.ts

@@ -1,5 +1,5 @@
-import { ITuningConfig } from '../../../utils/tuningConfig';
-type Constraints = Pick<ITuningConfig, 'audioVideoSyncRate' | 'disableYandexPiP'>;
+import type { ITuningConfig } from "../../../utils/tuningConfig";
+type Constraints = Pick<ITuningConfig, "audioVideoSyncRate" | "disableYandexPiP">;
 export declare const allocate: (container: HTMLElement, { audioVideoSyncRate, disableYandexPiP }: Constraints) => HTMLVideoElement;
 export declare const dispose: (element: HTMLVideoElement) => void;
 export {};

package/types/providers/utils/LiveOffset/index.d.ts

@@ -1,14 +1,14 @@
-import { Milliseconds } from '@vkontakte/videoplayer-shared';
-import { ILiveOffset } from './types';
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
+import type { ILiveOffset } from "./types";
 export default class LiveOffset implements ILiveOffset {
-    private pausedTime;
-    private streamOffset;
-    private pauseTimestamp;
-    getTotalPausedTime(): Milliseconds;
-    getCurrentPausedTime(): Milliseconds;
-    getStreamOffset(): Milliseconds;
-    getTotalOffset(): Milliseconds;
-    pause(): void;
-    resume(): void;
-    resetTo(offset: Milliseconds, isPaused?: boolean): void;
+	private pausedTime;
+	private streamOffset;
+	private pauseTimestamp;
+	getTotalPausedTime(): Milliseconds;
+	getCurrentPausedTime(): Milliseconds;
+	getStreamOffset(): Milliseconds;
+	getTotalOffset(): Milliseconds;
+	pause(): void;
+	resume(): void;
+	resetTo(offset: Milliseconds, isPaused?: boolean): void;
 }

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

@@ -1,10 +1,10 @@
-import { Milliseconds } from '@vkontakte/videoplayer-shared';
+import type { Milliseconds } from "@vkontakte/videoplayer-shared";
 export interface ILiveOffset {
-    getTotalPausedTime(): Milliseconds;
-    getCurrentPausedTime(): Milliseconds;
-    getStreamOffset(): Milliseconds;
-    getTotalOffset(): Milliseconds;
-    pause(): void;
-    resume(): void;
-    resetTo(offset: Milliseconds, isPaused?: boolean): void;
+	getTotalPausedTime(): Milliseconds;
+	getCurrentPausedTime(): Milliseconds;
+	getStreamOffset(): Milliseconds;
+	getTotalOffset(): Milliseconds;
+	pause(): void;
+	resume(): void;
+	resetTo(offset: Milliseconds, isPaused?: boolean): void;
 }

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

@@ -1,54 +1,54 @@
-import { ExactVideoQuality, IObservable, IValueSubject, Milliseconds, Kbps, Seconds } from '@vkontakte/videoplayer-shared';
-import { IVideoTrack } from '../../player/types';
-import { ITuningConfig } from '../../utils/tuningConfig';
+import type { ExactVideoQuality, IObservable, IValueSubject, Milliseconds, Kbps, Seconds } from "@vkontakte/videoplayer-shared";
+import type { IVideoTrack } from "../../player/types";
+import type { ITuningConfig } from "../../utils/tuningConfig";
 interface IConnectData {
-    videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
-    throughput$: IValueSubject<number>;
-    rtt$: IValueSubject<Milliseconds>;
-    isBuffering$: IObservable<boolean>;
-    isSeeked$: IObservable<boolean>;
-    looped$: IObservable<Seconds>;
-    playing$: IObservable<undefined>;
-    currentStallDuration$: IValueSubject<Milliseconds>;
-    tuning: ITuningConfig['stallsManager'];
-    abrParams: ITuningConfig['autoTrackSelection'];
-    duration: Seconds;
+	videoLastDataObtainedTimestamp$: IValueSubject<Milliseconds>;
+	throughput$: IValueSubject<number>;
+	rtt$: IValueSubject<Milliseconds>;
+	isBuffering$: IObservable<boolean>;
+	isSeeked$: IObservable<boolean>;
+	looped$: IObservable<Seconds>;
+	playing$: IObservable<undefined>;
+	currentStallDuration$: IValueSubject<Milliseconds>;
+	tuning: ITuningConfig["stallsManager"];
+	abrParams: ITuningConfig["autoTrackSelection"];
+	duration: Seconds;
 }
 declare class StallsManager {
-    private currentStallDuration$;
-    private videoLastDataObtainedTimestamp$;
-    private throughput$;
-    private rtt$;
-    private tuning;
-    private abrParams;
-    private duration;
-    private isSeeked$;
-    private isBuffering$;
-    private maxQualityLimit;
-    private lastUniqueVideoTrackSelected;
-    private currentStallsCount;
-    private sumStallsDuration;
-    private lastStallDuration;
-    private providerStartWatchingTimestamp;
-    private lastUniqueVideoTrackSelectedTimestamp;
-    private predictedThroughputWithoutData;
-    private qualityRestrictionTimer;
-    private subscription;
-    severeStallOccurred$: IValueSubject<boolean>;
-    init(data: IConnectData): void;
-    get videoMaxQualityLimit(): ExactVideoQuality | undefined;
-    get predictedThroughput(): Kbps;
-    get abrTuningParams(): ITuningConfig['autoTrackSelection'];
-    set lastVideoTrackSelected(lastUniqueVideoTrackSelected: IVideoTrack);
-    destroy(): void;
-    private resetStoredAbrParamsIfNeeded;
-    private updateStoredAbrParams;
-    private calculateOptimalAbrParams;
-    private getStoredData;
-    private setStoredData;
-    private removeStoredData;
-    private addStallInfoToHistory;
-    private updateStallData;
-    private subscribe;
+	private currentStallDuration$;
+	private videoLastDataObtainedTimestamp$;
+	private throughput$;
+	private rtt$;
+	private tuning;
+	private abrParams;
+	private duration;
+	private isSeeked$;
+	private isBuffering$;
+	private maxQualityLimit;
+	private lastUniqueVideoTrackSelected;
+	private currentStallsCount;
+	private sumStallsDuration;
+	private lastStallDuration;
+	private providerStartWatchingTimestamp;
+	private lastUniqueVideoTrackSelectedTimestamp;
+	private predictedThroughputWithoutData;
+	private qualityRestrictionTimer;
+	private subscription;
+	severeStallOccurred$: IValueSubject<boolean>;
+	init(data: IConnectData): void;
+	get videoMaxQualityLimit(): ExactVideoQuality | undefined;
+	get predictedThroughput(): Kbps;
+	get abrTuningParams(): ITuningConfig["autoTrackSelection"];
+	set lastVideoTrackSelected(lastUniqueVideoTrackSelected: IVideoTrack);
+	destroy(): void;
+	private resetStoredAbrParamsIfNeeded;
+	private updateStoredAbrParams;
+	private calculateOptimalAbrParams;
+	private getStoredData;
+	private setStoredData;
+	private removeStoredData;
+	private addStallInfoToHistory;
+	private updateStallData;
+	private subscribe;
 }
 export default StallsManager;

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

@@ -1,16 +1,17 @@
-import { DevNullEntry } from '@vkontakte/videoplayer-shared';
+import type { DevNullEntry } from "@vkontakte/videoplayer-shared";
 declare class Entry {
-    readonly tag: string;
-    readonly time: number;
-    readonly data: Record<string, unknown>;
-    readonly stack?: string | undefined;
-    constructor(tag: string, time: number, data: Record<string, unknown>, stack?: string | undefined);
-    toString(): string;
-    toDevNullEntry(): DevNullEntry;
+	readonly tag: string;
+	readonly time: number;
+	readonly data: Record<string, unknown>;
+	readonly stack?: string | undefined;
+	constructor(tag: string, time: number, data: Record<string, unknown>, stack?: string | undefined);
+	toString(): string;
+	toDevNullEntry(): DevNullEntry;
 }
-export declare const dashLiveDebug: {
-    (data: Record<string, unknown>, addTrace?: boolean): void;
-    reset(): void;
-    drain(): Entry[];
+type DebugFn = {
+	(data: Record<string, unknown>, addTrace?: boolean): void;
+	reset: () => void;
+	drain: () => Entry[];
 };
+export declare const dashLiveDebug: DebugFn;
 export {};