react-native-audio-api/lib/typescript/mock/index.d.ts

react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification

import { AudioContextOptions, AudioRecorderCallbackOptions, AudioRecorderFileOptions, AudioRecorderStartOptions, AudioWorkletRuntime, BiquadFilterType, ChannelCountMode, ChannelInterpretation, ContextState, FileDirectory, FileFormat, FileInfo, FilePresetType, OfflineAudioContextOptions, OscillatorType, OverSampleType, Result, AnalyserOptions, AudioBufferSourceOptions, BaseAudioBufferSourceOptions, BiquadFilterOptions, ConstantSourceOptions, ConvolverOptions, DelayOptions, DecodeDataInput, GainOptions, OscillatorOptions, PeriodicWaveOptions, StereoPannerOptions, StreamerOptions, WaveShaperOptions } from '../types';
declare class AudioParamMock {
    private _value;
    defaultValue: number;
    minValue: number;
    maxValue: number;
    constructor(_audioParam: unknown, _context: BaseAudioContextMock);
    get value(): number;
    set value(newValue: number);
    setValueAtTime(value: number, _startTime: number): AudioParamMock;
    linearRampToValueAtTime(value: number, _endTime: number): AudioParamMock;
    exponentialRampToValueAtTime(value: number, _endTime: number): AudioParamMock;
    setTargetAtTime(target: number, _startTime: number, _timeConstant: number): AudioParamMock;
    setValueCurveAtTime(_values: Float32Array, _startTime: number, _duration: number): AudioParamMock;
    cancelScheduledValues(_startTime: number): AudioParamMock;
    cancelAndHoldAtTime(_startTime: number): AudioParamMock;
}
declare class AudioBufferMock {
    sampleRate: number;
    length: number;
    duration: number;
    numberOfChannels: number;
    constructor(options: {
        numberOfChannels: number;
        length: number;
        sampleRate: number;
    });
    getChannelData(_channel: number): Float32Array;
    copyFromChannel(_destination: Float32Array, _channelNumber: number, _startInChannel?: number): void;
    copyToChannel(_source: Float32Array, _channelNumber: number, _startInChannel?: number): void;
}
declare class AudioNodeMock {
    context: BaseAudioContextMock;
    numberOfInputs: number;
    numberOfOutputs: number;
    channelCount: number;
    channelCountMode: ChannelCountMode;
    channelInterpretation: ChannelInterpretation;
    constructor(context: BaseAudioContextMock, _node: unknown);
    connect(destination: AudioNodeMock | AudioParamMock): AudioNodeMock | void;
    disconnect(_destination?: AudioNodeMock): void;
}
declare class AudioScheduledSourceNodeMock extends AudioNodeMock {
    private _onended;
    constructor(context: BaseAudioContextMock, node: unknown);
    start(_when?: number): void;
    stop(_when?: number): void;
    get onended(): ((event: Event) => void) | null;
    set onended(callback: ((event: Event) => void) | null);
}
declare class AnalyserNodeMock extends AudioNodeMock {
    fftSize: number;
    frequencyBinCount: number;
    minDecibels: number;
    maxDecibels: number;
    smoothingTimeConstant: number;
    constructor(context: BaseAudioContextMock, _options?: AnalyserOptions);
    getByteFrequencyData(_array: Uint8Array): void;
    getByteTimeDomainData(_array: Uint8Array): void;
    getFloatFrequencyData(_array: Float32Array): void;
    getFloatTimeDomainData(_array: Float32Array): void;
}
declare class GainNodeMock extends AudioNodeMock {
    readonly gain: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: GainOptions);
}
declare class DelayNodeMock extends AudioNodeMock {
    readonly delayTime: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: DelayOptions);
}
declare class BiquadFilterNodeMock extends AudioNodeMock {
    private _type;
    readonly frequency: AudioParamMock;
    readonly detune: AudioParamMock;
    readonly Q: AudioParamMock;
    readonly gain: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: BiquadFilterOptions);
    get type(): BiquadFilterType;
    set type(value: BiquadFilterType);
    getFrequencyResponse(_frequencyHz: Float32Array, _magResponse: Float32Array, _phaseResponse: Float32Array): void;
}
declare class ConvolverNodeMock extends AudioNodeMock {
    private _buffer;
    normalize: boolean;
    constructor(context: BaseAudioContextMock, _options?: ConvolverOptions);
    get buffer(): AudioBufferMock | null;
    set buffer(value: AudioBufferMock | null);
}
declare class WaveShaperNodeMock extends AudioNodeMock {
    private _curve;
    private _oversample;
    constructor(context: BaseAudioContextMock, _options?: WaveShaperOptions);
    get curve(): Float32Array | null;
    set curve(value: Float32Array | null);
    get oversample(): OverSampleType;
    set oversample(value: OverSampleType);
}
declare class StereoPannerNodeMock extends AudioNodeMock {
    readonly pan: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: StereoPannerOptions);
}
declare class OscillatorNodeMock extends AudioScheduledSourceNodeMock {
    private _type;
    readonly frequency: AudioParamMock;
    readonly detune: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: OscillatorOptions);
    get type(): OscillatorType;
    set type(value: OscillatorType);
    setPeriodicWave(_wave: PeriodicWaveMock): void;
}
declare class ConstantSourceNodeMock extends AudioScheduledSourceNodeMock {
    readonly offset: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: ConstantSourceOptions);
}
declare class AudioBufferSourceNodeMock extends AudioScheduledSourceNodeMock {
    private _buffer;
    private _loop;
    private _loopStart;
    private _loopEnd;
    readonly playbackRate: AudioParamMock;
    constructor(context: BaseAudioContextMock, _options?: AudioBufferSourceOptions);
    get buffer(): AudioBufferMock | null;
    set buffer(value: AudioBufferMock | null);
    get loop(): boolean;
    set loop(value: boolean);
    get loopStart(): number;
    set loopStart(value: number);
    get loopEnd(): number;
    set loopEnd(value: number);
}
declare class RecorderAdapterNodeMock extends AudioNodeMock {
    wasConnected: boolean;
    constructor(context: BaseAudioContextMock);
    getNode(): Record<string, unknown>;
}
declare class AudioBufferQueueSourceNodeMock extends AudioScheduledSourceNodeMock {
    private _onBufferEnded;
    private eventEmitter;
    constructor(context: BaseAudioContextMock, _options?: BaseAudioBufferSourceOptions);
    enqueueBuffer(_buffer: AudioBufferMock): string;
    dequeueBuffer(_bufferId: string): void;
    clearBuffers(): void;
    pause(): void;
    get onBufferEnded(): ((event: {
        bufferId: string;
    }) => void) | null;
    set onBufferEnded(callback: ((event: {
        bufferId: string;
    }) => void) | null);
}
declare class StreamerNodeMock extends AudioScheduledSourceNodeMock {
    readonly streamPath: string;
    constructor(context: BaseAudioContextMock, options: StreamerOptions);
    pause(): void;
    resume(): void;
}
declare class MediaElementAudioSourceNodeMock extends AudioNodeMock {
    readonly mediaElement: HTMLMediaElement | AudioNodeMock;
    constructor(context: BaseAudioContextMock, mediaElement: HTMLMediaElement | AudioNodeMock);
}
declare class WorkletNodeMock extends AudioNodeMock {
    constructor(context: BaseAudioContextMock, _runtime: AudioWorkletRuntime, _callback: (audioData: Array<Float32Array>, channelCount: number) => void, _bufferLength: number, _inputChannelCount: number);
}
declare class WorkletProcessingNodeMock extends AudioNodeMock {
    constructor(context: BaseAudioContextMock, _runtime: AudioWorkletRuntime, _callback: (inputData: Array<Float32Array>, outputData: Array<Float32Array>, framesToProcess: number, currentTime: number) => void);
}
declare class WorkletSourceNodeMock extends AudioScheduledSourceNodeMock {
    constructor(context: BaseAudioContextMock, _runtime: AudioWorkletRuntime, _callback: (audioData: Array<Float32Array>, framesToProcess: number, currentTime: number, startOffset: number) => void);
}
declare class PeriodicWaveMock {
    constructor(_context: BaseAudioContextMock, _options?: PeriodicWaveOptions);
}
declare class AudioDestinationNodeMock extends AudioNodeMock {
    maxChannelCount: number;
    constructor(context: BaseAudioContextMock);
}
declare class BaseAudioContextMock {
    destination: AudioDestinationNodeMock;
    private _sampleRate;
    private _currentTime;
    protected _state: ContextState;
    constructor(options?: AudioContextOptions);
    get currentTime(): number;
    get sampleRate(): number;
    get state(): ContextState;
    createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBufferMock;
    createPeriodicWave(_real?: Float32Array, _imag?: Float32Array, _constraints?: {
        disableNormalization?: boolean;
    }): PeriodicWaveMock;
    decodeAudioData(_audioData: ArrayBuffer): Promise<AudioBufferMock>;
    createAnalyser(options?: AnalyserOptions): AnalyserNodeMock;
    createBiquadFilter(options?: BiquadFilterOptions): BiquadFilterNodeMock;
    createBufferSource(options?: AudioBufferSourceOptions): AudioBufferSourceNodeMock;
    createChannelMerger(_numberOfInputs?: number): AudioNodeMock;
    createChannelSplitter(_numberOfOutputs?: number): AudioNodeMock;
    createConstantSource(options?: ConstantSourceOptions): ConstantSourceNodeMock;
    createConvolver(options?: ConvolverOptions): ConvolverNodeMock;
    createDelay(options?: DelayOptions): DelayNodeMock;
    createGain(options?: GainOptions): GainNodeMock;
    createOscillator(options?: OscillatorOptions): OscillatorNodeMock;
    createStereoPanner(options?: StereoPannerOptions): StereoPannerNodeMock;
    createWaveShaper(options?: WaveShaperOptions): WaveShaperNodeMock;
    createRecorderAdapter(): RecorderAdapterNodeMock;
    createBufferQueueSource(options?: BaseAudioBufferSourceOptions): AudioBufferQueueSourceNodeMock;
    createStreamer(options: StreamerOptions): StreamerNodeMock;
    createWorkletNode(_shareableWorklet: Record<string, unknown>, _runOnUI: boolean, _bufferLength: number, _inputChannelCount: number): WorkletNodeMock;
    createWorkletProcessingNode(_shareableWorklet: Record<string, unknown>, _runOnUI: boolean): WorkletProcessingNodeMock;
    createWorkletSourceNode(_shareableWorklet: Record<string, unknown>, _runOnUI: boolean): WorkletSourceNodeMock;
}
declare class AudioContextMock extends BaseAudioContextMock {
    constructor(options?: AudioContextOptions);
    close(): Promise<void>;
    resume(): Promise<void>;
    suspend(): Promise<void>;
    createMediaElementSource(mediaElement: HTMLMediaElement | AudioNodeMock): MediaElementAudioSourceNodeMock;
}
declare class OfflineAudioContextMock extends BaseAudioContextMock {
    length: number;
    constructor(options: OfflineAudioContextOptions);
    startRendering(): Promise<AudioBufferMock>;
}
declare class AudioRecorderMock {
    private _isRecording;
    private _isPaused;
    private _currentDuration;
    private _options;
    private isFileOutputEnabled;
    private eventEmitter;
    private onAudioReadySubscription;
    private onErrorSubscription;
    constructor();
    enableFileOutput(options?: AudioRecorderFileOptions): Result<{
        path: string;
    }>;
    get options(): AudioRecorderFileOptions | null;
    disableFileOutput(): void;
    start(options?: AudioRecorderStartOptions): Promise<Result<{
        path: string;
    }>>;
    stop(): Promise<Result<FileInfo>>;
    pause(): void;
    resume(): void;
    connect(_node: RecorderAdapterNodeMock): void;
    disconnect(): void;
    onAudioReady(_options: AudioRecorderCallbackOptions, callback: (event: Partial<Record<string, unknown>> | undefined) => void): Result<{}>;
    clearOnAudioReady(): void;
    isRecording(): boolean;
    isPaused(): boolean;
    getCurrentDuration(): number;
    onError(callback: (error: Record<string, unknown> | undefined) => void): void;
    clearOnError(): void;
}
declare const decodeAudioData: (_audioData: ArrayBuffer) => Promise<AudioBufferMock>;
declare const decodePCMInBase64: (_base64Data: string) => Promise<AudioBufferMock>;
declare const getAudioDuration: (_input: DecodeDataInput) => Promise<number>;
declare const concatAudioFiles: (inputPaths: string[], outputPath: string) => Promise<string>;
declare const isFfmpegEnabled: () => boolean;
declare class AudioManagerMock {
    static getDevicePreferredSampleRate(): number;
    static observeVolumeChanges(_observe: boolean): void;
    static addSystemEventListener(_event: string, _callback: (event: {
        value: number;
    }) => void): {
        remove: () => void;
    };
    static removeSystemEventListener(_listener: {
        remove: () => void;
    }): void;
}
declare class NotificationManagerMock {
    static create(_options: Record<string, unknown>): {
        update: () => void;
        destroy: () => void;
    };
}
declare class PlaybackNotificationManagerMock {
    static create(_options: Record<string, unknown>): {
        update: () => void;
        destroy: () => void;
    };
}
declare class RecordingNotificationManagerMock {
    static create(_options: Record<string, unknown>): {
        update: () => void;
        destroy: () => void;
    };
}
declare const useSystemVolume: () => number;
declare const setMockSystemVolume: (volume: number) => void;
declare class FilePresetMock {
    static get Low(): FilePresetType;
    static get Medium(): FilePresetType;
    static get High(): FilePresetType;
    static get Lossless(): FilePresetType;
}
declare class NotSupportedErrorMock extends Error {
    constructor(message: string);
}
declare class InvalidAccessErrorMock extends Error {
    constructor(message: string);
}
declare class InvalidStateErrorMock extends Error {
    constructor(message: string);
}
declare class IndexSizeErrorMock extends Error {
    constructor(message: string);
}
declare class RangeErrorMock extends Error {
    constructor(message: string);
}
declare class AudioApiErrorMock extends Error {
    constructor(message: string);
}
export declare const AnalyserNode: typeof AnalyserNodeMock;
export declare const AudioBuffer: typeof AudioBufferMock;
export declare const AudioBufferQueueSourceNode: typeof AudioBufferQueueSourceNodeMock;
export declare const AudioBufferSourceNode: typeof AudioBufferSourceNodeMock;
export declare const AudioContext: typeof AudioContextMock;
export declare const AudioDestinationNode: typeof AudioDestinationNodeMock;
export declare const AudioNode: typeof AudioNodeMock;
export declare const AudioParam: typeof AudioParamMock;
export declare const AudioRecorder: typeof AudioRecorderMock;
export declare const AudioScheduledSourceNode: typeof AudioScheduledSourceNodeMock;
export declare const BaseAudioContext: typeof BaseAudioContextMock;
export declare const BiquadFilterNode: typeof BiquadFilterNodeMock;
export declare const ConstantSourceNode: typeof ConstantSourceNodeMock;
export declare const ConvolverNode: typeof ConvolverNodeMock;
export declare const DelayNode: typeof DelayNodeMock;
export declare const GainNode: typeof GainNodeMock;
export declare const MediaElementAudioSourceNode: typeof MediaElementAudioSourceNodeMock;
export declare const OfflineAudioContext: typeof OfflineAudioContextMock;
export declare const OscillatorNode: typeof OscillatorNodeMock;
export declare const RecorderAdapterNode: typeof RecorderAdapterNodeMock;
export declare const StereoPannerNode: typeof StereoPannerNodeMock;
export declare const StreamerNode: typeof StreamerNodeMock;
export declare const WaveShaperNode: typeof WaveShaperNodeMock;
export declare const WorkletNode: typeof WorkletNodeMock;
export declare const WorkletProcessingNode: typeof WorkletProcessingNodeMock;
export declare const WorkletSourceNode: typeof WorkletSourceNodeMock;
export declare const PeriodicWave: typeof PeriodicWaveMock;
export declare const AudioManager: typeof AudioManagerMock;
export declare const NotificationManager: typeof NotificationManagerMock;
export declare const PlaybackNotificationManager: typeof PlaybackNotificationManagerMock;
export declare const RecordingNotificationManager: typeof RecordingNotificationManagerMock;
export declare const FilePreset: typeof FilePresetMock;
export declare const NotSupportedError: typeof NotSupportedErrorMock;
export declare const InvalidAccessError: typeof InvalidAccessErrorMock;
export declare const InvalidStateError: typeof InvalidStateErrorMock;
export declare const IndexSizeError: typeof IndexSizeErrorMock;
export declare const RangeError: typeof RangeErrorMock;
export declare const AudioApiError: typeof AudioApiErrorMock;
export { concatAudioFiles, decodeAudioData, decodePCMInBase64, getAudioDuration, isFfmpegEnabled, setMockSystemVolume, useSystemVolume, };
export type AnalyserNode = AnalyserNodeMock;
export type AudioBuffer = AudioBufferMock;
export type AudioBufferQueueSourceNode = AudioBufferQueueSourceNodeMock;
export type AudioBufferSourceNode = AudioBufferSourceNodeMock;
export type AudioContext = AudioContextMock;
export type AudioDestinationNode = AudioDestinationNodeMock;
export type AudioNode = AudioNodeMock;
export type AudioParam = AudioParamMock;
export type AudioRecorder = AudioRecorderMock;
export type AudioScheduledSourceNode = AudioScheduledSourceNodeMock;
export type BaseAudioContext = BaseAudioContextMock;
export type BiquadFilterNode = BiquadFilterNodeMock;
export type ConstantSourceNode = ConstantSourceNodeMock;
export type ConvolverNode = ConvolverNodeMock;
export type DelayNode = DelayNodeMock;
export type GainNode = GainNodeMock;
export type MediaElementAudioSourceNode = MediaElementAudioSourceNodeMock;
export type OfflineAudioContext = OfflineAudioContextMock;
export type OscillatorNode = OscillatorNodeMock;
export type RecorderAdapterNode = RecorderAdapterNodeMock;
export type StereoPannerNode = StereoPannerNodeMock;
export type StreamerNode = StreamerNodeMock;
export type WaveShaperNode = WaveShaperNodeMock;
export type WorkletNode = WorkletNodeMock;
export type WorkletProcessingNode = WorkletProcessingNodeMock;
export type WorkletSourceNode = WorkletSourceNodeMock;
export type PeriodicWave = PeriodicWaveMock;
export { AudioContextOptions, AudioRecorderCallbackOptions, AudioRecorderFileOptions, AudioRecorderStartOptions, AudioWorkletRuntime, BiquadFilterType, ChannelCountMode, ChannelInterpretation, ContextState, FileDirectory, FileFormat, FileInfo, FilePresetType, OfflineAudioContextOptions, OscillatorType, OverSampleType, Result, AnalyserOptions, AudioBufferSourceOptions, BaseAudioBufferSourceOptions, BiquadFilterOptions, ConstantSourceOptions, ConvolverOptions, DelayOptions, GainOptions, OscillatorOptions, PeriodicWaveOptions, StereoPannerOptions, StreamerOptions, WaveShaperOptions, };
declare const _default: {
    AnalyserNode: typeof AnalyserNodeMock;
    AudioBuffer: typeof AudioBufferMock;
    AudioBufferQueueSourceNode: typeof AudioBufferQueueSourceNodeMock;
    AudioBufferSourceNode: typeof AudioBufferSourceNodeMock;
    AudioContext: typeof AudioContextMock;
    AudioDestinationNode: typeof AudioDestinationNodeMock;
    AudioNode: typeof AudioNodeMock;
    AudioParam: typeof AudioParamMock;
    AudioRecorder: typeof AudioRecorderMock;
    AudioScheduledSourceNode: typeof AudioScheduledSourceNodeMock;
    BaseAudioContext: typeof BaseAudioContextMock;
    BiquadFilterNode: typeof BiquadFilterNodeMock;
    ConstantSourceNode: typeof ConstantSourceNodeMock;
    ConvolverNode: typeof ConvolverNodeMock;
    DelayNode: typeof DelayNodeMock;
    GainNode: typeof GainNodeMock;
    MediaElementAudioSourceNode: typeof MediaElementAudioSourceNodeMock;
    OfflineAudioContext: typeof OfflineAudioContextMock;
    OscillatorNode: typeof OscillatorNodeMock;
    RecorderAdapterNode: typeof RecorderAdapterNodeMock;
    StereoPannerNode: typeof StereoPannerNodeMock;
    StreamerNode: typeof StreamerNodeMock;
    WaveShaperNode: typeof WaveShaperNodeMock;
    WorkletNode: typeof WorkletNodeMock;
    WorkletProcessingNode: typeof WorkletProcessingNodeMock;
    WorkletSourceNode: typeof WorkletSourceNodeMock;
    PeriodicWave: typeof PeriodicWaveMock;
    decodeAudioData: (_audioData: ArrayBuffer) => Promise<AudioBufferMock>;
    decodePCMInBase64: (_base64Data: string) => Promise<AudioBufferMock>;
    getAudioDuration: (_input: DecodeDataInput) => Promise<number>;
    changePlaybackSpeed: (buffer: AudioBufferMock, _speed: number) => Promise<AudioBufferMock>;
    concatAudioFiles: (inputPaths: string[], outputPath: string) => Promise<string>;
    isFfmpegEnabled: () => boolean;
    useSystemVolume: () => number;
    setMockSystemVolume: (volume: number) => void;
    AudioManager: typeof AudioManagerMock;
    NotificationManager: typeof NotificationManagerMock;
    PlaybackNotificationManager: typeof PlaybackNotificationManagerMock;
    RecordingNotificationManager: typeof RecordingNotificationManagerMock;
    FilePreset: typeof FilePresetMock;
    NotSupportedError: typeof NotSupportedErrorMock;
    InvalidAccessError: typeof InvalidAccessErrorMock;
    InvalidStateError: typeof InvalidStateErrorMock;
    IndexSizeError: typeof IndexSizeErrorMock;
    RangeError: typeof RangeErrorMock;
    AudioApiError: typeof AudioApiErrorMock;
    FileDirectory: typeof FileDirectory;
    FileFormat: typeof FileFormat;
};
export default _default;
//# sourceMappingURL=index.d.ts.map