/**
 * Core types for AudioWave audio processing
 */
/**
 * Configuration for audio processing
 */
interface AudioConfig {
    /** Buffer size for audio processing (samples) */
    bufferSize: number;
    /** Number of initial frames to skip to avoid initialization noise (default: 0) */
    skipInitialFrames?: number;
    /** Input audio bits per sample (8, 16, 24, 32) - default: 32 */
    inputBitsPerSample?: 8 | 16 | 24 | 32;
    /** Input audio channels (1=mono, 2=stereo, etc.) - default: 1 */
    inputChannels?: number;
}
/**
 * Audio data provider interface - abstraction for any audio data source
 * Provider only needs to provide data subscription capability, configuration is handled internally by useCustomAudio
 */
interface AudioDataProvider {
    /** Subscribe to audio data events - returns unsubscribe function */
    onAudioData(callback: (data: Uint8Array) => void): () => void;
    /** Subscribe to error events (optional) - returns unsubscribe function */
    onAudioError?(callback: (error: string) => void): () => void;
}
/**
 * Processed audio data packet
 */
interface AudioDataPacket {
    /** Time domain audio data in range [0, 255] for visualization */
    timeDomainData: Uint8Array;
    /** Timestamp when data was processed (milliseconds) */
    timestamp: number;
    /** Buffer size used for this packet */
    bufferSize: number;
}
/**
 * Supported audio data input formats for processing
 */
type AudioDataInput = Buffer | Float32Array;
/**
 * Audio device information
 */
interface AudioDeviceInfo {
    /** Unique device identifier */
    id: string;
    /** Human-readable device name */
    name: string;
}

/**
 * Default configuration for audio processing
 */
declare const DEFAULT_AUDIO_CONFIG: AudioConfig;
/**
 * Common buffer sizes for audio processing
 */
declare const COMMON_BUFFER_SIZES: readonly [256, 512, 1024, 2048, 4096, 8192];
/**
 * Audio processing constants
 */
declare const AUDIO_CONSTANTS: {
    /** Maximum buffer size allowed */
    readonly MAX_BUFFER_SIZE: 16384;
    /** Minimum buffer size allowed */
    readonly MIN_BUFFER_SIZE: 64;
    /** Maximum skip frames allowed */
    readonly MAX_SKIP_FRAMES: 100;
    /** Sample rate normalization factor for 32-bit integers */
    readonly INT32_NORMALIZATION_FACTOR: number;
    /** Conversion factor for [-1, 1] to [0, 255] range */
    readonly UINT8_CONVERSION_FACTOR: 127.5;
};

/**
 * Simple audio processor with minimal state for skip frames functionality
 */
declare class AudioProcessor {
    private frameCount;
    private config;
    constructor(config: AudioConfig);
    /**
     * Process raw audio data and convert to visualization format
     * Handles skip frames logic internally
     */
    process(rawData: AudioDataInput): AudioDataPacket | null;
    /**
     * Reset frame counter (call when starting new audio stream)
     */
    reset(): void;
    /**
     * Update configuration
     */
    updateConfig(config: AudioConfig): void;
}
/**
 * Stateless audio processing function (for cases without skip frames)
 *
 * @param rawData - Raw audio data (Buffer or Float32Array)
 * @param config - Audio processing configuration
 * @returns Processed audio packet or null if processing fails
 */
declare function process(rawData: AudioDataInput, config: AudioConfig): AudioDataPacket | null;
/**
 * Convert Buffer directly to wave data (Uint8Array) for AudioWave visualization
 * One-step conversion: format parsing + channel mixing + resampling + amplitude mapping
 */
declare function convertBufferToWaveData(buffer: Buffer, bitsPerSample: number, channels: number, targetSize: number): Uint8Array;
/**
 * Validate audio configuration
 */
declare function validateAudioConfig(config: AudioConfig): boolean;

/**
 * Create audio configuration with defaults
 */
declare function createAudioConfig(config?: Partial<AudioConfig>): AudioConfig;
/**
 * Check if buffer size is a power of 2 (recommended for FFT)
 */
declare function isPowerOfTwo(n: number): boolean;
/**
 * Get the nearest power of 2 buffer size
 */
declare function getNearestPowerOfTwo(size: number): number;
/**
 * Validate buffer data format for 32-bit samples
 */
declare function isValidAudioBuffer(buffer: Buffer): boolean;

export { AUDIO_CONSTANTS, type AudioConfig, type AudioDataInput, type AudioDataPacket, type AudioDataProvider, type AudioDeviceInfo, AudioProcessor, COMMON_BUFFER_SIZES, DEFAULT_AUDIO_CONFIG, convertBufferToWaveData, createAudioConfig, getNearestPowerOfTwo, isPowerOfTwo, isValidAudioBuffer, process, validateAudioConfig };