type I16Ptr = number
type SpeexPreprocessState = number
type SpeexPreprocessCtlRequest = number

/** @internal */
interface SpeexModule extends Pick<EmscriptenModule, 'wasmBinary' | 'locateFile' | '_free' | '_malloc' | 'HEAP16' | 'HEAP32' | 'HEAPF32'> {
  /**
   * Creates a new preprocessing state. You MUST create one state per channel processed.
   * @param frame_size Number of samples to process at one time (should correspond to 10-20 ms). Must be
   * the same value as that used for the echo canceller for residual echo cancellation to work.
   * @param sampling_rate Sampling rate used for the input.
   * @return Newly created preprocessor state
   */
  _speex_preprocess_state_init(
    frame_size: number,
    sampling_rate: number
  ): SpeexPreprocessState
  /**
   * Destroys a preprocessor state
   * @param st Preprocessor state to destroy
   */
  _speex_preprocess_state_destroy(state: SpeexPreprocessState): void
  /**
   * Preprocess a frame
   * @param st Preprocessor state
   * @param x Audio sample vector (in and out). Must be same size as specified in speex_preprocess_state_init().
   * @return Bool value for voice activity (1 for speech, 0 for noise/silence), ONLY if VAD turned on.
   */
  _speex_preprocess_run(state: SpeexPreprocessState, x: I16Ptr): 1 | 0
  /**
   * Used like the ioctl function to control the preprocessor parameters
   * @param st Preprocessor state
   * @param request ioctl-type request (one of the SPEEX_PREPROCESS_* macros)
   * @param ptr Data exchanged to-from function
   * @return 0 if no error, -1 if request in unknown
   */
  _speex_preprocess_ctl(
    state: SpeexPreprocessState,
    request: SpeexPreprocessCtlRequest,
    void_: unknown
  ): -1 | 0
}

declare const loadModule: EmscriptenModuleFactory<SpeexModule>

type LoadOptions = Pick<SpeexModule, 'locateFile' | 'wasmBinary'>;
declare class SpeexPreprocessor {
    private readonly speexModule;
    readonly frameSize: number;
    readonly samplingRate: number;
    private readonly state;
    private processBuffPtr;
    private processI16Buff;
    private ctlBuffPtr?;
    constructor(speexModule: Readonly<SpeexModule>, frameSize: number, samplingRate: number);
    private mallocCtlBuffPtr;
    private ctl;
    private ctlGetI32;
    private ctlSetI32;
    private ctlGetBool;
    private ctlSetBool;
    private ctlGetF32;
    private ctlSetF32;
    private ctlGetI32Array;
    get denoise(): boolean;
    set denoise(value: boolean);
    get agc(): boolean;
    set agc(value: boolean);
    get vad(): boolean;
    set vad(value: boolean);
    get agcLevel(): number;
    set agcLevel(value: number);
    get probStart(): number;
    set probStart(value: number);
    get probContinue(): number;
    set probContinue(value: number);
    get noiseSuppress(): number;
    set noiseSuppress(value: number);
    get echoSuppress(): number;
    set echoSuppress(value: number);
    get echoSuppressActive(): number;
    set echoSuppressActive(value: number);
    get agcIncrement(): number;
    set agcIncrement(value: number);
    get agcDecrement(): number;
    set agcDecrement(value: number);
    get agcMaxGain(): number;
    set agcMaxGain(value: number);
    get agcLoudness(): number;
    get agcGain(): number;
    get psdSize(): number;
    get psd(): Int32Array<ArrayBuffer>;
    get noisePsdSize(): number;
    get noisePsd(): Int32Array<ArrayBuffer>;
    get prob(): number;
    get agcTarget(): number;
    set agcTarget(value: number);
    private assertFrameSize;
    processInt16(frame: Int16Array): boolean;
    process(frame: Float32Array): boolean;
    destroy(): void;
}

export { type LoadOptions, type SpeexModule, SpeexPreprocessor, loadModule as loadSpeexModule };