// TypeScript bindings for emscripten-generated code.  Automatically generated at compile time.
declare namespace RuntimeExports {
    let HEAPF32: any;
    let HEAPF64: any;
    let HEAP_DATA_VIEW: any;
    let HEAP8: any;
    let HEAPU8: any;
    let HEAP16: any;
    let HEAPU16: any;
    let HEAP32: any;
    let HEAPU32: any;
    let HEAP64: any;
    let HEAPU64: any;
    function stackSave(): any;
    function stackAlloc(sz: any): any;
    function stackRestore(val: any): any;
    let wasmTable: WebAssembly.Table;
}
interface WasmModule {
  _main(_0: number, _1: number): number;
}

type EmbindString = ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string;
export interface ClassHandle {
  isAliasOf(other: ClassHandle): boolean;
  delete(): void;
  deleteLater(): this;
  isDeleted(): boolean;
  clone(): this;
}
export interface BufferF32 extends ClassHandle {
  readonly channelCount: number;
  readonly frameCount: number;
  view(): Float32Array[];
  noise(): void;
  set(channels: Float32Array[]): void;
  setInto(outputTypedArrays: Float32Array[]): void;
  interleaveTo(destination: BufferF32 | null): void;
  deinterleaveFrom(source: BufferF32 | null): void;
  set(channel: number, inputTypedArray: Float32Array): void;
  set(channel: number, offset: number, inputTypedArray: Float32Array): void;
  view(channel: number): Float32Array;
  setInto(channel: number, outputTypedArray: Float32Array): void;
  fill(value: number): void;
  fill(offset: number, count: number, value: number): void;
  peak(): number;
}

export interface BufferF64 extends ClassHandle {
  readonly channelCount: number;
  readonly frameCount: number;
  view(): Float64Array[];
  noise(): void;
  set(channels: Float64Array[]): void;
  setInto(outputTypedArrays: Float64Array[]): void;
  interleaveTo(destination: BufferF64 | null): void;
  deinterleaveFrom(source: BufferF64 | null): void;
  set(channel: number, inputTypedArray: Float64Array): void;
  set(channel: number, offset: number, inputTypedArray: Float64Array): void;
  view(channel: number): Float64Array;
  setInto(channel: number, outputTypedArray: Float64Array): void;
  fill(value: number): void;
  fill(offset: number, count: number, value: number): void;
  peak(): number;
}

export interface RandomAccessAudioReadable extends ClassHandle {
  readonly sampleRate: number;
  readonly channelCount: number;
  readonly frameCount: number;
  read(offset: number, outputBuffer: BufferF32 | null): void;
  readZeroPadded(_0: number, _1: BufferF32): void;
}

export interface OffsetView extends RandomAccessAudioReadable {
}

export interface RemoteAudioBuffer extends RandomAccessAudioReadable {
  readonly sampleRate: number;
  readonly channelCount: number;
  readonly frameCount: number;
  read(_0: number, _1: BufferF32): void;
}

export interface RemoteAudioBufferWrapper extends RemoteAudioBuffer {
  notifyOnDestruction(): void;
}

export interface BufferAsRemoteAudioBuffer extends RemoteAudioBuffer {
}

export interface AudioClip extends ClassHandle {
  warpEnabled: boolean;
  gain: number;
  transposition: number;
  readonly timelineStartBeats: number;
  readonly timelineEndBeats: number;
  loopStartBeats: number;
  loopEndBeats: number;
  readStartBeats: number;
  fadeInBeats: number;
  fadeInExponent: number;
  fadeOutBeats: number;
  fadeOutExponent: number;
  warpedContentBps: number;
}

export interface Track extends ClassHandle {
  readonly meter: Meter | null;
  readonly filterChain: FilterChain | null;
  muted: boolean;
  gain: number;
  pan: number;
  getClipCount(): number;
  getClip(index: number): AudioClip | null;
}

export interface Meter extends ClassHandle {
  fftObserverEnabled: boolean;
  fftObserverDecayAlpha: number;
  getFFTObserverBuffer(): BufferF32;
  getPpmHoldIndicated(channel: number): number;
  getPpmIndicated(channel: number): number;
  getVuIndicated(channel: number): number;
}

export interface Timeline extends ClassHandle {
  playing: boolean;
  loopEnabled: boolean;
  masterGain: number;
  position: number;
  loopStart: number;
  loopEnd: number;
  fadeInStartBeats: number;
  fadeInLengthBeats: number;
  fadeInExponent: number;
  fadeOutEndBeats: number;
  fadeOutLengthBeats: number;
  fadeOutExponent: number;
  getTrackCount(): number;
  getTrack(index: number): Track | null;
}

export interface TimelineTempoMap extends ClassHandle {
  readonly defaultBps: number;
  transformBeatsToSeconds(beats: number): number | undefined;
}

export interface WarpMap extends ClassHandle {
}

export interface FfmpegAudioBuffer extends RandomAccessAudioReadable {
  readonly promise: Promise<FfmpegAudioBuffer>;
  readonly completed: boolean;
  readonly nextFrameOffset: number;
  readonly availableDuration: number;
  createClone(): FfmpegAudioBuffer;
}

export interface AOBDataSource extends ClassHandle {
  setCompleted(): void;
  write(_0: any): void;
}

export interface Resampler extends RandomAccessAudioReadable {
  readonly numerator: number;
  readonly denominator: number;
  setSampleRateRatio(numerator: number, denominator: number): void;
}

export interface Bouncer extends ClassHandle {
  bounceNext(): BufferF32 | null;
}

export interface SumOnlyBouncer extends ClassHandle {
  sumIntoMixdownBuffer(_0: BufferF32 | null): void;
  bounceNext(_0: boolean): BufferF32 | null;
}

export interface DSPContext extends ClassHandle {
  readonly meter: Meter | null;
  readonly analyticsObserver: AnalyticsObserver | null;
  readonly mipMapWorker: MipMapWorker | null;
  createMeter(): Meter;
  getAudioContext(): AudioContext;
  swapLiveTimeline(newLiveTimeline: Timeline | null): void;
  createFilterChain(filterCount: number): FilterChain;
  createSumOnlyBouncer(bufferSize: number): SumOnlyBouncer;
  setLimiterParams(lookaheadSeconds: number, attackSeconds: number, releaseSeconds: number, preGainDb: number, bypass: boolean, stereoLink: number): void;
  createBouncer(start: number, end: number, bufferSize: number): Bouncer;
  createAudioClip(underlyingReadable: RandomAccessAudioReadable | null, warpMap: WarpMap | null, gain: number, timelineStartBeats: number, timelineEndBeats: number, loopStartBeats: number, loopEndBeats: number, readStartBeats: number, fadeInBeats: number, fadeInExponent: number, fadeOutBeats: number, fadeOutExponent: number, transposition: number, warpedContentBps: number, warpEnabled: boolean, arrangementId: EmbindString): AudioClip;
  createTimeline(timing: TimelineTempoMap | null, tracks: any): Timeline;
  createTrack(gain: number, pan: number, muted: boolean, meter: Meter | null, filterChain: FilterChain | null, clips: any): Track;
}

export interface AnalyticsObserver extends ClassHandle {
  flushSpans(): PlaybackSpan[];
}

export interface MipMapRequest extends ClassHandle {
  readonly continueFrom: number | undefined;
  readonly status: number;
  readonly blocksProduced: number;
  getOutputBuffers(): Int16Array[];
  waitAsync(): { async: boolean, value: Promise<string> };
  cancel(): void;
}

export interface MipMapWorker extends ClassHandle {
  createRequest(_0: EmbindString, _1: number, _2: number, _3: number): MipMapRequest | null;
}

export interface BiQuadFilterModeValue<T extends number> {
  value: T;
}
export type BiQuadFilterMode = BiQuadFilterModeValue<0>|BiQuadFilterModeValue<1>|BiQuadFilterModeValue<2>|BiQuadFilterModeValue<3>|BiQuadFilterModeValue<4>|BiQuadFilterModeValue<5>|BiQuadFilterModeValue<6>|BiQuadFilterModeValue<7>|BiQuadFilterModeValue<8>;

export interface FilterChain extends ClassHandle {
  readonly filterCount: number;
  getMode(index: number): BiQuadFilterMode;
  setMode(index: number, mode: BiQuadFilterMode): void;
  getFrequency(index: number): number;
  setFrequency(index: number, frequency: number): void;
  getGain(index: number): number;
  setGain(index: number, dbGain: number): void;
  getQ(index: number): number;
  setQ(index: number, q: number): void;
}

export type PlaybackSpan = {
  arrangementId: EmbindString,
  begin: number,
  end: number
};

interface EmbindModule {
  BufferF32: {
    new(_0: number, _1: number): BufferF32;
    fromArray(inputTypedArrays: Float32Array[]): BufferF32;
  };
  BufferF64: {
    new(_0: number, _1: number): BufferF64;
    fromArray(inputTypedArrays: Float64Array[]): BufferF64;
  };
  RandomAccessAudioReadable: {};
  OffsetView: {
    new(_0: RandomAccessAudioReadable | null, _1: number, _2: number): OffsetView;
  };
  RemoteAudioBuffer: {
    implement(_0: any, _1: number, _2: number, _3: number): RemoteAudioBufferWrapper | null;
    extend(_0: EmbindString, _1: any): any;
  };
  RemoteAudioBufferWrapper: {};
  BufferAsRemoteAudioBuffer: {
    new(_0: number, _1: BufferF32 | null): BufferAsRemoteAudioBuffer;
  };
  AudioClip: {};
  Track: {};
  Meter: {};
  Timeline: {};
  TimelineTempoMap: {
    fromArray(defaultBps: number, automationPoints: { beats: number, value: number, curve: number }[]): TimelineTempoMap;
  };
  WarpMap: {
    fromArray(warpMarkers: { timeInOutput: number, timeInUnderlyingBuffer: number }[]): WarpMap;
  };
  FfmpegAudioBuffer: {
    createFromReadCallback(size: number, readCallback: (buf: Uint8Array, offset: number) => void, closeCallback: () => void): FfmpegAudioBuffer;
    createFromByteArray(source: Uint8Array, uuid?: EmbindString): FfmpegAudioBuffer;
    createFromUrl(url: EmbindString, uuid?: EmbindString): FfmpegAudioBuffer;
    createFromUrlStreaming(url: EmbindString, uuid?: EmbindString, streamReadOffset?: number): FfmpegAudioBuffer;
    createFromUuid(uuid: EmbindString): FfmpegAudioBuffer | null;
    addUuidAlias(existingUuid: EmbindString, newUuid: EmbindString): boolean;
  };
  AOBDataSource: {};
  Resampler: {
    new(_0: RandomAccessAudioReadable | null, _1: number, _2: number): Resampler;
  };
  Bouncer: {};
  SumOnlyBouncer: {};
  DSPContext: {
    create(name: EmbindString, vuAlpha: number, analyticsObserver: AnalyticsObserver | null, channelCount?: number): Promise<DSPContext>;
    createOffline(name: EmbindString, vuAlpha: number, channelCount: number, sampleRate: number, enableLimiter: boolean): Promise<DSPContext>;
  };
  AnalyticsObserver: {
    new(): AnalyticsObserver;
  };
  MipMapRequest: {};
  MipMapWorker: {};
  BiQuadFilterMode: {LOWPASS: BiQuadFilterModeValue<0>, HIGHPASS: BiQuadFilterModeValue<1>, BANDPASS: BiQuadFilterModeValue<2>, NOTCH: BiQuadFilterModeValue<3>, ALLPASS: BiQuadFilterModeValue<4>, EQ_BAND: BiQuadFilterModeValue<5>, LOW_SHELF: BiQuadFilterModeValue<6>, HIGH_SHELF: BiQuadFilterModeValue<7>, BYPASS: BiQuadFilterModeValue<8>};
  FilterChain: {};
  testFaultInJs(): void;
  doImportInWorker(_0: EmbindString): any;
}

interface GrowableTypes {
  GROWABLE_HEAP_U8(): Uint8Array;
  GROWABLE_HEAP_U16(): Uint16Array;
  GROWABLE_HEAP_U32(): Uint32Array;
  GROWABLE_HEAP_F32(): Float32Array;
  GROWABLE_HEAP_F64(): Float64Array;
  GROWABLE_HEAP_I8(): Int8Array;
  GROWABLE_HEAP_I16(): Int16Array;
  GROWABLE_HEAP_I32(): Int32Array;
}

export type MainModule = WasmModule & typeof RuntimeExports & EmbindModule & GrowableTypes;

export default function MainModuleFactory (options?: unknown): Promise<MainModule>;