import { Ref, UnwrapNestedRefs } from "vue";
//#region src/adapters/emitter.d.ts
type PlaybackListener = (...args: unknown[]) => void;
//#endregion
//#region src/types/playback.d.ts
interface MediaErrorLike {
  code: number;
  message: string;
}
interface CaptionTrackInfo {
  index: number;
  label: string;
  language: string;
}
interface QualityLevelInfo {
  index: number;
  height: number;
  bitrate: number;
  label: string;
}
interface AdapterCaptions {
  tracks(): CaptionTrackInfo[];
  active(): number | null;
  select(index: number | null): void;
}
interface AdapterQuality {
  levels(): QualityLevelInfo[];
  current(): number | null;
  isAuto(): boolean;
  select(index: number | null): void;
}
interface AdapterPip {
  isSupported(): boolean;
  isActive(): boolean;
  toggle(): void;
}
type PlaybackEvent = 'play' | 'pause' | 'playing' | 'ended' | 'error' | 'timeupdate' | 'durationchange' | 'progress' | 'volumechange' | 'ratechange' | 'seeked' | 'waiting' | 'canplay' | 'qualitychange' | 'captionschange' | 'pipchange' | 'adstart' | 'adend' | 'nativefullscreenenter' | 'nativefullscreenexit' | 'fullscreen-pending' | 'fullscreen-pending-done';
interface PlaybackAdapter {
  readonly el: HTMLElement;
  play(): Promise<void>;
  pause(): void;
  paused(): boolean;
  currentTime(): number;
  setCurrentTime(seconds: number): void;
  duration(): number;
  volume(): number;
  setVolume(vol: number): void;
  muted(): boolean;
  setMuted(muted: boolean): void;
  playbackRate(): number;
  setPlaybackRate(rate: number): void;
  bufferedEnd(): number;
  error(): MediaErrorLike | null;
  load(src: string, type?: string): void;
  retry(): void;
  supportsPlaybackRate(): boolean;
  captions?: AdapterCaptions;
  quality?: AdapterQuality;
  pip?: AdapterPip;
  reveal?(videoEl: HTMLVideoElement): void;
  enterFullscreen(): void;
  exitFullscreen(): void;
  on(event: PlaybackEvent, listener: PlaybackListener): void;
  off(event: PlaybackEvent, listener: PlaybackListener): void;
  dispose(): void;
}
interface ResolvedSource {
  src: string;
  type?: string;
  poster?: string | null;
  adTagUrl?: string | null;
}
interface Matcher {
  test: (src: string) => boolean;
  key: string;
  embed: boolean;
}
interface EmbedAdapterOptions {
  src: string;
  poster?: string;
  autoplay?: boolean;
  muted?: boolean;
  volume?: number;
  nativeUi?: boolean;
}
type EmbedAdapterFactory = (videoEl: HTMLVideoElement, options: EmbedAdapterOptions) => PlaybackAdapter;
type SourceResolver = (url: string) => ResolvedSource | Promise<ResolvedSource>;
type PlatformConfig = Pick<Matcher, 'key' | 'test'> & ({
  embed: true;
  createAdapter: EmbedAdapterFactory;
} | {
  embed: false;
  resolveSource?: SourceResolver;
});
//#endregion
//#region src/ui/player/playerState.d.ts
declare function createPlayerState(props: PlayerProps): {
  isPlaying: import("vue").Ref<boolean, boolean>;
  hasEnded: import("vue").Ref<boolean, boolean>;
  isReady: import("vue").Ref<boolean, boolean>;
  isLoaded: import("vue").Ref<boolean, boolean>;
  isLive: import("vue").Ref<boolean, boolean>;
  hasStarted: import("vue").Ref<boolean, boolean>;
  isError: import("vue").Ref<boolean, boolean>;
  errorMessage: import("vue").Ref<string, string>;
  currentTime: import("vue").Ref<number, number>;
  duration: import("vue").Ref<number, number>;
  buffered: import("vue").Ref<number, number>;
  progress: import("vue").ComputedRef<number>;
  bufferedDisplay: import("vue").ComputedRef<number>;
  currentVolume: import("vue").Ref<number, number>;
  isMuted: import("vue").Ref<boolean, boolean>;
  isAudible: import("vue").ComputedRef<boolean>;
  isLooping: import("vue").Ref<boolean, boolean>;
  currentPlaybackRate: import("vue").Ref<number, number>;
  supportsPlaybackRate: import("vue").Ref<boolean, boolean>;
  isAdPlaying: import("vue").Ref<boolean, boolean>;
  isAdPaused: import("vue").Ref<boolean, boolean>;
  isAdMuted: import("vue").Ref<boolean, boolean>;
  adRemainingTime: import("vue").Ref<number, number>;
  supportsCaptions: import("vue").Ref<boolean, boolean>;
  captionTracks: import("vue").Ref<{
    index: number;
    label: string;
    language: string;
  }[], CaptionTrackInfo[] | {
    index: number;
    label: string;
    language: string;
  }[]>;
  activeCaptionIndex: import("vue").Ref<number | null, number | null>;
  supportsQuality: import("vue").Ref<boolean, boolean>;
  qualityLevels: import("vue").Ref<{
    index: number;
    height: number;
    bitrate: number;
    label: string;
  }[], QualityLevelInfo[] | {
    index: number;
    height: number;
    bitrate: number;
    label: string;
  }[]>;
  currentQualityHeight: import("vue").Ref<number | null, number | null>;
  isAutoQuality: import("vue").Ref<boolean, boolean>;
  supportsPip: import("vue").Ref<boolean, boolean>;
  isPipActive: import("vue").Ref<boolean, boolean>;
  isNativeUi: import("vue").Ref<boolean, boolean>;
};
type PlayerState = ReturnType<typeof createPlayerState>;
//#endregion
//#region src/ui/player/createPlayerControls.d.ts
interface PlayerControls {
  play: () => Promise<void>;
  pause: () => void;
  replay: () => Promise<void>;
  togglePlay: () => void;
  seek: (seconds: number) => void;
  toggleMute: () => void;
  setVolume: (vol: number) => void;
  toggleLoop: () => void;
  setPlaybackRate: (rate: number) => void;
  setCaptionTrack: (index: number | null) => void;
  setQuality: (height: number | null) => void;
  applyQuality: (height: number | null, options?: {
    remember?: boolean;
  }) => void;
  togglePip: () => void;
}
//#endregion
//#region src/ui/player/usePlayer.d.ts
type UsePlayerReturn = PlayerState & PlayerControls & {
  fire: (type: StateChangeType, extras?: Partial<StateChangeEvent>) => void;
  retry: () => void;
  isBuffering: Ref<boolean>;
  toggleAdMute: () => void;
  isFullscreen: Ref<boolean>;
  isFullscreenPending: Ref<boolean>;
  toggleFullscreen: () => void;
};
//#endregion
//#region src/ui/player/playerSurface.d.ts
declare const PLAYER_METHOD_KEYS: readonly ["retry", "play", "pause", "replay", "togglePlay", "seek", "toggleMute", "setVolume", "toggleFullscreen", "toggleLoop", "toggleAdMute", "setPlaybackRate", "setCaptionTrack", "setQuality", "togglePip"];
declare const PLAYER_STATE_KEYS: readonly ["isPlaying", "hasEnded", "isReady", "isLoaded", "isAdPlaying", "isAdPaused", "isAdMuted", "adRemainingTime", "isLive", "isBuffering", "currentTime", "duration", "currentVolume", "isMuted", "isAudible", "isLooping", "currentPlaybackRate", "hasStarted", "isError", "errorMessage", "progress", "bufferedDisplay", "isFullscreen", "supportsPlaybackRate", "supportsCaptions", "captionTracks", "activeCaptionIndex", "supportsQuality", "qualityLevels", "currentQualityHeight", "isAutoQuality", "supportsPip", "isPipActive", "isNativeUi"];
type PlayerMethodKey = (typeof PLAYER_METHOD_KEYS)[number];
type PlayerStateKey = (typeof PLAYER_STATE_KEYS)[number];
//#endregion
//#region src/types/player.d.ts
type BuiltinAction = 'mute' | 'loop' | 'autoplay';
interface CustomAction {
  icon: string;
  label: string;
  onClick: () => void;
}
type PlayerAction = BuiltinAction | CustomAction;
type StateChangeType = 'loaded' | 'play' | 'pause' | 'ended' | 'seeked' | 'error' | 'adstart' | 'adend' | 'volumechange' | 'ratechange' | 'captionchange' | 'qualitychange' | 'pipchange' | 'loopchange' | 'firstQuartile' | 'midpoint' | 'thirdQuartile' | 'controlsopen' | 'controlsclose' | 'stageopen' | 'stageclose' | 'bufferstart' | 'bufferend' | 'timeupdate' | 'tap';
interface StateChangeEvent {
  type: StateChangeType;
  currentTime: number;
  duration: number;
  src: string;
  error?: {
    code: number;
    message: string;
  } | null;
  isMuted?: boolean;
  playbackRate?: number;
  captionIndex?: number | null;
  qualityHeight?: number | null;
  isPipActive?: boolean;
  isLooping?: boolean;
  element?: HTMLElement | null;
  payload?: Record<string, unknown>;
}
interface HeaderBiddingAdUnit {
  code: string;
  mediaTypes: {
    video: Record<string, unknown>;
  };
  bids: Array<{
    bidder: string;
    params?: Record<string, unknown>;
  }>;
}
interface HeaderBiddingConfig {
  adUnit: HeaderBiddingAdUnit;
  params?: Record<string, string>;
  timeoutMs?: number;
}
interface CaptionTrackDef {
  src: string;
  kind?: 'captions' | 'subtitles';
  srclang?: string;
  label?: string;
  default?: boolean;
}
interface PlayerProps {
  src: string;
  label?: string;
  poster?: string;
  aspectRatio?: string;
  adTagUrl?: string;
  adMacroParams?: Record<string, string>;
  headerBidding?: HeaderBiddingConfig;
  tracks?: CaptionTrackDef[];
  captionLine?: number;
  autoplay?: boolean;
  muted?: boolean;
  volume?: number;
  playbackRate?: number;
  quality?: number | null;
  nativeUi?: boolean;
  payload?: Record<string, unknown> | string;
  action?: PlayerAction | null;
  disableTapCapture?: boolean;
  disableKeyboardShortcuts?: boolean;
  controls?: boolean;
  playInView?: boolean;
  pin?: PinCorner;
  loop?: boolean;
  preload?: PreloadMode;
}
type PinCorner = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
type PreloadMode = 'none' | 'metadata' | 'auto';
interface VideoEntry extends PlayerProps {
  lazy?: boolean;
  autoStage?: boolean;
}
interface TranscriptCue {
  time: number;
  end?: number;
  text: string;
}
type PlayerHandle = Pick<UnwrapNestedRefs<UsePlayerReturn>, PlayerMethodKey | PlayerStateKey>;
//#endregion
//#region src/adapters/index.d.ts
export declare function resolvePlatform(url: string): {
  key: string;
  embed: boolean;
};
export declare function registerPlatform(config: PlatformConfig): void;
//#endregion
//#region src/elements/core.d.ts
declare const VideoPlayerElement: import("vue").VueElementConstructor<unknown>;
declare const VideoStageElement: import("vue").VueElementConstructor<unknown>;
declare const VideoPlaceholderElement: import("vue").VueElementConstructor<VideoEntry>;
declare const VideoCardElement: import("vue").VueElementConstructor<unknown>;
declare const HideMarkerElement: import("vue").VueElementConstructor<{}>;
export declare function defineElements(): void;
//#endregion
//#region src/ui/controls/useResolvedPlayer.d.ts
interface ResolvedPlayerProps {
  player?: PlayerHandle | null;
  for?: string;
}
//#endregion
//#region src/elements/controls.d.ts
declare const ScrubberElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const PlayButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const MuteButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const FullscreenButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const BufferingElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const LoopButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const PipButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const CaptionsButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const QualityButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const PlaybackRateButtonElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const VolumeSliderElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const TimeDisplayElement: import("vue").VueElementConstructor<ResolvedPlayerProps>;
declare const TranscriptElement: import("vue").VueElementConstructor<ResolvedPlayerProps & {
  cues?: TranscriptCue[] | string;
  speechPitch?: number;
  speechRate?: number;
}>;
//#endregion
export { type AdapterCaptions, type AdapterPip, type AdapterQuality, BufferingElement, CaptionsButtonElement, type EmbedAdapterFactory, type EmbedAdapterOptions, FullscreenButtonElement, HideMarkerElement, LoopButtonElement, type Matcher, type MediaErrorLike, MuteButtonElement, PipButtonElement, type PlatformConfig, PlayButtonElement, type PlaybackAdapter, type PlaybackEvent, PlaybackRateButtonElement, QualityButtonElement, type ResolvedSource, ScrubberElement, type SourceResolver, TimeDisplayElement, TranscriptElement, VideoCardElement, VideoPlaceholderElement, VideoPlayerElement, VideoStageElement, VolumeSliderElement };