audio.libx.js/build/types.d.ts

Comprehensive audio library with progressive streaming, recording capabilities, real-time processing, and intelligent caching for web applications

export interface AudioStreamerOptions {
    bufferThreshold?: number;
    enableCaching?: boolean;
    enableTrimming?: boolean;
    mimeType?: string;
    silenceThresholdDb?: number;
    minSilenceMs?: number;
    cacheDbName?: string;
    cacheStoreName?: string;
}
export interface StreamResult {
    onLoaded: Promise<string>;
    onEnded: Promise<string>;
    audioId: string;
    cancel: () => void;
}
export interface AudioCacheEntry {
    id: string;
    chunks: Uint8Array[];
    mimeType: string;
    cachedAt: number;
    originalSize: number;
    processed?: boolean;
}
export interface AudioProcessingResult {
    blob: Blob;
    metadata: {
        originalDuration: number;
        trimmedDuration: number;
        silenceRemovedStart: number;
        silenceRemovedEnd: number;
    };
}
export interface MediaSourceInfo {
    mediaSource: MediaSource | any;
    isManaged: boolean;
    supportedMimeTypes: string[];
}
export interface StreamingState {
    state: 'idle' | 'loading' | 'streaming' | 'playing' | 'paused' | 'ended' | 'error';
    currentAudioId?: string;
    bufferProgress: number;
    canPlay: boolean;
    error?: string;
}
export type StreamingEventType = 'stateChange' | 'bufferProgress' | 'canPlay' | 'loadStart' | 'loadEnd' | 'playStart' | 'playEnd' | 'error' | 'cacheHit' | 'cacheMiss';
export interface StreamingEvent {
    type: StreamingEventType;
    audioId?: string;
    data?: any;
    timestamp: number;
}
export type StreamingEventCallback = (event: StreamingEvent) => void;
export interface AudioFormat {
    type: 'mp3' | 'wav' | 'webm' | 'ogg' | 'unknown';
    mimeType: string;
    streamable: boolean;
    codec?: string;
    requiresConversion?: boolean;
}
export interface ChunkAppendOptions {
    waitForUpdate?: boolean;
    timeout?: number;
    retryCount?: number;
}
export interface CacheStats {
    entryCount: number;
    totalSize: number;
    availableQuota: number;
    usedQuota: number;
    hitRatio: number;
}
export declare class AudioStreamingError extends Error {
    code: string;
    audioId?: string;
    originalError?: Error;
    constructor(message: string, code: string, audioId?: string, originalError?: Error);
}
export declare class MediaSourceError extends AudioStreamingError {
    constructor(message: string, audioId?: string, originalError?: Error);
}
export declare class CacheError extends AudioStreamingError {
    constructor(message: string, audioId?: string, originalError?: Error);
}
export declare class ProcessingError extends AudioStreamingError {
    constructor(message: string, audioId?: string, originalError?: Error);
}
export declare class RecordingError extends AudioStreamingError {
    constructor(message: string, recordingId?: string, originalError?: Error);
}
export declare class PermissionError extends AudioStreamingError {
    constructor(message: string, originalError?: Error);
}
export interface AudioRecorderOptions {
    mimeType?: string;
    audioBitsPerSecond?: number;
    enableEchoCancellation?: boolean;
    enableNoiseSuppression?: boolean;
    enableAutoGainControl?: boolean;
    maxDuration?: number;
    enableRealtimeProcessing?: boolean;
    silenceThresholdDb?: number;
}
export interface RecordingState {
    state: 'idle' | 'requesting-permission' | 'recording' | 'paused' | 'processing' | 'completed' | 'error';
    recordingId?: string;
    duration: number;
    hasPermission: boolean;
    audioLevel?: number;
    error?: string;
}
export interface RecordingResult {
    recordingId: string;
    onStarted: Promise<string>;
    onCompleted: Promise<RecordingData>;
    stop: () => Promise<RecordingData>;
    pause: () => void;
    resume: () => void;
    cancel: () => void;
}
export interface RecordingData {
    id: string;
    blob: Blob;
    mimeType: string;
    duration: number;
    metadata: {
        startTime: number;
        endTime: number;
        sampleRate?: number;
        channels?: number;
        averageLevel?: number;
    };
}
export type RecordingEventType = 'permissionRequested' | 'permissionGranted' | 'permissionDenied' | 'recordingStarted' | 'recordingPaused' | 'recordingResumed' | 'recordingStopped' | 'recordingCompleted' | 'recordingCancelled' | 'audioLevel' | 'durationUpdate' | 'recordingError';
export interface RecordingEvent {
    type: RecordingEventType;
    recordingId?: string;
    data?: any;
    timestamp: number;
}
export type RecordingEventCallback = (event: RecordingEvent) => void;
export interface PermissionState {
    status: 'granted' | 'denied' | 'prompt' | 'unknown';
    isSupported: boolean;
    error?: PermissionError;
}
export interface PermissionResult {
    granted: boolean;
    state: PermissionState;
    stream?: MediaStream;
    error?: PermissionError;
}
export interface MediaConstraintsOptions {
    deviceId?: string;
    echoCancellation?: boolean;
    noiseSuppression?: boolean;
    autoGainControl?: boolean;
    sampleRate?: number;
    channelCount?: number;
}
export interface RealtimeProcessingOptions {
    enableSilenceDetection?: boolean;
    silenceThresholdDb?: number;
    enableLevelMonitoring?: boolean;
    levelUpdateInterval?: number;
    enableEffects?: boolean;
    effects?: AudioEffect[];
}
export interface AudioEffect {
    type: 'gain' | 'filter' | 'reverb' | 'echo' | 'custom';
    parameters: Record<string, any>;
    enabled: boolean;
}
export interface RealtimeAudioData {
    audioData: Float32Array;
    sampleRate: number;
    channels: number;
    level: number;
    isSilence: boolean;
    timestamp: number;
}
//# sourceMappingURL=types.d.ts.map