capacitor-audio-engine
Version:
High-quality audio recording Capacitor plugin with native iOS & Android support. Features pause/resume, microphone management, real-time monitoring, audio trimming, and comprehensive mobile audio recording capabilities.
787 lines (786 loc) • 28.8 kB
TypeScript
import type { PluginListenerHandle } from '@capacitor/core';
export declare type RecordingStatus = 'idle' | 'recording' | 'paused';
export declare type PlaybackStatus = 'idle' | 'loading' | 'playing' | 'paused' | 'stopped';
export declare type AudioRecordingEventName = 'durationChange' | 'error' | 'waveformData' | 'waveformInit' | 'waveformDestroy';
export declare type AudioPlaybackEventName = 'trackChanged' | 'trackEnded' | 'playbackStarted' | 'playbackPaused' | 'playbackError' | 'playbackProgress' | 'playbackStatusChanged';
export declare type AudioEventName = AudioRecordingEventName | AudioPlaybackEventName;
export interface AudioRecordingEvent<T = any> {
eventName: AudioRecordingEventName;
payload: T;
}
export interface AudioPlaybackEvent<T = any> {
eventName: AudioPlaybackEventName;
payload: T;
}
export declare type AudioRecordingEventMap = {
durationChange: DurationChangeData;
error: ErrorEventData;
waveformData: WaveformData;
waveformInit: WaveformInitData;
waveformDestroy: WaveformDestroyData;
};
export declare type AudioPlaybackEventMap = {
trackChanged: TrackChangedData;
trackEnded: TrackEndedData;
playbackStarted: PlaybackStartedData;
playbackPaused: PlaybackPausedData;
playbackError: ErrorEventData;
playbackProgress: PlaybackProgressData;
playbackStatusChanged: PlaybackStatusChangedData;
};
export declare type AudioEventMap = AudioRecordingEventMap & AudioPlaybackEventMap;
export interface DurationChangeData {
duration: number;
}
export interface WaveformData {
level: number;
timestamp: number;
}
export interface WaveformInitData {
numberOfBars: number;
speechOnlyMode?: boolean;
speechThreshold?: number;
vadEnabled?: boolean;
calibrationDuration?: number;
}
export interface WaveformDestroyData {
reason: string;
timestamp: number;
}
export interface ErrorEventData {
message: string;
code?: string | number;
details?: any;
}
export interface AudioTrack {
id: string;
url: string;
title?: string;
artist?: string;
artworkUrl?: string;
}
export interface TrackChangedData {
track: AudioTrack;
index: number;
}
export interface TrackEndedData {
track: AudioTrack;
index: number;
}
export interface PlaybackStartedData {
track: AudioTrack;
index: number;
}
export interface PlaybackPausedData {
track: AudioTrack;
index: number;
position: number;
}
export interface PlaybackProgressData {
track: AudioTrack;
index: number;
currentPosition: number;
duration: number;
isPlaying: boolean;
}
export interface PlaybackStatusChangedData {
track: AudioTrack | null;
index: number;
status: PlaybackStatus;
currentPosition: number;
duration: number;
isPlaying: boolean;
}
export declare enum AudioSampleRate {
/** Low quality - 8kHz for voice recording */
VOICE_8K = 8000,
/** Voice quality - 16kHz for speech */
VOICE_16K = 16000,
/** Standard quality - 22.05kHz (default optimized) */
STANDARD_22K = 22050,
/** CD quality - 44.1kHz */
CD_44K = 44100,
/** High quality - 48kHz */
HIGH_48K = 48000
}
export declare enum AudioChannels {
/** Mono - single channel */
MONO = 1,
/** Stereo - two channels */
STEREO = 2
}
export declare enum AudioBitrate {
/** Very low bitrate - 16kbps for voice notes */
VERY_LOW = 16000,
/** Low bitrate - 32kbps for voice recording */
LOW = 32000,
/** Medium bitrate - 64kbps (default optimized) */
MEDIUM = 64000,
/** High bitrate - 128kbps for music */
HIGH = 128000,
/** Very high bitrate - 256kbps for high quality */
VERY_HIGH = 256000
}
export declare enum AudioQuality {
/** Low quality: 16kHz, 32kbps - smallest files, suitable for voice notes */
LOW = "low",
/** Medium quality: 22.05kHz, 64kbps - balanced quality/size (default) */
MEDIUM = "medium",
/** High quality: 44.1kHz, 128kbps - higher quality, larger files */
HIGH = "high"
}
export interface RecordingOptions {
/**
* Audio sample rate (Hz). Default: AudioSampleRate.STANDARD_22K (optimized for smaller file sizes)
*/
sampleRate?: AudioSampleRate | number;
/**
* Number of audio channels. Default: AudioChannels.MONO
*/
channels?: AudioChannels | number;
/**
* Audio bitrate (bps). Default: AudioBitrate.MEDIUM (optimized for smaller file sizes)
*/
bitrate?: AudioBitrate | number;
/**
* Audio quality preset. If specified, overrides individual sampleRate and bitrate settings.
* - AudioQuality.LOW: 16kHz, 32kbps - smallest files, suitable for voice notes
* - AudioQuality.MEDIUM: 22.05kHz, 64kbps - balanced quality/size (default)
* - AudioQuality.HIGH: 44.1kHz, 128kbps - higher quality, larger files
*/
quality?: AudioQuality;
/**
* Maximum recording duration in seconds.
* When set, enables segment rolling mode:
* - Records in 30-second segments
* - Maintains rolling buffer of last 10 minutes (20 segments)
* - Automatically merges segments when recording stops
* If not set, uses linear recording mode.
*/
maxDuration?: number;
}
export interface AudioFileInfo {
path: string;
webPath: string;
uri: string;
mimeType: string;
size: number;
duration: number;
sampleRate: number;
channels: number;
bitrate: number;
createdAt: number;
filename: string;
/**
* Base64-encoded audio data with MIME prefix (Data URI format)
*
* iOS may return compressed data for better performance:
* - Compressed: "data:audio/m4a;base64,lzfse:<compressed-base64-data>"
* - Uncompressed: "data:audio/m4a;base64,<base64-data>"
*
* Use compression-utils.ts helpers to parse and handle compressed data.
* Compression is lossless LZFSE algorithm optimized for iOS.
*/
base64?: string;
}
export interface MicrophoneInfo {
id: number;
name: string;
type: 'internal' | 'external' | 'unknown';
description?: string;
uid?: string;
isConnected?: boolean;
}
export interface MicrophoneStatusResult {
busy: boolean;
reason?: string;
}
export interface AvailableMicrophonesResult {
microphones: MicrophoneInfo[];
}
export interface SwitchMicrophoneOptions {
microphoneId: number;
}
export interface SwitchMicrophoneResult {
success: boolean;
microphoneId: number;
}
export declare enum WaveformBarsCount {
BARS_16 = 16,
BARS_32 = 32,
BARS_64 = 64,
BARS_128 = 128,
BARS_256 = 256
}
export declare enum WaveformDebounceTime {
/** Real-time visualization (20ms) */
REALTIME = 0.02,
/** Very fast updates (50ms) */
VERY_FAST = 0.05,
/** Fast updates (100ms) */
FAST = 0.1,
/** Medium updates (250ms) */
MEDIUM = 0.25,
/** Slow updates (500ms) */
SLOW = 0.5,
/** Very slow updates (1000ms) - Default */
VERY_SLOW = 1
}
export declare enum SpeechThreshold {
/** Very sensitive (0.005) */
VERY_SENSITIVE = 0.005,
/** Sensitive (0.01) */
SENSITIVE = 0.01,
/** Normal (0.02) */
NORMAL = 0.02,
/** Moderate (0.04) */
MODERATE = 0.04,
/** Less sensitive (0.06) */
LESS_SENSITIVE = 0.06,
/** Not sensitive (0.1) */
NOT_SENSITIVE = 0.1
}
export declare enum VADWindowSize {
/** Minimum latency (~150ms) */
MINIMAL = 3,
/** Low latency (~200ms) */
LOW = 4,
/** Normal latency (~250ms) */
NORMAL = 5,
/** Medium latency (~400ms) */
MEDIUM = 8,
/** High accuracy (~500ms) */
HIGH = 10,
/** Maximum accuracy (~750ms) */
MAXIMUM = 15
}
export declare enum CalibrationDuration {
/** Quick calibration (500ms) */
QUICK = 500,
/** Normal calibration (1000ms) */
NORMAL = 1000,
/** Extended calibration (2000ms) */
EXTENDED = 2000,
/** Long calibration (3000ms) */
LONG = 3000
}
export declare enum GainFactor {
/** Minimal gain (5.0) */
MINIMAL = 5,
/** Low gain (10.0) */
LOW = 10,
/** Standard gain (15.0) */
STANDARD = 15,
/** Medium gain (20.0) - Default */
MEDIUM = 20,
/** High gain (30.0) */
HIGH = 30,
/** Maximum gain (50.0) */
MAXIMUM = 50
}
/**
* Options for setting gain factor for audio levels
*/
export interface SetGainFactorOptions {
/**
* Gain factor value (5.0-50.0)
* Higher values amplify audio levels more, especially useful for quiet recordings
*/
gainFactor: GainFactor | number;
}
/**
* Result of setting gain factor
*/
export interface SetGainFactorResult {
success: boolean;
gainFactor: number;
}
/**
* Unified waveform configuration options combining all waveform features
*/
export interface WaveformConfiguration {
/** Number of bars in the waveform visualization (default: 128) */
numberOfBars?: WaveformBarsCount | number;
/** Debounce time in seconds between waveform data emissions (default: 1.0) */
debounceTime?: WaveformDebounceTime | number;
/** Speech detection configuration */
speechDetection?: {
/** Enable speech-only detection */
enabled: boolean;
/** Speech detection sensitivity threshold */
threshold?: SpeechThreshold | number;
/** Background noise calibration duration */
calibrationDuration?: CalibrationDuration | number;
};
/** Voice Activity Detection (VAD) configuration */
vad?: {
/** Enable VAD for improved speech detection */
enabled: boolean;
/** VAD analysis window size (affects latency vs accuracy) */
windowSize?: VADWindowSize | number;
/** Enable human voice band filtering (85Hz-3400Hz) */
enableVoiceFilter?: boolean;
};
}
/**
* Result of waveform configuration
*/
export interface WaveformConfigurationResult {
success: boolean;
configuration: {
numberOfBars: number;
debounceTimeMs: number;
speechDetection: {
enabled: boolean;
threshold: number;
calibrationDuration: number;
};
vad: {
enabled: boolean;
windowSize: number;
estimatedLatencyMs: number;
enableVoiceFilter: boolean;
};
};
}
/** @deprecated Use WaveformConfiguration instead */
export interface WaveformOptions {
numberOfBars?: number;
debounceInSeconds?: number;
}
/** @deprecated Use WaveformConfiguration instead */
export interface WaveformConfigurationOptions {
numberOfBars?: number;
debounceInSeconds?: number;
}
/** @deprecated Use WaveformConfiguration instead */
export interface WaveformSpeechDetectionOptions {
enabled?: boolean;
threshold?: number;
useVAD?: boolean;
calibrationDuration?: number;
}
/** @deprecated Use WaveformConfigurationResult instead */
export interface WaveformSpeechDetectionResult {
success: boolean;
enabled: boolean;
threshold: number;
useVAD: boolean;
calibrationDuration: number;
}
/** @deprecated Use WaveformConfiguration instead */
export interface AdvancedVADOptions {
/** Enable VAD for speech detection */
enabled?: boolean;
/** VAD window size in frames (3-20). Smaller = lower latency, larger = more accuracy. Default: 5 */
windowSize?: number;
/** Enable human voice band filtering (85Hz-3400Hz) for noise rejection. Default: true */
enableVoiceFilter?: boolean;
}
/** @deprecated Use WaveformConfigurationResult instead */
export interface AdvancedVADResult {
success: boolean;
enabled: boolean;
windowSize: number;
/** Approximate VAD latency in milliseconds */
latencyMs: number;
enableVoiceFilter: boolean;
}
/** @deprecated Use WaveformConfigurationResult instead */
export interface ConfigureWaveformResult {
success: boolean;
numberOfBars: number;
debounceInSeconds: number;
}
export interface PreloadTracksOptions {
tracks: string[];
preloadNext?: boolean;
}
export interface PreloadedTrackInfo {
url: string;
loaded: boolean;
mimeType?: string;
duration?: number;
size?: number;
}
export interface PreloadTracksResult {
tracks: PreloadedTrackInfo[];
}
export interface PlaybackInfo {
currentTrack: AudioTrack | null;
currentIndex: number;
currentPosition: number;
duration: number;
isPlaying: boolean;
status: PlaybackStatus;
}
export interface SeekOptions {
seconds: number;
url?: string;
}
export interface PlayAudioOptions {
url?: string;
}
export interface PauseAudioOptions {
url?: string;
}
export interface ResumeAudioOptions {
url?: string;
}
export interface StopAudioOptions {
url?: string;
}
export interface SkipToIndexOptions {
index: number;
}
/**
* Interface for the Native Audio Plugin that provides audio recording capabilities.
*
* Platform-specific implementations:
* - Web: Uses MediaRecorder API with WebM/Opus format for recording
* - Android: Uses MediaRecorder with AAC format in MP4 container for recording
* - iOS: Uses AVAudioRecorder with AAC format in M4A container for recording
*
* Common settings across platforms:
* - Sample Rate: 44.1kHz
* - Channels: 1 (mono)
* - Bitrate: 128kbps
*/
export interface CapacitorAudioEnginePlugin {
/**
* Test method to verify plugin functionality.
* @param options - Echo options
* @param options.value - String value to echo back
* @returns Promise that resolves with the echoed value
*/
echo(options: {
value: string;
}): Promise<{
value: string;
}>;
/**
* Check if the app has microphone permission.
* @returns Promise that resolves with an object containing the permission status
* @property {boolean} granted - Whether microphone permission is granted
* @property {boolean} audioPermission - Whether audio permission is granted
* @property {boolean} notificationPermission - Whether notification permission is granted (Android 13+ only)
* @platform web Uses navigator.permissions.query API
* @platform android Uses ContextCompat.checkSelfPermission with RECORD_AUDIO permission
* @platform ios Uses AVAudioSession.recordPermission
*/
checkPermission(): Promise<{
granted: boolean;
audioPermission?: boolean;
notificationPermission?: boolean;
}>;
/**
* Request microphone permission from the user.
* @returns Promise that resolves with an object containing the permission status
* @property {boolean} granted - Whether microphone permission was granted
* @property {boolean} audioPermission - Whether audio permission was granted
* @property {boolean} notificationPermission - Whether notification permission was granted (Android 13+ only)
* @platform web Uses navigator.mediaDevices.getUserMedia API
* @platform android Uses ActivityCompat.requestPermissions with RECORD_AUDIO permission
* @platform ios Uses AVAudioSession.requestRecordPermission
*/
requestPermission(): Promise<{
granted: boolean;
audioPermission?: boolean;
notificationPermission?: boolean;
}>;
/**
* Start recording audio from the device's microphone.
* @param options - Recording options
* @returns Promise that resolves when recording starts successfully
* @throws {Error} If recording is already in progress
* @throws {Error} If microphone permission is not granted
* @throws {Error} If audio session setup fails
* @platform web Uses MediaRecorder API
* @platform android Uses MediaRecorder
* @platform ios Uses AVAudioRecorder
*/
startRecording(options?: RecordingOptions): Promise<void>;
/**
* Pause the current recording.
* @returns Promise that resolves when recording is paused successfully
* @throws {Error} If no active recording exists or if recording is already paused
* @platform web Uses MediaRecorder.pause()
* @platform android Uses MediaRecorder.pause() (Android N/API 24+ only)
* @platform ios Uses AVAudioRecorder.pause()
*/
pauseRecording(): Promise<void>;
/**
* Resume the current recording if it was previously paused.
* @returns Promise that resolves when recording is resumed successfully
* @throws {Error} If no active recording exists or if recording is not paused
* @platform web Uses MediaRecorder.resume()
* @platform android Uses MediaRecorder.resume() (Android N/API 24+ only)
* @platform ios Uses AVAudioRecorder.record()
*/
resumeRecording(): Promise<void>;
/**
* Reset the current recording session without finalizing a file.
* Behavior:
* - Discards the current recording (segments are cleared)
* - Discards current duration and waveform data
* - Keeps the previously configured recording settings for seamless resume
* - Leaves the session in paused state so resumeRecording() starts fresh
* @returns Promise that resolves when the session is reset
*/
resetRecording(): Promise<void>;
/**
* Stop the current recording and get the recorded file information.
* @returns Promise that resolves with the recorded audio file details
* @throws {Error} If no active recording exists
* @throws {Error} If file processing fails
*/
stopRecording(): Promise<AudioFileInfo>;
/**
* Get the current recording duration.
* @returns Promise that resolves with the current duration in seconds
* @throws {Error} If no active recording exists
* @property {number} duration - Recording duration in seconds
* @platform web Not supported - returns 0
* @platform android Uses MediaRecorder.getMaxAmplitude()
* @platform ios Uses AVAudioRecorder.currentTime
*/
getDuration(): Promise<{
duration: number;
}>;
/**
* Get the current recording status.
* @returns Promise that resolves with the current recording status
* @property {RecordingStatus} status - The current state of the recorder
* @property {boolean} isRecording - True if the recording session is active
* @property {number} duration - The current recording duration in seconds
*/
getStatus(): Promise<{
status: RecordingStatus;
isRecording: boolean;
duration: number;
}>;
/**
* Trim an audio file to the specified start and end times.
* @param options - Trim options
* @param options.uri - URI of the audio file to trim
* @param options.start - Start time in seconds
* @param options.end - End time in seconds
* @returns Promise that resolves with the trimmed audio file details
* @throws {Error} If file processing fails
* @platform web Not supported
* @platform android Uses MediaExtractor and MediaMuxer
* @platform ios Uses AVAssetExportSession
*/
trimAudio(options: {
uri: string;
start: number;
end: number;
}): Promise<AudioFileInfo>;
/**
* Add a listener for recording events
* @param eventName - The name of the event to listen to
* @param callback - The callback to invoke when the event occurs
* @returns A promise that resolves with a handle to the listener
* @platform web Not supported, recording events use MediaRecorder
* @platform android Uses MediaRecorder events
* @platform ios Uses AVAudioSession notifications
*
* @example
* ```typescript
* // Listen for playback progress updates (every 500ms)
* const progressListener = await CapacitorAudioEngine.addListener('playbackProgress', (data) => {
* console.log(`Progress: ${data.currentPosition}/${data.duration} seconds`);
* });
*
* // Listen for status changes
* const statusListener = await CapacitorAudioEngine.addListener('playbackStatusChanged', (data) => {
* console.log(`Status: ${data.status}, Playing: ${data.isPlaying}`);
* });
*
* // Don't forget to remove listeners when done
* progressListener.remove();
* statusListener.remove();
* ```
*/
addListener<T extends AudioEventName>(eventName: T, callback: (event: AudioEventMap[T]) => void): Promise<PluginListenerHandle>;
/**
* Remove all listeners
* @returns Promise that resolves when all listeners are removed
*/
removeAllListeners(): Promise<void>;
/**
* Check if microphone is currently being used by another application.
* @returns Promise that resolves with microphone status
* @property {boolean} busy - Whether microphone is currently in use
* @platform web Not supported
* @platform android Uses AudioRecord to test microphone availability
* @platform ios Uses AVAudioSession to check audio state
*/
isMicrophoneBusy(): Promise<MicrophoneStatusResult>;
/**
* Get list of available microphones (internal and external).
* @returns Promise that resolves with available microphones
* @property {MicrophoneInfo[]} microphones - Array of available microphones
* @platform web Not supported
* @platform android Uses AudioManager.getDevices() to enumerate audio inputs
* @platform ios Uses AVAudioSession.availableInputs to list audio inputs
*/
getAvailableMicrophones(): Promise<AvailableMicrophonesResult>;
/**
* Switch between microphones while keeping recording active.
* @param options - Switch microphone options
* @param options.microphoneId - ID of the microphone to switch to
* @returns Promise that resolves with switch result
* @throws {Error} If microphone ID is invalid
* @throws {Error} If switching fails
* @platform web Not supported
* @platform android Uses AudioRecord.setPreferredDevice() to switch input
* @platform ios Uses AVAudioSession.setPreferredInput() to switch input
*/
switchMicrophone(options: SwitchMicrophoneOptions): Promise<SwitchMicrophoneResult>;
/**
* Configure all waveform settings in one unified call.
* This method combines waveform visualization, speech detection, and VAD configuration.
*
* @param options - Unified waveform configuration options
* @returns Promise that resolves with complete configuration result
* @throws {Error} If configuration fails
* @platform web Not supported
* @platform android Configures real-time PCM audio processing with speech detection and VAD
* @platform ios Configures AVAudioEngine audio tap with speech detection and VAD
*
* @example
* ```typescript
* // Basic waveform configuration
* await CapacitorAudioEngine.configureWaveform({
* numberOfBars: WaveformBarsCount.BARS_64,
* debounceTime: WaveformDebounceTime.FAST
* });
*
* // Advanced configuration with speech detection and VAD
* await CapacitorAudioEngine.configureWaveform({
* numberOfBars: WaveformBarsCount.BARS_32,
* debounceTime: WaveformDebounceTime.REALTIME,
* speechDetection: {
* enabled: true,
* threshold: SpeechThreshold.NORMAL,
* calibrationDuration: CalibrationDuration.NORMAL
* },
* vad: {
* enabled: true,
* windowSize: VADWindowSize.LOW,
* enableVoiceFilter: true
* }
* });
*
* // Listen for waveform data events during recording
* const waveformListener = await CapacitorAudioEngine.addListener('waveformData', (data) => {
* console.log('Amplitude level:', data.level); // Single normalized value (0-1)
* });
* ```
*/
configureWaveform(): Promise<WaveformConfigurationResult>;
/**
* Destroy waveform configuration and clean up resources.
* This will stop waveform monitoring if active and reset configuration to defaults.
* @returns Promise that resolves when waveform configuration is destroyed
* @platform web Not supported
* @platform android Stops waveform monitoring and releases AudioRecord resources
* @platform ios Stops AVAudioEngine tap and cleans up resources
*
* @example
* ```typescript
* // Destroy waveform configuration when no longer needed
* await CapacitorAudioEngine.destroyWaveform();
* ```
*/
destroyWaveform(): Promise<void>;
/**
* Set gain factor for waveform visualization levels
* @param options - Gain factor options
* @returns Promise that resolves with gain factor result
* @platform web Not supported
* @platform android Amplifies audio levels by applying gain factor to RMS values
* @platform ios Amplifies audio levels by applying gain factor to RMS values
*
* @example
* ```typescript
* // Set gain factor to boost waveform visualization levels
* await CapacitorAudioEngine.setGainFactor({
* gainFactor: GainFactor.HIGH // or a custom value like 25.0
* });
* ```
*/
setGainFactor(options: SetGainFactorOptions): Promise<SetGainFactorResult>;
/**
* Preload audio tracks from URLs and initialize playlist
* @param options - Preload options containing track URLs and preload settings
* @returns Promise that resolves with preload results for each track including load status, mimetype, duration, and file size
* @platform web Uses HTML5 Audio API
* @platform android Uses ExoPlayer with ConcatenatingMediaSource
* @platform ios Uses AVQueuePlayer or AVPlayer with queue management
*/
preloadTracks(options: PreloadTracksOptions): Promise<PreloadTracksResult>;
/**
* Start or resume playback of current track or specific preloaded track by URL
* @param options - Optional playback options with URL to play specific preloaded track
* @returns Promise that resolves when playback starts
*/
playAudio(options?: PlayAudioOptions): Promise<void>;
/**
* Pause audio playback for current track or specific preloaded track by URL
* @param options - Optional pause options with URL to pause specific preloaded track
* @returns Promise that resolves when playback is paused
*/
pauseAudio(options?: PauseAudioOptions): Promise<void>;
/**
* Resume audio playback from paused state for current track or specific preloaded track by URL
* @param options - Optional resume options with URL to resume specific preloaded track
* @returns Promise that resolves when playback resumes
*/
resumeAudio(options?: ResumeAudioOptions): Promise<void>;
/**
* Stop audio playback and reset to beginning for current track or specific preloaded track by URL
* @param options - Optional stop options with URL to stop specific preloaded track
* @returns Promise that resolves when playback stops
*/
stopAudio(options?: StopAudioOptions): Promise<void>;
/**
* Seek to specific position in current track or specific preloaded track by URL
* @param options - Seek options with time in seconds and optional URL for specific preloaded track
* @returns Promise that resolves when seek completes
*/
seekAudio(options: SeekOptions): Promise<void>;
/**
* Skip to next track in playlist
* @returns Promise that resolves when skip completes
*/
skipToNext(): Promise<void>;
/**
* Skip to previous track in playlist
* @returns Promise that resolves when skip completes
*/
skipToPrevious(): Promise<void>;
/**
* Skip to specific track index in playlist
* @param options - Options with target track index
* @returns Promise that resolves when skip completes
*/
skipToIndex(options: SkipToIndexOptions): Promise<void>;
/**
* Get current playback information
* @returns Promise that resolves with current playback state
*/
getPlaybackInfo(): Promise<PlaybackInfo>;
/**
* Navigate to the app's permission settings screen.
* This method opens the system settings page where users can manually adjust permissions.
* Useful when permissions are denied and need to be changed through settings.
* @returns Promise that resolves when navigation is initiated
* @throws {Error} If navigation fails
* @platform web Not supported - shows alert with instructions
* @platform android Opens the app-specific settings page (App Info) using ACTION_APPLICATION_DETAILS_SETTINGS intent, where users can manage permissions, notifications, and other app settings
* @platform ios Opens the app-specific settings page using UIApplication.openSettingsURLString, which navigates directly to Settings > [App Name] where users can manage app permissions and settings
*/
openSettings(): Promise<void>;
}