@ringozz/godot 0.1.0

package/gen/classes/AudioEffectDelay.ts

@@ -0,0 +1,93 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "delay" effect plays the input audio signal back after a period of time. Each repetition is called a "delay tap" or simply "tap". Delay taps may be played back multiple times to create the sound of a repeating, decaying echo. Delay effects range from a subtle echo to a pronounced blending of previous sounds with new sounds.
+ * See also {@link AudioEffectReverb} for a blurry, continuous echo.
+ */
+export class AudioEffectDelay extends AudioEffect {
+    constructor(name = 94) { super(name); }
+
+    /**
+     * The volume ratio of the original audio. Value can range from 0 to 1.
+     */
+    get dry(): number { return _C(this, 4587) as number; }
+    set dry(v: number) { _C(this, 11201, v); }
+
+    /**
+     * If `true`, the first tap will be enabled.
+     */
+    get tap1Active(): boolean { return _C(this, 8357) as boolean; }
+    set tap1Active(v: boolean) { _C(this, 12993, v); }
+
+    /**
+     * First tap delay time in milliseconds, compared to the original audio. Value can range from 0 to 1500.
+     */
+    get tap1DelayMs(): number { return _C(this, 6691) as number; }
+    set tap1DelayMs(v: number) { _C(this, 12994, v); }
+
+    /**
+     * Gain for the first tap, in dB. Value can range from -60 to 0.
+     */
+    get tap1LevelDb(): number { return _C(this, 6692) as number; }
+    set tap1LevelDb(v: number) { _C(this, 12995, v); }
+
+    /**
+     * Pan position for the first tap. Negative values pan the sound to the left, positive pan to the right. Value can range from -1 to 1.
+     */
+    get tap1Pan(): number { return _C(this, 6693) as number; }
+    set tap1Pan(v: number) { _C(this, 12996, v); }
+
+    /**
+     * If `true`, the second tap will be enabled.
+     */
+    get tap2Active(): boolean { return _C(this, 8358) as boolean; }
+    set tap2Active(v: boolean) { _C(this, 12997, v); }
+
+    /**
+     * Second tap delay time in milliseconds, compared to the original audio. Value can range from 0 to 1500.
+     */
+    get tap2DelayMs(): number { return _C(this, 6694) as number; }
+    set tap2DelayMs(v: number) { _C(this, 12998, v); }
+
+    /**
+     * Gain for the second tap, in dB. Value can range from -60 to 0.
+     */
+    get tap2LevelDb(): number { return _C(this, 6695) as number; }
+    set tap2LevelDb(v: number) { _C(this, 12999, v); }
+
+    /**
+     * Pan position for the second tap. Negative values pan the sound to the left, positive pan to the right. Value can range from -1 to 1.
+     */
+    get tap2Pan(): number { return _C(this, 6696) as number; }
+    set tap2Pan(v: number) { _C(this, 13000, v); }
+
+    /**
+     * If `true`, feedback is enabled, repeating taps after they are played.
+     */
+    get feedbackActive(): boolean { return _C(this, 7947) as boolean; }
+    set feedbackActive(v: boolean) { _C(this, 11373, v); }
+
+    /**
+     * Feedback delay time in milliseconds. Value can range from 0 to 1500.
+     */
+    get feedbackDelayMs(): number { return _C(this, 4766) as number; }
+    set feedbackDelayMs(v: number) { _C(this, 11374, v); }
+
+    /**
+     * Gain for feedback, in dB. Value can range from -60 to 0.
+     */
+    get feedbackLevelDb(): number { return _C(this, 4767) as number; }
+    set feedbackLevelDb(v: number) { _C(this, 11375, v); }
+
+    /**
+     * Low-pass filter for feedback, in Hz. Frequencies above this value are filtered out. Value can range from 1 to 16000.
+     */
+    get feedbackLowpass(): number { return _C(this, 4768) as number; }
+    set feedbackLowpass(v: number) { _C(this, 11376, v); }
+
+    static readonly name = _R(94, AudioEffectDelay);
+}

package/gen/classes/AudioEffectDistortion.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "distortion" effect modifies the waveform via a nonlinear mathematical function (see available ones in {@link Mode}), based on the amplitude of the waveform's samples.
+ * **Note:** In a nonlinear function, an input sample at *x* amplitude value, will either have its amplitude increased or decreased to a *y* value, based on the function value at *x*, which is why even at the same {@link drive}, the output sound will vary depending on the input's volume. To change the volume while maintaining the output waveform, use {@link postGain}.
+ * In this effect, each type is a different nonlinear function. The different types available are: clip, atan, lofi (bitcrush), overdrive, and waveshape. Every distortion type available here is symmetric: negative amplitude values are affected the same way as positive ones.
+ * Although distortion will always change frequency content, usually by introducing high harmonics, different distortion types offer a range of sound qualities; from "soft" and "warm", to "crunchy" and "abrasive".
+ * For games, it can help simulate sound coming from some saturated device or speaker very efficiently. It can also help the audio stand out in a mix, by introducing higher frequencies and increasing the volume.
+ * **Note:** Although usually imperceptible, an enabled distortion effect still changes the sound even when {@link drive} is set to 0. This is not a bug. If this behavior is undesirable, consider disabling the effect using {@link AudioServer.setBusEffectEnabled}.
+ */
+export class AudioEffectDistortion extends AudioEffect {
+    constructor(name = 95) { super(name); }
+
+    /**
+     * Distortion type. Changes the nonlinear function used to distort the waveform. See {@link Mode}.
+     */
+    get mode(): Mode { return _C(this, 5568) as Mode; }
+    set mode(v: Mode) { _C(this, 12073, v); }
+
+    /**
+     * Gain before the effect, in dB. Value can range from -60 to 60.
+     */
+    get preGain(): number { return _C(this, 5982) as number; }
+    set preGain(v: number) { _C(this, 12390, v); }
+
+    /**
+     * High-pass filter, in Hz. Frequencies higher than this value will not be affected by the distortion. Value can range from 1 to 20000.
+     */
+    get keepHfHz(): number { return _C(this, 5283) as number; }
+    set keepHfHz(v: number) { _C(this, 11860, v); }
+
+    /**
+     * Distortion intensity. Controls how much of the input audio is affected by the distortion curve by moving from a linear function to a nonlinear one. Value can range from 0 to 1.
+     */
+    get drive(): number { return _C(this, 4571) as number; }
+    set drive(v: number) { _C(this, 11198, v); }
+
+    /**
+     * Gain after the effect, in dB. Value can range from -80 to 24.
+     */
+    get postGain(): number { return _C(this, 5981) as number; }
+    set postGain(v: number) { _C(this, 12389, v); }
+
+    static readonly name = _R(95, AudioEffectDistortion);
+}
+
+export const Mode = {
+    /**
+     * Flattens the waveform at 0 dB in a sharp manner. {@link drive} increases amplitude of samples exponentially. This mode functions as a hard clipper if {@link drive} is set to 0, and is the only mode that clips audio signals at 0 dB.
+     */
+    MODE_CLIP: 0,
+    /**
+     * Flattens the waveform in a smooth manner, following an arctangent curve. The audio decreases in volume, before flattening peaks to `PI * 4.0` (linear value), if it was normalized beforehand.
+     */
+    MODE_ATAN: 1,
+    /**
+     * Decreases audio bit depth to achieve a low-resolution audio signal, going from 16-bit to 2-bit. Can be used to emulate the sound of early digital audio devices.
+     */
+    MODE_LOFI: 2,
+    /**
+     * Emulates the warm distortion produced by a field effect transistor, which is commonly used in solid-state musical instrument amplifiers. {@link drive} has no effect in this mode.
+     */
+    MODE_OVERDRIVE: 3,
+    /**
+     * Flattens the waveform in a smooth manner, until it reaches a sharp peak at `drive = 1`, following a generic absolute sigmoid function.
+     */
+    MODE_WAVESHAPE: 4,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+

package/gen/classes/AudioEffectEQ.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * An "equalizer" gives you control over the gain of frequencies in the entire spectrum, by allowing their adjustment through bands. A band is a point in the frequency spectrum, and each band means a division of the spectrum that can be adjusted.
+ * Use equalizers to compensate for existing deficiencies in the audio, make room for other elements, or remove undesirable frequencies. AudioEffectEQs are useful on the Master bus to balance the entire mix or give it more character. They are also useful when a game is run on a mobile device, to adjust the mix to that kind of speakers (it can be disabled when headphones are plugged in).
+ */
+export class AudioEffectEQ extends AudioEffect {
+    constructor(name = 96) { super(name); }
+
+    /**
+     * Sets band's gain at the specified index, in dB.
+     */
+    setBandGainDb(bandIdx: number, volumeDb: number): void { _C(this, 10638, bandIdx, volumeDb); }
+
+    /**
+     * Returns the band's gain at the specified index, in dB.
+     */
+    getBandGainDb(bandIdx: number): number { return _C(this, 3890, bandIdx) as number; }
+
+    /**
+     * Returns the number of bands of the equalizer.
+     */
+    getBandCount(): number { return _C(this, 3889) as number; }
+
+    static readonly name = _R(96, AudioEffectEQ);
+}

package/gen/classes/AudioEffectEQ10.ts

@@ -0,0 +1,25 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectEQ } from './AudioEffectEQ.ts';
+
+/**
+ * Frequency bands:
+ * Band 1: 31 Hz
+ * Band 2: 62 Hz
+ * Band 3: 125 Hz
+ * Band 4: 250 Hz
+ * Band 5: 500 Hz
+ * Band 6: 1000 Hz
+ * Band 7: 2000 Hz
+ * Band 8: 4000 Hz
+ * Band 9: 8000 Hz
+ * Band 10: 16000 Hz
+ * See also {@link AudioEffectEQ}, {@link AudioEffectEQ6}, {@link AudioEffectEQ21}.
+ */
+export class AudioEffectEQ10 extends AudioEffectEQ {
+    constructor(name = 97) { super(name); }
+
+    static readonly name = _R(97, AudioEffectEQ10);
+}

package/gen/classes/AudioEffectEQ21.ts

@@ -0,0 +1,36 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectEQ } from './AudioEffectEQ.ts';
+
+/**
+ * Frequency bands:
+ * Band 1: 22 Hz
+ * Band 2: 32 Hz
+ * Band 3: 44 Hz
+ * Band 4: 63 Hz
+ * Band 5: 90 Hz
+ * Band 6: 125 Hz
+ * Band 7: 175 Hz
+ * Band 8: 250 Hz
+ * Band 9: 350 Hz
+ * Band 10: 500 Hz
+ * Band 11: 700 Hz
+ * Band 12: 1000 Hz
+ * Band 13: 1400 Hz
+ * Band 14: 2000 Hz
+ * Band 15: 2800 Hz
+ * Band 16: 4000 Hz
+ * Band 17: 5600 Hz
+ * Band 18: 8000 Hz
+ * Band 19: 11000 Hz
+ * Band 20: 16000 Hz
+ * Band 21: 22000 Hz
+ * See also {@link AudioEffectEQ}, {@link AudioEffectEQ6}, {@link AudioEffectEQ10}.
+ */
+export class AudioEffectEQ21 extends AudioEffectEQ {
+    constructor(name = 98) { super(name); }
+
+    static readonly name = _R(98, AudioEffectEQ21);
+}

package/gen/classes/AudioEffectEQ6.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectEQ } from './AudioEffectEQ.ts';
+
+/**
+ * Frequency bands:
+ * Band 1: 32 Hz
+ * Band 2: 100 Hz
+ * Band 3: 320 Hz
+ * Band 4: 1000 Hz
+ * Band 5: 3200 Hz
+ * Band 6: 10000 Hz
+ * See also {@link AudioEffectEQ}, {@link AudioEffectEQ10}, {@link AudioEffectEQ21}.
+ */
+export class AudioEffectEQ6 extends AudioEffectEQ {
+    constructor(name = 99) { super(name); }
+
+    static readonly name = _R(99, AudioEffectEQ6);
+}

package/gen/classes/AudioEffectFilter.ts

@@ -0,0 +1,68 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "filter" controls the gain of frequencies, using {@link cutoffHz} as a frequency threshold. Filters can help to give room for each sound, and create interesting effects.
+ * There are different types of filter that inherit this class:
+ * Shelf filters: {@link AudioEffectLowShelfFilter} and {@link AudioEffectHighShelfFilter}
+ * Band-pass and notch filters: {@link AudioEffectBandPassFilter}, {@link AudioEffectBandLimitFilter}, and {@link AudioEffectNotchFilter}
+ * Low/high-pass filters: {@link AudioEffectLowPassFilter} and {@link AudioEffectHighPassFilter}
+ */
+export class AudioEffectFilter extends AudioEffect {
+    constructor(name = 100) { super(name); }
+
+    /**
+     * Frequency threshold for the filter, in Hz. Value can range from 1 to 20500.
+     */
+    get cutoffHz(): number { return _C(this, 4403) as number; }
+    set cutoffHz(v: number) { _C(this, 11027, v); }
+
+    /**
+     * Gain at or directly next to the {@link cutoffHz} frequency threshold. Value can range from 0 to 1.
+     * Its exact behavior depends on the selected filter type:
+     * - For shelf filters, it accentuates or masks the order by increasing frequencies right next to the {@link cutoffHz} frequency and decreasing frequencies on the opposite side.
+     * - For the band-pass and notch filters, it widens or narrows the filter at the {@link cutoffHz} frequency threshold.
+     * - For low/high-pass filters, it increases or decreases frequencies at the {@link cutoffHz} frequency threshold.
+     */
+    get resonance(): number { return _C(this, 6159) as number; }
+    set resonance(v: number) { _C(this, 12542, v); }
+
+    /**
+     * Gain of the frequencies affected by the filter. This property is only available for {@link AudioEffectLowShelfFilter} and {@link AudioEffectHighShelfFilter}. Value can range from 0 to 4.
+     */
+    get gain(): number { return _C(this, 4914) as number; }
+    set gain(v: number) { _C(this, 11506, v); }
+
+    /**
+     * Steepness of the cutoff curve in dB per octave (twice the frequency above {@link cutoffHz}, or half the frequency below {@link cutoffHz}), also known as the "order" of the filter. Higher orders have a more aggressive cutoff.
+     */
+    get db(): FilterDB { return _C(this, 4426) as FilterDB; }
+    set db(v: FilterDB) { _C(this, 11036, v); }
+
+    static readonly name = _R(100, AudioEffectFilter);
+}
+
+export const FilterDB = {
+    /**
+     * Cutting off at 6 dB per octave. One octave is twice the frequency above {@link cutoffHz}, or half the frequency below {@link cutoffHz}.
+     */
+    FILTER_6DB: 0,
+    /**
+     * Cutting off at 12 dB per octave. One octave is twice the frequency above {@link cutoffHz}, or half the frequency below {@link cutoffHz}.
+     */
+    FILTER_12DB: 1,
+    /**
+     * Cutting off at 18 dB per octave. One octave is twice the frequency above {@link cutoffHz}, or half the frequency below {@link cutoffHz}.
+     */
+    FILTER_18DB: 2,
+    /**
+     * Cutting off at 24 dB per octave. One octave is twice the frequency above {@link cutoffHz}, or half the frequency below {@link cutoffHz}.
+     */
+    FILTER_24DB: 3,
+} as const;
+
+export type FilterDB = (typeof FilterDB)[keyof typeof FilterDB];
+

package/gen/classes/AudioEffectHardLimiter.ts

@@ -0,0 +1,34 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "limiter" disallows audio signals from exceeding a given volume threshold level in dB. Hard limiters predict volume peaks, and will smoothly apply gain reduction when a peak crosses the ceiling threshold level to prevent clipping. It preserves the waveform and prevents it from crossing the ceiling threshold level. Adding one in the Master bus is recommended as a safety measure to prevent sudden volume peaks from occurring, and to prevent distortion caused by clipping, when the volume exceeds 0 dB.
+ * If clipping is desired, consider {@link AudioEffectDistortion.MODE_CLIP}.
+ */
+export class AudioEffectHardLimiter extends AudioEffect {
+    constructor(name = 101) { super(name); }
+
+    /**
+     * Gain before limiting, in dB. Value can range from -24 to 24.
+     */
+    get preGainDb(): number { return _C(this, 5983) as number; }
+    set preGainDb(v: number) { _C(this, 12391, v); }
+
+    /**
+     * The waveform's maximum allowed value, in dB. This value can range from -24 to 0.
+     * The default value of -0.3 prevents potential inter-sample peaks (ISP) from crossing over 0 dB, which can cause slight distortion on some older hardware.
+     */
+    get ceilingDb(): number { return _C(this, 4105) as number; }
+    set ceilingDb(v: number) { _C(this, 10819, v); }
+
+    /**
+     * Time it takes in seconds for the gain reduction to fully release. Value can range from 0.01 to 3.
+     */
+    get release(): number { return _C(this, 6121) as number; }
+    set release(v: number) { _C(this, 12514, v); }
+
+    static readonly name = _R(101, AudioEffectHardLimiter);
+}

package/gen/classes/AudioEffectHighPassFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "high-pass" filter attenuates frequencies lower than {@link AudioEffectFilter.cutoffHz} and allows higher frequencies to pass unchanged.
+ * This filter can be used to remove "strength" from a sound, and give low-end space for basses and impact sounds.
+ */
+export class AudioEffectHighPassFilter extends AudioEffectFilter {
+    constructor(name = 102) { super(name); }
+
+    static readonly name = _R(102, AudioEffectHighPassFilter);
+}

package/gen/classes/AudioEffectHighShelfFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "high-shelf" filter controls the gain of all frequencies above {@link AudioEffectFilter.cutoffHz}.
+ * This filter can be used to increase or decrease clarity of a sound.
+ */
+export class AudioEffectHighShelfFilter extends AudioEffectFilter {
+    constructor(name = 103) { super(name); }
+
+    static readonly name = _R(103, AudioEffectHighShelfFilter);
+}

package/gen/classes/AudioEffectInstance.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * An audio effect instance manipulates the audio it receives for a given effect. This instance is automatically created by an {@link AudioEffect} when it is added to a bus, and should usually not be created directly. If necessary, it can be fetched at run-time with {@link AudioServer.getBusEffectInstance}.
+ */
+export class AudioEffectInstance extends RefCounted {
+    constructor(name = 104) { super(name); }
+
+    static readonly name = _R(104, AudioEffectInstance);
+}

package/gen/classes/AudioEffectLimiter.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "limiter" is an audio effect designed to stop audio signals from exceeding a specified volume threshold level, and usually works by decreasing the volume or soft-clipping the audio. Adding one in the Master bus is always recommended to prevent clipping when the volume goes above 0 dB.
+ * Soft clipping starts to decrease the peaks a little below the volume threshold level and progressively increases its effect as the input volume increases such that the threshold level is never exceeded.
+ * If hard clipping is desired, consider {@link AudioEffectDistortion.MODE_CLIP}.
+ */
+export class AudioEffectLimiter extends AudioEffect {
+    constructor(name = 105) { super(name); }
+
+    /**
+     * The waveform's maximum allowed value, in dB. Value can range from -20 to -0.1.
+     */
+    get ceilingDb(): number { return _C(this, 4105) as number; }
+    set ceilingDb(v: number) { _C(this, 10819, v); }
+
+    /**
+     * The volume threshold level from which the limiter begins to be active, in dB. Value can range from -30 to 0.
+     */
+    get thresholdDb(): number { return _C(this, 6776) as number; }
+    set thresholdDb(v: number) { _C(this, 13060, v); }
+
+    /**
+     * Modifies the volume of the limited waves, in dB. Value can range from 0 to 6.
+     */
+    get softClipDb(): number { return _C(this, 6448) as number; }
+    set softClipDb(v: number) { _C(this, 12805, v); }
+
+    /**
+     * This property has no effect on the audio. Use {@link AudioEffectHardLimiter} instead, as this Limiter effect is deprecated.
+     */
+    get softClipRatio(): number { return _C(this, 6449) as number; }
+    set softClipRatio(v: number) { _C(this, 12806, v); }
+
+    static readonly name = _R(105, AudioEffectLimiter);
+}

package/gen/classes/AudioEffectLowPassFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "low-pass" filter attenuates frequencies higher than {@link AudioEffectFilter.cutoffHz} and allows lower frequencies to pass unchanged.
+ * This filter can be used to muffle sounds.
+ */
+export class AudioEffectLowPassFilter extends AudioEffectFilter {
+    constructor(name = 106) { super(name); }
+
+    static readonly name = _R(106, AudioEffectLowPassFilter);
+}

package/gen/classes/AudioEffectLowShelfFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "low-shelf" filter controls the gain of all frequencies below {@link AudioEffectFilter.cutoffHz}.
+ * This filter can be used to adjust the "strength" of a sound, by increasing or decreasing its low-end.
+ */
+export class AudioEffectLowShelfFilter extends AudioEffectFilter {
+    constructor(name = 107) { super(name); }
+
+    static readonly name = _R(107, AudioEffectLowShelfFilter);
+}

package/gen/classes/AudioEffectNotchFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "notch" filter attenuates frequencies at {@link AudioEffectFilter.cutoffHz} and allows frequencies outside the frequency threshold to pass unchanged. It is a narrower and stronger version of {@link AudioEffectBandLimitFilter}, and is the opposite of {@link AudioEffectBandPassFilter}.
+ * This filter can be used to give more room for other sounds to play at that frequency. Because of how much it attenuates frequencies, it can also be used to completely remove undesired frequencies.
+ */
+export class AudioEffectNotchFilter extends AudioEffectFilter {
+    constructor(name = 108) { super(name); }
+
+    static readonly name = _R(108, AudioEffectNotchFilter);
+}

package/gen/classes/AudioEffectPanner.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * Determines how much of the audio signal is sent to the left and right channels. This helps with audio spatialization, giving sounds distinct places in a mix.
+ * {@link AudioStreamPlayer2D} and {@link AudioStreamPlayer3D} handle panning automatically, following where the source of the sound is on the screen.
+ */
+export class AudioEffectPanner extends AudioEffect {
+    constructor(name = 109) { super(name); }
+
+    /**
+     * Pan position. Negative values pan the sound to the left, positive pan to the right. Value can range from -1 to 1.
+     */
+    get pan(): number { return _C(this, 5800) as number; }
+    set pan(v: number) { _C(this, 12240, v); }
+
+    static readonly name = _R(109, AudioEffectPanner);
+}

package/gen/classes/AudioEffectPhaser.ts

@@ -0,0 +1,45 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "phaser" effect creates a copy of the original audio that phase-rotates differently across the entire frequency spectrum, with the use of a series of all-pass filter stages (6 in this effect). This copy modulates with a low-frequency oscillator and combines with the original audio, resulting in peaks and troughs that sweep across the spectrum.
+ * This effect can be used to create a "glassy" or "bubbly" sound.
+ */
+export class AudioEffectPhaser extends AudioEffect {
+    constructor(name = 110) { super(name); }
+
+    /**
+     * Determines the minimum frequency affected by the low-frequency oscillator modulations, in Hz. Value can range from 10 to 10000.
+     */
+    get rangeMinHz(): number { return _C(this, 6077) as number; }
+    set rangeMinHz(v: number) { _C(this, 12476, v); }
+
+    /**
+     * Determines the maximum frequency affected by the low-frequency oscillator modulations, in Hz. Value can range from 10 to 10000.
+     */
+    get rangeMaxHz(): number { return _C(this, 6076) as number; }
+    set rangeMaxHz(v: number) { _C(this, 12475, v); }
+
+    /**
+     * Adjusts the rate in Hz at which the effect sweeps up and down across the frequency range. Value can range from 0.01 to 20.
+     */
+    get rateHz(): number { return _C(this, 6078) as number; }
+    set rateHz(v: number) { _C(this, 12477, v); }
+
+    /**
+     * The volume ratio of the filtered audio that is fed back to the all-pass filters. The higher the value, the sharper and louder the peak filters created by the effect. Value can range from 0.1 to 0.9.
+     */
+    get feedback(): number { return _C(this, 4765) as number; }
+    set feedback(v: number) { _C(this, 11372, v); }
+
+    /**
+     * Intensity of the effect. Value can range from 0.1 to 4.0.
+     */
+    get depth(): number { return _C(this, 4468) as number; }
+    set depth(v: number) { _C(this, 11083, v); }
+
+    static readonly name = _R(110, AudioEffectPhaser);
+}

package/gen/classes/AudioEffectPitchShift.ts

@@ -0,0 +1,62 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * Allows modulation of pitch without modifying speed. All frequencies can be raised or lowered with minimal effect on transients.
+ */
+export class AudioEffectPitchShift extends AudioEffect {
+    constructor(name = 111) { super(name); }
+
+    /**
+     * The pitch scale to use. `1.0` is the default pitch and plays sounds unaffected. {@link pitchScale} can range from 0 (infinitely low pitch, inaudible) to 16 (16 times higher than the initial pitch).
+     */
+    get pitchScale(): number { return _C(this, 5910) as number; }
+    set pitchScale(v: number) { _C(this, 12330, v); }
+
+    /**
+     * The oversampling factor to use. Higher values result in better quality, but are more demanding on the CPU and may cause audio cracking if the CPU can't keep up.
+     */
+    get oversampling(): number { return _C(this, 5778) as number; }
+    set oversampling(v: number) { _C(this, 12229, v); }
+
+    /**
+     * The size of the [Fast Fourier transform](https://en.wikipedia.org/wiki/Fast_Fourier_transform) buffer. Higher values smooth out the effect over time, but have greater latency. The effects of this higher latency are especially noticeable on audio signals that have sudden amplitude changes.
+     */
+    get fftSize(): FFTSize { return _C(this, 4769) as FFTSize; }
+    set fftSize(v: FFTSize) { _C(this, 11377, v); }
+
+    static readonly name = _R(111, AudioEffectPitchShift);
+}
+
+export const FFTSize = {
+    /**
+     * Use a buffer of 256 samples for the Fast Fourier transform. Lowest latency, but least stable over time.
+     */
+    FFT_SIZE_256: 0,
+    /**
+     * Use a buffer of 512 samples for the Fast Fourier transform. Low latency, but less stable over time.
+     */
+    FFT_SIZE_512: 1,
+    /**
+     * Use a buffer of 1024 samples for the Fast Fourier transform. This is a compromise between latency and stability over time.
+     */
+    FFT_SIZE_1024: 2,
+    /**
+     * Use a buffer of 2048 samples for the Fast Fourier transform. High latency, but stable over time.
+     */
+    FFT_SIZE_2048: 3,
+    /**
+     * Use a buffer of 4096 samples for the Fast Fourier transform. Highest latency, but most stable over time.
+     */
+    FFT_SIZE_4096: 4,
+    /**
+     * Represents the size of the {@link FFTSize} enum.
+     */
+    FFT_SIZE_MAX: 5,
+} as const;
+
+export type FFTSize = (typeof FFTSize)[keyof typeof FFTSize];
+