@bitmovin/player-web-x 10.0.0-beta.10

package/types/framework/core/source/atoms/MediaTypeMapAtom.d.ts

@@ -0,0 +1,14 @@
+import type { ContextHaving } from '../../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../../BaseTypes';
+import { ComponentName } from '../../../Types';
+import type { MediaType } from '../../core/Constants';
+import type { CoreStateAtoms } from '../../core/Core.package';
+import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
+import type { MapStateAtom } from '../../core/state/MapStateAtom';
+import type { ContextWithState } from '../../Types';
+type ContextT = ContextHaving<{
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+}, EmptyObject, ContextWithState>;
+export type MediaTypeMapAtom = MapStateAtom<MediaType, ArrayAtom<string>>;
+export declare function createMediaTypeMapAtom(context: ContextT, ...activeMediaTypes: MediaType[]): MediaTypeMapAtom;
+export {};

package/types/framework/core/source/atoms/PlaybackAtom.d.ts

@@ -0,0 +1,17 @@
+import type { ContextWithState } from '../../Types';
+import type { PlayheadAtom } from './PlayheadAtom';
+export declare enum PlaybackState {
+    Initial = "initial",
+    CanPlay = "can-play",
+    Playing = "can-play"
+}
+interface Playback {
+    state: PlaybackState;
+    playhead: PlayheadAtom;
+}
+declare function setState(playback: Playback, state: PlaybackState): boolean;
+export type PlaybackAtom = ReturnType<typeof createPlaybackAtom>;
+export declare function createPlaybackAtom(context: ContextWithState): import("../../core/state/Types").StateAtom<Playback, {
+    setState: typeof setState;
+}>;
+export {};

package/types/framework/core/source/atoms/PlayheadAtom.d.ts

@@ -0,0 +1,16 @@
+import type { ContextWithState } from '../../Types';
+interface Playhead {
+    position: number;
+    precision: number;
+}
+declare function setPrecision(playhead: Playhead, precision: number): boolean;
+declare function setPosition(playhead: Playhead, position: number): boolean;
+export type PlayheadAtom = ReturnType<typeof createPlayheadAtom>;
+export declare function createPlayheadAtom(context: ContextWithState, basePlayhead?: Partial<Playhead>): import("../../core/state/Types").StateAtom<{
+    position: number;
+    precision: number;
+}, {
+    setPrecision: typeof setPrecision;
+    setPosition: typeof setPosition;
+}>;
+export {};

package/types/framework/core/source/atoms/SourceStateAtom.d.ts

@@ -0,0 +1,47 @@
+import type { ContextHaving } from '../../../../../framework-types/execution-context/Types';
+import type { EmptyObject } from '../../../../BaseTypes';
+import { ComponentName } from '../../../Types';
+import type { Constants } from '../../core/Constants';
+import type { CoreStateAtoms } from '../../core/Core.package';
+import type { ArrayAtom } from '../../core/state/ArrayStateAtom';
+import type { DataRangesAtom } from '../../core/state/data-ranges/DataRangesAtom';
+import type { SelectionGroupAtom } from '../../core/state/selection-group/SelectionGroupAtom';
+import type { StreamAtom } from '../../core/state/stream/StreamAtom';
+import type { TrackAtom } from '../../core/state/track/TrackAtom';
+import { LogLevel } from '../../core/utils/Logger';
+import type { CoreUtils } from '../../core/utils/Types';
+import type { ContextWithState } from '../../Types';
+import type { BufferConfigAtom } from './BufferConfigAtom';
+import type { MediaTypeMapAtom } from './MediaTypeMapAtom';
+import type { PlaybackAtom } from './PlaybackAtom';
+import type { StartupOptionsAtom } from './StartupOptionsAtom';
+import type { VideoElementAtom } from './VideoElementAtom';
+export type SourceContext = ContextHaving<{
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [ComponentName.Constants]: Constants;
+}, EmptyObject, ContextWithState>;
+export type ActiveTracksAtom = ArrayAtom<TrackAtom>;
+export type ActiveSelectionGroupsAtom = ArrayAtom<SelectionGroupAtom>;
+export type SourceState = {
+    url: string;
+    stream: StreamAtom;
+    activeTracks: ActiveTracksAtom;
+    activeSelectionGroups: ActiveSelectionGroupsAtom;
+    logLevel: LogLevel;
+    dataRanges: DataRangesAtom;
+    isActive: boolean;
+    video: VideoElementAtom;
+    config: {
+        buffer: BufferConfigAtom;
+        startup: StartupOptionsAtom;
+    };
+    playback: PlaybackAtom;
+    activeMediaTypes: MediaTypeMapAtom;
+};
+export type SourceStateAtom = ReturnType<typeof createSourceStateAtom>;
+export declare const createSourceStateAtom: (context: SourceContext, url: string) => import("../../core/state/Types").StateAtom<SourceState, {
+    forceVideoElementUpdate: () => true;
+    setLogLevel: (sourceState: SourceState, level: LogLevel) => boolean;
+    setActive(sourceState: SourceState, isActive: boolean): boolean;
+}>;

package/types/framework/core/source/atoms/StartupOptionsAtom.d.ts

@@ -0,0 +1,17 @@
+import type { ContextWithState } from '../../Types';
+export declare enum StartupMode {
+    Fast = "fast",
+    Precise = "precise"
+}
+interface StartupOptions {
+    position: number;
+    mode: StartupMode;
+}
+declare function setPosition(options: StartupOptions, startPosition: number): boolean;
+declare function setMode(options: StartupOptions, startupMode: StartupMode): boolean;
+export type StartupOptionsAtom = ReturnType<typeof createStartupOptionsAtom>;
+export declare function createStartupOptionsAtom(context: ContextWithState, baseOptions?: Partial<StartupOptions>): import("../../core/state/Types").StateAtom<StartupOptions, {
+    setPosition: typeof setPosition;
+    setMode: typeof setMode;
+}>;
+export {};

package/types/framework/core/source/atoms/VideoElementAtom.d.ts

@@ -0,0 +1,12 @@
+import type { SourceContext } from './SourceStateAtom';
+type VideoElementState = {
+    element: HTMLVideoElement | undefined;
+};
+export type VideoElementAtom = ReturnType<typeof createVideoElementAtom>;
+declare function clear(state: VideoElementState): boolean;
+declare function set(state: VideoElementState, video: HTMLVideoElement): boolean;
+export declare function createVideoElementAtom(context: SourceContext): import("../../core/state/Types").StateAtom<VideoElementState, {
+    clear: typeof clear;
+    set: typeof set;
+}>;
+export {};

package/types/framework/core/source-api/SourceApi.package.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @packageDocumentation SourceApi.package
+ *
+ * Extends API for playback related controls of each specific source.
+ *
+ * Currently exposes these methods on the ApiManager:
+ *
+ * - `PlaybackApi.load` loads source by providing manifest URL string
+ * - `PlaybackApi.unload` Unload current source
+ * - `PlaybackApi.play` Plays current source
+ *
+ * ### `SourceApi` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph SourceApi
+ *     ComponentName.SourceState#1["SourceState"]
+ *     ComponentName.VideoElementUtils#1["VideoElementUtils"]
+ *     end
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     SourceApi --> ComponentName.CoreEffects
+ *     SourceApi --> ComponentName.CoreStateAtoms
+ *     SourceApi --> ComponentName.Logger
+ *     SourceApi --> ComponentName.Utils
+ *     SourceApi --> ComponentName.Constants
+ * ```
+ */
+import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
+import { ComponentName } from '../../Types';
+import type { Constants } from '../core/Constants';
+import type { CoreEffects, CoreStateAtoms } from '../core/Core.package';
+import type { Logger } from '../core/utils/Logger';
+import type { CoreUtils } from '../core/utils/Types';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+import VideoElementUtils from '../sources-api/VideoElementUtils';
+import type { ContextWithState } from '../Types';
+import type { PlayerAndSourceApi } from './Types';
+type SourceApiDependencies = {
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [ComponentName.Logger]: Logger;
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.Constants]: Constants;
+};
+export type SourceApiExports = {
+    [ComponentName.SourceState]: SourceStateAtom;
+    [ComponentName.VideoElementUtils]: typeof VideoElementUtils;
+};
+export type SourcePackageContext = ContextHaving<SourceApiDependencies, SourceApiExports, ContextWithState>;
+export declare const SourceApiPackage: import("../../../../framework-types/package-api/Package").Package<SourceApiDependencies, SourceApiExports, PlayerAndSourceApi>;
+export default SourceApiPackage;

package/types/framework/core/source-api/Types.d.ts

@@ -0,0 +1,8 @@
+import type { MyApi } from '../../../bundles/Types';
+export interface PlaybackApi {
+    unload(): void;
+    play(): Promise<void>;
+    load(source: string): Promise<void>;
+}
+export interface PlayerAndSourceApi extends MyApi, PlaybackApi {
+}

package/types/framework/core/sources-api/PlaybackApi.d.ts

@@ -0,0 +1,9 @@
+import type { LogLevel } from '../core/utils/Logger';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+import type { SourcesApiContext } from './SourcesApi.package';
+export interface PlaybackApi {
+    play(): Promise<void>;
+    unload(): void;
+    setLogLevel(level: LogLevel): void;
+}
+export declare function createPlaybackApi(sourceState: SourceStateAtom, { effects: { state } }: SourcesApiContext): PlaybackApi;

package/types/framework/core/sources-api/SourcesApi.package.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @packageDocumentation SourcesApi.package
+ *
+ * Provides basic functionality that enables to play list
+ * of multiple sources and switching between them.
+ *
+ * Currently exposes these properties on the `ApiManager`:
+ * * `sources` gives access to `SourcesApi` with following methods:
+ *   * `add` Adds new source by providing manifest URL and active flag
+ *     and also returns `PlaybackApi` for this source
+ *   * `list` Returns current list of sources
+ *   * `get` Returns `PlaybackApi` for given source
+ *   * `setActive` Sets given source as active
+ *   * `remove` Removes given source
+ * * `dispose` Disposes sources API
+ * * `getVideoElement` returns current HTMLVideoElement reference
+ * * `setVideoElement` sets HTMLVideoElement reference
+ *
+ * ### `SourcesApi` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph SourcesApi
+ *     ComponentName.SourceState#2["SourceState"]
+ *     ComponentName.VideoElementUtils#2["VideoElementUtils"]
+ *     SourceApiExportNames.SourceList["SourceList"]
+ *     end
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     SourcesApi --> ComponentName.Utils
+ *     SourcesApi --> ComponentName.CoreEffects
+ *     SourcesApi --> ComponentName.CoreStateAtoms
+ *     SourcesApi --> ComponentName.Logger
+ *     SourcesApi --> ComponentName.Constants
+ * ```
+ */
+import type { ContextHaving } from '../../../../framework-types/execution-context/Types';
+import { ComponentName } from '../../Types';
+import type { Constants } from '../core/Constants';
+import type { CoreEffects, CoreStateAtoms } from '../core/Core.package';
+import type { ArrayAtom } from '../core/state/ArrayStateAtom';
+import type { Logger } from '../core/utils/Logger';
+import type { CoreUtils } from '../core/utils/Types';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+import type { ContextWithState } from '../Types';
+import type { PlayerAndSourcesApi } from './Types';
+import { SourceApiExportNames } from './Types';
+import VideoElementUtils from './VideoElementUtils';
+export type SourcesApiDependencies = {
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [ComponentName.Logger]: Logger;
+    [ComponentName.Constants]: Constants;
+};
+export type SourcesApiExports = {
+    [ComponentName.SourceState]: SourceStateAtom;
+    [ComponentName.VideoElementUtils]: typeof VideoElementUtils;
+    [SourceApiExportNames.SourceList]: ArrayAtom<SourceStateAtom>;
+};
+export type SourcesApiContext = ContextHaving<SourcesApiDependencies, SourcesApiExports, ContextWithState>;
+export declare const SourcesApiPackage: import("../../../../framework-types/package-api/Package").Package<SourcesApiDependencies, SourcesApiExports, PlayerAndSourcesApi>;
+export default SourcesApiPackage;

package/types/framework/core/sources-api/Types.d.ts

@@ -0,0 +1,17 @@
+import type { MyApi } from '../../../bundles/Types';
+import type { ArrayAtom } from '../core/state/ArrayStateAtom';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+import type { PlaybackApi } from './PlaybackApi';
+export interface SourcesApi {
+    add(manifestUrl: string): PlaybackApi;
+    list(): ArrayAtom<SourceStateAtom>;
+    get(source: SourceStateAtom): PlaybackApi | undefined;
+    setActive(source: SourceStateAtom): void;
+    remove(source: SourceStateAtom): void;
+}
+export interface PlayerAndSourcesApi extends MyApi {
+    sources: SourcesApi;
+}
+export declare enum SourceApiExportNames {
+    SourceList = "source-list"
+}

package/types/framework/core/sources-api/VideoElementUtils.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from '../core/utils/Logger';
+declare function attachVideoElement(video: HTMLVideoElement): () => void;
+declare function createVideoElement(logger: Logger): HTMLVideoElement;
+declare const _default: {
+    createVideoElement: typeof createVideoElement;
+    attachVideoElement: typeof attachVideoElement;
+};
+export default _default;

package/types/framework/core/trick-play/TrickPlay.package.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @packageDocumentation TrickPlay.package
+ *
+ * Serves as playback emulation tool that enables to test the data flow
+ * of other layers without a need to actually display the content.
+ *
+ * It simulates tasks like advancing of the playhead position or seeking.
+ *
+ * ### `TrickPlay` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph SourceApi
+ *     ComponentName.SourceState#1["SourceState"]
+ *     ComponentName.VideoElementUtils#1["VideoElementUtils"]
+ *     end
+ *     subgraph SourcesApi
+ *     ComponentName.SourceState#2["SourceState"]
+ *     ComponentName.VideoElementUtils#2["VideoElementUtils"]
+ *     SourceApiExportNames.SourceList["SourceList"]
+ *     end
+ *     TrickPlay --> ComponentName.Logger
+ *     TrickPlay --> ComponentName.CoreEffects
+ *     TrickPlay --> ComponentName.CoreStateAtoms
+ *     TrickPlay --> ComponentName.Utils
+ *     TrickPlay --> ComponentName.Constants
+ *     TrickPlay --> ComponentName.SourceState#1
+ *     TrickPlay --> ComponentName.SourceState#2
+ *     SourceApi --> ComponentName.CoreEffects
+ *     SourceApi --> ComponentName.CoreStateAtoms
+ *     SourceApi --> ComponentName.Logger
+ *     SourceApi --> ComponentName.Utils
+ *     SourceApi --> ComponentName.Constants
+ *     SourcesApi --> ComponentName.Utils
+ *     SourcesApi --> ComponentName.CoreEffects
+ *     SourcesApi --> ComponentName.CoreStateAtoms
+ *     SourcesApi --> ComponentName.Logger
+ *     SourcesApi --> ComponentName.Constants
+ * ```
+ */
+import type { EmptyObject } from '../../../BaseTypes';
+import type { MyApi } from '../../../bundles/Types';
+import { ComponentName } from '../../Types';
+import type { Constants } from '../core/Constants';
+import type { CoreEffects, CoreStateAtoms } from '../core/Core.package';
+import type { TimeRange } from '../core/state/track/TrackAtom';
+import type { Logger } from '../core/utils/Logger';
+import type { CoreUtils } from '../core/utils/Types';
+import type { SourceStateAtom } from '../source/atoms/SourceStateAtom';
+type Dependencies = {
+    [ComponentName.Logger]: Logger;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [ComponentName.SourceState]: SourceStateAtom;
+    [ComponentName.CoreStateAtoms]: CoreStateAtoms;
+    [ComponentName.Utils]: CoreUtils;
+    [ComponentName.Constants]: Constants;
+};
+type Api = MyApi & {
+    play(): void;
+    pause(): void;
+    seek(target: number): void;
+    getSeekableRanges(): TimeRange[];
+};
+export declare const TrickPlayPackage: import("../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, Api>;
+export default TrickPlayPackage;

package/types/framework/player/bitmovin-v8-compat/BitmovinUi.package.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @packageDocumentation BitmovinUi.package
+ *
+ * Loads and applies Bitmovin player UI js library and styles. Then it connects it
+ * to the instance API.
+ *
+ * ### `BitmovinUi` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph BitmovinV8Core
+ *     AdditionalPlayerExports.UserConfig["UserConfig"]
+ *     AdditionalPlayerExports.Container["Container"]
+ *     AdditionalPlayerExports.PlayerApi["PlayerApi"]
+ *     end
+ *     BitmovinUi --> AdditionalPlayerExports.UserConfig
+ *     BitmovinUi --> AdditionalPlayerExports.PlayerApi
+ * ```
+ */
+import type { EmptyObject } from '../../../BaseTypes';
+import { AdditionalPlayerExports } from './enums/PlayerExports';
+import type { BitmovinV8PlayerApi, PlayerConfig } from './types/Types';
+type Dependencies = {
+    [AdditionalPlayerExports.UserConfig]: PlayerConfig;
+    [AdditionalPlayerExports.PlayerApi]: BitmovinV8PlayerApi;
+};
+export declare const BitmovinPlayerUiPackage: import("../../../../framework-types/package-api/Package").Package<Dependencies, EmptyObject, BitmovinV8PlayerApi>;
+export default BitmovinPlayerUiPackage;

package/types/framework/player/bitmovin-v8-compat/BitmovinV8Core.package.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @packageDocumentation BitmovinCore.package
+ *
+ * Provides core Bitmovin player v8 compatibility and interface. The package itself
+ * however does not extend the PWX features so other packages needs to be added
+ * to support certain features.
+ *
+ * ### `BitmovinV8Core` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph BitmovinV8Core
+ *     AdditionalPlayerExports.UserConfig["UserConfig"]
+ *     AdditionalPlayerExports.Container["Container"]
+ *     AdditionalPlayerExports.PlayerApi["PlayerApi"]
+ *     end
+ * ```
+ */
+import type { EmptyObject } from '../../../BaseTypes';
+import { AdditionalPlayerExports } from './enums/PlayerExports';
+import type { PlayerConfig } from './types/PlayerConfig';
+import type { BitmovinV8PlayerApi } from './types/Types';
+type Exports = {
+    [AdditionalPlayerExports.UserConfig]: PlayerConfig;
+    [AdditionalPlayerExports.Container]: HTMLElement;
+    [AdditionalPlayerExports.PlayerApi]: BitmovinV8PlayerApi;
+};
+export declare const createBitmovinV8PlayerCorePackage: (container: HTMLElement, userConfig: PlayerConfig, playerApi: BitmovinV8PlayerApi) => import("../../../../framework-types/package-api/Package").Package<EmptyObject, Exports, BitmovinV8PlayerApi>;
+export {};

package/types/framework/player/bitmovin-v8-compat/BitmovinV8StaticApi.package.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @packageDocumentation BitmovinStaticApi.package
+ *
+ * Adds Bitmovin player v8 API methods defined in `BitdashPlayerApi`. There are
+ * still quite some methods that are not supported at the moment so in that case
+ * they are returning some empty values for specific return types defined by
+ * the interface.
+ *
+ * ### `BitmovinV8StaticApi` Package Dependency Graph
+ * ```mermaid
+ * flowchart LR
+ *     subgraph BitmovinV8StaticApi
+ *     AdditionalPlayerExports.EventListenerAtom["EventListenerAtom"]
+ *     end
+ *     subgraph Core
+ *     ComponentName.Utils["Utils"]
+ *     ComponentName.Constants["Constants"]
+ *     ComponentName.CoreEffects["CoreEffects"]
+ *     ComponentName.PlayerConfig["PlayerConfig"]
+ *     ComponentName.CoreStateAtoms["CoreStateAtoms"]
+ *     end
+ *     subgraph BitmovinV8Core
+ *     AdditionalPlayerExports.UserConfig["UserConfig"]
+ *     AdditionalPlayerExports.Container["Container"]
+ *     AdditionalPlayerExports.PlayerApi["PlayerApi"]
+ *     end
+ *     BitmovinV8StaticApi --> ComponentName.Logger
+ *     BitmovinV8StaticApi --> ComponentName.CoreEffects
+ *     BitmovinV8StaticApi --> AdditionalPlayerExports.Container
+ *     BitmovinV8StaticApi --> AdditionalPlayerExports.UserConfig
+ * ```
+ */
+import type { ContextHaving, ContextUsing } from '../../../../framework-types/execution-context/Types';
+import type { BaseContext } from '../../../../framework-types/Types';
+import type { CoreEffects } from '../../core/core/Core.package';
+import type { StateEffect } from '../../core/core/state/state-effect/StateEffectFactory';
+import type { Logger } from '../../core/core/utils/Logger';
+import { ComponentName } from '../../Types';
+import { AdditionalPlayerExports } from './enums/PlayerExports';
+import type { EventListenerAtom } from './event-handling/EventListenerAtom';
+import type { PlayerConfig } from './types/PlayerConfig';
+import type { BitmovinV8PlayerApi } from './types/Types';
+type PlayerApiCompatDependencies = {
+    [ComponentName.Logger]: Logger;
+    [ComponentName.CoreEffects]: CoreEffects;
+    [AdditionalPlayerExports.Container]: HTMLElement;
+    [AdditionalPlayerExports.UserConfig]: PlayerConfig;
+};
+type PlayerApiCompatExports = {
+    [AdditionalPlayerExports.EventListenerAtom]: EventListenerAtom;
+};
+export type PlayerApiCompatContext = ContextHaving<PlayerApiCompatDependencies, PlayerApiCompatExports, ContextUsing<[StateEffect], BaseContext>>;
+export declare const BitmovinV8PlayerStaticApiPackage: import("../../../../framework-types/package-api/Package").Package<PlayerApiCompatDependencies, PlayerApiCompatExports, BitmovinV8PlayerApi>;
+export default BitmovinV8PlayerStaticApiPackage;

package/types/framework/player/bitmovin-v8-compat/apis/BufferApi.d.ts

@@ -0,0 +1,4 @@
+export declare const BufferApi: {
+    setTargetLevel(_type: unknown, _value: number, _media: unknown): void;
+    getLevel(_type: unknown, _media: unknown): null;
+};

package/types/framework/player/bitmovin-v8-compat/apis/DrmApi.d.ts

@@ -0,0 +1,3 @@
+export declare const DrmApi: {
+    renewLicense(_drmLicenseId: string): Promise<never>;
+};

package/types/framework/player/bitmovin-v8-compat/apis/ManifestApi.d.ts

@@ -0,0 +1,4 @@
+export declare const ManifestApi: {
+    dash: undefined;
+    hls: undefined;
+};

package/types/framework/player/bitmovin-v8-compat/apis/SubtitleApi.d.ts

@@ -0,0 +1,9 @@
+export declare const SubtitleApi: {
+    add(_subtitle: unknown): void;
+    remove(_subtitleId: unknown): void;
+    list(): never[];
+    enable(_id: unknown, _exclusive?: boolean): void;
+    disable(_id: unknown): void;
+    cueEnter(_cue: unknown): void;
+    cueExit(_cue: unknown): void;
+};