react-native-theoplayer 1.8.2 → 2.0.0

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

@@ -0,0 +1,99 @@
+import { BaseEvent } from './BaseEvent';
+import { Ad, AdBreak, AdEvent, AdEventType, AirplayStateChangeEvent, CastEventType, CastState, ChromecastChangeEvent, ChromecastError, ChromecastErrorEvent, DurationChangeEvent, ErrorEvent, LoadedMetadataEvent, MediaTrack, MediaTrackEvent, MediaTrackEventType, MediaTrackListEvent, MediaTrackType, PlayerError, PlayerEventType, PresentationMode, PresentationModeChangeContext, PresentationModeChangeEvent, ProgressEvent, Quality, RateChangeEvent, ReadyStateChangeEvent, SegmentNotFoundEvent, TextTrack, TextTrackCue, TextTrackEvent, TextTrackEventType, TextTrackListEvent, TimeRange, TimeUpdateEvent, TrackListEventType, VolumeChangeEvent } from 'react-native-theoplayer';
+export declare class DefaultLoadedMetadataEvent extends BaseEvent<PlayerEventType.LOADED_METADATA> implements LoadedMetadataEvent {
+    textTracks: TextTrack[];
+    audioTracks: MediaTrack[];
+    videoTracks: MediaTrack[];
+    duration: number;
+    selectedTextTrack: number | undefined;
+    selectedVideoTrack: number | undefined;
+    selectedAudioTrack: number | undefined;
+    constructor(textTracks: TextTrack[], audioTracks: MediaTrack[], videoTracks: MediaTrack[], duration: number, selectedTextTrack: number | undefined, selectedVideoTrack: number | undefined, selectedAudioTrack: number | undefined);
+}
+export declare class DefaultReadyStateChangeEvent extends BaseEvent<PlayerEventType.READYSTATE_CHANGE> implements ReadyStateChangeEvent {
+    readyState: number;
+    constructor(readyState: number);
+}
+export declare class DefaultPresentationModeChangeEvent extends BaseEvent<PlayerEventType.PRESENTATIONMODE_CHANGE> implements PresentationModeChangeEvent {
+    presentationMode: PresentationMode;
+    previousPresentationMode: PresentationMode;
+    context?: PresentationModeChangeContext | undefined;
+    constructor(presentationMode: PresentationMode, previousPresentationMode: PresentationMode, context?: PresentationModeChangeContext | undefined);
+}
+export declare class DefaultVolumeChangeEvent extends BaseEvent<PlayerEventType.VOLUME_CHANGE> implements VolumeChangeEvent {
+    volume: number;
+    muted: boolean;
+    constructor(volume: number, muted: boolean);
+}
+export declare class DefaultErrorEvent extends BaseEvent<PlayerEventType.ERROR> implements ErrorEvent {
+    error: PlayerError;
+    constructor(error: PlayerError);
+}
+export declare class DefaultProgressEvent extends BaseEvent<PlayerEventType.PROGRESS> implements ProgressEvent {
+    seekable: TimeRange[];
+    buffered: TimeRange[];
+    constructor(seekable: TimeRange[], buffered: TimeRange[]);
+}
+export declare class DefaultTimeupdateEvent extends BaseEvent<PlayerEventType.TIME_UPDATE> implements TimeUpdateEvent {
+    currentTime: number;
+    currentProgramDateTime?: number | undefined;
+    constructor(currentTime: number, currentProgramDateTime?: number | undefined);
+}
+export declare class DefaultDurationChangeEvent extends BaseEvent<PlayerEventType.DURATION_CHANGE> implements DurationChangeEvent {
+    duration: number;
+    constructor(duration: number);
+}
+export declare class DefaultRateChangeEvent extends BaseEvent<PlayerEventType.RATE_CHANGE> implements RateChangeEvent {
+    playbackRate: number;
+    constructor(playbackRate: number);
+}
+export declare class DefaultSegmentNotFoundEvent extends BaseEvent<PlayerEventType.SEGMENT_NOT_FOUND> implements SegmentNotFoundEvent {
+    readonly segmentStartTime: number;
+    error: string;
+    retryCount: number;
+    constructor(segmentStartTime: number, error: string, retryCount: number);
+}
+export declare class DefaultTextTrackListEvent extends BaseEvent<PlayerEventType.TEXT_TRACK_LIST> implements TextTrackListEvent {
+    subType: TrackListEventType;
+    track: TextTrack;
+    constructor(subType: TrackListEventType, track: TextTrack);
+}
+export declare class DefaultTextTrackEvent extends BaseEvent<PlayerEventType.TEXT_TRACK> implements TextTrackEvent {
+    subType: TextTrackEventType;
+    trackUid: number;
+    cue: TextTrackCue;
+    constructor(subType: TextTrackEventType, trackUid: number, cue: TextTrackCue);
+}
+export declare class DefaultMediaTrackListEvent extends BaseEvent<PlayerEventType.MEDIA_TRACK_LIST> implements MediaTrackListEvent {
+    subType: TrackListEventType;
+    trackType: MediaTrackType;
+    track: MediaTrack;
+    constructor(subType: TrackListEventType, trackType: MediaTrackType, track: MediaTrack);
+}
+export declare class DefaultMediaTrackEvent extends BaseEvent<PlayerEventType.MEDIA_TRACK> implements MediaTrackEvent {
+    subType: MediaTrackEventType;
+    trackType: MediaTrackType;
+    trackUid: number;
+    qualities?: Quality | Quality[] | undefined;
+    constructor(subType: MediaTrackEventType, trackType: MediaTrackType, trackUid: number, qualities?: Quality | Quality[] | undefined);
+}
+export declare class DefaultAdEvent extends BaseEvent<PlayerEventType.AD_EVENT> implements AdEvent {
+    subType: AdEventType;
+    ad: Ad | AdBreak;
+    constructor(subType: AdEventType, ad: Ad | AdBreak);
+}
+export declare class DefaultChromecastChangeEvent extends BaseEvent<PlayerEventType.CAST_EVENT> implements ChromecastChangeEvent {
+    state: CastState;
+    readonly subType: CastEventType.CHROMECAST_STATE_CHANGE;
+    constructor(state: CastState);
+}
+export declare class DefaultAirplayStateChangeEvent extends BaseEvent<PlayerEventType.CAST_EVENT> implements AirplayStateChangeEvent {
+    state: CastState;
+    readonly subType: CastEventType.AIRPLAY_STATE_CHANGE;
+    constructor(state: CastState);
+}
+export declare class DefaultChromecastErrorEvent extends BaseEvent<PlayerEventType.CAST_EVENT> implements ChromecastErrorEvent {
+    error: ChromecastError;
+    readonly subType: CastEventType.CHROMECAST_ERROR;
+    constructor(error: ChromecastError);
+}

package/lib/typescript/internal/adapter/event/native/NativeAdEvent.d.ts

@@ -0,0 +1,11 @@
+import type { Ad, AdBreak, AdEventType } from 'react-native-theoplayer';
+export interface NativeAdEvent {
+    /**
+     * Type of ad event.
+     */
+    type: AdEventType;
+    /**
+     * The ad or adbreak for which the event was dispatched.
+     */
+    ad: Ad | AdBreak;
+}

package/lib/typescript/internal/adapter/event/native/NativeCastEvent.d.ts

@@ -0,0 +1,15 @@
+import type { CastState, ChromecastError } from 'react-native-theoplayer';
+import type { CastEventType } from 'react-native-theoplayer';
+export declare type NativeCastEvent = NativeChromecastChangeEvent | NativeAirplayStateChangeEvent | NativeChromecastErrorEvent;
+export interface NativeChromecastChangeEvent {
+    readonly type: CastEventType.CHROMECAST_STATE_CHANGE;
+    readonly state: CastState;
+}
+export interface NativeAirplayStateChangeEvent {
+    readonly type: CastEventType.AIRPLAY_STATE_CHANGE;
+    readonly state: CastState;
+}
+export interface NativeChromecastErrorEvent {
+    readonly type: CastEventType.CHROMECAST_ERROR;
+    readonly error: ChromecastError;
+}

package/lib/typescript/internal/adapter/event/native/NativePlayerEvent.d.ts

@@ -0,0 +1,93 @@
+import type { MediaTrack, PlayerError, PresentationMode, PresentationModeChangeContext, TextTrack, TimeRange } from 'react-native-theoplayer';
+import type { NativePlayerState } from '../../NativePlayerState';
+export interface NativeErrorEvent {
+    error: PlayerError;
+}
+export interface NativeLoadedMetadataEvent {
+    textTracks: TextTrack[];
+    audioTracks: MediaTrack[];
+    videoTracks: MediaTrack[];
+    duration: number;
+    selectedTextTrack: number | undefined;
+    selectedVideoTrack: number | undefined;
+    selectedAudioTrack: number | undefined;
+}
+export interface NativeVolumeChangeEvent {
+    /**
+     * The player's current volume.
+     */
+    readonly volume: number;
+    /**
+     * The player's current mute state.
+     */
+    readonly muted: boolean;
+}
+export interface NativeTimeUpdateEvent {
+    /**
+     * The player's current time, in msecs.
+     */
+    readonly currentTime: number;
+    /**
+     * The player's current program date time, in msecs.
+     */
+    readonly currentProgramDateTime?: number;
+}
+export interface NativeDurationChangeEvent {
+    /**
+     * The player's new duration, in msecs.
+     */
+    readonly duration: number;
+}
+export interface NativeRateChangeEvent {
+    /**
+     * The player's new playbackRate.
+     */
+    readonly playbackRate: number;
+}
+export interface NativeReadyStateChangeEvent {
+    /**
+     * The player's new ready state.
+     */
+    readonly readyState: number;
+}
+export interface NativePresentationModeChangeEvent {
+    /**
+     * The player's new presentation mode.
+     */
+    readonly presentationMode: PresentationMode;
+    /**
+     * The player's previous presentationMode.
+     */
+    readonly previousPresentationMode: PresentationMode;
+    /**
+     * The context for presentationMode change.
+     */
+    readonly context?: PresentationModeChangeContext;
+}
+export interface NativeProgressEvent {
+    /**
+     * The ranges of the media resource that are seekable by the player.
+     */
+    readonly seekable: TimeRange[];
+    /**
+     * The ranges of the media resource that are buffered by the player.
+     */
+    readonly buffered: TimeRange[];
+}
+export interface NativeSegmentNotFoundEvent {
+    /**
+     * Start time of the segment.
+     */
+    readonly segmentStartTime: number;
+    /**
+     * Descriptive error message.
+     */
+    readonly error: string;
+    /**
+     * Number of times the segment was retried.
+     */
+    readonly retryCount: number;
+}
+export interface NativePlayerStateEvent {
+    readonly state: NativePlayerState;
+}

package/lib/typescript/internal/adapter/event/native/NativeTrackEvent.d.ts

@@ -0,0 +1,102 @@
+import type { MediaTrack, Quality, TextTrack, TextTrackCue } from 'react-native-theoplayer';
+import { MediaTrackEventType, MediaTrackType, TextTrackEventType, TrackListEventType } from 'react-native-theoplayer';
+export declare enum NativeTrackListEventType {
+    /**
+     * Dispatched when track has been added to the track list.
+     */
+    AddTrack = 0,
+    /**
+     * Dispatched when track has been removed from the track list.
+     */
+    RemoveTrack = 1,
+    /**
+     * Fired when a track has been changed.
+     */
+    ChangeTrack = 2
+}
+export interface NativeTrackListEvent {
+    /**
+     * The type of track list event.
+     */
+    readonly type: NativeTrackListEventType;
+}
+export interface NativeTextTrackListEvent extends NativeTrackListEvent {
+    /**
+     * The relevant text track.
+     */
+    readonly track: TextTrack;
+}
+export declare enum NativeTextTrackEventType {
+    /**
+     * Dispatched when cue has been added to the text track.
+     */
+    AddCue = 0,
+    /**
+     * Dispatched when cue has been removed from the text track.
+     */
+    RemoveCue = 1,
+    /**
+     * Dispatched when a cue of the track enters.
+     */
+    EnterCue = 2,
+    /**
+     * Dispatched when a cue of the track exits.
+     */
+    ExitCue = 3
+}
+export interface NativeTextTrackEvent {
+    /**
+     * The type of text track event.
+     */
+    readonly type: NativeTextTrackEventType;
+    /**
+     * The text track's uid to which this cue belongs.
+     */
+    readonly trackUid: number;
+    /**
+     * The text track's cue.
+     */
+    readonly cue: TextTrackCue;
+}
+export declare enum NativeMediaTrackType {
+    Audio = 0,
+    Video = 1
+}
+export interface NativeMediaTrackListEvent extends NativeTrackListEvent {
+    /**
+     * The relevant media track type, either {@link NativeMediaTrackType.Audio} or {@link NativeMediaTrackType.Video}.
+     */
+    readonly trackType: NativeMediaTrackType;
+    /**
+     * The relevant media track.
+     */
+    readonly track: MediaTrack;
+}
+export declare enum NativeMediaTrackEventType {
+    /**
+     * Dispatched when the media track's active quality changes.
+     */
+    ActiveQualityChanged = 0
+}
+export interface NativeMediaTrackEvent {
+    /**
+     * The type of media track event.
+     */
+    readonly type: NativeMediaTrackEventType;
+    /**
+     * The media track's type to which event belongs, either {@link MediaTrackType.Audio} or {@link MediaTrackType.Video}.
+     */
+    readonly trackType: NativeMediaTrackType;
+    /**
+     * The media track's uid to which event belongs.
+     */
+    readonly trackUid: number;
+    /**
+     * The affected media track's qualities.
+     */
+    readonly qualities?: Quality | Quality[];
+}
+export declare function toTrackListEventType(type: NativeTrackListEventType): TrackListEventType;
+export declare function toTextTrackEventType(type: NativeTextTrackEventType): TextTrackEventType;
+export declare function toMediaTrackType(type: NativeMediaTrackType): MediaTrackType;
+export declare function toMediaTrackTypeEventType(type: NativeMediaTrackEventType): MediaTrackEventType;

package/lib/typescript/internal/adapter/track/TextTrackStyleAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { EdgeStyle, TextTrackStyle, THEOplayerView } from 'react-native-theoplayer';
+export declare class TextTrackStyleAdapter implements TextTrackStyle {
+    private readonly _player;
+    constructor(_player: THEOplayerView);
+    get backgroundColor(): string | undefined;
+    set backgroundColor(_: string | undefined);
+    get edgeStyle(): EdgeStyle | undefined;
+    set edgeStyle(_: EdgeStyle | undefined);
+    get fontColor(): string | undefined;
+    set fontColor(_: string | undefined);
+    get fontFamily(): string | undefined;
+    set fontFamily(_: string | undefined);
+    get fontSize(): string | undefined;
+    set fontSize(_: string | undefined);
+    get windowColor(): string | undefined;
+    set windowColor(_: string | undefined);
+}

package/lib/typescript/internal/adapter/web/TrackUtils.d.ts

@@ -0,0 +1,9 @@
+import type { MediaTrack as NativeMediaTrack, MediaTrackList as NativeMediaTrackList, Quality as NativeQuality, TextTrack as NativeTextTrack, TextTrackCue as NativeTextTrackCue, TextTracksList as NativeTextTrackList } from 'theoplayer';
+import type { MediaTrack, TextTrack, TextTrackCue } from 'react-native-theoplayer';
+export declare function fromNativeCue(cue: NativeTextTrackCue): TextTrackCue;
+export declare function fromNativeTextTrackList(tracks: NativeTextTrackList): TextTrack[];
+export declare function fromNativeTextTrack(track: NativeTextTrack): TextTrack;
+export declare function fromNativeMediaTrackList(tracks: NativeMediaTrackList): MediaTrack[];
+export declare function fromNativeMediaTrack(track: NativeMediaTrack): MediaTrack;
+export declare function findNativeQualityByUid(mediaTrack: NativeMediaTrack, uid: number | undefined): NativeQuality | undefined;
+export declare function findNativeQualitiesByUid(mediaTrack: NativeMediaTrack | undefined, uid: number | number[] | undefined): NativeQuality[] | undefined;

package/lib/typescript/internal/adapter/web/WebMediaSession.d.ts

@@ -0,0 +1,33 @@
+import type { ChromelessPlayer } from 'theoplayer';
+import type { THEOplayerWebAdapter } from '../THEOplayerWebAdapter';
+interface WebMediaSessionConfig {
+    skipTime: number;
+}
+export declare const defaultWebMediaSessionConfig: WebMediaSessionConfig;
+/**
+ * The MediaSession interface of the Media Session API allows a web page to provide custom behaviors for standard media playback interactions, and
+ * to report metadata that can be sent by the user agent to the device or operating system for presentation in standardized user interface elements.
+ *
+ * @link https://w3c.github.io/mediasession
+ */
+export declare class WebMediaSession {
+    private readonly _config;
+    private readonly _player;
+    private readonly _webAdapter;
+    constructor(adapter: THEOplayerWebAdapter, player: ChromelessPlayer, config?: WebMediaSessionConfig);
+    updateActionHandlers(): void;
+    destroy(): void;
+    private onSourceChange;
+    private onLoadedMetadata;
+    private onDurationChange;
+    private updateMetadata;
+    private updatePositionState;
+    private onAdbreakBegin;
+    private onAdbreakEnd;
+    private isLive;
+    private isAd;
+    private isInBackground;
+    private isTrickplayEnabled;
+    private isPlayPauseEnabled;
+}
+export {};

package/lib/typescript/internal/adapter/web/WebPresentationModeManager.d.ts

@@ -0,0 +1,15 @@
+import type { PlayerEventMap } from 'react-native-theoplayer';
+import { PresentationMode } from 'react-native-theoplayer';
+import type * as THEOplayerWeb from 'theoplayer';
+import type { DefaultEventDispatcher } from '../event/DefaultEventDispatcher';
+export declare class WebPresentationModeManager {
+    private readonly _player;
+    private _presentationMode;
+    private _element;
+    private _eventForwarder;
+    constructor(player: THEOplayerWeb.ChromelessPlayer, eventForwarder: DefaultEventDispatcher<PlayerEventMap>);
+    get presentationMode(): PresentationMode;
+    set presentationMode(presentationMode: PresentationMode);
+    private prepareForPresentationModeChanges;
+    private updatePresentationMode;
+}

package/lib/typescript/internal/utils/arrayUtil.d.ts

@@ -0,0 +1,2 @@
+export declare function arrayRemoveElement<T>(array: T[], element: T): boolean;
+export declare function arrayRemoveAt<T>(array: T[], index: number): void;

package/lib/typescript/ui/THEOplayerDefaultUi.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+import { PlayerConfiguration, THEOplayer } from 'react-native-theoplayer';
+import { THEOplayerTheme } from './THEOplayerTheme';
+import { StyleProp, ViewStyle } from 'react-native';
+export interface THEOplayerDefaultUiProps {
+    /**
+     * The style for the container.
+     */
+    style?: StyleProp<ViewStyle>;
+    /**
+     * The theme for all components.
+     */
+    theme?: Partial<THEOplayerTheme>;
+    /**
+     * The player configuration with THEOplayer license.
+     */
+    config?: PlayerConfiguration;
+    /**
+     * The callback that is called when the internal THEOplayer is created.
+     * @param player the internal THEOplayer
+     */
+    onPlayerReady?: (player: THEOplayer) => void;
+    /**
+     * A slot in the top right to add additional UI components.
+     */
+    topSlot?: ReactNode;
+    /**
+     * A slot in the bottom right to add additional UI components.
+     */
+    bottomSlot?: ReactNode;
+}
+/**
+ * A default UI layout which uses UI components from `react-native-theoplayer` to create a basic playback UI around a THEOplayerView.
+ */
+export declare function THEOplayerDefaultUi(props: THEOplayerDefaultUiProps): JSX.Element;

package/lib/typescript/ui/THEOplayerTheme.d.ts

@@ -0,0 +1,84 @@
+import type { TextStyle } from 'react-native';
+/**
+ * The theme colors.
+ */
+export interface ColorTheme {
+    /**
+     * The color of the UI background.
+     */
+    uiBackground: string;
+    /**
+     * The color of the error display background.
+     */
+    errorBackground: string;
+    /**
+     * The color of the SVG icons.
+     */
+    icon: string;
+    /**
+     * The color of the SVG icons when they are selected.
+     */
+    iconSelected: string;
+    /**
+     * The color of the text components.
+     */
+    text: string;
+    /**
+     * The color of the text components when they are selected.
+     */
+    textSelected: string;
+    /**
+     * The color of the text component background when it is selected.
+     */
+    textSelectedBackground: string;
+    /**
+     * The color of the left side of the seek bar.
+     */
+    seekBarMinimum: string;
+    /**
+     * The color of the right side of the seek bar.
+     */
+    seekBarMaximum: string;
+    /**
+     * The color of the dot on the seek bar.
+     */
+    seekBarDot: string;
+}
+/**
+ * The dimensions of various UI components.
+ */
+export interface Dimensions {
+    /**
+     * The height of the center control bar.
+     */
+    centerControlBarHeight: number;
+    /**
+     * The height of all other control bars.
+     */
+    controlBarHeight: number;
+}
+/**
+ * The theme used by `react-native-theoplayer` UI components.
+ */
+export interface THEOplayerTheme {
+    /**
+     * The theme colors.
+     */
+    colors: ColorTheme;
+    /**
+     * The styling for all text components.
+     */
+    text: TextStyle;
+    /**
+     * The amount of time after a user action where UI animations will resume.
+     */
+    fadeAnimationTimoutMs: number;
+    /**
+     * The dimensions of various UI components.
+     */
+    dimensions: Dimensions;
+}
+/**
+ * The default theme for the UI.
+ */
+export declare const DEFAULT_THEOPLAYER_THEME: THEOplayerTheme;

package/lib/typescript/ui/barrel.d.ts

@@ -0,0 +1,3 @@
+export * from './THEOplayerDefaultUi';
+export * from './THEOplayerTheme';
+export * from './components/barrel';

package/lib/typescript/ui/components/activityindicator/CenteredDelayedActivityIndicator.d.ts

@@ -0,0 +1,25 @@
+import { PureComponent } from 'react';
+import type { DelayedActivityIndicatorProps } from './DelayedActivityIndicator';
+import { PlayerError } from 'react-native-theoplayer';
+interface CenteredDelayedActivityIndicatorState {
+    showLoadingIndicator: boolean;
+    error: PlayerError | undefined;
+}
+/**
+ * The default spinner for the `react-native-theoplayer` UI. It renders a ActivityIndicator when the player's playback is stalling due
+ * readystate changes.
+ */
+export declare class CenteredDelayedActivityIndicator extends PureComponent<DelayedActivityIndicatorProps, CenteredDelayedActivityIndicatorState> {
+    private static initialState;
+    constructor(props: DelayedActivityIndicatorProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onReadyStateChange;
+    private onError;
+    private onPlaying;
+    private onSourceChange;
+    private onLoadStart;
+    private maybeShowLoadingIndicator;
+    render(): false | JSX.Element;
+}
+export {};

package/lib/typescript/ui/components/activityindicator/DelayedActivityIndicator.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { ActivityIndicatorProps } from 'react-native';
+export interface DelayedActivityIndicatorProps extends ActivityIndicatorProps {
+    delay?: number;
+}
+/**
+ * The DelayedActivityIndicator renders a native ActivityIndicator after a certain delay.
+ */
+export declare const DelayedActivityIndicator: (props: DelayedActivityIndicatorProps) => JSX.Element;

package/lib/typescript/ui/components/activityindicator/barrel.d.ts

@@ -0,0 +1,2 @@
+export * from './CenteredDelayedActivityIndicator';
+export * from './DelayedActivityIndicator';

package/lib/typescript/ui/components/barrel.d.ts

@@ -0,0 +1,9 @@
+export * from './activityindicator/barrel';
+export * from './button/barrel';
+export * from './controlbar/barrel';
+export * from './menu/barrel';
+export * from './message/barrel';
+export * from './seekbar/barrel';
+export * from './timelabel/barrel';
+export * from './uicontroller/barrel';
+export * from './util/barrel';

package/lib/typescript/ui/components/button/AirplayButton.d.ts

@@ -0,0 +1,18 @@
+import { PureComponent } from 'react';
+import { CastState } from './../../../api/barrel';
+interface CastButtonState {
+    castState: CastState;
+}
+/**
+ * The default button to enable Airplay for the `react-native-theoplayer` UI.
+ */
+export declare class AirplayButton extends PureComponent<unknown, CastButtonState> {
+    private static initialState;
+    constructor(props: unknown);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onCastStateChangeEvent;
+    private onUIAirplayToggled;
+    render(): JSX.Element;
+}
+export {};

package/lib/typescript/ui/components/button/ChromecastButton.d.ts

@@ -0,0 +1,19 @@
+import { PureComponent } from 'react';
+import { CastState } from 'react-native-theoplayer';
+interface CastButtonState {
+    connected: boolean;
+}
+export declare function isConnected(state: CastState | undefined): boolean;
+/**
+ * The native button to enable Chromecast for the `react-native-theoplayer` UI.
+ * This component uses the button from `react-native-google-cast` and is not supported on web.
+ */
+export declare class ChromecastButton extends PureComponent<unknown, CastButtonState> {
+    private static initialState;
+    constructor(props: unknown);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onCastStateChangeEvent;
+    render(): JSX.Element;
+}
+export {};

package/lib/typescript/ui/components/button/ChromecastButton.web.d.ts

@@ -0,0 +1,19 @@
+import { CastState } from './../../../api/barrel';
+import { PureComponent } from 'react';
+interface CastButtonState {
+    castState: CastState;
+}
+export declare function isConnected(state: CastState | undefined): boolean;
+/**
+ * The button to enable Chromecast for web for the `react-native-theoplayer` UI
+ */
+export declare class ChromecastButton extends PureComponent<unknown, CastButtonState> {
+    private static initialState;
+    constructor(props: unknown);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onCastStateChangeEvent;
+    private onPress;
+    render(): JSX.Element;
+}
+export {};

package/lib/typescript/ui/components/button/FullscreenButton.d.ts

@@ -0,0 +1,17 @@
+import { PureComponent } from 'react';
+import { PresentationMode } from 'react-native-theoplayer';
+interface FullscreenButtonState {
+    presentationMode: PresentationMode;
+}
+/**
+ * The button to enable/disable fullscreen for the `react-native-theoplayer` UI.
+ */
+export declare class FullscreenButton extends PureComponent<unknown, FullscreenButtonState> {
+    constructor(props: unknown);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private readonly onPresentationModeChange;
+    private toggleFullScreen;
+    render(): JSX.Element;
+}
+export {};