/**
 * Player abstraction types for swappable player implementations.
 *
 * Phase 1: WebView player (current implementation)
 * Phase 2: Native player (BBNativePlayerKit iOS, Android SDK)
 *
 * This abstraction allows the SDK to support different player backends
 * without changing the public API.
 */
import type { BBMediaInfo, BBPlayerState, BBPlayerEvent, BBTimeUpdateEvent, BBClipLoadedEvent, BBAdEvent } from './index';
/**
 * Player implementation type identifier
 */
export type PlayerType = 'webview' | 'native';
/**
 * Configuration for initializing a player
 */
export interface PlayerConfig {
    /** The clip/media ID to load */
    clipId?: string;
    /** The playout configuration name */
    playout?: string;
    /** Whether to autoplay when loaded */
    autoPlay?: boolean;
    /** Initial volume (0-1) */
    volume?: number;
    /** Initial muted state */
    muted?: boolean;
    /** JWT token for authenticated playback */
    jwt?: string;
}
/**
 * Events emitted by a player implementation.
 *
 * Event naming follows the web player (standardplayer) conventions:
 * - Web: 'play', 'playing', 'pause', 'ended', 'statechange', etc.
 * - Native iOS: didTriggerPlay, didTriggerPlaying, didTriggerPause, didTriggerEnded, etc.
 * - Native Android: didTriggerPlay, didTriggerPlaying, didTriggerPause, didTriggerEnded, etc.
 *
 * The React Native SDK uses 'on' + PascalCase (onPlay, onPlaying, etc.) which maps to:
 * | SDK Event       | Web Player Event | Native Delegate Method     |
 * |-----------------|------------------|----------------------------|
 * | onPlay          | play             | didTriggerPlay             |
 * | onPlaying       | playing          | didTriggerPlaying          |
 * | onPause         | pause            | didTriggerPause            |
 * | onEnded         | ended            | didTriggerEnded            |
 * | onStateChange   | statechange      | didTriggerStateChange      |
 * | onPhaseChange   | phasechange      | didTriggerPhaseChange      |
 * | onModeChange    | modechange       | didTriggerModeChange       |
 * | onTimeUpdate    | timeupdate       | (poll getCurrentTime)      |
 * | onDurationChange| durationchange   | didTriggerDurationChange   |
 * | onVolumeChange  | volumechange     | didTriggerVolumeChange     |
 * | onSeeking       | seeking          | didTriggerSeeking          |
 * | onSeeked        | seeked           | didTriggerSeeked           |
 * | onCanPlay       | canplay          | didTriggerCanPlay          |
 * | onClipLoaded    | loadedclipdata   | didTriggerMediaClipLoaded  |
 * | onAdStarted     | adstarted        | didTriggerAdStarted        |
 * | onAdFinished    | (adcomplete)     | didTriggerAdFinished       |
 * | onError         | error            | didFailWithError           |
 */
export interface PlayerEvents {
    /** Fired when play() is called (play command issued) */
    onPlay?: (media: BBMediaInfo) => void;
    /** Fired when media actually starts playing (after buffering) */
    onPlaying?: (media: BBMediaInfo) => void;
    /** Fired when media is paused */
    onPause?: (media: BBMediaInfo) => void;
    /** Fired when media playback ends */
    onEnded?: (media: BBMediaInfo) => void;
    /** Fired when player state changes */
    onStateChange?: (state: BBPlayerState) => void;
    /** Fired when player phase changes (pre/main/post) */
    onPhaseChange?: (phase: {
        phase: string;
    }) => void;
    /** Fired when player mode changes */
    onModeChange?: (mode: {
        mode: string;
    }) => void;
    /** Fired on time update during playback */
    onTimeUpdate?: (event: BBTimeUpdateEvent) => void;
    /** Fired when duration changes */
    onDurationChange?: (event: {
        duration: number;
    }) => void;
    /** Fired when volume or mute state changes */
    onVolumeChange?: (event: {
        volume: number;
        muted: boolean;
    }) => void;
    /** Fired when seeking starts */
    onSeeking?: () => void;
    /** Fired when seek completes */
    onSeeked?: (event: {
        seekOffset: number;
    }) => void;
    /** Fired when media is ready to play */
    onCanPlay?: () => void;
    /** Fired when clip/media data is loaded */
    onClipLoaded?: (event: BBClipLoadedEvent) => void;
    /** Fired when an ad starts playing */
    onAdStarted?: (event: BBAdEvent) => void;
    /** Fired when an ad finishes playing */
    onAdFinished?: (event: BBAdEvent) => void;
    /** Fired when an error occurs */
    onError?: (error: {
        code: string;
        message: string;
        details?: unknown;
    }) => void;
    /** Generic player event handler for all events */
    onPlayerEvent?: (event: BBPlayerEvent) => void;
}
/**
 * Imperative methods that a player implementation must provide
 */
export interface PlayerControls {
    play: () => void;
    pause: () => void;
    seek: (seconds: number) => void;
    setVolume: (volume: number) => void;
    setMuted: (muted: boolean) => void;
    enterFullscreen: () => void;
    exitFullscreen: () => void;
    loadWithContentIdAndType: (contentId: string, contentType: string, autoPlay?: boolean, context?: Record<string, unknown>) => void;
    /** @deprecated Use loadWithContentIdAndType() instead */
    loadWithJsonUrl: (jsonUrl: string, autoPlay?: boolean, context?: Record<string, unknown>) => void;
    /** @deprecated Use loadWithContentIdAndType() instead */
    loadClip: (clipId: string, options?: {
        autoPlay?: boolean;
    }) => void;
    getState: () => Promise<BBPlayerState | null>;
    destroy: () => void;
}
/**
 * Props for a player component
 */
export interface PlayerComponentProps extends PlayerConfig, PlayerEvents {
    /** Unique identifier for this player instance */
    playerId: string;
    /** Style for the player container */
    style?: object;
}
/**
 * Ref type for player components.
 * Extends PlayerControls - implementations must provide all control methods.
 */
export type PlayerComponentRef = PlayerControls;
/**
 * A player provider supplies a player component implementation.
 * This allows swapping between WebView and native player implementations.
 *
 * @example
 * ```tsx
 * // Default WebView player (Phase 1)
 * const webViewProvider: PlayerProvider = {
 *   type: 'webview',
 *   // WebView player is built into BBChannel
 * };
 *
 * // Native player (Phase 2)
 * const nativeProvider: PlayerProvider = {
 *   type: 'native',
 *   PlayerComponent: BBNativePlayer,
 * };
 *
 * <BBChannel
 *   channelUrl="..."
 *   playerProvider={nativeProvider}
 * />
 * ```
 */
export interface PlayerProvider {
    /** The type of player this provider supplies */
    type: PlayerType;
    /**
     * The player component to render.
     * If not provided, the default WebView-based player is used.
     * This is a React component that accepts PlayerComponentProps and exposes PlayerComponentRef.
     */
    PlayerComponent?: React.ForwardRefExoticComponent<PlayerComponentProps & React.RefAttributes<PlayerComponentRef>>;
    /**
     * Optional configuration for the player provider
     */
    config?: {
        /** iOS-specific configuration */
        ios?: Record<string, unknown>;
        /** Android-specific configuration */
        android?: Record<string, unknown>;
    };
}
/**
 * Default player provider using WebView-based player.
 * This is used when no playerProvider prop is specified.
 */
export declare const DEFAULT_PLAYER_PROVIDER: PlayerProvider;
//# sourceMappingURL=player.d.ts.map