@ng-web-apis/audio/index.d.ts

This is a library for declarative use of Web Audio API with Angular

import * as i0 from '@angular/core';
import { OnDestroy, OnInit, PipeTransform, InjectionToken, Type, ExistingProvider } from '@angular/core';

declare class WaAudioContext extends AudioContext implements OnDestroy {
    readonly rate: i0.InputSignal<string>;
    readonly latencyHint: i0.InputSignal<AudioContextLatencyCategory | undefined>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaAudioContext, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaAudioContext, "[waAudioContext]", never, { "rate": { "alias": "sampleRate"; "required": false; "isSignal": true; }; "latencyHint": { "alias": "latencyHint"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class WaChannel extends GainNode implements OnDestroy {
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaChannel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaChannel, "[waChannel]", ["AudioNode"], {}, {}, never, never, true, never>;
}

declare class WaDestination extends AnalyserNode implements OnDestroy {
    readonly quiet: i0.OutputRef<unknown>;
    constructor();
    ngOnDestroy(): void;
    private isSilent;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaDestination, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaDestination, "[waAudioDestinationNode]", ["AudioNode"], {}, { "quiet": "quiet"; }, never, never, true, never>;
}

type AudioParamAutomationMode = 'exponential' | 'instant' | 'linear';

type AudioParamAutomation = Readonly<{
    value: number;
    duration: number;
    mode: AudioParamAutomationMode;
}>;

type AudioParamCurve = Readonly<{
    value: number[];
    duration: number;
}>;

type AudioParamInput = Array<AudioParamAutomation | AudioParamCurve> | AudioParamAutomation | AudioParamCurve | number | string;

declare class WaListener extends GainNode {
    constructor();
    set forwardXSetter(value: AudioParamInput);
    set forwardYSetter(value: AudioParamInput);
    set forwardZSetter(value: AudioParamInput);
    set positionXSetter(value: AudioParamInput);
    set positionYSetter(value: AudioParamInput);
    set positionZSetter(value: AudioParamInput);
    set upXSetter(value: AudioParamInput);
    set upYSetter(value: AudioParamInput);
    set upZSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaListener, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaListener, "[waAudioContext],[waOfflineAudioContext][length][sampleRate]", never, { "forwardXSetter": { "alias": "forwardX"; "required": false; }; "forwardYSetter": { "alias": "forwardY"; "required": false; }; "forwardZSetter": { "alias": "forwardZ"; "required": false; }; "positionXSetter": { "alias": "positionX"; "required": false; }; "positionYSetter": { "alias": "positionY"; "required": false; }; "positionZSetter": { "alias": "positionZ"; "required": false; }; "upXSetter": { "alias": "upX"; "required": false; }; "upYSetter": { "alias": "upY"; "required": false; }; "upZSetter": { "alias": "upZ"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaNode implements OnInit, OnDestroy {
    private readonly node;
    private readonly parent;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaNode, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaNode, never, never, {}, {}, never, never, true, never>;
}

declare class WaOfflineContext extends OfflineAudioContext implements OnInit {
    readonly lngth: i0.InputSignal<string>;
    readonly rate: i0.InputSignal<string>;
    readonly channels: i0.InputSignal<string>;
    readonly autoplay: i0.InputSignalWithTransform<boolean, unknown>;
    readonly complete: i0.OutputEmitterRef<AudioBuffer>;
    constructor();
    readonly oncomplete: (e: OfflineAudioCompletionEvent) => void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaOfflineContext, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaOfflineContext, "[waOfflineAudioContext][length][sampleRate]", never, { "lngth": { "alias": "length"; "required": false; "isSignal": true; }; "rate": { "alias": "sampleRate"; "required": false; "isSignal": true; }; "channels": { "alias": "numberOfChannels"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; }, { "complete": "complete"; }, never, never, true, never>;
}

declare class WaOutput extends GainNode implements OnDestroy {
    constructor();
    set waOutput(destination: AudioNode | AudioParam | undefined);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaOutput, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaOutput, "[waOutput]", never, { "waOutput": { "alias": "waOutput"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaScheduledSource implements OnInit, OnDestroy {
    private readonly node;
    readonly autoplay: i0.InputSignalWithTransform<boolean, unknown>;
    readonly ended: i0.OutputEmitterRef<void>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaScheduledSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaScheduledSource, never, never, { "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; }, { "ended": "ended"; }, never, never, true, never>;
}
declare class WaSource {
    static ɵfac: i0.ɵɵFactoryDeclaration<WaSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaSource, never, never, {}, {}, never, never, true, [{ directive: typeof WaScheduledSource; inputs: { "autoplay": "autoplay"; }; outputs: { "ended": "ended"; }; }]>;
}

declare class WaMediaStreamDestination extends MediaStreamAudioDestinationNode {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaMediaStreamDestination, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaMediaStreamDestination, "[waMediaStreamAudioDestinationNode]", ["AudioNode"], {}, {}, never, never, true, never>;
}

declare class WaAnalyser extends AnalyserNode {
    private fByte;
    private fFloat;
    private tByte;
    private tFloat;
    readonly frequencyByte: i0.OutputRef<Uint8Array<ArrayBuffer>>;
    readonly frequencyFloat: i0.OutputRef<Float32Array<ArrayBuffer>>;
    readonly timeByte: i0.OutputRef<Uint8Array<ArrayBuffer>>;
    readonly timeFloat: i0.OutputRef<Float32Array<ArrayBuffer>>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaAnalyser, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaAnalyser, "[waAnalyserNode]", ["AudioNode"], { "fftSize": { "alias": "fftSize"; "required": false; }; "minDecibels": { "alias": "minDecibels"; "required": false; }; "maxDecibels": { "alias": "maxDecibels"; "required": false; }; "smoothingTimeConstant": { "alias": "smoothingTimeConstant"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, { "frequencyByte": "frequencyByte"; "frequencyFloat": "frequencyFloat"; "timeByte": "timeByte"; "timeFloat": "timeFloat"; }, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaBiquadFilter extends BiquadFilterNode {
    constructor();
    set detuneSetter(value: AudioParamInput);
    set frequencySetter(value: AudioParamInput);
    set gainSetter(value: AudioParamInput);
    set qSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaBiquadFilter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaBiquadFilter, "[waBiquadFilterNode]", ["AudioNode"], { "detuneSetter": { "alias": "detune"; "required": false; }; "frequencySetter": { "alias": "frequency"; "required": false; }; "gainSetter": { "alias": "gain"; "required": false; }; "qSetter": { "alias": "Q"; "required": false; }; "type": { "alias": "type"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaChannelMerger extends ChannelMergerNode implements OnDestroy {
    private readonly channels;
    readonly inputs: i0.InputSignal<string>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaChannelMerger, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaChannelMerger, "[waChannelMergerNode]", ["AudioNode"], { "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; "inputs": { "alias": "numberOfInputs"; "required": false; "isSignal": true; }; }, {}, ["channels"], never, true, never>;
}

declare class WaChannelSplitter extends ChannelSplitterNode {
    private readonly channels;
    readonly outputs: i0.InputSignal<string>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaChannelSplitter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaChannelSplitter, "[waChannelSplitterNode]", ["AudioNode"], { "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; "outputs": { "alias": "numberOfOutputs"; "required": false; "isSignal": true; }; }, {}, ["channels"], never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaConvolver extends ConvolverNode {
    private readonly service;
    constructor();
    set bufferSetter(source: AudioBuffer | string | null);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaConvolver, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaConvolver, "[waConvolverNode]", ["AudioNode"], { "bufferSetter": { "alias": "buffer"; "required": false; }; "normalize": { "alias": "normalize"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaDelay extends DelayNode {
    readonly maxDelayTime: i0.InputSignal<string>;
    constructor();
    set delayTimeSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaDelay, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaDelay, "[waDelayNode]", ["AudioNode"], { "delayTimeSetter": { "alias": "delayTime"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; "maxDelayTime": { "alias": "maxDelayTime"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaDynamicsCompressor extends DynamicsCompressorNode {
    constructor();
    set attackSetter(value: AudioParamInput);
    set kneeSetter(value: AudioParamInput);
    set ratioSetter(value: AudioParamInput);
    set releaseSetter(value: AudioParamInput);
    set thresholdSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaDynamicsCompressor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaDynamicsCompressor, "[waDynamicsCompressorNode]", ["AudioNode"], { "attackSetter": { "alias": "attack"; "required": false; }; "kneeSetter": { "alias": "knee"; "required": false; }; "ratioSetter": { "alias": "ratio"; "required": false; }; "releaseSetter": { "alias": "release"; "required": false; }; "thresholdSetter": { "alias": "threshold"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaGain extends GainNode {
    constructor();
    set gainSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaGain, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaGain, "[waGainNode]", ["AudioNode"], { "gainSetter": { "alias": "gain"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaIIRFilter extends IIRFilterNode {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaIIRFilter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaIIRFilter, "[waIIRFilterNode]", ["AudioNode"], { "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaPanner extends PannerNode {
    constructor();
    set orientationXSetter(value: AudioParamInput);
    set orientationYSetter(value: AudioParamInput);
    set orientationZSetter(value: AudioParamInput);
    set positionXSetter(value: AudioParamInput);
    set positionYSetter(value: AudioParamInput);
    set positionZSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaPanner, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaPanner, "[waPannerNode]", ["AudioNode"], { "orientationXSetter": { "alias": "orientationX"; "required": false; }; "orientationYSetter": { "alias": "orientationY"; "required": false; }; "orientationZSetter": { "alias": "orientationZ"; "required": false; }; "positionXSetter": { "alias": "positionX"; "required": false; }; "positionYSetter": { "alias": "positionY"; "required": false; }; "positionZSetter": { "alias": "positionZ"; "required": false; }; "coneInnerAngle": { "alias": "coneInnerAngle"; "required": false; }; "coneOuterAngle": { "alias": "coneOuterAngle"; "required": false; }; "coneOuterGain": { "alias": "coneOuterGain"; "required": false; }; "distanceModel": { "alias": "distanceModel"; "required": false; }; "maxDistance": { "alias": "maxDistance"; "required": false; }; "panningModel": { "alias": "panningModel"; "required": false; }; "refDistance": { "alias": "refDistance"; "required": false; }; "rolloffFactor": { "alias": "rolloffFactor"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaStereoPanner extends StereoPannerNode {
    constructor();
    set panSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaStereoPanner, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaStereoPanner, "[waStereoPannerNode]", ["AudioNode"], { "panSetter": { "alias": "pan"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaWaveShaper extends WaveShaperNode {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaWaveShaper, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaWaveShaper, "[waWaveShaperNode]", ["AudioNode"], { "oversample": { "alias": "oversample"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaWorklet extends AudioWorkletNode {
    readonly name: i0.InputSignal<string>;
    readonly processorerror: i0.OutputEmitterRef<void>;
    constructor();
    readonly onprocessorerror: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaWorklet, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaWorklet, "[waAudioWorkletNode][name]", ["AudioNode"], { "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "processorerror": "processorerror"; }, never, never, true, [{ directive: typeof WaNode; inputs: {}; outputs: {}; }]>;
}

declare class WaAudioParamPipe implements PipeTransform {
    /**
     * Creates {@link AudioParamAutomation} to use with {@link AudioParam} inputs
     *
     * @param value target value
     * @param duration duration of the automation
     * @param mode either instant for given duration or linear/exponential ramp
     */
    transform(value: number[] | number, duration: number, mode?: AudioParamAutomationMode): AudioParamAutomation | AudioParamCurve;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaAudioParamPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaAudioParamPipe, "waAudioParam", true>;
}

declare class WaPeriodicWavePipe implements PipeTransform {
    private readonly context;
    /**
     * Creates {@link PeriodicWave} to use with {@link OscillatorNode}
     *
     * @param real cosine terms (traditionally the A terms)
     * @param imag sine terms (traditionally the B terms)
     * @param disableNormalization see {@lin PeriodicWaveConstraints}
     */
    transform(real: number[], imag?: number[], disableNormalization?: boolean): PeriodicWave;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaPeriodicWavePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaPeriodicWavePipe, "waPeriodicWave", true>;
}

declare class WaAudioBufferService {
    private readonly context;
    private readonly cache;
    fetch(url: string): Promise<AudioBuffer>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaAudioBufferService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WaAudioBufferService>;
}

declare class WaBufferSource extends AudioBufferSourceNode {
    private readonly service;
    constructor();
    set detuneSetter(value: AudioParamInput);
    set playbackRateSetter(value: AudioParamInput);
    set bufferSetter(source: AudioBuffer | string | null);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaBufferSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaBufferSource, "[waAudioBufferSourceNode]", ["AudioNode"], { "bufferSetter": { "alias": "buffer"; "required": false; }; "detuneSetter": { "alias": "detune"; "required": false; }; "playbackRateSetter": { "alias": "playbackRate"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "loopStart": { "alias": "loopStart"; "required": false; }; "loopEnd": { "alias": "loopEnd"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaSource; inputs: {}; outputs: {}; }]>;
}

declare class WaConstantSource extends ConstantSourceNode {
    constructor();
    set offsetSetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaConstantSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaConstantSource, "[waConstantSourceNode]", ["AudioNode"], { "offsetSetter": { "alias": "offset"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaSource; inputs: {}; outputs: {}; }]>;
}

declare class WaMediaSource extends MediaElementAudioSourceNode implements OnDestroy {
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaMediaSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaMediaSource, "audio[waMediaElementAudioSourceNode], video[waMediaElementAudioSourceNode]", ["AudioNode"], {}, {}, never, never, true, never>;
}

declare class WaMediaStreamSource extends MediaStreamAudioSourceNode implements OnDestroy {
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaMediaStreamSource, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaMediaStreamSource, "[waMediaStreamAudioSourceNode]", ["AudioNode"], {}, {}, never, never, true, never>;
}

declare class WaOscillator extends OscillatorNode {
    constructor();
    set periodicWave(periodicWave: PeriodicWave);
    set detuneSetter(value: AudioParamInput);
    set frequencySetter(value: AudioParamInput);
    static ɵfac: i0.ɵɵFactoryDeclaration<WaOscillator, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaOscillator, "[waOscillatorNode]", ["AudioNode"], { "detuneSetter": { "alias": "detune"; "required": false; }; "frequencySetter": { "alias": "frequency"; "required": false; }; "type": { "alias": "type"; "required": false; }; "channelCount": { "alias": "channelCount"; "required": false; }; "channelCountMode": { "alias": "channelCountMode"; "required": false; }; "channelInterpretation": { "alias": "channelInterpretation"; "required": false; }; "periodicWave": { "alias": "periodicWave"; "required": false; }; }, {}, never, never, true, [{ directive: typeof WaSource; inputs: {}; outputs: {}; }]>;
}

declare const WA_AUDIO_CONTEXT: InjectionToken<BaseAudioContext>;

declare const WA_AUDIO_NODE: InjectionToken<AudioNode | null>;
declare function asAudioNode(useExisting: Type<AudioNode>): ExistingProvider;

declare const WA_AUDIO_WORKLET_PROCESSORS: InjectionToken<readonly string[]>;

declare const WA_AUDIO_WORKLET_PROCESSORS_READY: InjectionToken<Promise<boolean>>;

declare const WA_FEEDBACK_COEFFICIENTS: InjectionToken<number[]>;

declare const WA_FEEDFORWARD_COEFFICIENTS: InjectionToken<number[]>;

declare const WA_MEDIA_STREAM: InjectionToken<MediaStream>;

declare const WA_WEB_AUDIO_SUPPORT: InjectionToken<boolean>;

declare const WaWebAudio: readonly [typeof WaAudioContext, typeof WaChannel, typeof WaDestination, typeof WaListener, typeof WaOfflineContext, typeof WaOutput, typeof WaMediaStreamDestination, typeof WaBufferSource, typeof WaConstantSource, typeof WaMediaSource, typeof WaMediaStreamSource, typeof WaOscillator, typeof WaAnalyser, typeof WaBiquadFilter, typeof WaChannelSplitter, typeof WaChannelMerger, typeof WaConvolver, typeof WaDelay, typeof WaDynamicsCompressor, typeof WaGain, typeof WaIIRFilter, typeof WaPanner, typeof WaStereoPanner, typeof WaWaveShaper, typeof WaWorklet, typeof WaAudioParamPipe, typeof WaPeriodicWavePipe];

export { WA_AUDIO_CONTEXT, WA_AUDIO_NODE, WA_AUDIO_WORKLET_PROCESSORS, WA_AUDIO_WORKLET_PROCESSORS_READY, WA_FEEDBACK_COEFFICIENTS, WA_FEEDFORWARD_COEFFICIENTS, WA_MEDIA_STREAM, WA_WEB_AUDIO_SUPPORT, WaAnalyser, WaAudioBufferService, WaAudioContext, WaAudioParamPipe, WaBiquadFilter, WaBufferSource, WaChannel, WaChannelMerger, WaChannelSplitter, WaConstantSource, WaConvolver, WaDelay, WaDestination, WaDynamicsCompressor, WaGain, WaIIRFilter, WaListener, WaMediaSource, WaMediaStreamDestination, WaMediaStreamSource, WaNode, WaOfflineContext, WaOscillator, WaOutput, WaPanner, WaPeriodicWavePipe, WaScheduledSource, WaSource, WaStereoPanner, WaWaveShaper, WaWebAudio, WaWorklet, asAudioNode };
export type { AudioParamAutomation, AudioParamAutomationMode, AudioParamCurve, AudioParamInput };