@e9g/buffered-audio-nodes 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1236 @@
+import { SourceNode, SourceNodeProperties, BufferedSourceStream, SourceMetadata, AudioChunk, TargetNode, TargetNodeProperties, BufferedTargetStream, StreamContext, TransformNode, TransformNodeProperties, BufferedTransformStream, ChunkBuffer, BufferedAudioNodeInput } from 'buffered-audio-nodes-core';
+export * from 'buffered-audio-nodes-core';
+export * from 'buffered-audio-nodes-utils';
+import { z } from 'zod';
+
+declare const ffmpegSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    ffprobePath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface ReadFfmpegProperties extends z.infer<typeof ffmpegSchema>, SourceNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare class ReadFfmpegStream<P extends ReadFfmpegProperties = ReadFfmpegProperties> extends BufferedSourceStream<P> {
+    private ffmpegProcess?;
+    private stdout?;
+    private frameOffset;
+    private remainder?;
+    private outputChannels;
+    private sourceSampleRate;
+    private sourceBitDepth;
+    getMetadata(): Promise<SourceMetadata>;
+    private ensureInitialized;
+    _read(): Promise<AudioChunk | undefined>;
+    _flush(): Promise<void>;
+    _teardown(): void;
+    private probe;
+    private readBytes;
+}
+declare class ReadFfmpegNode extends SourceNode<ReadFfmpegProperties> {
+    static readonly moduleName = "ReadFfmpeg";
+    static readonly moduleDescription = "Read audio from a file using FFmpeg";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        ffprobePath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read-ffmpeg"];
+    protected createStream(): ReadFfmpegStream;
+    clone(overrides?: Partial<ReadFfmpegProperties>): ReadFfmpegNode;
+}
+declare function readFfmpeg(path: string, options: {
+    channels?: ReadonlyArray<number>;
+    ffmpegPath: string;
+    ffprobePath: string;
+}): ReadFfmpegNode;
+
+declare const wavSchema: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface ReadWavProperties extends z.infer<typeof wavSchema>, SourceNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare function readSample(data: Buffer, offset: number, bitsPerSample: number, audioFormat: number): number;
+declare class ReadWavStream<P extends ReadWavProperties = ReadWavProperties> extends BufferedSourceStream<P> {
+    private fileHandle?;
+    private format?;
+    private bytesRead;
+    private sourceSampleRate;
+    private sourceBitDepth;
+    getMetadata(): Promise<SourceMetadata>;
+    private ensureInitialized;
+    _read(): Promise<AudioChunk | undefined>;
+    _flush(): Promise<void>;
+    _teardown(): void;
+}
+declare class ReadWavNode extends SourceNode<ReadWavProperties> {
+    static readonly moduleName = "ReadWav";
+    static readonly moduleDescription = "Read audio from a WAV file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read-wav"];
+    protected createStream(): ReadWavStream;
+    clone(overrides?: Partial<ReadWavProperties>): ReadWavNode;
+}
+declare function readWav(path: string, options?: {
+    channels?: ReadonlyArray<number>;
+}): ReadWavNode;
+
+declare const schema$m: z.ZodObject<{
+    path: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    ffprobePath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface ReadProperties extends z.infer<typeof schema$m>, SourceNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare class ReadNode extends SourceNode<ReadProperties> {
+    static readonly moduleName = "Read";
+    static readonly moduleDescription = "Read audio from a file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        ffprobePath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "source", "read"];
+    protected createStream(): ReadWavStream<ReadProperties> | ReadFfmpegStream<ReadProperties>;
+    clone(overrides?: Partial<ReadProperties>): ReadNode;
+}
+declare function read(path: string, options?: {
+    channels?: ReadonlyArray<number>;
+    ffmpegPath?: string;
+    ffprobePath?: string;
+}): ReadNode;
+
+interface LoudnessStats {
+    readonly integrated: number;
+    readonly shortTerm: Array<number>;
+    readonly momentary: Array<number>;
+    readonly truePeak: number;
+    readonly range: number;
+}
+declare class LoudnessStatsStream extends BufferedTargetStream {
+    private channels;
+    private sampleRate;
+    private truePeakValue;
+    private channelBuffers;
+    private totalFrames;
+    private _stats?;
+    private statsInitialized;
+    get stats(): LoudnessStats | undefined;
+    private ensureInit;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+}
+declare class LoudnessStatsNode extends TargetNode {
+    static readonly moduleName = "Loudness Stats";
+    static readonly moduleDescription = "Measure integrated loudness, true peak, loudness range, and short-term/momentary loudness per EBU R128";
+    static readonly schema: z.ZodObject<{}, z.core.$strip>;
+    static is(value: unknown): value is LoudnessStatsNode;
+    readonly type: readonly ["buffered-audio-node", "target", "loudness-stats"];
+    private cachedStats?;
+    constructor(properties?: TargetNodeProperties);
+    get stats(): LoudnessStats | undefined;
+    _teardown(): void;
+    createStream(): LoudnessStatsStream;
+    clone(overrides?: Partial<TargetNodeProperties>): LoudnessStatsNode;
+}
+declare function loudnessStats(options?: {
+    id?: string;
+}): LoudnessStatsNode;
+
+declare const schema$l: z.ZodObject<{
+    outputPath: z.ZodDefault<z.ZodString>;
+    fftSize: z.ZodDefault<z.ZodNumber>;
+    hopSize: z.ZodDefault<z.ZodNumber>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type FrequencyScale = "linear" | "log" | "mel" | "erb";
+interface SpectrogramProperties extends z.infer<typeof schema$l>, TargetNodeProperties {
+    readonly frequencyScale?: FrequencyScale;
+    readonly numBands?: number;
+    readonly minFrequency?: number;
+    readonly maxFrequency?: number;
+}
+declare class SpectrogramStream extends BufferedTargetStream<SpectrogramProperties> {
+    private fileHandle?;
+    private channels;
+    private linearBins;
+    private outputBins;
+    private numFrames;
+    private fileOffset;
+    private windowCoefficients;
+    private workspace?;
+    private addon;
+    private bandMappings?;
+    private magnitudes;
+    private sampleBuffers;
+    private sampleBufferOffset;
+    private sampleBufferCapacity;
+    private writeBuffer?;
+    private writeBufferOffset;
+    private writeBufferFileOffset;
+    private readonly WRITE_BATCH_FRAMES;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    private processAccumulatedSamples;
+    private writeFrame;
+    private flushWriteBuffer;
+}
+declare class SpectrogramNode extends TargetNode<SpectrogramProperties> {
+    static readonly moduleName = "Spectrogram";
+    static readonly moduleDescription = "Generate spectrogram visualization data";
+    static readonly schema: z.ZodObject<{
+        outputPath: z.ZodDefault<z.ZodString>;
+        fftSize: z.ZodDefault<z.ZodNumber>;
+        hopSize: z.ZodDefault<z.ZodNumber>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is SpectrogramNode;
+    readonly type: readonly ["buffered-audio-node", "target", "spectrogram"];
+    constructor(properties: SpectrogramProperties);
+    createStream(): SpectrogramStream;
+    clone(overrides?: Partial<SpectrogramProperties>): SpectrogramNode;
+}
+declare function spectrogram(outputPath: string, options?: {
+    fftSize?: number;
+    hopSize?: number;
+    frequencyScale?: FrequencyScale;
+    numBands?: number;
+    minFrequency?: number;
+    maxFrequency?: number;
+    fftwAddonPath?: string;
+}): SpectrogramNode;
+
+declare const schema$k: z.ZodObject<{
+    outputPath: z.ZodDefault<z.ZodString>;
+    resolution: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface WaveformProperties extends z.infer<typeof schema$k>, TargetNodeProperties {
+}
+declare class WaveformStream extends BufferedTargetStream<WaveformProperties> {
+    private fileHandle?;
+    private channels;
+    private samplesPerPoint;
+    private totalPoints;
+    private fileOffset;
+    private samplesInCurrentWindow;
+    private currentMin;
+    private currentMax;
+    private writeBuffer;
+    private writeBufferOffset;
+    private writeBufferFileOffset;
+    private readonly WRITE_BATCH_POINTS;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    private writeHeader;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    private flushPoint;
+    private flushWriteBuffer;
+}
+declare class WaveformNode extends TargetNode<WaveformProperties> {
+    static readonly moduleName = "Waveform";
+    static readonly moduleDescription = "Generate waveform visualization data";
+    static readonly schema: z.ZodObject<{
+        outputPath: z.ZodDefault<z.ZodString>;
+        resolution: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is WaveformNode;
+    readonly type: readonly ["buffered-audio-node", "target", "waveform"];
+    constructor(properties: WaveformProperties);
+    createStream(): WaveformStream;
+    clone(overrides?: Partial<WaveformProperties>): WaveformNode;
+}
+declare function waveform(outputPath: string, options?: {
+    resolution?: number;
+}): WaveformNode;
+
+type WavBitDepth = "16" | "24" | "32" | "32f";
+interface EncodingOptions {
+    readonly format: "wav" | "flac" | "mp3" | "aac";
+    readonly bitrate?: string;
+    readonly vbr?: number;
+}
+interface WriteProperties extends TargetNodeProperties {
+    readonly path: string;
+    readonly ffmpegPath?: string;
+    readonly bitDepth: WavBitDepth;
+    readonly encoding?: EncodingOptions;
+}
+declare class WriteStream extends BufferedTargetStream<WriteProperties> {
+    private fileHandle?;
+    private ffmpegProcess?;
+    private ffmpegStdin?;
+    private ffmpegDone?;
+    private sampleRate;
+    private channels;
+    private bytesWritten;
+    private useEncoding;
+    private headerWritten;
+    private initialized;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<void>;
+    private initialize;
+    _write(chunk: AudioChunk): Promise<void>;
+    _close(): Promise<void>;
+    private convertChunk;
+    private buildFfmpegArgs;
+    private writeToStdin;
+}
+declare class WriteNode extends TargetNode<WriteProperties> {
+    static readonly moduleName = "Write";
+    static readonly moduleDescription = "Write audio to a file";
+    static readonly schema: z.ZodObject<{
+        path: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        bitDepth: z.ZodDefault<z.ZodEnum<{
+            16: "16";
+            24: "24";
+            32: "32";
+            "32f": "32f";
+        }>>;
+    }, z.core.$strip>;
+    readonly type: readonly ["buffered-audio-node", "target", "write"];
+    createStream(): WriteStream;
+    clone(overrides?: Partial<WriteProperties>): WriteNode;
+}
+declare function write(path: string, options?: {
+    bitDepth?: WavBitDepth;
+    ffmpegPath?: string;
+    encoding?: EncodingOptions;
+}): WriteNode;
+
+declare const cutRegionSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+declare const schema$j: z.ZodObject<{
+    regions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CutRegion = z.infer<typeof cutRegionSchema>;
+interface CutProperties extends z.infer<typeof schema$j>, TransformNodeProperties {
+}
+declare class CutStream extends BufferedTransformStream<CutProperties> {
+    private sortedRegions;
+    private removedFrames;
+    constructor(properties: CutProperties);
+    _unbuffer(chunk: AudioChunk): AudioChunk | undefined;
+}
+declare class CutNode extends TransformNode<CutProperties> {
+    static readonly moduleName = "Cut";
+    static readonly moduleDescription = "Remove a region of audio";
+    static readonly schema: z.ZodObject<{
+        regions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is CutNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "cut"];
+    createStream(): CutStream;
+    clone(overrides?: Partial<CutProperties>): CutNode;
+}
+declare function cut(regions: Array<CutRegion>, options?: {
+    id?: string;
+}): CutNode;
+
+declare const schema$i: z.ZodObject<{
+    bitDepth: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<16>, z.ZodLiteral<24>]>>;
+    noiseShaping: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+interface DitherProperties extends z.infer<typeof schema$i>, TransformNodeProperties {
+}
+declare class DitherStream extends BufferedTransformStream<DitherProperties> {
+    private lastError;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class DitherNode extends TransformNode<DitherProperties> {
+    static readonly moduleName = "Dither";
+    static readonly moduleDescription = "Add shaped noise to reduce quantization distortion";
+    static readonly schema: z.ZodObject<{
+        bitDepth: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<16>, z.ZodLiteral<24>]>>;
+        noiseShaping: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DitherNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "dither"];
+    createStream(): DitherStream;
+    clone(overrides?: Partial<DitherProperties>): DitherNode;
+}
+declare function dither(bitDepth: 16 | 24, options?: {
+    noiseShaping?: boolean;
+    id?: string;
+}): DitherNode;
+
+declare const schema$h: z.ZodObject<{
+    ceiling: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface NormalizeProperties extends z.infer<typeof schema$h>, TransformNodeProperties {
+}
+declare class NormalizeStream extends BufferedTransformStream<NormalizeProperties> {
+    private peak;
+    private scale;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _process(_buffer: ChunkBuffer): void;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class NormalizeNode extends TransformNode<NormalizeProperties> {
+    static readonly moduleName = "Normalize";
+    static readonly moduleDescription = "Adjust peak or loudness level to a target ceiling";
+    static readonly schema: z.ZodObject<{
+        ceiling: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is NormalizeNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "normalize"];
+    constructor(properties: NormalizeProperties);
+    createStream(): NormalizeStream;
+    clone(overrides?: Partial<NormalizeProperties>): NormalizeNode;
+}
+declare function normalize(options?: {
+    ceiling?: number;
+    id?: string;
+}): NormalizeNode;
+
+declare const schema$g: z.ZodObject<{
+    before: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface PadProperties extends z.infer<typeof schema$g>, TransformNodeProperties {
+}
+declare class PadStream extends BufferedTransformStream<PadProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class PadNode extends TransformNode<PadProperties> {
+    static readonly moduleName = "Pad";
+    static readonly moduleDescription = "Add silence to start or end of audio";
+    static readonly schema: z.ZodObject<{
+        before: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PadNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "pad"];
+    constructor(properties: PadProperties);
+    createStream(): PadStream;
+    clone(overrides?: Partial<PadProperties>): PadNode;
+}
+declare function pad(options: {
+    before?: number;
+    after?: number;
+    id?: string;
+}): PadNode;
+
+declare const schema$f: z.ZodObject<{
+    invert: z.ZodDefault<z.ZodBoolean>;
+    angle: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+interface PhaseProperties extends z.infer<typeof schema$f>, TransformNodeProperties {
+}
+declare class PhaseStream extends BufferedTransformStream<PhaseProperties> {
+    private allpassState;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+    private applyInvert;
+    private applyPhaseRotation;
+}
+declare class PhaseNode extends TransformNode<PhaseProperties> {
+    static readonly moduleName = "Phase";
+    static readonly moduleDescription = "Invert or rotate signal phase";
+    static readonly schema: z.ZodObject<{
+        invert: z.ZodDefault<z.ZodBoolean>;
+        angle: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PhaseNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "phase"];
+    createStream(): PhaseStream;
+    clone(overrides?: Partial<PhaseProperties>): PhaseNode;
+}
+declare function phase(options?: {
+    invert?: boolean;
+    angle?: number;
+    id?: string;
+}): PhaseNode;
+declare function invert(options?: {
+    id?: string;
+}): PhaseNode;
+
+declare class ReverseStream extends BufferedTransformStream {
+    private spareBuffer?;
+    private spareChunkSize;
+    private spareInitialized;
+    private reverseMemoryLimit?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    private ensureSpareBuffer;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): Promise<void>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class ReverseNode extends TransformNode {
+    static readonly moduleName = "Reverse";
+    static readonly moduleDescription = "Reverse audio playback direction";
+    static readonly schema: z.ZodObject<{}, z.core.$strip>;
+    static is(value: unknown): value is ReverseNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "reverse"];
+    constructor(properties?: TransformNodeProperties);
+    createStream(): ReverseStream;
+    clone(overrides?: Partial<TransformNodeProperties>): ReverseNode;
+}
+declare function reverse(options?: {
+    id?: string;
+}): ReverseNode;
+
+declare const schema$e: z.ZodObject<{
+    insertPath: z.ZodDefault<z.ZodString>;
+    insertAt: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface SpliceProperties extends z.infer<typeof schema$e>, TransformNodeProperties {
+    readonly channels?: ReadonlyArray<number>;
+}
+declare class SpliceStream extends BufferedTransformStream<SpliceProperties> {
+    private insertSamples;
+    private insertSampleRate;
+    private insertLength;
+    private sampleRateChecked;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class SpliceNode extends TransformNode<SpliceProperties> {
+    static readonly moduleName = "Splice";
+    static readonly moduleDescription = "Replace a region of audio with processed content";
+    static readonly schema: z.ZodObject<{
+        insertPath: z.ZodDefault<z.ZodString>;
+        insertAt: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is SpliceNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "splice"];
+    createStream(): SpliceStream;
+    clone(overrides?: Partial<SpliceProperties>): SpliceNode;
+}
+declare function splice(insertPath: string, insertAt: number, options?: {
+    channels?: ReadonlyArray<number>;
+}): SpliceNode;
+
+declare const schema$d: z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    margin: z.ZodDefault<z.ZodNumber>;
+    start: z.ZodDefault<z.ZodBoolean>;
+    end: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+interface TrimProperties extends z.infer<typeof schema$d>, TransformNodeProperties {
+}
+declare class TrimStream extends BufferedTransformStream<TrimProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class TrimNode extends TransformNode<TrimProperties> {
+    static readonly moduleName = "Trim";
+    static readonly moduleDescription = "Remove silence from start and end";
+    static readonly schema: z.ZodObject<{
+        threshold: z.ZodDefault<z.ZodNumber>;
+        margin: z.ZodDefault<z.ZodNumber>;
+        start: z.ZodDefault<z.ZodBoolean>;
+        end: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is TrimNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "trim"];
+    constructor(properties: TrimProperties);
+    createStream(): TrimStream;
+    clone(overrides?: Partial<TrimProperties>): TrimNode;
+}
+declare function trim(options?: {
+    threshold?: number;
+    margin?: number;
+    start?: boolean;
+    end?: boolean;
+    id?: string;
+}): TrimNode;
+
+interface FfmpegProperties extends TransformNodeProperties {
+    readonly ffmpegPath: string;
+    readonly args?: Array<string> | ((context: StreamContext) => Array<string>);
+}
+declare class FfmpegStream<P extends FfmpegProperties = FfmpegProperties> extends BufferedTransformStream<P> {
+    private streamContext?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    protected _buildArgs(_context: StreamContext): Array<string>;
+    protected _buildOutputArgs(_context: StreamContext): Array<string>;
+    protected get ffmpegChannels(): number;
+    private _ffmpegChannels;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class FfmpegNode<P extends FfmpegProperties = FfmpegProperties> extends TransformNode<P> {
+    static readonly moduleName: string;
+    static readonly moduleDescription: string;
+    static readonly schema: z.ZodType;
+    static is(value: unknown): value is FfmpegNode;
+    readonly type: ReadonlyArray<string>;
+    constructor(properties: P);
+    createStream(): FfmpegStream<P>;
+    clone(overrides?: Partial<P>): FfmpegNode<P>;
+}
+declare function ffmpeg(options: {
+    ffmpegPath: string;
+    args: Array<string> | ((context: StreamContext) => Array<string>);
+    id?: string;
+}): FfmpegNode;
+
+interface LoudnessProperties extends FfmpegProperties {
+    readonly target: number;
+    readonly truePeak: number;
+    readonly lra?: number;
+}
+declare class LoudnessStream extends FfmpegStream<LoudnessProperties> {
+    private measuredValues?;
+    protected _buildArgs(_context: StreamContext): Array<string>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+    private buildArgsWithMeasurement;
+}
+declare class LoudnessNode extends FfmpegNode<LoudnessProperties> {
+    static readonly moduleName = "Loudness";
+    static readonly moduleDescription = "Measure integrated, short-term, and momentary loudness";
+    static readonly schema: z.ZodObject<{
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        target: z.ZodDefault<z.ZodNumber>;
+        truePeak: z.ZodDefault<z.ZodNumber>;
+        lra: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is LoudnessNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "ffmpeg", "loudness"];
+    createStream(): LoudnessStream;
+    clone(overrides?: Partial<LoudnessProperties>): LoudnessNode;
+}
+declare function loudness(ffmpegPath: string, options?: {
+    target?: number;
+    truePeak?: number;
+    lra?: number;
+    id?: string;
+}): LoudnessNode;
+
+interface ResampleProperties extends FfmpegProperties {
+    readonly sampleRate: number;
+    readonly dither?: "triangular" | "lipshitz" | "none";
+}
+declare class ResampleStream extends FfmpegStream<ResampleProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+    protected _buildArgs(_context: StreamContext): Array<string>;
+    protected _buildOutputArgs(_context: StreamContext): Array<string>;
+}
+declare class ResampleNode extends FfmpegNode<ResampleProperties> {
+    static readonly moduleName = "Resample";
+    static readonly moduleDescription = "Change sample rate";
+    static readonly schema: z.ZodObject<{
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        sampleRate: z.ZodDefault<z.ZodNumber>;
+        dither: z.ZodDefault<z.ZodEnum<{
+            triangular: "triangular";
+            lipshitz: "lipshitz";
+            none: "none";
+        }>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is ResampleNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "ffmpeg", "resample"];
+    createStream(): ResampleStream;
+    clone(overrides?: Partial<ResampleProperties>): ResampleNode;
+}
+declare function resample(ffmpegPath: string, sampleRate: number, options?: {
+    dither?: "triangular" | "lipshitz" | "none";
+    id?: string;
+}): ResampleNode;
+
+declare const schema$c: z.ZodObject<{
+    sensitivity: z.ZodDefault<z.ZodNumber>;
+    reduction: z.ZodDefault<z.ZodNumber>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        remove: "remove";
+        attenuate: "attenuate";
+    }>>;
+}, z.core.$strip>;
+interface BreathControlProperties extends z.infer<typeof schema$c>, TransformNodeProperties {
+}
+declare class BreathControlStream extends BufferedTransformStream<BreathControlProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class BreathControlNode extends TransformNode<BreathControlProperties> {
+    static readonly moduleName = "Breath Control";
+    static readonly moduleDescription = "Attenuate or remove breath sounds between phrases";
+    static readonly schema: z.ZodObject<{
+        sensitivity: z.ZodDefault<z.ZodNumber>;
+        reduction: z.ZodDefault<z.ZodNumber>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            remove: "remove";
+            attenuate: "attenuate";
+        }>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is BreathControlNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "breath-control"];
+    constructor(properties: BreathControlProperties);
+    createStream(): BreathControlStream;
+    clone(overrides?: Partial<BreathControlProperties>): BreathControlNode;
+}
+declare function breathControl(options?: {
+    sensitivity?: number;
+    reduction?: number;
+    mode?: "remove" | "attenuate";
+    id?: string;
+}): BreathControlNode;
+
+declare const schema$b: z.ZodObject<{
+    referencePath: z.ZodDefault<z.ZodString>;
+    filterLength: z.ZodDefault<z.ZodNumber>;
+    stepSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DeBleedProperties extends z.infer<typeof schema$b>, TransformNodeProperties {
+}
+declare class DeBleedStream extends BufferedTransformStream<DeBleedProperties> {
+    private referenceSignal;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class DeBleedNode extends TransformNode<DeBleedProperties> {
+    static readonly moduleName = "De-Bleed";
+    static readonly moduleDescription = "Reduce microphone bleed between channels";
+    static readonly schema: z.ZodObject<{
+        referencePath: z.ZodDefault<z.ZodString>;
+        filterLength: z.ZodDefault<z.ZodNumber>;
+        stepSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeBleedNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "de-bleed"];
+    constructor(properties: DeBleedProperties);
+    createStream(): DeBleedStream;
+    clone(overrides?: Partial<DeBleedProperties>): DeBleedNode;
+}
+declare function deBleed(referencePath: string, options?: {
+    filterLength?: number;
+    stepSize?: number;
+    id?: string;
+}): DeBleedNode;
+
+declare const schema$a: z.ZodObject<{
+    sensitivity: z.ZodDefault<z.ZodNumber>;
+    maxClickDuration: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DeClickProperties extends z.infer<typeof schema$a>, TransformNodeProperties {
+}
+declare class DeClickStream extends BufferedTransformStream<DeClickProperties> {
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+/**
+ * Detects impulsive noise (clicks, pops) and removes them by momentarily
+ * ducking a low-pass filter over the click region. Clicks are high-frequency
+ * transients, so the LPF removes the click energy while preserving the
+ * underlying speech signal.
+ */
+declare class DeClickNode<P extends DeClickProperties = DeClickProperties> extends TransformNode<P> {
+    static readonly moduleName: string;
+    static readonly moduleDescription = "Remove clicks, pops, and impulse artifacts";
+    static readonly schema: z.ZodType;
+    static is(value: unknown): value is DeClickNode;
+    readonly type: string[];
+    constructor(properties: BufferedAudioNodeInput<P>);
+    createStream(): DeClickStream;
+    clone(overrides?: Partial<DeClickProperties>): DeClickNode;
+}
+declare function deClick(options?: {
+    sensitivity?: number;
+    maxClickDuration?: number;
+    id?: string;
+}): DeClickNode;
+
+declare const schema$9: z.ZodObject<{
+    sensitivity: z.ZodDefault<z.ZodNumber>;
+    maxClickDuration: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DeCrackleProperties extends z.infer<typeof schema$9>, DeClickProperties {
+}
+declare class DeCrackleNode extends DeClickNode<DeCrackleProperties> {
+    static readonly moduleName: string;
+    static readonly schema: z.ZodObject<{
+        sensitivity: z.ZodDefault<z.ZodNumber>;
+        maxClickDuration: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeCrackleNode;
+    readonly type: string[];
+    constructor(properties: BufferedAudioNodeInput<DeCrackleProperties>);
+    clone(overrides?: Partial<DeCrackleProperties>): DeCrackleNode;
+}
+declare function deCrackle(options?: {
+    sensitivity?: number;
+    id?: string;
+}): DeCrackleNode;
+
+declare const mouthDeClickSchema: z.ZodObject<{
+    sensitivity: z.ZodDefault<z.ZodNumber>;
+    maxClickDuration: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface MouthDeClickProperties extends z.infer<typeof mouthDeClickSchema>, DeClickProperties {
+}
+declare class MouthDeClickNode extends DeClickNode<MouthDeClickProperties> {
+    static readonly moduleName: string;
+    static readonly schema: z.ZodObject<{
+        sensitivity: z.ZodDefault<z.ZodNumber>;
+        maxClickDuration: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is MouthDeClickNode;
+    readonly type: string[];
+    constructor(properties: BufferedAudioNodeInput<MouthDeClickProperties>);
+    clone(overrides?: Partial<MouthDeClickProperties>): MouthDeClickNode;
+}
+declare function mouthDeClick(options?: {
+    sensitivity?: number;
+    id?: string;
+}): MouthDeClickNode;
+
+declare const schema$8: z.ZodObject<{
+    threshold: z.ZodDefault<z.ZodNumber>;
+    method: z.ZodDefault<z.ZodEnum<{
+        ar: "ar";
+        sparse: "sparse";
+    }>>;
+}, z.core.$strip>;
+interface DeClipProperties extends z.infer<typeof schema$8>, TransformNodeProperties {
+}
+/**
+ * Detects clipped samples and reconstructs the original waveform using
+ * iterative AR interpolation.
+ *
+ * @see Janssen, A.J.E.M., Veldhuis, R.N.J., Vries, L.B. (1986). "Adaptive interpolation of
+ *   discrete-time signals that can be modeled as autoregressive processes."
+ *   IEEE TASSP, 34(2), 317-330. https://doi.org/10.1109/TASSP.1986.1164824
+ * @see Zaviska, P., Rajmic, P., Ozerov, A., Rencker, L. (2021). "A Survey and an Extensive
+ *   Evaluation of Popular Audio Declipping Methods."
+ *   IEEE JSTSP, 15(1), 5-24. https://doi.org/10.1109/JSTSP.2020.3042071
+ */
+declare class DeClipStream extends BufferedTransformStream<DeClipProperties> {
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): void | Promise<void>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class DeClipNode extends TransformNode<DeClipProperties> {
+    static readonly moduleName = "De-Clip";
+    static readonly moduleDescription = "Restore clipped audio peaks";
+    static readonly schema: z.ZodObject<{
+        threshold: z.ZodDefault<z.ZodNumber>;
+        method: z.ZodDefault<z.ZodEnum<{
+            ar: "ar";
+            sparse: "sparse";
+        }>>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeClipNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "de-clip"];
+    createStream(): DeClipStream;
+    clone(overrides?: Partial<DeClipProperties>): DeClipNode;
+}
+declare function deClip(options?: {
+    threshold?: number;
+    method?: "ar" | "sparse";
+    id?: string;
+}): DeClipNode;
+
+declare const schema$7: z.ZodObject<{
+    sensitivity: z.ZodDefault<z.ZodNumber>;
+    frequency: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DePlosiveProperties extends z.infer<typeof schema$7>, TransformNodeProperties {
+}
+declare class DePlosiveStream extends BufferedTransformStream<DePlosiveProperties> {
+    private lpState;
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): void | Promise<void>;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class DePlosiveNode extends TransformNode<DePlosiveProperties> {
+    static readonly moduleName = "De-Plosive";
+    static readonly moduleDescription = "Reduce plosive bursts (p, b, t, d sounds)";
+    static readonly schema: z.ZodObject<{
+        sensitivity: z.ZodDefault<z.ZodNumber>;
+        frequency: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DePlosiveNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "de-plosive"];
+    createStream(): DePlosiveStream;
+    clone(overrides?: Partial<DePlosiveProperties>): DePlosiveNode;
+}
+declare function dePlosive(options?: {
+    sensitivity?: number;
+    frequency?: number;
+    id?: string;
+}): DePlosiveNode;
+
+declare const schema$6: z.ZodObject<{
+    predictionDelay: z.ZodDefault<z.ZodNumber>;
+    filterLength: z.ZodDefault<z.ZodNumber>;
+    iterations: z.ZodDefault<z.ZodNumber>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface DeReverbProperties extends z.infer<typeof schema$6>, TransformNodeProperties {
+}
+/**
+ * Reduces late reverberation from speech using the Weighted Prediction Error (WPE) algorithm.
+ * WPE models reverb as a linear prediction problem in the STFT domain — for each frequency bin,
+ * it estimates how past frames predict the current frame's reverberant tail, then subtracts that
+ * prediction. This is a classical signal processing approach: fully deterministic, tunable via
+ * prediction delay and filter length, and requires no pretrained model. The tradeoff is compute
+ * cost — WPE solves a linear system per frequency bin per iteration, which scales linearly with
+ * audio length but with a large constant factor. Best suited for offline processing or when
+ * precise parameter control is needed. For faster real-time dereverberation, consider a
+ * neural-network-based alternative.
+ *
+ * @see Nakatani, T., Yoshioka, T., Kinoshita, K., Miyoshi, M., Juang, B.H. (2010).
+ *   "Speech Dereverberation Based on Variance-Normalized Delayed Linear Prediction."
+ *   IEEE TASLP, 18(7), 1717-1731. https://doi.org/10.1109/TASL.2010.2052251
+ */
+declare class DeReverbStream extends BufferedTransformStream<DeReverbProperties> {
+    private fftBackend?;
+    private fftAddonOptions?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class DeReverbNode extends TransformNode<DeReverbProperties> {
+    static readonly moduleName = "De-Reverb (WPE)";
+    static readonly moduleDescription = "Reduce room reverb using Weighted Prediction Error \u2014 classical DSP, fully tunable, no model required";
+    static readonly schema: z.ZodObject<{
+        predictionDelay: z.ZodDefault<z.ZodNumber>;
+        filterLength: z.ZodDefault<z.ZodNumber>;
+        iterations: z.ZodDefault<z.ZodNumber>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DeReverbNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "de-reverb"];
+    constructor(properties: DeReverbProperties);
+    createStream(): DeReverbStream;
+    clone(overrides?: Partial<DeReverbProperties>): DeReverbNode;
+}
+declare function deReverb(options?: {
+    sensitivity?: number;
+    predictionDelay?: number;
+    filterLength?: number;
+    iterations?: number;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): DeReverbNode;
+
+declare const schema$5: z.ZodObject<{
+    modelPath: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    highPass: z.ZodDefault<z.ZodNumber>;
+    lowPass: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface DialogueIsolateProperties extends z.infer<typeof schema$5>, TransformNodeProperties {
+}
+declare class DialogueIsolateStream extends BufferedTransformStream<DialogueIsolateProperties> {
+    private session;
+    private fftInstance;
+    constructor(properties: DialogueIsolateProperties);
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class DialogueIsolateNode extends TransformNode<DialogueIsolateProperties> {
+    static readonly moduleName = "Dialogue Isolate";
+    static readonly moduleDescription = "Isolate dialogue from background using MDX-Net vocal separation";
+    static readonly schema: z.ZodObject<{
+        modelPath: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        highPass: z.ZodDefault<z.ZodNumber>;
+        lowPass: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is DialogueIsolateNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "dialogue-isolate"];
+    constructor(properties: DialogueIsolateProperties);
+    createStream(): DialogueIsolateStream;
+    clone(overrides?: Partial<DialogueIsolateProperties>): DialogueIsolateNode;
+}
+declare function dialogueIsolate(options: {
+    modelPath: string;
+    ffmpegPath: string;
+    onnxAddonPath?: string;
+    highPass?: number;
+    lowPass?: number;
+    id?: string;
+}): DialogueIsolateNode;
+
+declare const schema$4: z.ZodObject<{
+    referencePath: z.ZodDefault<z.ZodString>;
+    smoothing: z.ZodDefault<z.ZodNumber>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface EqMatchProperties extends z.infer<typeof schema$4>, TransformNodeProperties {
+}
+/**
+ * Analyzes a reference file's spectral profile and applies a correction filter
+ * to match the target signal's spectrum to the reference.
+ *
+ * @see Valimaki, V., Reiss, J.D. (2016). "All About Audio Equalization: Solutions and
+ *   Frontiers." Applied Sciences, 6(5), 129. https://doi.org/10.3390/app6050129
+ */
+declare class EqMatchStream extends BufferedTransformStream<EqMatchProperties> {
+    private referenceSpectrum?;
+    private fftBackend?;
+    private fftAddonOptions?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class EqMatchNode extends TransformNode<EqMatchProperties> {
+    static readonly moduleName = "EQ Match";
+    static readonly moduleDescription = "Match frequency response to a reference profile";
+    static readonly schema: z.ZodObject<{
+        referencePath: z.ZodDefault<z.ZodString>;
+        smoothing: z.ZodDefault<z.ZodNumber>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is EqMatchNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "eq-match"];
+    constructor(properties: EqMatchProperties);
+    createStream(): EqMatchStream;
+    clone(overrides?: Partial<EqMatchProperties>): EqMatchNode;
+}
+declare function eqMatch(referencePath: string, options?: {
+    smoothing?: number;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): EqMatchNode;
+
+declare const schema$3: z.ZodObject<{
+    target: z.ZodDefault<z.ZodNumber>;
+    window: z.ZodDefault<z.ZodNumber>;
+    speed: z.ZodDefault<z.ZodNumber>;
+    maxGain: z.ZodDefault<z.ZodNumber>;
+    maxCut: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface LevelerProperties extends z.infer<typeof schema$3>, TransformNodeProperties {
+}
+declare class LevelerStream extends BufferedTransformStream<LevelerProperties> {
+    private windowSamples;
+    private currentGainDb;
+    private windowSeconds;
+    constructor(properties: LevelerProperties);
+    _buffer(chunk: AudioChunk, buffer: ChunkBuffer): void | Promise<void>;
+    _process(_buffer: ChunkBuffer): void;
+    _unbuffer(chunk: AudioChunk): AudioChunk;
+}
+declare class LevelerNode extends TransformNode<LevelerProperties> {
+    static readonly moduleName = "Leveler";
+    static readonly moduleDescription = "Smooth volume variations for consistent loudness";
+    static readonly schema: z.ZodObject<{
+        target: z.ZodDefault<z.ZodNumber>;
+        window: z.ZodDefault<z.ZodNumber>;
+        speed: z.ZodDefault<z.ZodNumber>;
+        maxGain: z.ZodDefault<z.ZodNumber>;
+        maxCut: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is LevelerNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "leveler"];
+    createStream(): LevelerStream;
+    clone(overrides?: Partial<LevelerProperties>): LevelerNode;
+}
+declare function leveler(options?: {
+    target?: number;
+    window?: number;
+    speed?: number;
+    maxGain?: number;
+    maxCut?: number;
+    id?: string;
+}): LevelerNode;
+
+interface StemGains {
+    readonly vocals: number;
+    readonly drums: number;
+    readonly bass: number;
+    readonly other: number;
+}
+declare const schema$2: z.ZodObject<{
+    modelPath: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    highPass: z.ZodDefault<z.ZodNumber>;
+    lowPass: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface MusicRebalanceProperties extends z.infer<typeof schema$2>, TransformNodeProperties {
+    readonly stems: StemGains;
+}
+declare class MusicRebalanceStream extends BufferedTransformStream<MusicRebalanceProperties> {
+    private session;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class MusicRebalanceNode extends TransformNode<MusicRebalanceProperties> {
+    static readonly moduleName = "Music Rebalance";
+    static readonly moduleDescription = "Rebalance stem volumes using HTDemucs source separation";
+    static readonly schema: z.ZodObject<{
+        modelPath: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        highPass: z.ZodDefault<z.ZodNumber>;
+        lowPass: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is MusicRebalanceNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "music-rebalance"];
+    constructor(properties: MusicRebalanceProperties);
+    createStream(): MusicRebalanceStream;
+    clone(overrides?: Partial<MusicRebalanceProperties>): MusicRebalanceNode;
+}
+declare function musicRebalance(modelPath: string, stems: Partial<StemGains>, options?: {
+    ffmpegPath?: string;
+    onnxAddonPath?: string;
+    id?: string;
+}): MusicRebalanceNode;
+
+interface PitchShiftProperties extends FfmpegProperties {
+    readonly semitones: number;
+    readonly cents?: number;
+}
+declare class PitchShiftStream extends FfmpegStream<PitchShiftProperties> {
+    protected _buildArgs(_context: StreamContext): Array<string>;
+}
+declare class PitchShiftNode extends FfmpegNode<PitchShiftProperties> {
+    static readonly moduleName = "Pitch Shift";
+    static readonly moduleDescription = "Change pitch without affecting duration";
+    static readonly schema: z.ZodObject<{
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        semitones: z.ZodDefault<z.ZodNumber>;
+        cents: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is PitchShiftNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "ffmpeg", "pitch-shift"];
+    createStream(): PitchShiftStream;
+    clone(overrides?: Partial<PitchShiftProperties>): PitchShiftNode;
+}
+declare function pitchShift(ffmpegPath: string, semitones: number, options?: {
+    cents?: number;
+    id?: string;
+}): PitchShiftNode;
+
+interface SpectralRegion {
+    readonly startTime: number;
+    readonly endTime: number;
+    readonly startFreq: number;
+    readonly endFreq: number;
+}
+
+declare const schema$1: z.ZodObject<{
+    method: z.ZodDefault<z.ZodEnum<{
+        ar: "ar";
+        nmf: "nmf";
+    }>>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface SpectralRepairProperties extends z.infer<typeof schema$1>, TransformNodeProperties {
+    readonly regions: Array<SpectralRegion>;
+}
+/**
+ * Reconstructs damaged or missing regions in the spectrogram using
+ * time-frequency domain AR interpolation.
+ *
+ * @see Mokry, O., Balusik, P., Rajmic, P. (2024). "Janssen 2.0: Audio Inpainting in the
+ *   Time-frequency Domain." arXiv:2409.06392. https://arxiv.org/abs/2409.06392
+ */
+declare class SpectralRepairStream extends BufferedTransformStream<SpectralRepairProperties> {
+    private fftBackend?;
+    private fftAddonOptions?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class SpectralRepairNode extends TransformNode<SpectralRepairProperties> {
+    static readonly moduleName = "Spectral Repair";
+    static readonly moduleDescription = "Repair spectral artifacts by interpolating from surrounding content";
+    static readonly schema: z.ZodObject<{
+        method: z.ZodDefault<z.ZodEnum<{
+            ar: "ar";
+            nmf: "nmf";
+        }>>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is SpectralRepairNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "spectral-repair"];
+    constructor(properties: SpectralRepairProperties);
+    createStream(): SpectralRepairStream;
+    clone(overrides?: Partial<SpectralRepairProperties>): SpectralRepairNode;
+}
+declare function spectralRepair(regions: Array<SpectralRegion>, options?: {
+    method?: "ar" | "nmf";
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): SpectralRepairNode;
+
+interface TimeStretchProperties extends FfmpegProperties {
+    readonly rate: number;
+}
+declare class TimeStretchStream extends FfmpegStream<TimeStretchProperties> {
+    protected _buildArgs(_context: StreamContext): Array<string>;
+}
+declare class TimeStretchNode extends FfmpegNode<TimeStretchProperties> {
+    static readonly moduleName = "Time Stretch";
+    static readonly moduleDescription = "Change duration without affecting pitch";
+    static readonly schema: z.ZodObject<{
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        rate: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is TimeStretchNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "ffmpeg", "time-stretch"];
+    createStream(): TimeStretchStream;
+    clone(overrides?: Partial<TimeStretchProperties>): TimeStretchNode;
+}
+declare function timeStretch(ffmpegPath: string, rate: number, options?: {
+    id?: string;
+}): TimeStretchNode;
+
+declare const schema: z.ZodObject<{
+    modelPath1: z.ZodDefault<z.ZodString>;
+    modelPath2: z.ZodDefault<z.ZodString>;
+    ffmpegPath: z.ZodDefault<z.ZodString>;
+    onnxAddonPath: z.ZodDefault<z.ZodString>;
+    vkfftAddonPath: z.ZodDefault<z.ZodString>;
+    fftwAddonPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+interface VoiceDenoiseProperties extends z.infer<typeof schema>, TransformNodeProperties {
+}
+declare class VoiceDenoiseStream extends BufferedTransformStream<VoiceDenoiseProperties> {
+    private session1;
+    private session2;
+    private fftBackend?;
+    private fftAddonOptions?;
+    _setup(input: ReadableStream<AudioChunk>, context: StreamContext): Promise<ReadableStream<AudioChunk>>;
+    _process(buffer: ChunkBuffer): Promise<void>;
+}
+declare class VoiceDenoiseNode extends TransformNode<VoiceDenoiseProperties> {
+    static readonly moduleName = "Voice Denoise";
+    static readonly moduleDescription = "Remove background noise from speech using DTLN neural network";
+    static readonly schema: z.ZodObject<{
+        modelPath1: z.ZodDefault<z.ZodString>;
+        modelPath2: z.ZodDefault<z.ZodString>;
+        ffmpegPath: z.ZodDefault<z.ZodString>;
+        onnxAddonPath: z.ZodDefault<z.ZodString>;
+        vkfftAddonPath: z.ZodDefault<z.ZodString>;
+        fftwAddonPath: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    static is(value: unknown): value is VoiceDenoiseNode;
+    readonly type: readonly ["buffered-audio-node", "transform", "voice-denoise"];
+    constructor(properties: VoiceDenoiseProperties);
+    createStream(): VoiceDenoiseStream;
+    clone(overrides?: Partial<VoiceDenoiseProperties>): VoiceDenoiseNode;
+}
+declare function voiceDenoise(options: {
+    modelPath1: string;
+    modelPath2: string;
+    ffmpegPath: string;
+    onnxAddonPath?: string;
+    vkfftAddonPath?: string;
+    fftwAddonPath?: string;
+    id?: string;
+}): VoiceDenoiseNode;
+
+export { BreathControlNode, type BreathControlProperties, BreathControlStream, CutNode, type CutProperties, type CutRegion, CutStream, DeBleedNode, type DeBleedProperties, DeBleedStream, DeClickNode, type DeClickProperties, DeClickStream, DeClipNode, type DeClipProperties, DeClipStream, DeCrackleNode, type DeCrackleProperties, DePlosiveNode, type DePlosiveProperties, DePlosiveStream, DeReverbNode, type DeReverbProperties, DeReverbStream, DialogueIsolateNode, type DialogueIsolateProperties, DialogueIsolateStream, DitherNode, type DitherProperties, DitherStream, type EncodingOptions, EqMatchNode, type EqMatchProperties, EqMatchStream, FfmpegNode, type FfmpegProperties, FfmpegStream, type FrequencyScale, LevelerNode, type LevelerProperties, LevelerStream, LoudnessNode, type LoudnessProperties, type LoudnessStats, LoudnessStatsNode, LoudnessStatsStream, LoudnessStream, MouthDeClickNode, type MouthDeClickProperties, MusicRebalanceNode, type MusicRebalanceProperties, MusicRebalanceStream, NormalizeNode, type NormalizeProperties, NormalizeStream, PadNode, type PadProperties, PadStream, PhaseNode, type PhaseProperties, PhaseStream, PitchShiftNode, type PitchShiftProperties, ReadFfmpegNode, type ReadFfmpegProperties, ReadFfmpegStream, ReadNode, type ReadProperties, ReadWavNode, type ReadWavProperties, ReadWavStream, ResampleNode, type ResampleProperties, ReverseNode, ReverseStream, type SpectralRegion, SpectralRepairNode, type SpectralRepairProperties, SpectralRepairStream, SpectrogramNode, type SpectrogramProperties, SpectrogramStream, SpliceNode, type SpliceProperties, SpliceStream, type StemGains, TimeStretchNode, type TimeStretchProperties, TrimNode, type TrimProperties, TrimStream, VoiceDenoiseNode, type VoiceDenoiseProperties, VoiceDenoiseStream, type WavBitDepth, WaveformNode, type WaveformProperties, WaveformStream, WriteNode, type WriteProperties, WriteStream, breathControl, cut, deBleed, deClick, deClip, deCrackle, dePlosive, deReverb, dialogueIsolate, dither, eqMatch, ffmpeg, ffmpegSchema, invert, leveler, loudness, loudnessStats, mouthDeClick, musicRebalance, normalize, pad, phase, pitchShift, read, readFfmpeg, readSample, readWav, resample, reverse, spectralRepair, spectrogram, splice, timeStretch, trim, voiceDenoise, wavSchema, waveform, write };