import { SharedObject } from 'expo';
import { VideoPlayerEvents } from './VideoPlayerEvents.types';
import { VideoThumbnail } from './VideoThumbnail';
/**
 * A class that represents an instance of the video player.
 */
export declare class VideoPlayer extends SharedObject<VideoPlayerEvents> {
    /**
     * Boolean value whether the player is currently playing.
     * > Use `play` and `pause` methods to control the playback.
     */
    readonly playing: boolean;
    /**
     * Determines whether the player should automatically replay after reaching the end of the video.
     * @default false
     */
    loop: boolean;
    /**
     * Determines whether the player should allow external playback.
     * @default true
     * @platform ios
     */
    allowsExternalPlayback: boolean;
    /**
     * Determines how the player will interact with other audio playing in the system.
     *
     * @default 'auto'
     * @platform android
     * @platform ios
     */
    audioMixingMode: AudioMixingMode;
    /**
     * Boolean value whether the player is currently muted.
     * Setting this property to `true`/`false` will mute/unmute the player.
     * @default false
     */
    muted: boolean;
    /**
     * Float value indicating the current playback time in seconds.
     *
     * If the player is not yet playing, this value indicates the time position
     * at which playback will begin once the `play()` method is called.
     *
     * Setting `currentTime` to a new value seeks the player to the given time.
     * Note that frame accurate seeking may incur additional decoding delay which can impact seeking performance.
     * Consider using the [`seekBy`](#seekbyseconds) function if the time does not have to be set precisely.
     */
    currentTime: number;
    /**
     * The exact timestamp when the currently displayed video frame was sent from the server,
     * based on the `EXT-X-PROGRAM-DATE-TIME` tag in the livestream metadata.
     * If this metadata is missing, this property will return `null`.
     * @platform android
     * @platform ios
     */
    readonly currentLiveTimestamp: number | null;
    /**
     * Float value indicating the latency of the live stream in seconds.
     * If a livestream doesn't have the required metadata, this will return `null`.
     * @platform android
     * @platform ios
     */
    readonly currentOffsetFromLive: number | null;
    /**
     * Float value indicating the time offset from the live in seconds.
     * @platform ios
     */
    targetOffsetFromLive: number;
    /**
     * Float value indicating the duration of the current video in seconds.
     */
    readonly duration: number;
    /**
     * Float value between `0` and `1.0` representing the current volume.
     * Muting the player doesn't affect the volume. In other words, when the player is muted, the volume is the same as
     * when unmuted. Similarly, setting the volume doesn't unmute the player.
     * @default 1.0
     */
    volume: number;
    /**
     * Boolean value indicating if the player should correct audio pitch when the playback speed changes.
     * @default true
     */
    preservesPitch: boolean;
    /**
     * Float value indicating the interval in seconds at which the player will emit the [`timeUpdate`](#videoplayerevents) event.
     * When the value is equal to `0`, the event will not be emitted.
     *
     * @default 0
     */
    timeUpdateEventInterval: number;
    /**
     * Float value between `0` and `16.0` indicating the current playback speed of the player.
     * @default 1.0
     */
    playbackRate: number;
    /**
     * Boolean value indicating whether the player is currently playing a live stream.
     */
    readonly isLive: boolean;
    /**
     * Indicates the current status of the player.
     */
    readonly status: VideoPlayerStatus;
    /**
     * Boolean value determining whether the player should show the now playing notification.
     *
     * @default false
     * @platform android
     * @platform ios
     */
    showNowPlayingNotification: boolean;
    /**
     * Determines whether the player should continue playing after the app enters the background.
     * @default false
     * @platform ios
     * @platform android
     */
    staysActiveInBackground: boolean;
    /**
     * Float value indicating how far the player has buffered the video in seconds.
     *
     * This value is 0 when the player has not buffered up to the current playback time.
     * When it's impossible to determine the buffer state (for example, when the player isn't playing any media), this value is -1.
     */
    readonly bufferedPosition: number;
    /**
     * Specifies buffer options which will be used by the player when buffering the video.
     *
     * > You should provide a `BufferOptions` object when setting this property. Setting individual buffer properties is not supported.
     * @platform android
     * @platform ios
     */
    bufferOptions: BufferOptions;
    /**
     * Specifies the subtitle track which is currently displayed by the player. `null` when no subtitles are displayed.
     *
     * > To ensure a valid subtitle track, always assign one of the subtitle tracks from the [`availableSubtitleTracks`](#availablesubtitletracks) array.
     *
     * @default null
     * @platform android
     * @platform ios
     */
    subtitleTrack: SubtitleTrack | null;
    /**
     * Specifies the audio track currently played by the player. `null` when no audio is played.
     *
     * @default null
     * @platform android
     * @platform ios
     */
    audioTrack: AudioTrack | null;
    /**
     * An array of audio tracks available for the current video.
     *
     * @platform android
     * @platform ios
     */
    readonly availableAudioTracks: AudioTrack[];
    /**
     * An array of subtitle tracks available for the current video.
     *
     * @platform android
     * @platform ios
     */
    readonly availableSubtitleTracks: SubtitleTrack[];
    /**
     * Specifies the video track currently played by the player. `null` when no video is displayed.
     *
     * @default null
     * @platform android
     * @platform ios
     */
    readonly videoTrack: VideoTrack | null;
    /**
     * An array of video tracks available for the current video.
     *
     * > On iOS, when using a HLS source, make sure that the uri contains `.m3u8` extension or that the [`contentType`](#contenttype) property of the [`VideoSource`](#videosource) has been set to `'hls'`. Otherwise, the video tracks will not be available.
     *
     * @platform android
     * @platform ios
     */
    readonly availableVideoTracks: VideoTrack[];
    /**
     * Initializes a new video player instance with the given source.
     *
     * @param source The source of the video to be played.
     * @param useSynchronousReplace Optional parameter, when `true` `source` from the first parameter will be loaded on the main thread.
     * @hidden
     */
    constructor(source: VideoSource, useSynchronousReplace?: boolean);
    /**
     * Resumes the player.
     */
    play(): void;
    /**
     * Pauses the player.
     */
    pause(): void;
    /**
     * Replaces the current source with a new one.
     *
     * > On iOS, this method loads the asset data synchronously on the UI thread and can block it for extended periods of time.
     * > Use `replaceAsync` to load the asset asynchronously and avoid UI lags.
     *
     * > This method will be deprecated in the future.
     */
    replace(source: VideoSource, disableWarning?: boolean): void;
    /**
     * Replaces the current source with a new one, while offloading loading of the asset to a different thread.
     *
     * > On Android and Web, this method is equivalent to `replace`.
     */
    replaceAsync(source: VideoSource): Promise<void>;
    /**
     * Seeks the playback by the given number of seconds. The time to which the player seeks may differ from the specified requested time for efficiency,
     * depending on the encoding and what is currently buffered by the player. Use this function to implement playback controls that seek by specific amount of time,
     * in which case, the actual time usually does not have to be precise. For frame accurate seeking, use the [`currentTime`](#currenttime) property.
     */
    seekBy(seconds: number): void;
    /**
     * Seeks the playback to the beginning.
     */
    replay(): void;
    /**
     * Generates thumbnails from the currently played asset. The thumbnails are references to native images,
     * thus they can be used as a source of the `Image` component from `expo-image`.
     * @platform android
     * @platform ios
     */
    generateThumbnailsAsync(times: number | number[], options?: VideoThumbnailOptions): Promise<VideoThumbnail[]>;
}
/**
 * Additional options for video thumbnails generation.
 */
export type VideoThumbnailOptions = {
    /**
     * If provided, the generated thumbnail will not exceed this width in pixels, preserving its aspect ratio.
     * @platform android
     * @platform ios
     */
    maxWidth?: number;
    /**
     * If provided, the generated thumbnail will not exceed this height in pixels, preserving its aspect ratio.
     * @platform android
     * @platform ios
     */
    maxHeight?: number;
};
/**
 * Describes the current status of the player.
 * - `idle`: The player is not playing or loading any videos.
 * - `loading`: The player is loading video data from the provided source
 * - `readyToPlay`: The player has loaded enough data to start playing or to continue playback.
 * - `error`: The player has encountered an error while loading or playing the video.
 */
export type VideoPlayerStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';
export type VideoSource = string | number | null | {
    /**
     * The URI of the video.
     *
     * This property is exclusive with the `assetId` property. When both are present, the `assetId` will be ignored.
     */
    uri?: string;
    /**
     * The asset ID of a local video asset, acquired with the `require` function.
     * This property is exclusive with the `uri` property. When both are present, the `assetId` will be ignored.
     */
    assetId?: number;
    /**
     * Specifies the DRM options which will be used by the player while loading the video.
     */
    drm?: DRMOptions;
    /**
     * Specifies information which will be displayed in the now playing notification.
     * When undefined the player will display information contained in the video metadata.
     * @platform android
     * @platform ios
     */
    metadata?: VideoMetadata;
    /**
     * Specifies headers sent with the video request.
     * > For DRM license headers use the `headers` field of [`DRMOptions`](#drmoptions).
     * @platform android
     * @platform ios
     */
    headers?: Record<string, string>;
    /**
     * Specifies whether the player should use caching for the video.
     * > Due to platform limitations, the cache cannot be used with HLS video sources on iOS. Caching DRM-protected videos is not supported on Android and iOS.
     * @default false
     * @platform android
     * @platform ios
     */
    useCaching?: boolean;
    /**
     * Specifies the content type of the video source. When set to `'auto'`, the player will try to automatically determine the content type.
     *
     * You should use this property when playing HLS, SmoothStreaming or DASH videos from an uri, which does not contain a standardized extension for the corresponding media type.
     * @default 'auto'
     * @platform android
     * @platform ios
     */
    contentType?: ContentType;
};
/**
 * Contains information about any errors that the player encountered during the playback
 */
export type PlayerError = {
    message: string;
};
/**
 * Contains information that will be displayed in the now playing notification when the video is playing.
 * @platform android
 * @platform ios
 */
export type VideoMetadata = {
    /**
     * The title of the video.
     * @platform android
     * @platform ios
     */
    title?: string;
    /**
     * Secondary text that will be displayed under the title.
     * @platform android
     * @platform ios
     */
    artist?: string;
    /**
     * The uri of the video artwork.
     * @platform android
     * @platform ios
     */
    artwork?: string;
};
/**
 * Specifies which type of DRM to use:
 * - Android supports ClearKey, PlayReady and Widevine.
 * - iOS supports FairPlay.
 */
export type DRMType = 'clearkey' | 'fairplay' | 'playready' | 'widevine';
/**
 * Specifies DRM options which will be used by the player while loading the video.
 */
export type DRMOptions = {
    /**
     * Determines which type of DRM to use.
     */
    type: DRMType;
    /**
     * Determines the license server URL.
     */
    licenseServer: string;
    /**
     * Determines headers sent to the license server on license requests.
     */
    headers?: Record<string, string>;
    /**
     * Specifies whether the DRM is a multi-key DRM.
     * @platform android
     */
    multiKey?: boolean;
    /**
     * Specifies the content ID of the stream.
     * @platform ios
     */
    contentId?: string;
    /**
     * Specifies the certificate URL for the FairPlay DRM.
     * @platform ios
     */
    certificateUrl?: string;
    /**
     * Specifies the base64 encoded certificate data for the FairPlay DRM.
     * When this property is set, the `certificateUrl` property is ignored.
     * @platform ios
     */
    base64CertificateData?: string;
};
/**
 * Specifies buffer options which will be used by the player when buffering the video.
 *
 * @platform android
 * @platform ios
 */
export type BufferOptions = {
    /**
     * The duration in seconds which determines how much media the player should buffer ahead of the current playback time.
     *
     * On iOS when set to `0` the player will automatically decide appropriate buffer duration.
     *
     * Equivalent to [`AVPlayerItem.preferredForwardBufferDuration`](https://developer.apple.com/documentation/avfoundation/avplayeritem/1643630-preferredforwardbufferduration).
     * @default Android: 20, iOS: 0
     * @platform android
     * @platform ios
     */
    readonly preferredForwardBufferDuration?: number;
    /**
     * A Boolean value that indicates whether the player should automatically delay playback in order to minimize stalling.
     *
     * Equivalent to [`AVPlayer.automaticallyWaitsToMinimizeStalling`](https://developer.apple.com/documentation/avfoundation/avplayer/1643482-automaticallywaitstominimizestal).
     * @default true
     * @platform ios
     */
    readonly waitsToMinimizeStalling?: boolean;
    /**
     * Minimum duration of the buffer in seconds required to continue playing after the player has been paused or started buffering.
     *
     * > This property will be ignored if `preferredForwardBufferDuration` is lower.
     * @default 2
     * @platform android
     */
    readonly minBufferForPlayback?: number;
    /**
     * The maximum number of bytes that the player can buffer from the network.
     * When 0 the player will automatically decide appropriate buffer size.
     *
     * @default 0
     * @platform android
     */
    readonly maxBufferBytes?: number | null;
    /**
     * A Boolean value which determines whether the player should prioritize time over size when buffering media.
     *
     * @default false
     * @platform android
     */
    readonly prioritizeTimeOverSizeThreshold?: boolean;
};
/**
 * Specifies the content type of the source.
 *
 * - `auto`: The player will automatically determine the content type of the video.
 * - `progressive`: The player will use progressive download content type. This is the default `ContentType` when the uri does not contain an extension.
 * - `hls`: The player will use HLS content type.
 * - `dash`: The player will use DASH content type (Android-only).
 * - `smoothStreaming`: The player will use SmoothStreaming content type (Android-only).
 *
 * @default `auto`
 */
export type ContentType = 'auto' | 'progressive' | 'hls' | 'dash' | 'smoothStreaming';
/**
 * Specifies the audio mode that the player should use. Audio mode is set on per-app basis, if there are multiple players playing and
 * have different a `AudioMode` specified, the highest priority mode will be used. Priority order: 'doNotMix' > 'auto' > 'duckOthers' > 'mixWithOthers'.
 *
 * - `mixWithOthers`: The player will mix its audio output with other apps.
 * - `duckOthers`: The player will lower the volume of other apps if any of the active players is outputting audio.
 * - `auto`: The player will allow other apps to keep playing audio only when it is muted. On iOS it will always interrupt other apps when `showNowPlayingNotification` is `true` due to system requirements.
 * - `doNotMix`: The player will pause playback in other apps, even when it's muted.
 *
 * > On iOS, the Now Playing notification is dependent on the audio mode. If the audio mode is different from `doNotMix` or `auto` this feature will not work.
 */
export type AudioMixingMode = 'mixWithOthers' | 'duckOthers' | 'auto' | 'doNotMix';
export type SubtitleTrack = {
    /**
     * A string used by `expo-video` to identify the subtitle track.
     *
     * @platform android
     */
    id: string;
    /**
     * Language of the subtitle track. For example, `en`, `pl`, `de`.
     */
    language: string;
    /**
     * Label of the subtitle track in the language of the device.
     */
    label: string;
};
/**
 * Specifies a VideoTrack loaded from a [`VideoSource`](#videosource).
 */
export type VideoTrack = {
    /**
     * The id of the video track.
     *
     * > This field is platform-specific and may return different depending on the operating system.
     */
    id: string;
    /**
     * Size of the video track.
     */
    size: VideoSize;
    /**
     * MimeType of the video track or null if unknown.
     */
    mimeType: string | null;
    /**
     * Indicates whether the video track format is supported by the device.
     *
     * @platform android
     */
    isSupported: boolean;
    /**
     * Specifies the bitrate in bits per second. This is the peak bitrate if known, or else the average bitrate if known, or else null.
     */
    bitrate: number | null;
    /**
     * Specifies the frame rate of the video track in frames per second.
     */
    frameRate: number | null;
};
/**
 * Specifies the size of a video track.
 */
export type VideoSize = {
    /**
     * Width of the video track in pixels.
     */
    width: number;
    /**
     * Height of the video track in pixels.
     */
    height: number;
};
export type AudioTrack = {
    /**
     * A string used by expo-video to identify the audio track.
     * @platform android
     */
    id: string;
    /**
     * Language of the audio track. For example, 'en', 'pl', 'de'.
     */
    language: string;
    /**
     * Label of the audio track in the language of the device.
     */
    label: string;
};
//# sourceMappingURL=VideoPlayer.types.d.ts.map