import { ComputedRef, Plugin, 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/overlay/useHud.d.ts
interface UseHudReturn {
  showHUD: Ref<boolean>;
  isOpen: Ref<boolean>;
  scheduleHide: (delay?: number) => void;
  pauseHide: () => void;
  onVideoTap: () => void;
  onMouseMove: () => void;
  onMouseLeave: () => void;
  openControls: () => void;
  closeControls: (immediate?: boolean) => void;
  keepOpen: () => void;
  suppressMouseLeave: (ms?: number) => void;
}
//#endregion
//#region src/ui/player/playerContext.d.ts
type PlayerContext = UnwrapNestedRefs<UsePlayerReturn>;
type HudContext = UnwrapNestedRefs<UseHudReturn>;
interface PlaylistContext {
  hasPlaylist: boolean;
  hasNext: boolean;
  hasPrevious: boolean;
  autoAdvance: boolean;
  playNext: () => void;
  playPrevious: () => void;
  toggleAutoAdvance: () => 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
export type BuiltinAction = 'mute' | 'loop' | 'autoplay';
export interface CustomAction {
  icon: string;
  label: string;
  onClick: () => void;
}
export type PlayerAction = BuiltinAction | CustomAction;
export 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';
export 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>;
}
export interface HeaderBiddingAdUnit {
  code: string;
  mediaTypes: {
    video: Record<string, unknown>;
  };
  bids: Array<{
    bidder: string;
    params?: Record<string, unknown>;
  }>;
}
export interface HeaderBiddingConfig {
  adUnit: HeaderBiddingAdUnit;
  params?: Record<string, string>;
  timeoutMs?: number;
}
export interface CaptionTrackDef {
  src: string;
  kind?: 'captions' | 'subtitles';
  srclang?: string;
  label?: string;
  default?: boolean;
}
export 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;
}
export type PinCorner = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
export type PreloadMode = 'none' | 'metadata' | 'auto';
export interface VideoToggleDetail {
  src: string;
}
export interface VideoEntry extends PlayerProps {
  lazy?: boolean;
  autoStage?: boolean;
}
export interface VideoSelectDetail extends VideoEntry {
  fromGesture?: boolean;
}
export interface TranscriptCue {
  time: number;
  end?: number;
  text: string;
}
export type PlayerHandle = Pick<UnwrapNestedRefs<UsePlayerReturn>, PlayerMethodKey | PlayerStateKey>;
//#endregion
//#region src/ui/player/VideoPlayer.vue.d.ts
declare var __VLS_32: {};
type __VLS_Slots$15 = {} & {
  default?: (props: typeof __VLS_32) => any;
};
declare const __VLS_base$15: import("vue").DefineComponent<PlayerProps, PlayerHandle, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  "state-change": (event: StateChangeEvent) => any;
}, string, import("vue").PublicProps, Readonly<PlayerProps> & Readonly<{
  "onState-change"?: ((event: StateChangeEvent) => any) | undefined;
}>, {
  label: string;
  poster: string;
  aspectRatio: string;
  adTagUrl: string;
  tracks: CaptionTrackDef[];
  captionLine: number;
  autoplay: boolean;
  muted: boolean;
  quality: number | null;
  nativeUi: boolean;
  payload: Record<string, unknown> | string;
  action: PlayerAction | null;
  disableTapCapture: boolean;
  disableKeyboardShortcuts: boolean;
  controls: boolean;
  playInView: boolean;
  loop: boolean;
  preload: PreloadMode;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$17: __VLS_WithSlots$15<typeof __VLS_base$15, __VLS_Slots$15>;
declare const _default$15: typeof __VLS_export$17;
type __VLS_WithSlots$15<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/stage/VideoStage.vue.d.ts
type __VLS_Props$1 = {
  pin?: PinCorner | 'full-width';
  playlist?: VideoEntry[];
};
declare function playNext(fromGesture?: boolean): void;
declare function playPrevious(fromGesture?: boolean): void;
declare var __VLS_19: {};
type __VLS_Slots$14 = {} & {
  default?: (props: typeof __VLS_19) => any;
};
declare const __VLS_base$14: import("vue").DefineComponent<__VLS_Props$1, {
  play: () => Promise<void>;
  pause: () => Promise<void>;
  replay: () => Promise<void>;
  togglePlay: () => Promise<void>;
  seek: (seconds: number) => Promise<void>;
  toggleMute: () => Promise<void>;
  setVolume: (vol: number) => Promise<void>;
  toggleLoop: () => Promise<void>;
  setPlaybackRate: (rate: number) => Promise<void>;
  setCaptionTrack: (index: number | null) => Promise<void>;
  setQuality: (height: number | null) => Promise<void>;
  togglePip: () => Promise<void>;
  retry: () => Promise<void>;
  toggleAdMute: () => Promise<void>;
  toggleFullscreen: () => Promise<void>;
  isPlaying: import("vue").ComputedRef<boolean>;
  hasEnded: import("vue").ComputedRef<boolean>;
  isReady: import("vue").ComputedRef<boolean>;
  isLoaded: import("vue").ComputedRef<boolean>;
  isLive: import("vue").ComputedRef<boolean>;
  hasStarted: import("vue").ComputedRef<boolean>;
  isError: import("vue").ComputedRef<boolean>;
  errorMessage: import("vue").ComputedRef<string>;
  currentTime: import("vue").ComputedRef<number>;
  duration: import("vue").ComputedRef<number>;
  progress: import("vue").ComputedRef<number>;
  bufferedDisplay: import("vue").ComputedRef<number>;
  currentVolume: import("vue").ComputedRef<number>;
  isMuted: import("vue").ComputedRef<boolean>;
  isAudible: import("vue").ComputedRef<boolean>;
  isLooping: import("vue").ComputedRef<boolean>;
  currentPlaybackRate: import("vue").ComputedRef<number>;
  supportsPlaybackRate: import("vue").ComputedRef<boolean>;
  isAdPlaying: import("vue").ComputedRef<boolean>;
  isAdPaused: import("vue").ComputedRef<boolean>;
  isAdMuted: import("vue").ComputedRef<boolean>;
  adRemainingTime: import("vue").ComputedRef<number>;
  supportsCaptions: import("vue").ComputedRef<boolean>;
  captionTracks: import("vue").ComputedRef<{
    index: number;
    label: string;
    language: string;
  }[]>;
  activeCaptionIndex: import("vue").ComputedRef<number | null>;
  supportsQuality: import("vue").ComputedRef<boolean>;
  qualityLevels: import("vue").ComputedRef<{
    index: number;
    height: number;
    bitrate: number;
    label: string;
  }[]>;
  currentQualityHeight: import("vue").ComputedRef<number | null>;
  isAutoQuality: import("vue").ComputedRef<boolean>;
  supportsPip: import("vue").ComputedRef<boolean>;
  isPipActive: import("vue").ComputedRef<boolean>;
  isNativeUi: import("vue").ComputedRef<boolean>;
  isBuffering: import("vue").ComputedRef<boolean>;
  isFullscreen: import("vue").ComputedRef<boolean>;
  playNext: typeof playNext;
  playPrevious: typeof playPrevious;
  hasNext: import("vue").ComputedRef<boolean>;
  hasPrevious: import("vue").ComputedRef<boolean>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  "state-change": (event: StateChangeEvent) => any;
}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{
  "onState-change"?: ((event: StateChangeEvent) => any) | undefined;
}>, {
  pin: PinCorner | "full-width";
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$16: __VLS_WithSlots$14<typeof __VLS_base$14, __VLS_Slots$14>;
declare const _default$16: typeof __VLS_export$16;
type __VLS_WithSlots$14<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/stage/VideoPlaceholder.vue.d.ts
declare const __VLS_export$15: import("vue").DefineComponent<VideoEntry, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  "enter-view": () => any;
}, string, import("vue").PublicProps, Readonly<VideoEntry> & Readonly<{
  "onEnter-view"?: (() => any) | undefined;
}>, {
  label: string;
  poster: string;
  aspectRatio: string;
  adTagUrl: string;
  autoplay: boolean;
  muted: boolean;
  nativeUi: boolean;
  payload: Record<string, unknown> | string;
  action: PlayerAction | null;
  autoStage: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const _default$14: typeof __VLS_export$15;
//#endregion
//#region src/ui/player/useForwardedPlayer.d.ts
type ForwardedPlayer = { [K in PlayerMethodKey]: (...args: Parameters<PlayerContext[K]>) => Promise<void>; } & { [K in PlayerStateKey]: ComputedRef<PlayerContext[K]>; };
interface UseForwardedPlayerReturn {
  playerRef: Ref<PlayerContext | null>;
  forwarded: ForwardedPlayer;
}
export declare function useForwardedPlayer(guard?: (key: PlayerMethodKey) => boolean | Promise<boolean>): UseForwardedPlayerReturn;
//#endregion
//#region src/ui/stage/VideoCard.vue.d.ts
declare var __VLS_26: {};
type __VLS_Slots$13 = {} & {
  default?: (props: typeof __VLS_26) => any;
};
declare const __VLS_base$13: import("vue").DefineComponent<VideoEntry, ForwardedPlayer, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
  "state-change": (event: StateChangeEvent) => any;
}, string, import("vue").PublicProps, Readonly<VideoEntry> & Readonly<{
  "onState-change"?: ((event: StateChangeEvent) => any) | undefined;
}>, {
  muted: boolean;
  action: PlayerAction | null;
  controls: boolean;
  lazy: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$14: __VLS_WithSlots$13<typeof __VLS_base$13, __VLS_Slots$13>;
declare const _default$13: typeof __VLS_export$14;
type __VLS_WithSlots$13<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/stage/HideMarker.vue.d.ts
declare const __VLS_export$13: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
declare const _default$3: typeof __VLS_export$13;
//#endregion
//#region src/ui/controls/useResolvedPlayer.d.ts
interface ResolvedPlayerProps {
  player?: PlayerHandle | null;
  for?: string;
}
//#endregion
//#region src/ui/controls/Scrubber.vue.d.ts
declare var __VLS_1$11: {
  scrubbing: boolean;
  percent: number;
  previewSeconds: number;
  formatTime: (seconds: number) => string;
};
type __VLS_Slots$12 = {} & {
  preview?: (props: typeof __VLS_1$11) => any;
};
declare const __VLS_base$12: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$12: __VLS_WithSlots$12<typeof __VLS_base$12, __VLS_Slots$12>;
declare const _default$10: typeof __VLS_export$12;
type __VLS_WithSlots$12<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/PlayButton.vue.d.ts
declare var __VLS_1$10: {
  isPlaying: boolean;
  hasEnded: boolean;
  isError: boolean;
};
type __VLS_Slots$11 = {} & {
  default?: (props: typeof __VLS_1$10) => any;
};
declare const __VLS_base$11: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$11: __VLS_WithSlots$11<typeof __VLS_base$11, __VLS_Slots$11>;
declare const _default$7: typeof __VLS_export$11;
type __VLS_WithSlots$11<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/MuteButton.vue.d.ts
declare var __VLS_1$9: {
  isMuted: boolean;
};
type __VLS_Slots$10 = {} & {
  default?: (props: typeof __VLS_1$9) => any;
};
declare const __VLS_base$10: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$10: __VLS_WithSlots$10<typeof __VLS_base$10, __VLS_Slots$10>;
declare const _default$5: typeof __VLS_export$10;
type __VLS_WithSlots$10<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/FullscreenButton.vue.d.ts
declare var __VLS_1$8: {
  isFullscreen: boolean;
};
type __VLS_Slots$9 = {} & {
  default?: (props: typeof __VLS_1$8) => any;
};
declare const __VLS_base$9: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$9: __VLS_WithSlots$9<typeof __VLS_base$9, __VLS_Slots$9>;
declare const _default$2: typeof __VLS_export$9;
type __VLS_WithSlots$9<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/Buffering.vue.d.ts
declare var __VLS_1$7: {
  isBuffering: boolean;
};
type __VLS_Slots$8 = {} & {
  default?: (props: typeof __VLS_1$7) => any;
};
declare const __VLS_base$8: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$8: __VLS_WithSlots$8<typeof __VLS_base$8, __VLS_Slots$8>;
declare const _default: typeof __VLS_export$8;
type __VLS_WithSlots$8<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/LoopButton.vue.d.ts
declare var __VLS_1$6: {
  isLooping: boolean;
};
type __VLS_Slots$7 = {} & {
  default?: (props: typeof __VLS_1$6) => any;
};
declare const __VLS_base$7: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$7: __VLS_WithSlots$7<typeof __VLS_base$7, __VLS_Slots$7>;
declare const _default$4: typeof __VLS_export$7;
type __VLS_WithSlots$7<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/PipButton.vue.d.ts
declare var __VLS_1$5: {
  isPipActive: boolean;
};
type __VLS_Slots$6 = {} & {
  default?: (props: typeof __VLS_1$5) => any;
};
declare const __VLS_base$6: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$6: __VLS_WithSlots$6<typeof __VLS_base$6, __VLS_Slots$6>;
declare const _default$6: typeof __VLS_export$6;
type __VLS_WithSlots$6<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/CaptionsButton.vue.d.ts
declare var __VLS_1$4: {
  currentLabel: string;
  tracks: {
    index: number;
    label: string;
    language: string;
  }[];
  activeIndex: number | null;
};
type __VLS_Slots$5 = {} & {
  default?: (props: typeof __VLS_1$4) => any;
};
declare const __VLS_base$5: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$5: __VLS_WithSlots$5<typeof __VLS_base$5, __VLS_Slots$5>;
declare const _default$1: typeof __VLS_export$5;
type __VLS_WithSlots$5<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/QualityButton.vue.d.ts
declare var __VLS_1$3: {
  currentLabel: string;
  levels: {
    index: number;
    height: number;
    bitrate: number;
    label: string;
  }[];
  currentHeight: number | null;
  isAuto: boolean;
};
type __VLS_Slots$4 = {} & {
  default?: (props: typeof __VLS_1$3) => any;
};
declare const __VLS_base$4: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$4: __VLS_WithSlots$4<typeof __VLS_base$4, __VLS_Slots$4>;
declare const _default$9: typeof __VLS_export$4;
type __VLS_WithSlots$4<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/PlaybackRateButton.vue.d.ts
declare var __VLS_1$2: {
  currentLabel: string;
  rate: number;
  rates: number[];
};
type __VLS_Slots$3 = {} & {
  default?: (props: typeof __VLS_1$2) => any;
};
declare const __VLS_base$3: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$3: __VLS_WithSlots$3<typeof __VLS_base$3, __VLS_Slots$3>;
declare const _default$8: typeof __VLS_export$3;
type __VLS_WithSlots$3<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/VolumeSlider.vue.d.ts
declare var __VLS_1$1: {
  percent: number;
};
type __VLS_Slots$2 = {} & {
  default?: (props: typeof __VLS_1$1) => any;
};
declare const __VLS_base$2: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
declare const _default$17: typeof __VLS_export$2;
type __VLS_WithSlots$2<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/utils/time.d.ts
declare function fmtTime(s: number, round?: boolean): string;
//#endregion
//#region src/ui/controls/TimeDisplay.vue.d.ts
declare var __VLS_1: {
  isLive: boolean;
  currentTime: number;
  duration: number;
  formatTime: typeof fmtTime;
};
type __VLS_Slots$1 = {} & {
  default?: (props: typeof __VLS_1) => any;
};
declare const __VLS_base$1: import("vue").DefineComponent<ResolvedPlayerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResolvedPlayerProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
declare const _default$11: typeof __VLS_export$1;
type __VLS_WithSlots$1<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#endregion
//#region src/ui/controls/Transcript.vue.d.ts
type __VLS_Props = ResolvedPlayerProps & {
  cues?: TranscriptCue[] | string;
  speechPitch?: number;
  speechRate?: number;
};
declare var __VLS_11: {
  cue: TranscriptCue;
  index: number;
  isActive: boolean;
  formatTime: typeof fmtTime;
};
type __VLS_Slots = {} & {
  default?: (props: typeof __VLS_11) => any;
};
declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
declare const _default$12: typeof __VLS_export;
type __VLS_WithSlots<T, S> = T & {
  new (): {
    $slots: S;
  };
};
//#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/ui/controls/useScrubber.d.ts
interface UseScrubberReturn {
  scrubbing: ComputedRef<boolean>;
  displayPercent: ComputedRef<number>;
  previewSeconds: ComputedRef<number>;
  onInput: (e: Event) => void;
  onChange: (e: Event) => void;
  onTouchStart: () => void;
  onTouchEnd: (e: TouchEvent) => void;
  onPointerCancel: () => void;
}
export declare function useScrubber(player: Ref<PlayerHandle | null | undefined>): UseScrubberReturn;
//#endregion
//#region src/ui/controls/useSpokenCues.d.ts
interface SpokenCuesOptions {
  pitch?: number;
  rate?: number;
}
interface UseSpokenCuesReturn {
  canSpeak: boolean;
  speechEnabled: Ref<boolean>;
  toggleSpeech: () => void;
}
export declare function useSpokenCues(player: ComputedRef<PlayerHandle | null>, cues: ComputedRef<TranscriptCue[]>, activeIndex: ComputedRef<number | null>, options?: SpokenCuesOptions): UseSpokenCuesReturn;
//#endregion
//#region src/utils/playerActions.d.ts
export declare function cycleCaptionTrack(player: PlayerHandle): void;
export declare function captionTrackLabel(player: PlayerHandle): string;
export declare function cycleQuality(player: PlayerHandle): void;
export declare function qualityLabel(player: PlayerHandle): string;
export declare function cyclePlaybackRate(player: PlayerHandle): void;
export declare function playbackRateLabel(rate: number): string;
//#endregion
//#region src/utils/exposePlayerOnElement.d.ts
export declare function exposePlayerOnElement(el: Element, player: object | null | undefined): void;
//#endregion
//#region src/index.d.ts
declare const VideoPlayerPlugin: Plugin;
//#endregion
export { type AdapterCaptions, type AdapterPip, type AdapterQuality, _default as Buffering, type CaptionTrackInfo, _default$1 as CaptionsButton, type EmbedAdapterFactory, type EmbedAdapterOptions, type ForwardedPlayer, _default$2 as FullscreenButton, _default$3 as HideMarker, type HudContext, _default$4 as LoopButton, type Matcher, type MediaErrorLike, _default$5 as MuteButton, _default$6 as PipButton, type PlatformConfig, _default$7 as PlayButton, type PlaybackAdapter, type PlaybackEvent, _default$8 as PlaybackRateButton, type PlayerContext, type PlayerMethodKey, type PlayerStateKey, type PlaylistContext, _default$9 as QualityButton, type QualityLevelInfo, type ResolvedSource, _default$10 as Scrubber, type SourceResolver, type SpokenCuesOptions, _default$11 as TimeDisplay, _default$12 as Transcript, type UseForwardedPlayerReturn, type UseSpokenCuesReturn, _default$13 as VideoCard, _default$14 as VideoPlaceholder, _default$15 as VideoPlayer, VideoPlayerPlugin, VideoPlayerPlugin as default, _default$16 as VideoStage, _default$17 as VolumeSlider };