import { ColoredNoiseOpts } from '@thi.ng/colored-noise';
import type { INorm } from '@thi.ng/random';

/** Noise Type */
declare type Noise =
| 'blue'
| 'brown'
| 'green'
| 'pink'
| 'red'
| 'violet'
| 'white';

/** Map of noise types to their respective generator functions. */
declare const Noise: Record<Noise, NoiseGenerator> = {
    blue,
    brown: red,
    green,
    pink,
    red,
    violet,
    white,
};

/** A colored-noise generator function. */
declare type NoiseGenerator = (
opts?: Partial<ColoredNoiseOpts>,
) => Generator<number, void, unknown>;

/**
 * Reverb effect class
 */
declare class Reverb {
    /** Version strings */
    static readonly version: string;
    /** Build date */
    static readonly build: string;
    /** AudioContext */
    private readonly ctx;
    /** Wet Level (Reverberated node) */
    private readonly wetGainNode;
    /** Dry Level (Original sound node) */
    private readonly dryGainNode;
    /** Impulse response filter */
    private readonly filterNode;
    /** Convolution node for applying impulse response */
    private readonly convolverNode;
    /** Output gain node */
    private readonly outputNode;
    /** Option */
    private readonly options;
    /** Connected flag */
    private isConnected;
    /** Noise generator */
    private noise;
    /** Map of noise types to their respective generator functions. */
    private readonly noiseMap;
    /**
     * Constructor
     *
     * @param ctx - Root AudioContext
     * @param options - Configure
     */
    constructor(ctx: AudioContext, options?: Partial<ReverbOptions>);
    private initializeAudioChain;
    /**
     * Connect the node for the reverb effect to the original sound node.
     *
     * @param sourceNode - Input source node
     */
    connect(sourceNode: AudioNode): AudioNode;
    /**
     * Disconnect the reverb node.
     *
     * @param sourceNode - Input source node
     */
    disconnect(sourceNode?: AudioNode): AudioNode | undefined;
    /**
     * Dry/Wet ratio.
     *
     * @param mix - Ratio (0~1)
     */
    mix(mix: number): void;
    /**
     * Set Impulse Response time length (second).
     *
     * @param value - IR length
     */
    time(value: number): void;
    /**
     * Impulse response decay rate.
     *
     * @param value - Decay value
     */
    decay(value: number): void;
    /**
     * Delay before reverberation starts.
     *
     * @param value - Time[ms]
     */
    delay(value: number): void;
    /**
     * Reverse the impulse response.
     *
     * @param reverse - Reverse IR
     */
    reverse(reverse: boolean): void;
    /**
     * Filter for impulse response.
     *
     * @param type - Filter type
     */
    filterType(type?: BiquadFilterType): void;
    /**
     * Filter frequency applied to impulse response.
     *
     * @param freq - Frequency
     */
    filterFreq(freq: number): void;
    /**
     * Filter quality.
     *
     * @param q - Quality
     */
    filterQ(q: number): void;
    /**
     * Set IR source noise peaks.
     *
     * @param p - Peaks
     */
    peaks(p: number): void;
    /**
     * Set IR source noise scale.
     *
     * @param s - Scale
     */
    scale(s: number): void;
    /**
     * Noise source.
     *
     * @param duration - length of IR.
     */
    private getNoise;
    /**
     * Inpulse Response noise algorithm.
     *
     * @param type - IR noise algorithm type.
     */
    setNoise(type: Noise): void;
    /**
     * Set the random number algorithm used for noise generation.
     *
     * @param algorithm - Random algorithm implementing {@link INorm}
     */
    setRandomAlgorithm(algorithm: INorm): void;
    /**
     * Return true if in range, otherwise false.
     *
     * @param x - Target value
     * @param min - Minimum value
     * @param max - Maximum value
     */
    private static inRange;
    private assertRange;
    private resolveNoiseGenerator;
    /** Builds the impulse response buffer from the current options. */
    private buildImpulse;
}
export default Reverb;

/** Reverb Option */
declare type ReverbOptions = {
    /**
     * IR (Impulse Response) waveform table generation color noise algorithm.
     * @see {@link https://github.com/thi-ng/umbrella/tree/develop/packages/colored-noise}
     */
    noise: Noise;
    /** IR source noise scale */
    scale: number;
    /** Number of IR source noise peaks */
    peaks: number;
    /**
     * Random noise algorithm.
     * @see {@link https://github.com/thi-ng/umbrella/tree/develop/packages/random}
     */
    randomAlgorithm: INorm;
    /** Decay */
    decay: number;
    /** Delay until impulse response is generated */
    delay: number;
    /** Filter frequency applied to impulse response[Hz] */
    filterFreq: number;
    /** Filter quality for impulse response */
    filterQ: number;
    /** Filter type for impulse response */
    filterType: BiquadFilterType;
    /** Dry/Wet ratio */
    mix: number;
    /** Reverse the impulse response waveform table */
    reverse: boolean;
    /** Impulse response length */
    time: number;
    /** Prevents multiple effectors from being connected. */
    once: boolean;
};

/** Default Value */
declare const ReverbOptions: ReverbOptions = {
    noise: 'white',
    scale: 1,
    peaks: 2,
    randomAlgorithm: SYSTEM,
    decay: 2,
    delay: 0,
    reverse: false,
    time: 2,
    filterType: 'allpass',
    filterFreq: 2200,
    filterQ: 1,
    mix: 0.5,
    once: false,
};

export { }