audiotoolheadless

import Hls, { HlsConfig } from 'hls.js'; type InitMode = 'REACT' | 'VANILLA'; type PlaybackRate = 1.0 | 1.25 | 1.5 | 1.75 | 2.0 | 2.5 | 3.0; type PreloadStrategy = 'none' | 'metadata' | 'auto' | ''; type CrossOriginValue = 'anonymous' | 'use-credentials' | null; type PlaybackState = 'idle' | 'playing' | 'ended' | 'ready' | 'paused' | 'stalled' | 'error' | 'buffering' | 'trackchanged' | 'durationchanged' | 'queueended'; type QueuePlaybackType = 'DEFAULT' | 'REVERSE' | 'SHUFFLE'; type LoopMode = 'SINGLE' | 'QUEUE' | 'OFF'; interface MediaArtwork { src: string; name?: string; sizes?: string; type?: string; } interface MediaTrack { id: string; title: string; source: string; artwork: MediaArtwork[] | null; duration?: number; genre?: string; album?: string; comment?: string; year?: number | string; artist?: string; } interface PlayerConfiguration { mode: InitMode; useDefaultEventListeners: boolean; showNotificationActions?: boolean; preloadStrategy?: PreloadStrategy; playbackRate?: PlaybackRate; customEventListeners?: EventCallbackMap | null; autoPlay?: boolean; enablePlayLog?: boolean; enableHls?: boolean; enableEqualizer?: boolean; crossOrigin?: CrossOriginValue; hlsConfig?: HlsConfig; } interface PlayerError { code: number | string | null; message: string; readable: string; } interface PlayerState { playbackState: PlaybackState; duration: number | undefined; bufferedDuration: number; progress: number | undefined; volume: number; playbackRate: PlaybackRate; error: PlayerError; currentTrack: MediaTrack; currentTrackPlayTime: number; previousTrackPlayTime: number; } interface ReadyState { HAVE_NOTHING: 0; HAVE_METADATA: 1; HAVE_CURRENT_DATA: 2; HAVE_FUTURE_DATA: 3; HAVE_ENOUGH_DATA: 4; } interface NetworkState { NETWORK_EMPTY: 0; NETWORK_IDLE: 1; NETWORK_LOADING: 2; NETWORK_NO_SOURCE: 3; } interface AudioEvents { ABORT: 'abort'; TIME_UPDATE: 'timeupdate'; CAN_PLAY: 'canplay'; CAN_PLAY_THROUGH: 'canplaythrough'; DURATION_CHANGE: 'durationchange'; ENDED: 'ended'; EMPTIED: 'emptied'; PLAYING: 'playing'; WAITING: 'waiting'; SEEKING: 'seeking'; SEEKED: 'seeked'; LOADED_META_DATA: 'loadedmetadata'; LOADED_DATA: 'loadeddata'; PLAY: 'play'; PAUSE: 'pause'; RATE_CHANGE: 'ratechange'; VOLUME_CHANGE: 'volumechange'; SUSPEND: 'suspend'; STALLED: 'stalled'; PROGRESS: 'progress'; LOAD_START: 'loadstart'; ERROR: 'error'; TRACK_CHANGE: 'trackchange'; QUEUE_ENDED: 'queueended'; } interface HlsEvents { MEDIA_ATTACHING: 'hlsMediaAttaching'; MEDIA_ATTACHED: 'hlsMediaAttached'; MEDIA_DETACHING: 'hlsMediaDetaching'; MEDIA_DETACHED: 'hlsMediaDetached'; BUFFER_RESET: 'hlsBufferReset'; BUFFER_CODECS: 'hlsBufferCodecs'; BUFFER_CREATED: 'hlsBufferCreated'; BUFFER_APPENDING: 'hlsBufferAppending'; BUFFER_APPENDED: 'hlsBufferAppended'; BUFFER_EOS: 'hlsBufferEos'; BUFFER_FLUSHING: 'hlsBufferFlushing'; BUFFER_FLUSHED: 'hlsBufferFlushed'; MANIFEST_LOADING: 'hlsManifestLoading'; MANIFEST_LOADED: 'hlsManifestLoaded'; MANIFEST_PARSED: 'hlsManifestParsed'; LEVEL_SWITCHING: 'hlsLevelSwitching'; LEVEL_SWITCHED: 'hlsLevelSwitched'; LEVEL_LOADING: 'hlsLevelLoading'; LEVEL_LOADED: 'hlsLevelLoaded'; LEVEL_UPDATED: 'hlsLevelUpdated'; LEVEL_PTS_UPDATED: 'hlsLevelPtsUpdated'; LEVELS_UPDATED: 'hlsLevelsUpdated'; AUDIO_TRACKS_UPDATED: 'hlsAudioTracksUpdated'; AUDIO_TRACK_SWITCHING: 'hlsAudioTrackSwitching'; AUDIO_TRACK_SWITCHED: 'hlsAudioTrackSwitched'; AUDIO_TRACK_LOADING: 'hlsAudioTrackLoading'; AUDIO_TRACK_LOADED: 'hlsAudioTrackLoaded'; SUBTITLE_TRACKS_UPDATED: 'hlsSubtitleTracksUpdated'; SUBTITLE_TRACKS_CLEARED: 'hlsSubtitleTracksCleared'; SUBTITLE_TRACK_SWITCH: 'hlsSubtitleTrackSwitch'; SUBTITLE_TRACK_LOADING: 'hlsSubtitleTrackLoading'; SUBTITLE_TRACK_LOADED: 'hlsSubtitleTrackLoaded'; SUBTITLE_FRAG_PROCESSED: 'hlsSubtitleFragProcessed'; CUES_PARSED: 'hlsCuesParsed'; NON_NATIVE_TEXT_TRACKS_FOUND: 'hlsNonNativeTextTracksFound'; INIT_PTS_FOUND: 'hlsInitPtsFound'; FRAG_LOADING: 'hlsFragLoading'; FRAG_LOAD_EMERGENCY_ABORTED: 'hlsFragLoadEmergencyAborted'; FRAG_LOADED: 'hlsFragLoaded'; FRAG_DECRYPTED: 'hlsFragDecrypted'; FRAG_PARSING_INIT_SEGMENT: 'hlsFragParsingInitSegment'; FRAG_PARSING_USERDATA: 'hlsFragParsingUserdata'; FRAG_PARSING_METADATA: 'hlsFragParsingMetadata'; FRAG_PARSED: 'hlsFragParsed'; FRAG_BUFFERED: 'hlsFragBuffered'; FRAG_CHANGED: 'hlsFragChanged'; FPS_DROP: 'hlsFpsDrop'; FPS_DROP_LEVEL_CAPPING: 'hlsFpsDropLevelCapping'; ERROR: 'hlsError'; DESTROYING: 'hlsDestroying'; KEY_LOADING: 'hlsKeyLoading'; KEY_LOADED: 'hlsKeyLoaded'; LIVE_BACK_BUFFER_REACHED: 'hlsLiveBackBufferReached'; BACK_BUFFER_REACHED: 'hlsBackBufferReached'; } type EventCallbackMap = { [key in keyof Partial<AudioEvents>]: (event: Event, audioInstance: HTMLAudioElement, playLogEnabled: boolean) => void; }; type HlsEventCallbackMap = { [key in keyof Partial<HlsEvents>]: (event: Event, data: any, hlsInstance: Hls, playLogEnabled: boolean) => void; }; type EqualizerStatus = 'IDEAL' | 'RUNNING' | 'SUSPENDED' | 'CLOSED'; interface EqualizerBand { type: BiquadFilterType; frequency: number; Q: number; gain: number; } interface EqualizerPresets { FLAT: number[]; ACOUSTIC: number[]; BASS_BOOSTER: number[]; BASS_REDUCER: number[]; CLASSICAL: number[]; DEEP: number[]; ELECTRONIC: number[]; LATIN: number[]; LOUDNESS: number[]; LOUNGE: number[]; PIANO: number[]; POP: number[]; RNB: number[]; ROCK: number[]; SMALL_SPEAKERS: number[]; SPOKEN_WORD: number[]; TREBLE_BOOSTER: number[]; TREBLE_REDUCER: number[]; VOCAL_BOOSTER: number[]; } interface ErrorEvents { MEDIA_ERR_ABORTED: 'Media playback was aborted'; MEDIA_ERR_NETWORK: 'Network error occurred'; MEDIA_ERR_DECODE: 'Media decoding error'; MEDIA_ERR_SRC_NOT_SUPPORTED: 'Media source not supported'; } interface ErrorMessageMap { MEDIA_ERR_ABORTED: string; MEDIA_ERR_DECODE: string; MEDIA_ERR_NETWORK: string; MEDIA_ERR_SRC_NOT_SUPPORTED: string; DEFAULT: string; } /** * AudioHeadless - A modern, headless audio player with HLS support, * equalizer, queue management, and media session integration. */ declare class AudioHeadless { private audioElement; private static playerInstance; private isPlaybackLoggingEnabled; private isEqualizerEnabled; private shouldShowNotifications; private playbackQueue; private currentTrackIndex; private originalPlaybackQueue; private isShuffleEnabled; private currentLoopMode; private mediaFetchFunction; private equalizerStatus; private equalizerInstance; private hlsManager; private mediaSessionManager; private eventEmitter; private queueManager; constructor(); /** * Initialize core utility modules * @private */ private initializeCoreModules; /** * Initialize the audio player with configuration * @param config - Player configuration options */ initialize(config: PlayerConfiguration): Promise<void>; /** * Initialize event listeners for the audio element * @private */ private initializeEventListeners; /** * Initialize the equalizer module * @private */ private initializeEqualizer; /** * Load a media track into the player * @param track - The media track to load * @param fetchFunction - Optional function to fetch track data */ loadTrack(track: MediaTrack, fetchFunction?: (track: MediaTrack) => Promise<void>): Promise<void>; /** * Load and immediately play a media track * @param track - The media track to load and play * @param fetchFunction - Optional function to fetch track data */ loadAndPlay(track?: MediaTrack | null, fetchFunction?: (track: MediaTrack) => Promise<void>): Promise<void>; /** * Load HLS stream using HLS manager * @private */ private loadHlsStream; /** * Start audio playback */ play(): Promise<void>; /** * Pause audio playback */ pause(): void; /** * Stop audio playback and reset position */ stop(): void; /** * Set audio volume (0-100) * @param volume - Volume level between 0 and 100 */ setVolume(volume: number): void; /** * Get current volume (0-100) */ getVolume(): number; /** * Set playback rate * @param rate - Playback rate multiplier */ setPlaybackRate(rate: PlaybackRate): void; /** * Get current playback rate */ getPlaybackRate(): PlaybackRate; /** * Seek to specific time in seconds * @param seconds - Time position in seconds */ seekToTime(seconds: number): void; /** * Seek by relative time offset * @param seconds - Time offset in seconds (can be negative) */ seekByTime(seconds: number): void; /** * Mute audio */ mute(): void; /** * Unmute audio */ unmute(): void; /** * Check if audio is muted */ isMuted(): boolean; /** * Set the playback queue * @param tracks - Array of media tracks * @param playbackType - Type of queue playback (default, reverse, shuffle) */ setQueue(tracks: MediaTrack[], playbackType?: QueuePlaybackType): void; /** * Add tracks to the current queue * @param tracks - Single track or array of tracks to add */ addToQueue(tracks: MediaTrack | MediaTrack[]): void; /** * Remove track from queue by ID * @param trackId - ID of the track to remove */ removeFromQueue(trackId: string): void; /** * Clear the entire queue */ clearQueue(): void; /** * Get current queue */ getQueue(): MediaTrack[]; /** * Get current track index */ getCurrentTrackIndex(): number; /** * Play next track in queue */ playNext(): Promise<void>; /** * Play previous track in queue */ playPrevious(): Promise<void>; /** * Play track at specific index * @param index - Index of track to play */ playTrackAt(index: number): Promise<void>; /** * Enable or disable shuffle mode * @param enabled - Whether to enable shuffle */ enableShuffle(enabled: boolean): void; /** * Check if shuffle is enabled */ isShuffleActive(): boolean; /** * Set loop mode * @param mode - Loop mode (SINGLE, QUEUE, OFF) */ setLoopMode(mode: LoopMode): void; /** * Get current loop mode */ getLoopMode(): LoopMode; /** * Get available equalizer presets */ getEqualizerPresets(): EqualizerPresets; /** * Set equalizer preset * @param presetName - Name of the preset to apply */ setEqualizerPreset(presetName: keyof EqualizerPresets): void; /** * Set custom equalizer gains * @param gains - Array of gain values for each band */ setCustomEqualizer(gains: number[]): void; /** * Enable or disable bass boost * @param enabled - Whether to enable bass boost * @param boost - Boost amount (default: 6) */ enableBassBoost(enabled: boolean, boost?: number): void; /** * Get equalizer status */ getEqualizerState(): EqualizerStatus; /** * Subscribe to state changes * @param callback - Function to call when state changes * @returns Unsubscribe function */ onStateChange(callback: (state: PlayerState) => void): () => void; /** * Get current player state */ getCurrentState(): PlayerState; /** * Add event listener to audio element * @param event - Event name * @param callback - Event callback */ addEventListener(event: keyof HTMLMediaElementEventMap, callback: EventListener): void; /** * Remove event listener from audio element * @param event - Event name * @param callback - Event callback */ removeEventListener(event: keyof HTMLMediaElementEventMap, callback: EventListener): void; /** * Reset player to initial state */ reset(): Promise<void>; /** * Destroy player instance and cleanup resources */ destroy(): Promise<void>; /** * Get singleton instance */ static getInstance(): AudioHeadless; /** * Get audio element */ static getAudioElement(): HTMLAudioElement; /** * Legacy method name for backward compatibility */ static getAudioInstance(): HTMLAudioElement; /** * Update current track index based on track ID * @private */ private updateCurrentTrackIndex; /** * Emit state change event * @private */ private emitStateChange; /** * Emit queue change event * @private */ private emitQueueChange; } declare const PLAYER_CONSTANTS: Readonly<{ REACT: InitMode; VANILLA: InitMode; DEVELOPMENT: "development"; PRODUCTION: "production"; }>; declare const PLAYBACK_STATES: Readonly<{ BUFFERING: "buffering"; PLAYING: "playing"; PAUSED: "paused"; READY: "ready"; IDLE: "idle"; ENDED: "ended"; STALLED: "stalled"; ERROR: "error"; TRACK_CHANGE: "trackchanged"; DURATION_CHANGE: "durationchanged"; QUEUE_ENDED: "queueended"; }>; declare const READY_STATES: Readonly<{ HAVE_NOTHING: 0; HAVE_METADATA: 1; HAVE_CURRENT_DATA: 2; HAVE_FUTURE_DATA: 3; HAVE_ENOUGH_DATA: 4; }>; declare const NETWORK_STATES: Readonly<{ NETWORK_EMPTY: 0; NETWORK_IDLE: 1; NETWORK_LOADING: 2; NETWORK_NO_SOURCE: 3; }>; declare const ERROR_MESSAGES: ErrorMessageMap; declare const EXTERNAL_URLS: Readonly<{ HLS_CDN: "https://cdnjs.cloudflare.com/ajax/libs/hls.js/1.5.18/hls.min.js"; CAST_SDK: "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"; }>; declare const EQUALIZER_PRESETS: Readonly<{ FLAT: number[]; ACOUSTIC: number[]; BASS_BOOSTER: number[]; BASS_REDUCER: number[]; CLASSICAL: number[]; DEEP: number[]; ELECTRONIC: number[]; LATIN: number[]; LOUDNESS: number[]; LOUNGE: number[]; PIANO: number[]; POP: number[]; RNB: number[]; ROCK: number[]; SMALL_SPEAKERS: number[]; SPOKEN_WORD: number[]; TREBLE_BOOSTER: number[]; TREBLE_REDUCER: number[]; VOCAL_BOOSTER: number[]; }>; declare const EQUALIZER_BANDS: { type: BiquadFilterType; frequency: number; Q: number; gain: number; }[]; declare const AUDIO_EVENTS: Readonly<{ ABORT: "abort"; TIME_UPDATE: "timeupdate"; CAN_PLAY: "canplay"; CAN_PLAY_THROUGH: "canplaythrough"; DURATION_CHANGE: "durationchange"; ENDED: "ended"; EMPTIED: "emptied"; PLAYING: "playing"; WAITING: "waiting"; SEEKING: "seeking"; SEEKED: "seeked"; LOADED_META_DATA: "loadedmetadata"; LOADED_DATA: "loadeddata"; PLAY: "play"; PAUSE: "pause"; RATE_CHANGE: "ratechange"; VOLUME_CHANGE: "volumechange"; SUSPEND: "suspend"; STALLED: "stalled"; PROGRESS: "progress"; LOAD_START: "loadstart"; ERROR: "error"; TRACK_CHANGE: "trackchange"; QUEUE_ENDED: "queueended"; }>; declare const HLS_EVENTS: Readonly<{ MEDIA_ATTACHING: "hlsMediaAttaching"; MEDIA_ATTACHED: "hlsMediaAttached"; MEDIA_DETACHING: "hlsMediaDetaching"; MEDIA_DETACHED: "hlsMediaDetached"; BUFFER_RESET: "hlsBufferReset"; BUFFER_CODECS: "hlsBufferCodecs"; BUFFER_CREATED: "hlsBufferCreated"; BUFFER_APPENDING: "hlsBufferAppending"; BUFFER_APPENDED: "hlsBufferAppended"; BUFFER_EOS: "hlsBufferEos"; BUFFER_FLUSHING: "hlsBufferFlushing"; BUFFER_FLUSHED: "hlsBufferFlushed"; MANIFEST_LOADING: "hlsManifestLoading"; MANIFEST_LOADED: "hlsManifestLoaded"; MANIFEST_PARSED: "hlsManifestParsed"; LEVEL_SWITCHING: "hlsLevelSwitching"; LEVEL_SWITCHED: "hlsLevelSwitched"; LEVEL_LOADING: "hlsLevelLoading"; LEVEL_LOADED: "hlsLevelLoaded"; LEVEL_UPDATED: "hlsLevelUpdated"; LEVEL_PTS_UPDATED: "hlsLevelPtsUpdated"; LEVELS_UPDATED: "hlsLevelsUpdated"; AUDIO_TRACKS_UPDATED: "hlsAudioTracksUpdated"; AUDIO_TRACK_SWITCHING: "hlsAudioTrackSwitching"; AUDIO_TRACK_SWITCHED: "hlsAudioTrackSwitched"; AUDIO_TRACK_LOADING: "hlsAudioTrackLoading"; AUDIO_TRACK_LOADED: "hlsAudioTrackLoaded"; SUBTITLE_TRACKS_UPDATED: "hlsSubtitleTracksUpdated"; SUBTITLE_TRACKS_CLEARED: "hlsSubtitleTracksCleared"; SUBTITLE_TRACK_SWITCH: "hlsSubtitleTrackSwitch"; SUBTITLE_TRACK_LOADING: "hlsSubtitleTrackLoading"; SUBTITLE_TRACK_LOADED: "hlsSubtitleTrackLoaded"; SUBTITLE_FRAG_PROCESSED: "hlsSubtitleFragProcessed"; CUES_PARSED: "hlsCuesParsed"; NON_NATIVE_TEXT_TRACKS_FOUND: "hlsNonNativeTextTracksFound"; INIT_PTS_FOUND: "hlsInitPtsFound"; FRAG_LOADING: "hlsFragLoading"; FRAG_LOAD_EMERGENCY_ABORTED: "hlsFragLoadEmergencyAborted"; FRAG_LOADED: "hlsFragLoaded"; FRAG_DECRYPTED: "hlsFragDecrypted"; FRAG_PARSING_INIT_SEGMENT: "hlsFragParsingInitSegment"; FRAG_PARSING_USERDATA: "hlsFragParsingUserdata"; FRAG_PARSING_METADATA: "hlsFragParsingMetadata"; FRAG_PARSED: "hlsFragParsed"; FRAG_BUFFERED: "hlsFragBuffered"; FRAG_CHANGED: "hlsFragChanged"; FPS_DROP: "hlsFpsDrop"; FPS_DROP_LEVEL_CAPPING: "hlsFpsDropLevelCapping"; ERROR: "hlsError"; DESTROYING: "hlsDestroying"; KEY_LOADING: "hlsKeyLoading"; KEY_LOADED: "hlsKeyLoaded"; LIVE_BACK_BUFFER_REACHED: "hlsLiveBackBufferReached"; BACK_BUFFER_REACHED: "hlsBackBufferReached"; }>; declare const ERROR_EVENTS: Readonly<{ MEDIA_ERR_ABORTED: "Media playback was aborted"; MEDIA_ERR_NETWORK: "Network error occurred"; MEDIA_ERR_DECODE: "Media decoding error"; MEDIA_ERR_SRC_NOT_SUPPORTED: "Media source not supported"; }>; declare const AUDIO_X_CONSTANTS: Readonly<{ REACT: InitMode; VANILLA: InitMode; DEVELOPMENT: "development"; PRODUCTION: "production"; }>; declare const PLAYBACK_STATE: Readonly<{ BUFFERING: "buffering"; PLAYING: "playing"; PAUSED: "paused"; READY: "ready"; IDLE: "idle"; ENDED: "ended"; STALLED: "stalled"; ERROR: "error"; TRACK_CHANGE: "trackchanged"; DURATION_CHANGE: "durationchanged"; QUEUE_ENDED: "queueended"; }>; declare const READY_STATE: Readonly<{ HAVE_NOTHING: 0; HAVE_METADATA: 1; HAVE_CURRENT_DATA: 2; HAVE_FUTURE_DATA: 3; HAVE_ENOUGH_DATA: 4; }>; declare const ERROR_MSG_MAP: ErrorMessageMap; declare const URLS: Readonly<{ HLS_CDN: "https://cdnjs.cloudflare.com/ajax/libs/hls.js/1.5.18/hls.min.js"; CAST_SDK: "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1"; }>; type EventCallback = (data: any) => void; /** * Simple event emitter for player state management */ declare class EventEmitter { private eventMap; /** * Subscribe to an event * @param eventName - Name of the event * @param callback - Function to call when event is emitted * @returns Unsubscribe function */ subscribe(eventName: string, callback: EventCallback): () => void; /** * Unsubscribe from an event * @param eventName - Name of the event * @param callback - Function to remove */ unsubscribe(eventName: string, callback: EventCallback): void; /** * Emit an event to all subscribers * @param eventName - Name of the event * @param data - Data to pass to callbacks */ emit(eventName: string, data: any): void; /** * Remove all listeners for an event * @param eventName - Name of the event */ removeAllListeners(eventName?: string): void; /** * Get the number of listeners for an event * @param eventName - Name of the event * @returns Number of listeners */ listenerCount(eventName: string): number; /** * Get all event names that have listeners * @returns Array of event names */ eventNames(): string[]; } /** * Queue management utility for the audio player */ declare class QueueManager { private queue; /** * Set the queue with specific playback type * @param tracks - Array of tracks * @param playbackType - Type of playback ordering */ setQueue(tracks: MediaTrack[], playbackType: QueuePlaybackType): void; /** * Get the current queue * @returns Array of tracks */ getQueue(): MediaTrack[]; /** * Add tracks to the queue * @param tracks - Single track or array of tracks */ addToQueue(tracks: MediaTrack | MediaTrack[]): void; /** * Remove track from queue by ID * @param trackId - ID of track to remove * @returns True if track was removed */ removeFromQueue(trackId: string): boolean; /** * Clear the entire queue */ clearQueue(): void; /** * Get queue length * @returns Number of tracks in queue */ getQueueLength(): number; /** * Get track at specific index * @param index - Index of track * @returns Track at index or undefined */ getTrackAt(index: number): MediaTrack | undefined; /** * Find track index by ID * @param trackId - ID of track to find * @returns Index of track or -1 if not found */ findTrackIndex(trackId: string): number; /** * Move track to new position * @param fromIndex - Current index * @param toIndex - Target index * @returns True if move was successful */ moveTrack(fromIndex: number, toIndex: number): boolean; /** * Shuffle the queue using Fisher-Yates algorithm * @param currentTrackId - Optional current track ID to keep at current position * @returns Shuffled queue */ shuffleQueue(currentTrackId?: string): MediaTrack[]; /** * Shuffle an array using Fisher-Yates algorithm * @param array - Array to shuffle * @returns New shuffled array */ private shuffleArray; /** * Get next track index with loop support * @param currentIndex - Current track index * @param loopMode - Current loop mode * @returns Next track index or -1 if no next track */ getNextTrackIndex(currentIndex: number, loopMode: 'OFF' | 'SINGLE' | 'QUEUE'): number; /** * Get previous track index * @param currentIndex - Current track index * @returns Previous track index or -1 if no previous track */ getPreviousTrackIndex(currentIndex: number): number; /** * Check if queue is empty * @returns True if queue is empty */ isEmpty(): boolean; /** * Get queue statistics * @returns Object with queue statistics */ getQueueStats(): { totalTracks: number; totalDuration: number; averageDuration: number; }; } /** * Validation utilities for the audio player */ declare class ValidationUtils { /** * Check if an array is valid and has elements * @param arr - Array to validate * @returns True if array is valid and not empty */ static isValidArray(arr: any[]): boolean; /** * Check if a function is valid * @param fn - Function to validate * @returns True if function is valid */ static isValidFunction(fn: any): boolean; /** * Check if an object is valid and not null * @param obj - Object to validate * @returns True if object is valid */ static isValidObject(obj: any): boolean; /** * Check if a string is valid and not empty * @param str - String to validate * @returns True if string is valid */ static isValidString(str: any): boolean; /** * Check if a number is valid and finite * @param num - Number to validate * @returns True if number is valid */ static isValidNumber(num: any): boolean; /** * Check if a value is defined (not null or undefined) * @param value - Value to check * @returns True if value is defined */ static isDefined(value: any): boolean; /** * Validate volume range (0-100) * @param volume - Volume value to validate * @returns True if volume is in valid range */ static isValidVolume(volume: number): boolean; /** * Validate time value (non-negative) * @param time - Time value to validate * @returns True if time is valid */ static isValidTime(time: number): boolean; } /** * Playback utility functions */ declare class PlaybackUtils { private static playbackStartTime; private static totalPlayTime; /** * Calculate actual played length for analytics * @param audioElement - HTML audio element * @param event - Event type that triggered calculation */ static calculateActualPlayedLength(audioElement: HTMLAudioElement, event: string): void; /** * Get total playback time * @returns Total playback time in milliseconds */ static getTotalPlayTime(): number; /** * Reset playback time tracking */ static resetPlayTime(): void; /** * Handle loop playback mode * @param loopMode - The loop mode to apply */ static handleLoopPlayback(loopMode: LoopMode): void; /** * Handle queue playback progression */ static handleQueuePlayback(): void; /** * Calculate playback progress percentage * @param currentTime - Current playback time * @param duration - Total track duration * @returns Progress percentage (0-100) */ static calculateProgress(currentTime: number, duration: number): number; /** * Calculate remaining time * @param currentTime - Current playback time * @param duration - Total track duration * @returns Remaining time in seconds */ static calculateRemainingTime(currentTime: number, duration: number): number; /** * Format time for display * @param seconds - Time in seconds * @returns Formatted time string (MM:SS or HH:MM:SS) */ static formatTime(seconds: number): string; /** * Get buffered duration * @param audioElement - HTML audio element * @returns Buffered duration in seconds */ static getBufferedDuration(audioElement: HTMLAudioElement): number; /** * Check if track can be played through without buffering * @param audioElement - HTML audio element * @returns True if track can play through */ static canPlayThrough(audioElement: HTMLAudioElement): boolean; /** * Get playback rate adjusted duration * @param duration - Original duration * @param playbackRate - Current playback rate * @returns Adjusted duration */ static getAdjustedDuration(duration: number, playbackRate: number): number; /** * Smooth seek to prevent audio glitches * @param audioElement - HTML audio element * @param targetTime - Target time to seek to * @param smooth - Whether to use smooth seeking */ static seekTo(audioElement: HTMLAudioElement, targetTime: number, smooth?: boolean): void; } /** * Professional audio equalizer with 10-band EQ and bass boost */ declare class Equalizer { private static equalizerInstance; private audioContext; private contextStatus; private filterBands; private bassBoostFilter; private compressorNode; private gainNode; constructor(); /** * Initialize AudioContext with browser compatibility * @private */ private initializeAudioContext; /** * Add listener to resume AudioContext on user interaction * @private */ private addContextResumeListener; /** * Initialize all audio processing nodes * @param audioElement - The HTML audio element to connect */ initializeWithAudioElement(audioElement: HTMLAudioElement): void; /** * Connect all audio nodes in the processing chain * @private */ private connectAudioChain; /** * Apply equalizer preset * @param presetName - Name of the preset to apply */ setPreset(presetName: keyof EqualizerPresets): void; /** * Set custom equalizer gains * @param gains - Array of gain values (-12 to +12 dB) */ setCustomEQ(gains: number[]): void; /** * Enable or disable bass boost * @param enabled - Whether to enable bass boost * @param boostAmount - Boost amount in dB (default: 6) */ setBassBoost(enabled: boolean, boostAmount?: number): void; /** * Set master volume * @param volume - Volume level (0.0 to 1.0) */ setMasterVolume(volume: number): void; /** * Get current equalizer gains * @returns Array of current gain values */ getCurrentGains(): number[]; /** * Reset equalizer to flat response */ reset(): void; /** * Get equalizer status * @returns Current equalizer status */ status(): EqualizerStatus; /** * Update compressor settings * @param settings - Partial compressor settings */ setCompressorSettings(settings: Partial<{ threshold: number; knee: number; ratio: number; attack: number; release: number; }>): void; /** * Get available presets * @returns Object containing all available presets */ static getPresets(): EqualizerPresets; /** * Destroy equalizer and cleanup resources */ destroy(): Promise<void>; } export { AUDIO_EVENTS, AUDIO_X_CONSTANTS, type AudioEvents, AudioHeadless, AudioHeadless as AudioX, type CrossOriginValue, EQUALIZER_BANDS, EQUALIZER_PRESETS, ERROR_EVENTS, ERROR_MESSAGES, ERROR_MSG_MAP, EXTERNAL_URLS, Equalizer, type EqualizerBand, type EqualizerPresets, type EqualizerStatus, type ErrorEvents, type EventCallbackMap, EventEmitter, HLS_EVENTS, type HlsEventCallbackMap, type HlsEvents, type InitMode, type LoopMode, type MediaArtwork, type MediaTrack, NETWORK_STATES, type NetworkState, PLAYBACK_STATE, PLAYBACK_STATES, PLAYER_CONSTANTS, type PlaybackRate, PlaybackUtils, type PlayerConfiguration, type PlayerError, type PlayerState, type PreloadStrategy, QueueManager, type QueuePlaybackType, READY_STATE, READY_STATES, type ReadyState, URLS, ValidationUtils };