typescript-to-gdscript 0.1.0

package/typings/classes/AudioEffectReverb.d.ts

@@ -0,0 +1,55 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Adds a reverberation audio effect to an audio bus.
+ * Emulates an echo by playing a blurred version of the input audio.
+ */
+declare class AudioEffectReverb extends AudioEffect {
+  /**
+   * Defines how reflective the imaginary room's walls are. The more reflective, the more high frequency content the reverb has. Value can range from 0 to 1.
+   */
+  damping: float;
+  /**
+   * The volume ratio of the original audio. At 0, only the modified audio is outputted. Value can range from 0 to 1.
+   */
+  dry: float;
+  /**
+   * High-pass filter allows frequencies higher than a certain cutoff threshold and attenuates frequencies lower than the cutoff threshold. Value can range from 0 to 1.
+   */
+  hipass: float;
+  /**
+   * Gain of early reflection copies. At higher values, early reflection copies are louder and ring out for longer. Value can range from 0 to 1.
+   */
+  predelay_feedback: float;
+  /**
+   * Time between the original audio and the early reflections of the reverb signal, in milliseconds. Value can range from 20 to 500.
+   */
+  predelay_msec: float;
+  /** Dimensions of simulated room. Bigger means more echoes. Value can range from 0 to 1. */
+  room_size: float;
+  /**
+   * Widens or narrows the stereo image of the reverb tail. At 1, it fully widens. Value can range from 0 to 1.
+   */
+  spread: float;
+  /**
+   * The volume ratio of the modified audio. At 0, only the original audio is outputted. Value can range from 0 to 1.
+   */
+  wet: float;
+  set_damping(value: float): void;
+  get_damping(): float;
+  set_dry(value: float): void;
+  get_dry(): float;
+  set_hpf(value: float): void;
+  get_hpf(): float;
+  set_predelay_feedback(value: float): void;
+  get_predelay_feedback(): float;
+  set_predelay_msec(value: float): void;
+  get_predelay_msec(): float;
+  set_room_size(value: float): void;
+  get_room_size(): float;
+  set_spread(value: float): void;
+  get_spread(): float;
+  set_wet(value: float): void;
+  get_wet(): float;
+}

package/typings/classes/AudioEffectSpectrumAnalyzer.d.ts

@@ -0,0 +1,40 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Creates an {@link AudioEffectInstance} which performs frequency analysis and exposes results to be accessed in real-time.
+ */
+declare class AudioEffectSpectrumAnalyzer extends AudioEffect {
+  /**
+   * The length of the buffer to keep, in seconds. Higher values keep data around for longer, but require more memory. Value can range from 0.1 to 4.
+   */
+  buffer_length: float;
+  /**
+   * The size of the Fast Fourier transform (https://en.wikipedia.org/wiki/Fast_Fourier_transform) buffer. Higher values smooth out the spectrum analysis over time, but have greater latency. The effects of this higher latency are especially noticeable with sudden amplitude changes.
+   */
+  fft_size: int;
+  set_buffer_length(value: float): void;
+  get_buffer_length(): float;
+  set_fft_size(value: int): void;
+  get_fft_size(): int;
+
+  // enum FFTSize
+  /**
+   * Use a buffer of 256 samples for the Fast Fourier transform. Lowest latency, but least stable over time.
+   */
+  static readonly FFT_SIZE_256: int;
+  /** Use a buffer of 512 samples for the Fast Fourier transform. Low latency, but less stable over time. */
+  static readonly FFT_SIZE_512: int;
+  /**
+   * Use a buffer of 1024 samples for the Fast Fourier transform. This is a compromise between latency and stability over time.
+   */
+  static readonly FFT_SIZE_1024: int;
+  /** Use a buffer of 2048 samples for the Fast Fourier transform. High latency, but stable over time. */
+  static readonly FFT_SIZE_2048: int;
+  /**
+   * Use a buffer of 4096 samples for the Fast Fourier transform. Highest latency, but most stable over time.
+   */
+  static readonly FFT_SIZE_4096: int;
+  /** Represents the size of the {@link FFTSize} enum. */
+  static readonly FFT_SIZE_MAX: int;
+}

package/typings/classes/AudioEffectSpectrumAnalyzerInstance.d.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Queryable instance of an {@link AudioEffectSpectrumAnalyzer}. */
+declare class AudioEffectSpectrumAnalyzerInstance extends AudioEffectInstance {
+  /**
+   * Returns the magnitude of the frequencies from `from_hz` to `to_hz` in linear energy as a Vector2. The `x` component of the return value represents the left stereo channel, and `y` represents the right channel.
+   * `mode` determines how the frequency range will be processed.
+   */
+  get_magnitude_for_frequency_range(from_hz: float, to_hz: float, mode: int): Vector2;
+
+  // enum MagnitudeMode
+  /** Use the average value across the frequency range as magnitude. */
+  static readonly MAGNITUDE_AVERAGE: int;
+  /** Use the maximum value of the frequency range as magnitude. */
+  static readonly MAGNITUDE_MAX: int;
+}

package/typings/classes/AudioEffectStereoEnhance.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Adds a stereo manipulation audio effect to an audio bus.
+ * Controls gain of the side channels, and widens the stereo image.
+ */
+declare class AudioEffectStereoEnhance extends AudioEffect {
+  /**
+   * Gain of the side channels, if they exist. A value of 0 will downmix stereo to mono. Value can range from 0 to 4.
+   */
+  pan_pullout: float;
+  /**
+   * Widens the stereo image through phase shifting in conjunction with {@link time_pullout_ms}. Just pans sound to the left channel if {@link time_pullout_ms} is 0. Value can range from 0 to 1.
+   */
+  surround: float;
+  /**
+   * Widens the stereo image through phase shifting in conjunction with {@link surround}. Just delays the right channel if {@link surround} is 0. Value is in milliseconds, and can range from 0 to 50.
+   */
+  time_pullout_ms: float;
+  set_pan_pullout(value: float): void;
+  get_pan_pullout(): float;
+  set_surround(value: float): void;
+  get_surround(): float;
+  set_time_pullout(value: float): void;
+  get_time_pullout(): float;
+}

package/typings/classes/AudioListener2D.d.ts

@@ -0,0 +1,15 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Overrides the location sounds are heard from. */
+declare class AudioListener2D extends Node2D {
+  /** Disables the {@link AudioListener2D}. If it's not set as current, this method will have no effect. */
+  clear_current(): void;
+  /** Returns `true` if this {@link AudioListener2D} is currently active. */
+  is_current(): boolean;
+  /**
+   * Makes the {@link AudioListener2D} active, setting it as the hearing point for the sounds. If there is already another active {@link AudioListener2D}, it will be disabled.
+   * This method will have no effect if the {@link AudioListener2D} is not added to {@link SceneTree}.
+   */
+  make_current(): void;
+}

package/typings/classes/AudioListener3D.d.ts

@@ -0,0 +1,37 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Overrides the location sounds are heard from. */
+declare class AudioListener3D extends Node3D {
+  /**
+   * If not {@link DOPPLER_TRACKING_DISABLED}, this listener will simulate the Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) for objects changed in particular `_process` methods.
+   * **Note:** The Doppler effect will only be heard on {@link AudioStreamPlayer3D}s if {@link AudioStreamPlayer3D.doppler_tracking} is not set to {@link AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED}.
+   */
+  doppler_tracking: int;
+  set_doppler_tracking(value: int): void;
+  get_doppler_tracking(): int;
+
+  /** Disables the listener to use the current camera's listener instead. */
+  clear_current(): void;
+  /** Returns the listener's global orthonormalized {@link Transform3D}. */
+  get_listener_transform(): Transform3D;
+  /**
+   * Returns `true` if the listener was made current using {@link make_current}, `false` otherwise.
+   * **Note:** There may be more than one AudioListener3D marked as "current" in the scene tree, but only the one that was made current last will be used.
+   */
+  is_current(): boolean;
+  /** Enables the listener. This will override the current camera's listener. */
+  make_current(): void;
+
+  // enum DopplerTracking
+  /** Disables Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) simulation (default). */
+  static readonly DOPPLER_TRACKING_DISABLED: int;
+  /**
+   * Simulate Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) by tracking positions of objects that are changed in `_process`. Changes in the relative velocity of this listener compared to those objects affect how audio is perceived (changing the audio's {@link AudioStreamPlayer3D.pitch_scale}).
+   */
+  static readonly DOPPLER_TRACKING_IDLE_STEP: int;
+  /**
+   * Simulate Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) by tracking positions of objects that are changed in `_physics_process`. Changes in the relative velocity of this listener compared to those objects affect how audio is perceived (changing the audio's {@link AudioStreamPlayer3D.pitch_scale}).
+   */
+  static readonly DOPPLER_TRACKING_PHYSICS_STEP: int;
+}

package/typings/classes/AudioSample.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for audio samples. */
+declare class AudioSample extends RefCounted {
+}

package/typings/classes/AudioSamplePlayback.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Meta class for playing back audio samples. */
+declare class AudioSamplePlayback extends RefCounted {
+}

package/typings/classes/AudioServer.d.ts

@@ -0,0 +1,199 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Server interface for low-level audio access. */
+declare interface AudioServer extends GodotObject {
+  /** Number of available audio buses. */
+  bus_count: int;
+  /**
+   * Name of the current device for audio input (see {@link get_input_device_list}). On systems with multiple audio inputs (such as analog, USB and HDMI audio), this can be used to select the audio input device. The value `"Default"` will record audio on the system-wide default audio input. If an invalid device name is set, the value will be reverted back to `"Default"`.
+   * **Note:** {@link ProjectSettings.audio/driver/enable_input} must be `true` for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.
+   */
+  input_device: string;
+  /**
+   * Name of the current device for audio output (see {@link get_output_device_list}). On systems with multiple audio outputs (such as analog, USB and HDMI audio), this can be used to select the audio output device. The value `"Default"` will play audio on the system-wide default audio output. If an invalid device name is set, the value will be reverted back to `"Default"`.
+   */
+  output_device: string;
+  /**
+   * Scales the rate at which audio is played (i.e. setting it to `0.5` will make the audio be played at half its speed). See also {@link Engine.time_scale} to affect the general simulation speed, which is independent from {@link AudioServer.playback_speed_scale}.
+   */
+  playback_speed_scale: float;
+  set_bus_count(value: int): void;
+  get_bus_count(): int;
+  set_input_device(value: string | NodePath): void;
+  get_input_device(): string;
+  set_output_device(value: string | NodePath): void;
+  get_output_device(): string;
+  set_playback_speed_scale(value: float): void;
+  get_playback_speed_scale(): float;
+
+  /** Adds a bus at `at_position`. */
+  add_bus(at_position?: int): void;
+  /** Adds an {@link AudioEffect} effect to the bus `bus_idx` at `at_position`. */
+  add_bus_effect(bus_idx: int, effect: AudioEffect, at_position?: int): void;
+  /** Generates an {@link AudioBusLayout} using the available buses and effects. */
+  generate_bus_layout(): AudioBusLayout;
+  /** Returns the number of channels of the bus at index `bus_idx`. */
+  get_bus_channels(bus_idx: int): int;
+  /** Returns the {@link AudioEffect} at position `effect_idx` in bus `bus_idx`. */
+  get_bus_effect(bus_idx: int, effect_idx: int): AudioEffect | null;
+  /** Returns the number of effects on the bus at `bus_idx`. */
+  get_bus_effect_count(bus_idx: int): int;
+  /**
+   * Returns the {@link AudioEffectInstance} assigned to the given bus and effect indices (and optionally channel).
+   */
+  get_bus_effect_instance(bus_idx: int, effect_idx: int, channel?: int): AudioEffectInstance | null;
+  /**
+   * Returns the index of the bus with the name `bus_name`. Returns `-1` if no bus with the specified name exist.
+   */
+  get_bus_index(bus_name: string): int;
+  /** Returns the name of the bus with the index `bus_idx`. */
+  get_bus_name(bus_idx: int): string;
+  /** Returns the peak volume of the left speaker at bus index `bus_idx` and channel index `channel`. */
+  get_bus_peak_volume_left_db(bus_idx: int, channel: int): float;
+  /** Returns the peak volume of the right speaker at bus index `bus_idx` and channel index `channel`. */
+  get_bus_peak_volume_right_db(bus_idx: int, channel: int): float;
+  /** Returns the name of the bus that the bus at index `bus_idx` sends to. */
+  get_bus_send(bus_idx: int): string;
+  /** Returns the volume of the bus at index `bus_idx` in dB. */
+  get_bus_volume_db(bus_idx: int): float;
+  /**
+   * Returns the volume of the bus at index `bus_idx` as a linear value.
+   * **Note:** The returned value is equivalent to the result of {@link @GlobalScope.db_to_linear} on the result of {@link get_bus_volume_db}.
+   */
+  get_bus_volume_linear(bus_idx: int): float;
+  /**
+   * Returns the name of the current audio driver. The default usually depends on the operating system, but may be overridden via the `--audio-driver` command line argument ($DOCS_URL/tutorials/editor/command_line_tutorial.html). `--headless` also automatically sets the audio driver to `Dummy`. See also {@link ProjectSettings.audio/driver/driver}.
+   */
+  get_driver_name(): string;
+  /**
+   * Returns the absolute size of the microphone input buffer. This is set to a multiple of the audio latency and can be used to estimate the minimum rate at which the frames need to be fetched.
+   */
+  get_input_buffer_length_frames(): int;
+  /**
+   * Returns the names of all audio input devices detected on the system.
+   * **Note:** {@link ProjectSettings.audio/driver/enable_input} must be `true` for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.
+   */
+  get_input_device_list(): PackedStringArray;
+  /**
+   * Returns a {@link PackedVector2Array} containing exactly `frames` audio samples from the internal microphone buffer if available, otherwise returns an empty {@link PackedVector2Array}.
+   * The buffer is filled at the rate of {@link get_input_mix_rate} frames per second when {@link set_input_device_active} has successfully been set to `true`.
+   * The samples are signed floating-point PCM values between `-1` and `1`.
+   */
+  get_input_frames(frames: int): PackedVector2Array;
+  /** Returns the number of frames available to read using {@link get_input_frames}. */
+  get_input_frames_available(): int;
+  /** Returns the sample rate at the input of the {@link AudioServer}. */
+  get_input_mix_rate(): float;
+  /** Returns the sample rate at the output of the {@link AudioServer}. */
+  get_mix_rate(): float;
+  /** Returns the names of all audio output devices detected on the system. */
+  get_output_device_list(): PackedStringArray;
+  /**
+   * Returns the audio driver's effective output latency. This is based on {@link ProjectSettings.audio/driver/output_latency}, but the exact returned value will differ depending on the operating system and audio driver.
+   * **Note:** This can be expensive; it is not recommended to call {@link get_output_latency} every frame.
+   */
+  get_output_latency(): float;
+  /** Returns the speaker configuration. */
+  get_speaker_mode(): int;
+  /** Returns the relative time since the last mix occurred, in seconds. */
+  get_time_since_last_mix(): float;
+  /** Returns the relative time until the next mix occurs, in seconds. */
+  get_time_to_next_mix(): float;
+  /** If `true`, the bus at index `bus_idx` is bypassing effects. */
+  is_bus_bypassing_effects(bus_idx: int): boolean;
+  /** If `true`, the effect at index `effect_idx` on the bus at index `bus_idx` is enabled. */
+  is_bus_effect_enabled(bus_idx: int, effect_idx: int): boolean;
+  /** If `true`, the bus at index `bus_idx` is muted. */
+  is_bus_mute(bus_idx: int): boolean;
+  /** If `true`, the bus at index `bus_idx` is in solo mode. */
+  is_bus_solo(bus_idx: int): boolean;
+  /**
+   * If `true`, the stream is registered as a sample. The engine will not have to register it before playing the sample.
+   * If `false`, the stream will have to be registered before playing it. To prevent lag spikes, register the stream as sample with {@link register_stream_as_sample}.
+   */
+  is_stream_registered_as_sample(stream: AudioStream): boolean;
+  /**
+   * Locks the audio driver's main loop.
+   * **Note:** Remember to unlock it afterwards.
+   */
+  lock(): void;
+  /** Moves the bus from index `index` to index `to_index`. */
+  move_bus(index: int, to_index: int): void;
+  /**
+   * Forces the registration of a stream as a sample.
+   * **Note:** Lag spikes may occur when calling this method, especially on single-threaded builds. It is suggested to call this method while loading assets, where the lag spike could be masked, instead of registering the sample right before it needs to be played.
+   */
+  register_stream_as_sample(stream: AudioStream): void;
+  /** Removes the bus at index `index`. */
+  remove_bus(index: int): void;
+  /** Removes the effect at index `effect_idx` from the bus at index `bus_idx`. */
+  remove_bus_effect(bus_idx: int, effect_idx: int): void;
+  /** If `true`, the bus at index `bus_idx` is bypassing effects. */
+  set_bus_bypass_effects(bus_idx: int, enable: boolean): void;
+  /** If `true`, the effect at index `effect_idx` on the bus at index `bus_idx` is enabled. */
+  set_bus_effect_enabled(bus_idx: int, effect_idx: int, enabled: boolean): void;
+  /** Overwrites the currently used {@link AudioBusLayout}. */
+  set_bus_layout(bus_layout: AudioBusLayout): void;
+  /** If `true`, the bus at index `bus_idx` is muted. */
+  set_bus_mute(bus_idx: int, enable: boolean): void;
+  /** Sets the name of the bus at index `bus_idx` to `name`. */
+  set_bus_name(bus_idx: int, name: string | NodePath): void;
+  /** Connects the output of the bus at `bus_idx` to the bus named `send`. */
+  set_bus_send(bus_idx: int, send: string): void;
+  /** If `true`, the bus at index `bus_idx` is in solo mode. */
+  set_bus_solo(bus_idx: int, enable: boolean): void;
+  /** Sets the volume in decibels of the bus at index `bus_idx` to `volume_db`. */
+  set_bus_volume_db(bus_idx: int, volume_db: float): void;
+  /**
+   * Sets the volume as a linear value of the bus at index `bus_idx` to `volume_linear`.
+   * **Note:** Using this method is equivalent to calling {@link set_bus_volume_db} with the result of {@link @GlobalScope.linear_to_db} on a value.
+   */
+  set_bus_volume_linear(bus_idx: int, volume_linear: float): void;
+  /**
+   * If set to `true`, all instances of {@link AudioStreamPlayback} will call {@link AudioStreamPlayback._tag_used_streams} every mix step.
+   * **Note:** This is enabled by default in the editor, as it is used by editor plugins for the audio stream previews.
+   */
+  set_enable_tagging_used_audio_streams(enable: boolean): void;
+  /**
+   * If `active` is `true`, starts the microphone input stream specified by {@link input_device} or returns an error if it failed.
+   * If `active` is `false`, stops the input stream if it is running.
+   */
+  set_input_device_active(active: boolean): int;
+  /** Swaps the position of two effects in bus `bus_idx`. */
+  swap_bus_effects(bus_idx: int, effect_idx: int, by_effect_idx: int): void;
+  /** Unlocks the audio driver's main loop. (After locking it, you should always unlock it.) */
+  unlock(): void;
+
+  /** Emitted when an audio bus is added, deleted, or moved. */
+  bus_layout_changed: Signal<[]>;
+  /** Emitted when the audio bus at `bus_index` is renamed from `old_name` to `new_name`. */
+  bus_renamed: Signal<[int, string, string]>;
+
+  // enum SpeakerMode
+  /** Two or fewer speakers were detected. */
+  readonly SPEAKER_MODE_STEREO: int;
+  /** A 3.1 channel surround setup was detected. */
+  readonly SPEAKER_SURROUND_31: int;
+  /** A 5.1 channel surround setup was detected. */
+  readonly SPEAKER_SURROUND_51: int;
+  /** A 7.1 channel surround setup was detected. */
+  readonly SPEAKER_SURROUND_71: int;
+  // enum PlaybackType
+  /**
+   * The playback will be considered of the type declared at {@link ProjectSettings.audio/general/default_playback_type}.
+   */
+  readonly PLAYBACK_TYPE_DEFAULT: int;
+  /** Force the playback to be considered as a stream. */
+  readonly PLAYBACK_TYPE_STREAM: int;
+  /**
+   * Force the playback to be considered as a sample. This can provide lower latency and more stable playback (with less risk of audio crackling), at the cost of having less flexibility.
+   * **Note:** Only currently supported on the web platform.
+   * **Note:** {@link AudioEffect}s are not supported when playback is considered as a sample.
+   */
+  readonly PLAYBACK_TYPE_SAMPLE: int;
+  /** Represents the size of the {@link PlaybackType} enum. */
+  readonly PLAYBACK_TYPE_MAX: int;
+}
+declare const AudioServer: AudioServer;
+

package/typings/classes/AudioStream.d.ts

@@ -0,0 +1,66 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for audio streams. */
+declare class AudioStream extends Resource {
+  /** Override this method to return the bar beats of this stream. */
+  _get_bar_beats(): int;
+  /**
+   * Overridable method. Should return the total number of beats of this audio stream. Used by the engine to determine the position of every beat.
+   * Ideally, the returned value should be based off the stream's sample rate ({@link AudioStreamWAV.mix_rate}, for example).
+   */
+  _get_beat_count(): int;
+  /**
+   * Overridable method. Should return the tempo of this audio stream, in beats per minute (BPM). Used by the engine to determine the position of every beat.
+   * Ideally, the returned value should be based off the stream's sample rate ({@link AudioStreamWAV.mix_rate}, for example).
+   */
+  _get_bpm(): float;
+  /**
+   * Override this method to customize the returned value of {@link get_length}. Should return the length of this audio stream, in seconds.
+   */
+  _get_length(): float;
+  /**
+   * Return the controllable parameters of this stream. This array contains dictionaries with a property info description format (see {@link Object.get_property_list}). Additionally, the default value for this parameter must be added tho each dictionary in "default_value" field.
+   */
+  _get_parameter_list(): Array<Dictionary>;
+  /** Override this method to customize the name assigned to this audio stream. Unused by the engine. */
+  _get_stream_name(): string;
+  /**
+   * Override this method to customize the tags for this audio stream. Should return a {@link Dictionary} of strings with the tag as the key and its content as the value.
+   * Commonly used tags include `title`, `artist`, `album`, `tracknumber`, and `date`.
+   */
+  _get_tags(): Dictionary;
+  /** Override this method to return `true` if this stream has a loop. */
+  _has_loop(): boolean;
+  /**
+   * Override this method to customize the returned value of {@link instantiate_playback}. Should return a new {@link AudioStreamPlayback} created when the stream is played (such as by an {@link AudioStreamPlayer}).
+   */
+  _instantiate_playback(): AudioStreamPlayback | null;
+  /**
+   * Override this method to customize the returned value of {@link is_monophonic}. Should return `true` if this audio stream only supports one channel.
+   */
+  _is_monophonic(): boolean;
+  /**
+   * Returns if the current {@link AudioStream} can be used as a sample. Only static streams can be sampled.
+   */
+  can_be_sampled(): boolean;
+  /** Generates an {@link AudioSample} based on the current stream. */
+  generate_sample(): AudioSample | null;
+  /**
+   * Returns the length of the audio stream in seconds. If this stream is an {@link AudioStreamRandomizer}, returns the length of the last played stream. If this stream has an indefinite length (such as for {@link AudioStreamGenerator} and {@link AudioStreamMicrophone}), returns `0.0`.
+   */
+  get_length(): float;
+  /**
+   * Returns a newly created {@link AudioStreamPlayback} intended to play this audio stream. Useful for when you want to extend {@link _instantiate_playback} but call {@link instantiate_playback} from an internally held AudioStream subresource. An example of this can be found in the source code for `AudioStreamRandomPitch::instantiate_playback`.
+   */
+  instantiate_playback(): AudioStreamPlayback | null;
+  /** Returns `true` if the stream is a collection of other streams, `false` otherwise. */
+  is_meta_stream(): boolean;
+  /**
+   * Returns `true` if this audio stream only supports one channel (*monophony*), or `false` if the audio stream supports two or more channels (*polyphony*).
+   */
+  is_monophonic(): boolean;
+
+  /** Signal to be emitted to notify when the parameter list changed. */
+  parameter_list_changed: Signal<[]>;
+}

package/typings/classes/AudioStreamGenerator.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An audio stream with utilities for procedural sound generation. */
+declare class AudioStreamGenerator extends AudioStream {
+  /**
+   * The length of the buffer to generate (in seconds). Lower values result in less latency, but require the script to generate audio data faster, resulting in increased CPU usage and more risk for audio cracking if the CPU can't keep up.
+   */
+  buffer_length: float;
+  /**
+   * The sample rate to use (in Hz). Higher values are more demanding for the CPU to generate, but result in better quality.
+   * In games, common sample rates in use are `11025`, `16000`, `22050`, `32000`, `44100`, and `48000`.
+   * According to the Nyquist-Shannon sampling theorem (https://en.wikipedia.org/wiki/Nyquist%E2%80%93Shannon_sampling_theorem), there is no quality difference to human hearing when going past 40,000 Hz (since most humans can only hear up to ~20,000 Hz, often less). If you are generating lower-pitched sounds such as voices, lower sample rates such as `32000` or `22050` may be usable with no loss in quality.
+   * **Note:** {@link AudioStreamGenerator} is not automatically resampling input data, to produce expected result {@link mix_rate_mode} should match the sampling rate of input data.
+   * **Note:** If you are using {@link AudioEffectCapture} as the source of your data, set {@link mix_rate_mode} to {@link MIX_RATE_INPUT} or {@link MIX_RATE_OUTPUT} to automatically match current {@link AudioServer} mixing rate.
+   */
+  mix_rate: float;
+  /**
+   * Mixing rate mode. If set to {@link MIX_RATE_CUSTOM}, {@link mix_rate} is used, otherwise current {@link AudioServer} mixing rate is used.
+   */
+  mix_rate_mode: int;
+  set_buffer_length(value: float): void;
+  get_buffer_length(): float;
+  set_mix_rate(value: float): void;
+  get_mix_rate(): float;
+  set_mix_rate_mode(value: int): void;
+  get_mix_rate_mode(): int;
+
+  // enum AudioStreamGeneratorMixRate
+  /** Current {@link AudioServer} output mixing rate. */
+  static readonly MIX_RATE_OUTPUT: int;
+  /** Current {@link AudioServer} input mixing rate. */
+  static readonly MIX_RATE_INPUT: int;
+  /** Custom mixing rate, specified by {@link mix_rate}. */
+  static readonly MIX_RATE_CUSTOM: int;
+  /** Maximum value for the mixing rate mode enum. */
+  static readonly MIX_RATE_MAX: int;
+}

package/typings/classes/AudioStreamGeneratorPlayback.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plays back audio generated using {@link AudioStreamGenerator}. */
+declare class AudioStreamGeneratorPlayback extends AudioStreamPlaybackResampled {
+  /**
+   * Returns `true` if a buffer of the size `amount` can be pushed to the audio sample data buffer without overflowing it, `false` otherwise.
+   */
+  can_push_buffer(amount: int): boolean;
+  /** Clears the audio sample data buffer. */
+  clear_buffer(): void;
+  /**
+   * Returns the number of frames that can be pushed to the audio sample data buffer without overflowing it. If the result is `0`, the buffer is full.
+   */
+  get_frames_available(): int;
+  /**
+   * Returns the number of times the playback skipped due to a buffer underrun in the audio sample data. This value is reset at the start of the playback.
+   */
+  get_skips(): int;
+  /**
+   * Pushes several audio data frames to the buffer. This is usually more efficient than {@link push_frame} in C# and compiled languages via GDExtension, but {@link push_buffer} may be *less* efficient in GDScript.
+   */
+  push_buffer(frames: PackedVector2Array | Array<unknown>): boolean;
+  /**
+   * Pushes a single audio data frame to the buffer. This is usually less efficient than {@link push_buffer} in C# and compiled languages via GDExtension, but {@link push_frame} may be *more* efficient in GDScript.
+   */
+  push_frame(frame: Vector2 | Vector2i): boolean;
+}

package/typings/classes/AudioStreamMicrophone.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plays real-time audio input data. */
+declare class AudioStreamMicrophone extends AudioStream {
+}

package/typings/classes/AudioStreamPlayback.d.ts

@@ -0,0 +1,69 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Meta class for playing back audio. */
+declare class AudioStreamPlayback extends RefCounted {
+  /**
+   * Overridable method. Should return how many times this audio stream has looped. Most built-in playbacks always return `0`.
+   */
+  _get_loop_count(): int;
+  /**
+   * Return the current value of a playback parameter by name (see {@link AudioStream._get_parameter_list}).
+   */
+  _get_parameter(name: string): unknown;
+  /** Overridable method. Should return the current progress along the audio stream, in seconds. */
+  _get_playback_position(): float;
+  /** Overridable method. Should return `true` if this playback is active and playing its audio stream. */
+  _is_playing(): boolean;
+  /**
+   * Override this method to customize how the audio stream is mixed. This method is called even if the playback is not active.
+   * **Note:** It is not useful to override this method in GDScript or C#. Only GDExtension can take advantage of it.
+   */
+  _mix(buffer: unknown, rate_scale: float, frames: int): int;
+  /**
+   * Override this method to customize what happens when seeking this audio stream at the given `position`, such as by calling {@link AudioStreamPlayer.seek}.
+   */
+  _seek(position: float): void;
+  /**
+   * Set the current value of a playback parameter by name (see {@link AudioStream._get_parameter_list}).
+   */
+  _set_parameter(name: string, value: unknown): void;
+  /**
+   * Override this method to customize what happens when the playback starts at the given position, such as by calling {@link AudioStreamPlayer.play}.
+   */
+  _start(from_pos: float): void;
+  /**
+   * Override this method to customize what happens when the playback is stopped, such as by calling {@link AudioStreamPlayer.stop}.
+   */
+  _stop(): void;
+  /**
+   * Overridable method. Called whenever the audio stream is mixed if the playback is active and {@link AudioServer.set_enable_tagging_used_audio_streams} has been set to `true`. Editor plugins may use this method to "tag" the current position along the audio stream and display it in a preview.
+   */
+  _tag_used_streams(): void;
+  /** Returns the number of times the stream has looped. */
+  get_loop_count(): int;
+  /** Returns the current position in the stream, in seconds. */
+  get_playback_position(): float;
+  /**
+   * Returns the {@link AudioSamplePlayback} associated with this {@link AudioStreamPlayback} for playing back the audio sample of this stream.
+   */
+  get_sample_playback(): AudioSamplePlayback | null;
+  /** Returns `true` if the stream is playing. */
+  is_playing(): boolean;
+  /**
+   * Mixes up to `frames` of audio from the stream from the current position, at a rate of `rate_scale`, advancing the stream.
+   * Returns a {@link PackedVector2Array} where each element holds the left and right channel volume levels of each frame.
+   * **Note:** Can return fewer frames than requested, make sure to use the size of the return value.
+   */
+  mix_audio(rate_scale: float, frames: int): PackedVector2Array;
+  /** Seeks the stream at the given `time`, in seconds. */
+  seek(time?: float): void;
+  /**
+   * Associates {@link AudioSamplePlayback} to this {@link AudioStreamPlayback} for playing back the audio sample of this stream.
+   */
+  set_sample_playback(playback_sample: AudioSamplePlayback): void;
+  /** Starts the stream from the given `from_pos`, in seconds. */
+  start(from_pos?: float): void;
+  /** Stops the stream. */
+  stop(): void;
+}