react-native-theoplayer 1.8.2 → 2.0.0

package/lib/typescript/api/track/TextTrack.d.ts

@@ -0,0 +1,100 @@
+import type { Track } from './Track';
+import type { TextTrackCue } from './TextTrackCue';
+export declare enum TextTrackType {
+    cea608 = "cea608",
+    id3 = "id3",
+    srt = "srt",
+    ttml = "ttml",
+    webvtt = "webvtt"
+}
+export declare enum TextTrackKind {
+    captions = "captions",
+    chapters = "chapters",
+    descriptions = "descriptions",
+    metadata = "metadata",
+    subtitles = "subtitles",
+    thumbnails = "thumbnails"
+}
+export declare enum TextTrackMode {
+    disabled = "disabled",
+    showing = "showing",
+    hidden = "hidden"
+}
+export interface TextTrack extends Track {
+    /**
+     * The kind of the text track, represented by a value from the following list:
+     * <br/> - `'subtitles'`: The track contains subtitles.
+     * <br/> - `'captions'`: The track contains closed captions, a translation of dialogue and sound effects.
+     * <br/> - `'descriptions'`: The track contains descriptions, a textual description of the video.
+     * <br/> - `'chapters'`: The track contains chapter titles.
+     * <br/> - `'metadata'`: The track contains metadata. This track will not serve display purposes.
+     */
+    readonly kind: TextTrackKind;
+    /**
+     * The label of the text track.
+     */
+    label: string;
+    /**
+     * The language of the text track.
+     */
+    readonly language: string;
+    /**
+     * The identifier of the text track.
+     *
+     * @remarks
+     * <br/> - This identifier can be used to distinguish between related tracks, e.g. tracks in the same list.
+     */
+    readonly id: string;
+    /**
+     * A unique identifier of the text track.
+     *
+     * @remarks
+     * <br/> - This identifier is unique across tracks of a THEOplayer instance and can be used to distinguish between tracks.
+     */
+    readonly uid: number;
+    /**
+     * The mode of the text track, represented by a value from the following list:
+     * <br/> - `'disabled'`: The track is disabled.
+     * <br/> - `'showing'`: The track is showing.
+     */
+    mode: TextTrackMode;
+    /**
+     * The content type of the text track.
+     */
+    readonly type: TextTrackType;
+    /**
+     * The list of cues of the track.
+     *
+     * @remarks
+     * <br/> - If the {@link TextTrack.mode} is `'disabled'`, this property is `null`.
+     */
+    cues: TextTrackCue[] | null;
+    /**
+     * The source of the text track.
+     */
+    readonly src: string;
+    /**
+     * Indicates whether the track contains Forced Narrative cues.
+     * This may only be true for subtitle tracks where
+     * <br/> - For DASH: the corresponding AdaptationSet contains a child Role with its value attribute equal to `'forced_subtitle'`
+     * <br/> - For HLS: the corresponding #EXT-X-MEDIA tag contains the attributes TYPE=SUBTITLES and FORCED=YES (not supported yet)
+     */
+    readonly forced: boolean;
+}
+/**
+ * Retain renderable tracks.
+ * https://html.spec.whatwg.org/multipage/embedded-content.html#text-track-showing
+ */
+export declare function filterRenderableTracks(textTracks: TextTrack[] | undefined): TextTrack[] | undefined;
+/**
+ * Retain first thumbnail track encountered in the textTracks list.
+ */
+export declare function filterThumbnailTracks(textTracks: TextTrack[] | undefined): TextTrack | undefined;
+/**
+ * Query whether a track is a valid thumbnail track.
+ */
+export declare function isThumbnailTrack(textTrack: TextTrack | undefined): boolean;
+export declare function hasTextTrackCue(textTrack: TextTrack, cue: TextTrackCue): boolean;
+export declare function removeTextTrackCue(textTrack: TextTrack, cue: TextTrackCue): void;
+export declare function addTextTrackCue(textTrack: TextTrack, cue: TextTrackCue): void;
+export declare function findTextTrackByUid(textTracks: TextTrack[], uid: number): TextTrack | undefined;

package/lib/typescript/api/track/TextTrackStyle.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The text track style API.
+ *
+ * @public
+ */
+export interface TextTrackStyle {
+    /**
+     * The font family for the text track.
+     */
+    fontFamily: string | undefined;
+    /**
+     * The font color for the text track.
+     *
+     * @example
+     * <br/> - `red` will set the color of the text to red.
+     * <br/> - `#ff0000` will set the color of the text to red.
+     * <br/> - `rgba(255,0,0,0.5)` will set the color of the text to red, with 50% opacity.
+     */
+    fontColor: string | undefined;
+    /**
+     * The font size for the text track.
+     *
+     * @remarks
+     * Can be a percentage value such as '50%', '75%', '100%', '150%' or '200%'.
+     */
+    fontSize: string | undefined;
+    /**
+     * The background color for the text track.
+     *
+     * @remarks
+     * This targets the area directly behind the text.
+     *
+     * @example
+     * <br/> - `red` will set the background color of the text track to red.
+     * <br/> - `#ff0000` will set the background color of the text track to red.
+     * <br/> - `rgba(255,0,0,0.5)` will set the background color of the text track to red, with 50% opacity.
+     */
+    backgroundColor: string | undefined;
+    /**
+     * The window color for the text track.
+     *
+     * @remarks
+     * This targets the area covering the full width of the text track.
+     *
+     * @example
+     * <br/> - `red` will set the background color of the window of the text track to red.
+     * <br/> - `#ff0000` will set the background color of the window of the text track to red.
+     * <br/> - `rgba(255,0,0,0.5)` will set the background color of the window of the text track to red, with 50% opacity.
+     */
+    windowColor: string | undefined;
+    /**
+     * The edge style of the text, represented by a value from the following list:
+     * <br/> - `'none'`
+     * <br/> - `'dropshadow'`
+     * <br/> - `'raised'`
+     * <br/> - `'depressed'`
+     * <br/> - `'uniform`
+     */
+    edgeStyle: EdgeStyle | undefined;
+}
+/**
+ * The style of the edge, represented by a value from the following list:
+ * <br/> - `'none'`
+ * <br/> - `'dropshadow'`
+ * <br/> - `'raised'`
+ * <br/> - `'depressed'`
+ * <br/> - `'uniform'`
+ *
+ * @public
+ */
+export declare type EdgeStyle = 'none' | 'dropshadow' | 'raised' | 'depressed' | 'uniform';

package/lib/typescript/api/track/Track.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Represents a track of a media resource.
+ *
+ * @remarks
+ * <br/> - A specific track type (e.g. {@link TextTrack}) will always be used.
+ *
+ * @public
+ */
+export interface Track {
+    /**
+     * The kind of the track.
+     *
+     * @remarks
+     * <br/> - The values for this property depend on the specific type of the track.
+     */
+    readonly kind: string;
+    /**
+     * The label of the track.
+     */
+    label: string;
+    /**
+     * The identifier of the track.
+     *
+     * @remarks
+     * <br/> - This identifier can be used to distinguish between related tracks, e.g. tracks in the same list.
+     *
+     * @privateRemarks
+     * <br/> - This identifier is a randomly generated string.
+     */
+    readonly id: string;
+    /**
+     * A unique identifier of the track.
+     *
+     * @remarks
+     * <br/> - This identifier is unique across tracks of a THEOplayer instance and can be used to distinguish between tracks.
+     * <br/> - This identifier is a randomly generated number.
+     */
+    readonly uid: number;
+    /**
+     * The language of the track.
+     */
+    readonly language: string;
+}
+export declare function hasTrack<TTrack extends Track>(trackList: TTrack[], track: TTrack): boolean;
+export declare function removeTrack<TTrack extends Track>(trackList: TTrack[], track: TTrack): TTrack[];
+export declare function addTrack<TTrack extends Track>(trackList: TTrack[], track: TTrack): TTrack[];

package/lib/typescript/api/track/barrel.d.ts

@@ -0,0 +1,6 @@
+export * from './MediaTrack';
+export * from './Quality';
+export * from './TextTrack';
+export * from './TextTrackCue';
+export * from './Track';
+export * from './TextTrackStyle';

package/lib/typescript/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api/barrel';
+export * from './ui/barrel';
+export { THEOplayerView } from './internal/THEOplayerView';
+export { ContentProtectionRegistry } from './internal/drm/ContentProtectionRegistry';

package/lib/typescript/internal/THEOplayerView.d.ts

@@ -0,0 +1,44 @@
+import React, { PureComponent } from 'react';
+import type { PlayerError, THEOplayerViewProps } from 'react-native-theoplayer';
+interface THEOplayerRCTViewState {
+    error?: PlayerError;
+}
+export declare class THEOplayerView extends PureComponent<React.PropsWithChildren<THEOplayerViewProps>, THEOplayerRCTViewState> {
+    private readonly _root;
+    private readonly _facade;
+    private static initialState;
+    constructor(props: THEOplayerViewProps);
+    componentWillUnmount(): void;
+    get nativeHandle(): number;
+    private reset;
+    private _onNativePlayerReady;
+    private _onSourceChange;
+    private _onLoadStart;
+    private _onLoadedData;
+    private _onLoadedMetadata;
+    private _onVolumeChange;
+    private _onError;
+    private _onProgress;
+    private _onCanPlay;
+    private _onPlay;
+    private _onPlaying;
+    private _onPause;
+    private _onSeeking;
+    private _onSeeked;
+    private _onWaiting;
+    private _onEnded;
+    private _onReadStateChange;
+    private _onTimeUpdate;
+    private _onDurationChange;
+    private _onRateChange;
+    private _onSegmentNotFound;
+    private _onTextTrackListEvent;
+    private _onTextTrackEvent;
+    private _onMediaTrackListEvent;
+    private _onMediaTrackEvent;
+    private _onAdEvent;
+    private _onCastEvent;
+    private _onPresentationModeChange;
+    render(): JSX.Element;
+}
+export {};

package/lib/typescript/internal/THEOplayerView.web.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { THEOplayerViewProps } from 'react-native-theoplayer';
+export declare function THEOplayerView(props: React.PropsWithChildren<THEOplayerViewProps>): JSX.Element;

package/lib/typescript/internal/adapter/NativePlayerState.d.ts

@@ -0,0 +1,27 @@
+import type { MediaTrack, PreloadType, PresentationMode, SourceDescription, TextTrack, TimeRange } from 'react-native-theoplayer';
+import type { BackgroundAudioConfiguration } from '../../api/backgroundAudio/BackgroundAudioConfiguration';
+import type { PiPConfiguration } from 'react-native-theoplayer';
+export interface NativePlayerState {
+    source: SourceDescription | undefined;
+    autoplay: boolean;
+    paused: boolean;
+    seekable: TimeRange[];
+    buffered: TimeRange[];
+    pipConfig: PiPConfiguration;
+    backgroundAudioConfig: BackgroundAudioConfiguration;
+    presentationMode: PresentationMode;
+    muted: boolean;
+    seeking: boolean;
+    volume: number;
+    currentTime: number;
+    duration: number;
+    playbackRate: number;
+    preload: PreloadType;
+    audioTracks: MediaTrack[];
+    videoTracks: MediaTrack[];
+    textTracks: TextTrack[];
+    targetVideoQuality: number | number[] | undefined;
+    selectedVideoTrack: number | undefined;
+    selectedAudioTrack: number | undefined;
+    selectedTextTrack: number | undefined;
+}

package/lib/typescript/internal/adapter/THEOplayerAdapter.d.ts

@@ -0,0 +1,73 @@
+import { DefaultEventDispatcher } from './event/DefaultEventDispatcher';
+import type { ABRConfiguration, AdsAPI, CastAPI, MediaTrack, NativeHandleType, PiPConfiguration, PlayerEventMap, SourceDescription, TextTrack, THEOplayer, THEOplayerView } from 'react-native-theoplayer';
+import { PreloadType, PresentationMode, TextTrackStyle } from 'react-native-theoplayer';
+import type { BackgroundAudioConfiguration } from 'src/api/backgroundAudio/BackgroundAudioConfiguration';
+import type { NativePlayerState } from './NativePlayerState';
+export declare class THEOplayerAdapter extends DefaultEventDispatcher<PlayerEventMap> implements THEOplayer {
+    private readonly _view;
+    private readonly _state;
+    private readonly _adsAdapter;
+    private readonly _castAdapter;
+    private readonly _abrAdapter;
+    private readonly _textTrackStyleAdapter;
+    constructor(view: THEOplayerView, initialState?: NativePlayerState);
+    private onSourceChange;
+    private onPause;
+    private onPlaying;
+    private onPresentationModeChange;
+    private onTimeupdate;
+    private onLoadedMetadata;
+    private onDurationChange;
+    private onRateChange;
+    private onSeeking;
+    private onSeeked;
+    private onProgress;
+    private onTextTrackList;
+    private onMediaTrack;
+    private onMediaTrackList;
+    get abr(): ABRConfiguration | undefined;
+    get ads(): AdsAPI;
+    set autoplay(autoplay: boolean);
+    get autoplay(): boolean;
+    set preload(type: PreloadType);
+    get preload(): PreloadType;
+    get seekable(): import("react-native-theoplayer").TimeRange[];
+    private seekableEnd;
+    get buffered(): import("react-native-theoplayer").TimeRange[];
+    get cast(): CastAPI;
+    get currentTime(): number;
+    set currentTime(currentTime: number);
+    get duration(): number;
+    get pipConfiguration(): PiPConfiguration;
+    set pipConfiguration(pipConfiguration: PiPConfiguration);
+    get backgroundAudioConfiguration(): BackgroundAudioConfiguration;
+    set backgroundAudioConfiguration(backgroundAudioConfiguration: BackgroundAudioConfiguration);
+    get presentationMode(): PresentationMode;
+    set presentationMode(presentationMode: PresentationMode);
+    get muted(): boolean;
+    set muted(muted: boolean);
+    get seeking(): boolean;
+    get paused(): boolean;
+    get playbackRate(): number;
+    set playbackRate(playbackRate: number);
+    get audioTracks(): MediaTrack[];
+    get selectedAudioTrack(): number | undefined;
+    set selectedAudioTrack(trackUid: number | undefined);
+    get videoTracks(): MediaTrack[];
+    get selectedVideoTrack(): number | undefined;
+    set selectedVideoTrack(trackUid: number | undefined);
+    get textTracks(): TextTrack[];
+    get selectedTextTrack(): number | undefined;
+    set selectedTextTrack(trackUid: number | undefined);
+    get textTrackStyle(): TextTrackStyle;
+    get source(): SourceDescription | undefined;
+    set source(source: SourceDescription | undefined);
+    get targetVideoQuality(): number | number[] | undefined;
+    set targetVideoQuality(target: number | number[] | undefined);
+    get volume(): number;
+    set volume(volume: number);
+    pause(): void;
+    play(): void;
+    get nativeHandle(): NativeHandleType;
+    initializeWithNativePlayerState_(state: NativePlayerState): void;
+}

package/lib/typescript/internal/adapter/THEOplayerWebAdapter.d.ts

@@ -0,0 +1,70 @@
+import { DefaultEventDispatcher } from './event/DefaultEventDispatcher';
+import type { AdsAPI, CastAPI, MediaTrack, NativeHandleType, PlayerEventMap, PreloadType, TextTrack, TextTrackStyle, THEOplayer, PlayerConfiguration } from 'react-native-theoplayer';
+import type * as THEOplayerWeb from 'theoplayer';
+import type { ABRConfiguration, SourceDescription } from 'src/api/barrel';
+import type { PiPConfiguration } from 'src/api/pip/PiPConfiguration';
+import type { BackgroundAudioConfiguration } from 'src/api/backgroundAudio/BackgroundAudioConfiguration';
+import { PresentationMode } from 'react-native-theoplayer';
+export declare class THEOplayerWebAdapter extends DefaultEventDispatcher<PlayerEventMap> implements THEOplayer {
+    private readonly _player;
+    private readonly _adsAdapter;
+    private readonly _castAdapter;
+    private readonly _eventForwarder;
+    private readonly _presentationModeManager;
+    private readonly _mediaSession;
+    private _targetVideoQuality;
+    private _backgroundAudioConfiguration;
+    private _pipConfiguration;
+    constructor(player: THEOplayerWeb.ChromelessPlayer, config?: PlayerConfiguration);
+    get abr(): ABRConfiguration | undefined;
+    get source(): SourceDescription | undefined;
+    set source(source: SourceDescription | undefined);
+    play(): void;
+    pause(): void;
+    get paused(): boolean;
+    get autoplay(): boolean;
+    set autoplay(autoplay: boolean);
+    set preload(type: PreloadType);
+    get preload(): PreloadType;
+    get seekable(): {
+        start: number;
+        end: number;
+    }[];
+    get buffered(): {
+        start: number;
+        end: number;
+    }[];
+    get playbackRate(): number;
+    set playbackRate(playbackRate: number);
+    get pipConfiguration(): PiPConfiguration;
+    set pipConfiguration(config: PiPConfiguration);
+    get backgroundAudioConfiguration(): BackgroundAudioConfiguration;
+    set backgroundAudioConfiguration(config: BackgroundAudioConfiguration);
+    get volume(): number;
+    set volume(volume: number);
+    get muted(): boolean;
+    set muted(muted: boolean);
+    get seeking(): boolean;
+    get presentationMode(): PresentationMode;
+    set presentationMode(presentationMode: PresentationMode);
+    get audioTracks(): MediaTrack[];
+    get videoTracks(): MediaTrack[];
+    get textTracks(): TextTrack[];
+    get selectedTextTrack(): number | undefined;
+    set selectedTextTrack(selectedTextTrack: number | undefined);
+    get textTrackStyle(): TextTrackStyle;
+    get selectedVideoTrack(): number | undefined;
+    set selectedVideoTrack(selectedVideoTrack: number | undefined);
+    get selectedAudioTrack(): number | undefined;
+    set selectedAudioTrack(selectedAudioTrack: number | undefined);
+    get targetVideoQuality(): number | number[] | undefined;
+    set targetVideoQuality(targetVideoQuality: number | number[] | undefined);
+    get currentTime(): number;
+    set currentTime(currentTime: number);
+    get duration(): number;
+    get ads(): AdsAPI;
+    get cast(): CastAPI;
+    destroy(): void;
+    get nativeHandle(): NativeHandleType;
+    private readonly onVisibilityChange;
+}

package/lib/typescript/internal/adapter/WebEventForwarder.d.ts

@@ -0,0 +1,52 @@
+import type * as THEOplayer from 'theoplayer';
+import type { THEOplayerWebAdapter } from './THEOplayerWebAdapter';
+export declare class WebEventForwarder {
+    private readonly _player;
+    private readonly _facade;
+    constructor(player: THEOplayer.ChromelessPlayer, facade: THEOplayerWebAdapter);
+    private addEventListeners;
+    unload(): void;
+    private removeEventListeners;
+    private readonly onSourceChange;
+    private readonly onLoadStart;
+    private readonly onLoadedData;
+    private readonly onLoadedMetadata;
+    private readonly onError;
+    private readonly onProgress;
+    private readonly onCanPlay;
+    private readonly onPlay;
+    private readonly onPlaying;
+    private readonly onPause;
+    private readonly onSeeking;
+    private readonly onSeeked;
+    private readonly onEnded;
+    private readonly onWaiting;
+    private readonly onReadyStateChanged;
+    private readonly onTimeUpdate;
+    private readonly onDurationChange;
+    private readonly onPlaybackRateChange;
+    private readonly onSegmentNotFound;
+    private readonly onVolumeChangeEvent;
+    private readonly onPresentationModeChange;
+    private readonly onAddTextTrack;
+    private readonly onRemoveTextTrack;
+    private readonly onChangeTextTrack;
+    private readonly onAddAudioTrack;
+    private readonly onAddVideoTrack;
+    private readonly onAddMediaTrack;
+    private readonly onRemoveAudioTrack;
+    private readonly onRemoveVideoTrack;
+    private readonly onRemoveMediaTrack;
+    private readonly onChangeAudioTrack;
+    private readonly onChangeVideoTrack;
+    private onChangeMediaTrack;
+    private readonly onChromecastStateChange;
+    private readonly onChromecastError;
+    private readonly onAirplayStateChange;
+    private readonly onAdEvent;
+    private readonly onAddTextTrackCue;
+    private readonly onRemoveTextTrackCue;
+    private readonly onEnterTextTrackCue;
+    private readonly onExitTextTrackCue;
+    private readonly onActiveQualityChanged;
+}

package/lib/typescript/internal/adapter/abr/AbrAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { ABRConfiguration, ABRStrategy, THEOplayerView } from 'react-native-theoplayer';
+export declare class AbrAdapter implements ABRConfiguration {
+    private readonly _view;
+    private _strategy;
+    private _targetBuffer;
+    constructor(view: THEOplayerView);
+    get strategy(): ABRStrategy | undefined;
+    set strategy(strategy: ABRStrategy | undefined);
+    get targetBuffer(): number | undefined;
+    set targetBuffer(targetBuffer: number | undefined);
+    private updateConfig;
+}

package/lib/typescript/internal/adapter/ads/THEOplayerNativeAdsAdapter.d.ts

@@ -0,0 +1,13 @@
+import type { Ad, AdBreak, AdDescription, AdsAPI, GoogleDAI, THEOplayerView } from 'react-native-theoplayer';
+export declare class THEOplayerNativeAdsAdapter implements AdsAPI {
+    private _player;
+    private readonly _dai;
+    constructor(_player: THEOplayerView);
+    playing(): Promise<boolean>;
+    skip(): void;
+    currentAdBreak(): Promise<AdBreak>;
+    currentAds(): Promise<Ad[]>;
+    scheduledAdBreaks(): Promise<AdBreak[]>;
+    schedule(ad: AdDescription): void;
+    get dai(): GoogleDAI | undefined;
+}

package/lib/typescript/internal/adapter/ads/THEOplayerNativeGoogleDAI.d.ts

@@ -0,0 +1,9 @@
+import type { GoogleDAI, THEOplayerView } from 'react-native-theoplayer';
+export declare class THEOplayerNativeGoogleDAI implements GoogleDAI {
+    private readonly _player;
+    constructor(_player: THEOplayerView);
+    get snapback(): Promise<boolean>;
+    setSnapback(enabled: boolean): void;
+    contentTimeForStreamTime(time: number): Promise<number>;
+    streamTimeForContentTime(time: number): Promise<number>;
+}

package/lib/typescript/internal/adapter/ads/THEOplayerWebAdsAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { Ad, AdBreak, AdDescription, AdsAPI, GoogleDAI } from 'react-native-theoplayer';
+import type * as THEOplayer from 'theoplayer';
+export declare class THEOplayerWebAdsAdapter implements AdsAPI {
+    private readonly _player;
+    private _dai;
+    constructor(player: THEOplayer.ChromelessPlayer);
+    currentAdBreak(): Promise<AdBreak>;
+    currentAds(): Promise<Ad[]>;
+    playing(): Promise<boolean>;
+    schedule(ad: AdDescription): void;
+    scheduledAdBreaks(): Promise<AdBreak[]>;
+    skip(): void;
+    get dai(): GoogleDAI | undefined;
+}

package/lib/typescript/internal/adapter/cast/THEOplayerNativeAirplay.d.ts

@@ -0,0 +1,15 @@
+import type { Airplay } from 'react-native-theoplayer';
+import { CastState, THEOplayer } from 'react-native-theoplayer';
+export declare class THEOplayerNativeAirplay implements Airplay {
+    private readonly _player;
+    private _casting;
+    private _state;
+    constructor(player: THEOplayer);
+    init_(): Promise<void>;
+    private readonly _onCastStateChange;
+    get casting(): boolean;
+    get state(): CastState;
+    start(): void;
+    stop(): void;
+    unload_(): void;
+}

package/lib/typescript/internal/adapter/cast/THEOplayerNativeCastAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { Airplay, CastAPI, Chromecast, THEOplayerView } from 'react-native-theoplayer';
+import type { THEOplayer } from 'react-native-theoplayer';
+export declare class THEOplayerNativeCastAdapter implements CastAPI {
+    private readonly _player;
+    private readonly _view;
+    private readonly _chromecast;
+    private readonly _airplay;
+    constructor(_player: THEOplayer, _view: THEOplayerView);
+    get casting(): boolean;
+    get chromecast(): Chromecast | undefined;
+    get airplay(): Airplay | undefined;
+    init_(): void;
+    unload_(): void;
+}

package/lib/typescript/internal/adapter/cast/THEOplayerNativeChromecast.d.ts

@@ -0,0 +1,18 @@
+import type { Chromecast, THEOplayerView } from 'react-native-theoplayer';
+import { CastState, THEOplayer } from 'react-native-theoplayer';
+export declare class THEOplayerNativeChromecast implements Chromecast {
+    private readonly _player;
+    private readonly _view;
+    private _casting;
+    private _state;
+    constructor(player: THEOplayer, view: THEOplayerView);
+    init_(): Promise<void>;
+    private readonly _onCastStateChange;
+    get casting(): boolean;
+    get state(): CastState;
+    start(): void;
+    stop(): void;
+    join(): void;
+    leave(): void;
+    unload_(): void;
+}

package/lib/typescript/internal/adapter/cast/THEOplayerWebCastAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { Airplay, CastAPI, Chromecast } from 'react-native-theoplayer';
+import type * as THEOplayer from 'theoplayer';
+export declare class THEOplayerWebCastAdapter implements CastAPI {
+    private readonly _player;
+    constructor(player: THEOplayer.ChromelessPlayer);
+    get casting(): boolean;
+    get chromecast(): Chromecast | undefined;
+    get airplay(): Airplay | undefined;
+}

package/lib/typescript/internal/adapter/event/BaseEvent.d.ts

@@ -0,0 +1,6 @@
+import type { Event } from 'react-native-theoplayer';
+export declare class BaseEvent<TType extends string = string> implements Event<TType> {
+    readonly type: TType;
+    readonly date: Date;
+    constructor(type: TType, date?: Date);
+}

package/lib/typescript/internal/adapter/event/DefaultEventDispatcher.d.ts

@@ -0,0 +1,9 @@
+import type { EventDispatcher, EventMap, StringKeyOf } from '../../../api/event/EventDispatcher';
+import type { EventListener } from '../../../api/event/EventListener';
+export declare class DefaultEventDispatcher<TMap extends EventMap<StringKeyOf<TMap>>> implements EventDispatcher<TMap> {
+    readonly _eventListeners: Map<StringKeyOf<TMap>, EventListener<TMap[StringKeyOf<TMap>]>[]>;
+    addEventListener<K extends StringKeyOf<TMap>>(type: K, listener: EventListener<TMap[K]>): void;
+    clearEventListeners(): void;
+    dispatchEvent: <K extends Extract<keyof TMap, string>>(event: TMap[K]) => void;
+    removeEventListener<K extends StringKeyOf<TMap>>(type: K, listener: EventListener<TMap[K]>): void;
+}