import { AnalyserOptions, AudioContextOptions, AudioParamBase, BaseAudioContext, ConstantSourceOptions, ConvolverOptions, DelayOptions, IIRFilterOptions, PannerOptions, PeriodicWaveOptions, StereoPannerOptions, WaveShaperOptions, context_, native_ } from './common';
type NativeBaseAudioContext = BaseAudioContext & {
    native: NSCAudioContext;
};
export declare class AudioParam extends AudioParamBase {
    private [native_];
    constructor(a?: any, b?: any);
    get native(): NSCAudioParam;
}
export declare class AudioNode {
    private [context_];
    constructor(context: NativeBaseAudioContext);
    get context(): BaseAudioContext;
    connect(node: any, output?: number, input?: number): void;
    disconnect(destinationOrOutput?: any, output?: number, input?: number): void;
}
export declare class AudioBuffer {
    private [native_];
    constructor(options: {
        length: number;
        numberOfChannels?: number;
        sampleRate?: number;
    } | Symbol, buffer?: NSCAudioBuffer);
    get native(): NSCAudioBuffer;
    get sampleRate(): number;
    get length(): number;
    get duration(): number;
    get numberOfChannels(): number;
    getChannelData(channel: number): Float32Array | null;
    copyFromChannel(dest: Float32Array, channel: number, startInChannel?: number): void;
    copyToChannel(source: Float32Array, channel: number, startInChannel?: number): void;
}
export declare class GainNode extends AudioNode {
    private _native;
    private _gainParam;
    private _initialGain;
    constructor(context: NativeBaseAudioContext, options?: {
        gain?: number;
    });
    get native(): NSCGainNode;
    get gain(): AudioParam;
}
export declare class BiquadFilterNode extends AudioNode {
    private [native_];
    private _frequencyParam;
    private _qParam;
    private _gainParam;
    private _detuneParam;
    constructor(context: NativeBaseAudioContext, options?: {
        type?: string;
        frequency?: number;
        Q?: number;
        gain?: number;
    });
    get native(): NSCBiquadNode;
    get frequency(): AudioParam;
    get Q(): AudioParam;
    get gain(): AudioParam;
    get detune(): AudioParam;
    set type(v: string);
    get type(): string;
}
export declare class PannerNode extends AudioNode {
    [native_]: NSCAudioPannerNode;
    constructor(context: NativeBaseAudioContext, options?: PannerOptions);
    get native(): NSCAudioPannerNode;
    private _positionX;
    private _positionY;
    private _positionZ;
    private _orientationX;
    private _orientationY;
    private _orientationZ;
    get positionX(): AudioParam;
    get positionY(): AudioParam;
    get positionZ(): AudioParam;
    get orientationX(): AudioParam;
    get orientationY(): AudioParam;
    get orientationZ(): AudioParam;
    get distanceModel(): number;
    set distanceModel(v: number);
    get panningModel(): number;
    set panningModel(v: number);
    get refDistance(): number;
    set refDistance(v: number);
    get maxDistance(): number;
    set maxDistance(v: number);
    get rolloffFactor(): number;
    set rolloffFactor(v: number);
    get coneInnerAngle(): number;
    set coneInnerAngle(v: number);
    get coneOuterAngle(): number;
    set coneOuterAngle(v: number);
    get coneOuterGain(): number;
    set coneOuterGain(v: number);
    setPosition(x: number, y: number, z: number): void;
    setOrientation(x: number, y: number, z: number): void;
}
export declare class AudioDestinationNode extends AudioNode {
    [native_]: NSCAudioNode;
    constructor(context: NativeBaseAudioContext, node: NSCAudioNode);
    get native(): NSCAudioNode;
}
export declare class AudioScheduledSourceNode extends AudioNode {
    [native_]: NSCAudioScheduledSourceNode;
    constructor(context: NativeBaseAudioContext, node: NSCAudioScheduledSourceNode);
    get native(): NSCAudioScheduledSourceNode;
    start(): void;
    stop(): void;
}
export declare class OscillatorNode extends AudioScheduledSourceNode {
    constructor(context: NativeBaseAudioContext, options?: {
        type?: string;
        frequency?: number;
    });
    get native(): NSCAudioOscillatorNode;
    private _frequencyParam;
    get frequency(): AudioParam;
    setPeriodicWave(wave: PeriodicWave): void;
}
export declare class StereoPannerNode extends AudioNode {
    [native_]: NSCStereoPannerNode;
    private _panParam;
    constructor(context: NativeBaseAudioContext, options?: StereoPannerOptions);
    get native(): NSCStereoPannerNode;
    get pan(): AudioParam;
}
export declare class DelayNode extends AudioNode {
    [native_]: NSCDelayNode;
    private _delayTimeParam;
    constructor(context: NativeBaseAudioContext, options?: DelayOptions);
    get native(): NSCDelayNode;
    get delayTime(): AudioParamBase;
    get maxDelayTime(): number;
}
export declare class ConstantSourceNode extends AudioScheduledSourceNode {
    private _offsetParam;
    constructor(context: NativeBaseAudioContext, options?: ConstantSourceOptions);
    get native(): NSCConstantSourceNode;
    get offset(): AudioParamBase;
}
export declare class AnalyserNode extends AudioNode {
    [native_]: NSCAnalyserNode;
    constructor(context: NativeBaseAudioContext, options?: AnalyserOptions);
    get native(): NSCAnalyserNode;
    get fftSize(): number;
    set fftSize(v: number);
    get frequencyBinCount(): number;
    get smoothingTimeConstant(): number;
    set smoothingTimeConstant(v: number);
    get minDecibels(): number;
    set minDecibels(v: number);
    get maxDecibels(): number;
    set maxDecibels(v: number);
    getFloatTimeDomainData(dest: Float32Array): void;
    getByteTimeDomainData(dest: Uint8Array): void;
    getFloatFrequencyData(dest: Float32Array): void;
    getByteFrequencyData(dest: Uint8Array): void;
}
export declare class WaveShaperNode extends AudioNode {
    [native_]: NSCWaveShaperNode;
    private _curve;
    constructor(context: NativeBaseAudioContext, options?: WaveShaperOptions);
    get native(): NSCWaveShaperNode;
    get curve(): Float32Array | null;
    set curve(v: Float32Array | null);
    get oversample(): 'none' | '2x' | '4x';
    set oversample(v: 'none' | '2x' | '4x');
}
export declare class IIRFilterNode extends AudioNode {
    [native_]: NSCIIRFilterNode;
    constructor(context: NativeBaseAudioContext, options: IIRFilterOptions);
    get native(): NSCIIRFilterNode;
    getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
}
export declare class ConvolverNode extends AudioNode {
    [native_]: NSCConvolverNode;
    constructor(context: NativeBaseAudioContext, options?: ConvolverOptions);
    get native(): NSCConvolverNode;
    get buffer(): AudioBuffer | null;
    set buffer(v: AudioBuffer | null);
    get normalize(): boolean;
    set normalize(v: boolean);
}
export declare class PeriodicWave {
    [native_]: NSCPeriodicWave;
    constructor(_context: NativeBaseAudioContext, options?: PeriodicWaveOptions);
    get native(): NSCPeriodicWave;
}
export declare class AudioBufferSourceNode extends AudioScheduledSourceNode {
    constructor(context: NativeBaseAudioContext, options?: {
        buffer?: AudioBuffer;
    });
    get native(): NSCAudioBufferSourceNode;
    set loop(v: boolean);
    get loop(): boolean;
    get buffer(): AudioBuffer | null;
    set buffer(v: AudioBuffer | null);
}
export declare class AudioContext extends BaseAudioContext {
    private [native_];
    private _destination;
    constructor(options?: AudioContextOptions);
    get destination(): AudioDestinationNode;
    createGain(options?: {
        gain?: number;
    }): GainNode;
    createBiquad(options?: {
        type?: string;
        frequency?: number;
        Q?: number;
        gain?: number;
    }): BiquadFilterNode;
    createPanner(options?: PannerOptions): PannerNode;
    createOscillator(options?: {
        type?: string;
        frequency?: number;
    }): OscillatorNode;
    createBuffer(options: {
        length: number;
        numberOfChannels: number;
        sampleRate: number;
    }): AudioBuffer;
    createBufferSource(options?: {
        buffer?: AudioBuffer;
    }): AudioBufferSourceNode;
    createStereoPanner(options?: StereoPannerOptions): StereoPannerNode;
    createDelay(options?: DelayOptions): DelayNode;
    createConstantSource(options?: ConstantSourceOptions): ConstantSourceNode;
    createAnalyser(options?: AnalyserOptions): AnalyserNode;
    createWaveShaper(options?: WaveShaperOptions): WaveShaperNode;
    createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
    createConvolver(options?: ConvolverOptions): ConvolverNode;
    createPeriodicWave(real: Float32Array | number[], imag: Float32Array | number[], options?: {
        disableNormalization?: boolean;
    }): PeriodicWave;
    get native(): NSCAudioContext;
    get sampleRate(): number;
    get currentTime(): number;
    resume(): Promise<void>;
    suspend(): Promise<void>;
    close(): Promise<void>;
    get sinkId(): string;
    setSinkId(deviceId: string): Promise<void>;
    decodeAudioData(source: string | ArrayBuffer | ArrayBufferView): Promise<AudioBuffer>;
}
export declare class OfflineAudioContext extends BaseAudioContext {
    private [native_];
    destination: AudioDestinationNode | null;
    constructor(numberOfChannels: number, lengthInFrames: number, sampleRate: number);
    get native(): NSCOfflineAudioContext;
    createGain(options?: {
        gain?: number;
    }): GainNode;
    createBiquad(options?: {
        type?: string;
        frequency?: number;
        Q?: number;
        gain?: number;
    }): BiquadFilterNode;
    createPanner(options?: PannerOptions): PannerNode;
    createOscillator(options?: {
        type?: string;
        frequency?: number;
    }): OscillatorNode;
    createBufferSource(options?: {
        buffer?: AudioBuffer;
    }): AudioBufferSourceNode;
    createStereoPanner(options?: StereoPannerOptions): StereoPannerNode;
    createDelay(options?: DelayOptions): DelayNode;
    createConstantSource(options?: ConstantSourceOptions): ConstantSourceNode;
    createAnalyser(options?: AnalyserOptions): AnalyserNode;
    createWaveShaper(options?: WaveShaperOptions): WaveShaperNode;
    createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
    createConvolver(options?: ConvolverOptions): ConvolverNode;
    createPeriodicWave(real: Float32Array | number[], imag: Float32Array | number[], options?: {
        disableNormalization?: boolean;
    }): PeriodicWave;
    decodeAudioData(source: string | ArrayBuffer | ArrayBufferView): Promise<AudioBuffer>;
    startRendering(): Promise<AudioBuffer>;
}
export {};
