typescript-to-gdscript 0.1.0

package/typings/classes/AudioStreamPlaybackPolyphonic.d.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Playback instance for {@link AudioStreamPolyphonic}. */
+declare class AudioStreamPlaybackPolyphonic extends AudioStreamPlayback {
+  /**
+   * Returns `true` if the stream associated with the given integer ID is still playing. Check {@link play_stream} for information on when this ID becomes invalid.
+   */
+  is_stream_playing(stream: int): boolean;
+  /**
+   * Play an {@link AudioStream} at a given offset, volume, pitch scale, playback type, and bus. Playback starts immediately.
+   * The return value is a unique integer ID that is associated to this playback stream and which can be used to control it.
+   * This ID becomes invalid when the stream ends (if it does not loop), when the {@link AudioStreamPlaybackPolyphonic} is stopped, or when {@link stop_stream} is called.
+   * This function returns {@link INVALID_ID} if the amount of streams currently playing equals {@link AudioStreamPolyphonic.polyphony}. If you need a higher amount of maximum polyphony, raise this value.
+   */
+  play_stream(stream: AudioStream, from_offset?: float, volume_db?: float, pitch_scale?: float, playback_type?: int, bus?: string): int;
+  /**
+   * Change the stream pitch scale. The `stream` argument is an integer ID returned by {@link play_stream}.
+   */
+  set_stream_pitch_scale(stream: int, pitch_scale: float): void;
+  /**
+   * Change the stream volume (in db). The `stream` argument is an integer ID returned by {@link play_stream}.
+   */
+  set_stream_volume(stream: int, volume_db: float): void;
+  /**
+   * Stop a stream. The `stream` argument is an integer ID returned by {@link play_stream}, which becomes invalid after calling this function.
+   */
+  stop_stream(stream: int): void;
+
+  /** Returned by {@link play_stream} in case it could not allocate a stream for playback. */
+  static readonly INVALID_ID: int;
+}

package/typings/classes/AudioStreamPlaybackResampled.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Playback class used for resampled {@link AudioStream}s. */
+declare class AudioStreamPlaybackResampled extends AudioStreamPlayback {
+  /** Returns an {@link AudioStream}'s sample rate, in Hz. Used to perform resampling. */
+  _get_stream_sampling_rate(): float;
+  /**
+   * Called by {@link begin_resample} to mix an {@link AudioStream} to {@link AudioServer.get_mix_rate}. Uses {@link _get_stream_sampling_rate} as the source sample rate. Returns the number of mixed frames.
+   */
+  _mix_resampled(dst_buffer: unknown, frame_count: int): int;
+  /**
+   * Called when an {@link AudioStream} is played. Clears the cubic interpolation history and starts mixing by calling {@link _mix_resampled}.
+   */
+  begin_resample(): void;
+}

package/typings/classes/AudioStreamPlayer.d.ts

@@ -0,0 +1,110 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node for audio playback. */
+declare class AudioStreamPlayer extends Node {
+  /** If `true`, this node calls {@link play} when entering the tree. */
+  autoplay: boolean;
+  /**
+   * The target bus name. All sounds from this node will be playing on this bus.
+   * **Note:** At runtime, if no bus with the given name exists, all sounds will fall back on `"Master"`. See also {@link AudioServer.get_bus_name}.
+   */
+  bus: string;
+  /**
+   * The maximum number of sounds this node can play at the same time. Calling {@link play} after this value is reached will cut off the oldest sounds.
+   */
+  max_polyphony: int;
+  /**
+   * The mix target channels. Has no effect when two speakers or less are detected (see {@link AudioServer.SpeakerMode}).
+   */
+  mix_target: int;
+  /**
+   * The audio's pitch and tempo, as a multiplier of the {@link stream}'s sample rate. A value of `2.0` doubles the audio's pitch, while a value of `0.5` halves the pitch.
+   */
+  pitch_scale: float;
+  /**
+   * The playback type of the stream player. If set other than to the default value, it will force that playback type.
+   */
+  playback_type: int;
+  /**
+   * If `true`, this node is playing sounds. Setting this property has the same effect as {@link play} and {@link stop}.
+   */
+  playing: boolean;
+  /**
+   * The {@link AudioStream} resource to be played. Setting this property stops all currently playing sounds. If left empty, the {@link AudioStreamPlayer} does not work.
+   */
+  stream: AudioStream | null;
+  /**
+   * If `true`, the sounds are paused. Setting {@link stream_paused} to `false` resumes all sounds.
+   * **Note:** This property is automatically changed when exiting or entering the tree, or this node is paused (see {@link Node.process_mode}).
+   */
+  stream_paused: boolean;
+  /**
+   * Volume of sound, in decibels. This is an offset of the {@link stream}'s volume.
+   * **Note:** To convert between decibel and linear energy (like most volume sliders do), use {@link volume_linear}, or {@link @GlobalScope.db_to_linear} and {@link @GlobalScope.linear_to_db}.
+   */
+  volume_db: float;
+  /**
+   * Volume of sound, as a linear value.
+   * **Note:** This member modifies {@link volume_db} for convenience. The returned value is equivalent to the result of {@link @GlobalScope.db_to_linear} on {@link volume_db}. Setting this member is equivalent to setting {@link volume_db} to the result of {@link @GlobalScope.linear_to_db} on a value.
+   */
+  volume_linear: float;
+  set_autoplay(value: boolean): void;
+  is_autoplay_enabled(): boolean;
+  set_bus(value: string): void;
+  get_bus(): string;
+  set_max_polyphony(value: int): void;
+  get_max_polyphony(): int;
+  set_mix_target(value: int): void;
+  get_mix_target(): int;
+  set_pitch_scale(value: float): void;
+  get_pitch_scale(): float;
+  set_playback_type(value: int): void;
+  get_playback_type(): int;
+  set_playing(value: boolean): void;
+  is_playing(): boolean;
+  set_stream(value: AudioStream | null): void;
+  get_stream(): AudioStream | null;
+  set_stream_paused(value: boolean): void;
+  get_stream_paused(): boolean;
+  set_volume_db(value: float): void;
+  get_volume_db(): float;
+  set_volume_linear(value: float): void;
+  get_volume_linear(): float;
+
+  /**
+   * Returns the position in the {@link AudioStream} of the latest sound, in seconds. Returns `0.0` if no sounds are playing.
+   * **Note:** The position is not always accurate, as the {@link AudioServer} does not mix audio every processed frame. To get more accurate results, add {@link AudioServer.get_time_since_last_mix} to the returned position.
+   * **Note:** This method always returns `0.0` if the {@link stream} is an {@link AudioStreamInteractive}, since it can have multiple clips playing at once.
+   */
+  get_playback_position(): float;
+  /**
+   * Returns the latest {@link AudioStreamPlayback} of this node, usually the most recently created by {@link play}. If no sounds are playing, this method fails and returns an empty playback.
+   */
+  get_stream_playback(): AudioStreamPlayback | null;
+  /**
+   * Returns `true` if any sound is active, even if {@link stream_paused} is set to `true`. See also {@link playing} and {@link get_stream_playback}.
+   */
+  has_stream_playback(): boolean;
+  /** Plays a sound from the beginning, or the given `from_position` in seconds. */
+  play(from_position?: float): void;
+  /**
+   * Restarts all sounds to be played from the given `to_position`, in seconds. Does nothing if no sounds are playing.
+   */
+  seek(to_position: float): void;
+  /** Stops all sounds from this node. */
+  stop(): void;
+
+  /**
+   * Emitted when a sound finishes playing without interruptions. This signal is *not* emitted when calling {@link stop}, or when exiting the tree while sounds are playing.
+   */
+  finished: Signal<[]>;
+
+  // enum MixTarget
+  /** The audio will be played only on the first channel. This is the default. */
+  static readonly MIX_TARGET_STEREO: int;
+  /** The audio will be played on all surround channels. */
+  static readonly MIX_TARGET_SURROUND: int;
+  /** The audio will be played on the second channel, which is usually the center. */
+  static readonly MIX_TARGET_CENTER: int;
+}

package/typings/classes/AudioStreamPlayer2D.d.ts

@@ -0,0 +1,96 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plays positional sound in 2D space. */
+declare class AudioStreamPlayer2D extends Node2D {
+  /**
+   * Determines which {@link Area2D} layers affect the sound for reverb and audio bus effects. Areas can be used to redirect {@link AudioStream}s so that they play in a certain audio bus. An example of how you might use this is making a "water" area so that sounds played in the water are redirected through an audio bus to make them sound like they are being played underwater.
+   */
+  area_mask: int;
+  /** The volume is attenuated over distance with this as an exponent. */
+  attenuation: float;
+  /** If `true`, audio plays when added to scene tree. */
+  autoplay: boolean;
+  /**
+   * Bus on which this audio is playing.
+   * **Note:** When setting this property, keep in mind that no validation is performed to see if the given name matches an existing bus. This is because audio bus layouts might be loaded after this property is set. If this given name can't be resolved at runtime, it will fall back to `"Master"`.
+   */
+  bus: string;
+  /** Maximum distance from which audio is still hearable. */
+  max_distance: float;
+  /**
+   * The maximum number of sounds this node can play at the same time. Playing additional sounds after this value is reached will cut off the oldest sounds.
+   */
+  max_polyphony: int;
+  /**
+   * Scales the panning strength for this node by multiplying the base {@link ProjectSettings.audio/general/2d_panning_strength} with this factor. Higher values will pan audio from left to right more dramatically than lower values.
+   */
+  panning_strength: float;
+  /** The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. */
+  pitch_scale: float;
+  /**
+   * The playback type of the stream player. If set other than to the default value, it will force that playback type.
+   */
+  playback_type: int;
+  /** If `true`, audio is playing or is queued to be played (see {@link play}). */
+  playing: boolean;
+  /** The {@link AudioStream} object to be played. */
+  stream: AudioStream | null;
+  /** If `true`, the playback is paused. You can resume it by setting {@link stream_paused} to `false`. */
+  stream_paused: boolean;
+  /** Base volume before attenuation, in decibels. */
+  volume_db: float;
+  /**
+   * Base volume before attenuation, as a linear value.
+   * **Note:** This member modifies {@link volume_db} for convenience. The returned value is equivalent to the result of {@link @GlobalScope.db_to_linear} on {@link volume_db}. Setting this member is equivalent to setting {@link volume_db} to the result of {@link @GlobalScope.linear_to_db} on a value.
+   */
+  volume_linear: float;
+  set_area_mask(value: int): void;
+  get_area_mask(): int;
+  set_attenuation(value: float): void;
+  get_attenuation(): float;
+  set_autoplay(value: boolean): void;
+  is_autoplay_enabled(): boolean;
+  set_bus(value: string): void;
+  get_bus(): string;
+  set_max_distance(value: float): void;
+  get_max_distance(): float;
+  set_max_polyphony(value: int): void;
+  get_max_polyphony(): int;
+  set_panning_strength(value: float): void;
+  get_panning_strength(): float;
+  set_pitch_scale(value: float): void;
+  get_pitch_scale(): float;
+  set_playback_type(value: int): void;
+  get_playback_type(): int;
+  set_playing(value: boolean): void;
+  is_playing(): boolean;
+  set_stream(value: AudioStream | null): void;
+  get_stream(): AudioStream | null;
+  set_stream_paused(value: boolean): void;
+  get_stream_paused(): boolean;
+  set_volume_db(value: float): void;
+  get_volume_db(): float;
+  set_volume_linear(value: float): void;
+  get_volume_linear(): float;
+
+  /** Returns the position in the {@link AudioStream}. */
+  get_playback_position(): float;
+  /** Returns the {@link AudioStreamPlayback} object associated with this {@link AudioStreamPlayer2D}. */
+  get_stream_playback(): AudioStreamPlayback | null;
+  /**
+   * Returns whether the {@link AudioStreamPlayer} can return the {@link AudioStreamPlayback} object or not.
+   */
+  has_stream_playback(): boolean;
+  /**
+   * Queues the audio to play on the next physics frame, from the given position `from_position`, in seconds.
+   */
+  play(from_position?: float): void;
+  /** Sets the position from which audio will be played, in seconds. */
+  seek(to_position: float): void;
+  /** Stops the audio. */
+  stop(): void;
+
+  /** Emitted when the audio stops playing. */
+  finished: Signal<[]>;
+}

package/typings/classes/AudioStreamPlayer3D.d.ts

@@ -0,0 +1,162 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plays positional sound in 3D space. */
+declare class AudioStreamPlayer3D extends Node3D {
+  /**
+   * Determines which {@link Area3D} layers affect the sound for reverb and audio bus effects. Areas can be used to redirect {@link AudioStream}s so that they play in a certain audio bus. An example of how you might use this is making a "water" area so that sounds played in the water are redirected through an audio bus to make them sound like they are being played underwater.
+   */
+  area_mask: int;
+  /**
+   * The cutoff frequency of the attenuation low-pass filter, in Hz. A sound above this frequency is attenuated more than a sound below this frequency. To disable this effect, set this to `20500` as this frequency is above the human hearing limit.
+   */
+  attenuation_filter_cutoff_hz: float;
+  /** Amount how much the filter affects the loudness, in decibels. */
+  attenuation_filter_db: float;
+  /**
+   * Decides if audio should get quieter with distance linearly, quadratically, logarithmically, or not be affected by distance, effectively disabling attenuation.
+   */
+  attenuation_model: int;
+  /** If `true`, audio plays when the AudioStreamPlayer3D node is added to scene tree. */
+  autoplay: boolean;
+  /**
+   * The bus on which this audio is playing.
+   * **Note:** When setting this property, keep in mind that no validation is performed to see if the given name matches an existing bus. This is because audio bus layouts might be loaded after this property is set. If this given name can't be resolved at runtime, it will fall back to `"Master"`.
+   */
+  bus: string;
+  /**
+   * Decides in which step the Doppler effect should be calculated.
+   * **Note:** If {@link doppler_tracking} is not {@link DOPPLER_TRACKING_DISABLED} but the current {@link Camera3D}/{@link AudioListener3D} has doppler tracking disabled, the Doppler effect will be heard but will not take the movement of the current listener into account. If accurate Doppler effect is desired, doppler tracking should be enabled on both the {@link AudioStreamPlayer3D} and the current {@link Camera3D}/{@link AudioListener3D}.
+   */
+  doppler_tracking: int;
+  /** The angle in which the audio reaches a listener unattenuated. */
+  emission_angle_degrees: float;
+  /** If `true`, the audio should be attenuated according to the direction of the sound. */
+  emission_angle_enabled: boolean;
+  /**
+   * Attenuation factor used if listener is outside of {@link emission_angle_degrees} and {@link emission_angle_enabled} is set, in decibels.
+   */
+  emission_angle_filter_attenuation_db: float;
+  /** Sets the absolute maximum of the sound level, in decibels. */
+  max_db: float;
+  /**
+   * The distance past which the sound can no longer be heard at all. Only has an effect if set to a value greater than `0.0`. {@link max_distance} works in tandem with {@link unit_size}. However, unlike {@link unit_size} whose behavior depends on the {@link attenuation_model}, {@link max_distance} always works in a linear fashion. This can be used to prevent the {@link AudioStreamPlayer3D} from requiring audio mixing when the listener is far away, which saves CPU resources.
+   */
+  max_distance: float;
+  /**
+   * The maximum number of sounds this node can play at the same time. Playing additional sounds after this value is reached will cut off the oldest sounds.
+   */
+  max_polyphony: int;
+  /**
+   * Scales the panning strength for this node by multiplying the base {@link ProjectSettings.audio/general/3d_panning_strength} by this factor. If the product is `0.0` then stereo panning is disabled and the volume is the same for all channels. If the product is `1.0` then one of the channels will be muted when the sound is located exactly to the left (or right) of the listener.
+   * Two speaker stereo arrangements implement the WebAudio standard for StereoPannerNode Panning (https://webaudio.github.io/web-audio-api/#stereopanner-algorithm) where the volume is cosine of half the azimuth angle to the ear.
+   * For other speaker arrangements such as the 5.1 and 7.1 the SPCAP (Speaker-Placement Correction Amplitude) algorithm is implemented.
+   */
+  panning_strength: float;
+  /** The pitch and the tempo of the audio, as a multiplier of the audio sample's sample rate. */
+  pitch_scale: float;
+  /**
+   * The playback type of the stream player. If set other than to the default value, it will force that playback type.
+   */
+  playback_type: int;
+  /** If `true`, audio is playing or is queued to be played (see {@link play}). */
+  playing: boolean;
+  /** The {@link AudioStream} resource to be played. */
+  stream: AudioStream | null;
+  /** If `true`, the playback is paused. You can resume it by setting {@link stream_paused} to `false`. */
+  stream_paused: boolean;
+  /** The factor for the attenuation effect. Higher values make the sound audible over a larger distance. */
+  unit_size: float;
+  /** The base sound level before attenuation, in decibels. */
+  volume_db: float;
+  /**
+   * The base sound level before attenuation, as a linear value.
+   * **Note:** This member modifies {@link volume_db} for convenience. The returned value is equivalent to the result of {@link @GlobalScope.db_to_linear} on {@link volume_db}. Setting this member is equivalent to setting {@link volume_db} to the result of {@link @GlobalScope.linear_to_db} on a value.
+   */
+  volume_linear: float;
+  set_area_mask(value: int): void;
+  get_area_mask(): int;
+  set_attenuation_filter_cutoff_hz(value: float): void;
+  get_attenuation_filter_cutoff_hz(): float;
+  set_attenuation_filter_db(value: float): void;
+  get_attenuation_filter_db(): float;
+  set_attenuation_model(value: int): void;
+  get_attenuation_model(): int;
+  set_autoplay(value: boolean): void;
+  is_autoplay_enabled(): boolean;
+  set_bus(value: string): void;
+  get_bus(): string;
+  set_doppler_tracking(value: int): void;
+  get_doppler_tracking(): int;
+  set_emission_angle(value: float): void;
+  get_emission_angle(): float;
+  set_emission_angle_enabled(value: boolean): void;
+  is_emission_angle_enabled(): boolean;
+  set_emission_angle_filter_attenuation_db(value: float): void;
+  get_emission_angle_filter_attenuation_db(): float;
+  set_max_db(value: float): void;
+  get_max_db(): float;
+  set_max_distance(value: float): void;
+  get_max_distance(): float;
+  set_max_polyphony(value: int): void;
+  get_max_polyphony(): int;
+  set_panning_strength(value: float): void;
+  get_panning_strength(): float;
+  set_pitch_scale(value: float): void;
+  get_pitch_scale(): float;
+  set_playback_type(value: int): void;
+  get_playback_type(): int;
+  set_playing(value: boolean): void;
+  is_playing(): boolean;
+  set_stream(value: AudioStream | null): void;
+  get_stream(): AudioStream | null;
+  set_stream_paused(value: boolean): void;
+  get_stream_paused(): boolean;
+  set_unit_size(value: float): void;
+  get_unit_size(): float;
+  set_volume_db(value: float): void;
+  get_volume_db(): float;
+  set_volume_linear(value: float): void;
+  get_volume_linear(): float;
+
+  /** Returns the position in the {@link AudioStream}. */
+  get_playback_position(): float;
+  /** Returns the {@link AudioStreamPlayback} object associated with this {@link AudioStreamPlayer3D}. */
+  get_stream_playback(): AudioStreamPlayback | null;
+  /**
+   * Returns whether the {@link AudioStreamPlayer} can return the {@link AudioStreamPlayback} object or not.
+   */
+  has_stream_playback(): boolean;
+  /**
+   * Queues the audio to play on the next physics frame, from the given position `from_position`, in seconds.
+   */
+  play(from_position?: float): void;
+  /** Sets the position from which audio will be played, in seconds. */
+  seek(to_position: float): void;
+  /** Stops the audio. */
+  stop(): void;
+
+  /** Emitted when the audio stops playing. */
+  finished: Signal<[]>;
+
+  // enum AttenuationModel
+  /** Attenuation of loudness according to linear distance. */
+  static readonly ATTENUATION_INVERSE_DISTANCE: int;
+  /** Attenuation of loudness according to squared distance. */
+  static readonly ATTENUATION_INVERSE_SQUARE_DISTANCE: int;
+  /** Attenuation of loudness according to logarithmic distance. */
+  static readonly ATTENUATION_LOGARITHMIC: int;
+  /**
+   * No attenuation of loudness according to distance. The sound will still be heard positionally, unlike an {@link AudioStreamPlayer}. {@link ATTENUATION_DISABLED} can be combined with a {@link max_distance} value greater than `0.0` to achieve linear attenuation clamped to a sphere of a defined size.
+   */
+  static readonly ATTENUATION_DISABLED: int;
+  // enum DopplerTracking
+  /** Disables doppler tracking. */
+  static readonly DOPPLER_TRACKING_DISABLED: int;
+  /** Executes doppler tracking during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}). */
+  static readonly DOPPLER_TRACKING_IDLE_STEP: int;
+  /**
+   * Executes doppler tracking during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+   */
+  static readonly DOPPLER_TRACKING_PHYSICS_STEP: int;
+}

package/typings/classes/AudioStreamPolyphonic.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * AudioStream that lets the user play custom streams at any time from code, simultaneously using a single player.
+ */
+declare class AudioStreamPolyphonic extends AudioStream {
+  /** Maximum amount of simultaneous streams that can be played. */
+  polyphony: int;
+  set_polyphony(value: int): void;
+  get_polyphony(): int;
+}

package/typings/classes/AudioStreamRandomizer.d.ts

@@ -0,0 +1,67 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Wraps a pool of audio streams with pitch and volume shifting. */
+declare class AudioStreamRandomizer extends AudioStream {
+  /** Controls how this AudioStreamRandomizer picks which AudioStream to play next. */
+  playback_mode: int;
+  /**
+   * The largest possible frequency multiplier of the random pitch variation. Pitch will be randomly chosen within a range of [code skip-lint]1.0 / random_pitch[/code] and [code skip-lint]random_pitch[/code]. A value of `1.0` means no variation. A value of `2.0` means pitch will be randomized between double and half.
+   * **Note:** Setting this property also sets {@link random_pitch_semitones}.
+   */
+  random_pitch: float;
+  /**
+   * The largest possible distance, in semitones, of the random pitch variation. A value of `0.0` means no variation.
+   * **Note:** Setting this property also sets {@link random_pitch}.
+   */
+  random_pitch_semitones: float;
+  /**
+   * The intensity of random volume variation. Volume will be increased or decreased by a random value up to [code skip-lint]random_volume_offset_db[/code]. A value of `0.0` means no variation. A value of `3.0` means volume will be randomized between `-3.0 dB` and `+3.0 dB`.
+   */
+  random_volume_offset_db: float;
+  /** The number of streams in the stream pool. */
+  streams_count: int;
+  set_playback_mode(value: int): void;
+  get_playback_mode(): int;
+  set_random_pitch(value: float): void;
+  get_random_pitch(): float;
+  set_random_pitch_semitones(value: float): void;
+  get_random_pitch_semitones(): float;
+  set_random_volume_offset_db(value: float): void;
+  get_random_volume_offset_db(): float;
+  set_streams_count(value: int): void;
+  get_streams_count(): int;
+
+  /**
+   * Insert a stream at the specified index. If the index is less than zero, the insertion occurs at the end of the underlying pool.
+   */
+  add_stream(index: int, stream: AudioStream, weight?: float): void;
+  /** Returns the stream at the specified index. */
+  get_stream(index: int): AudioStream | null;
+  /** Returns the probability weight associated with the stream at the given index. */
+  get_stream_probability_weight(index: int): float;
+  /** Move a stream from one index to another. */
+  move_stream(index_from: int, index_to: int): void;
+  /** Remove the stream at the specified index. */
+  remove_stream(index: int): void;
+  /** Set the AudioStream at the specified index. */
+  set_stream(index: int, stream: AudioStream): void;
+  /**
+   * Set the probability weight of the stream at the specified index. The higher this value, the more likely that the randomizer will choose this stream during random playback modes.
+   */
+  set_stream_probability_weight(index: int, weight: float): void;
+
+  // enum PlaybackMode
+  /**
+   * Pick a stream at random according to the probability weights chosen for each stream, but avoid playing the same stream twice in a row whenever possible. If only 1 sound is present in the pool, the same sound will always play, effectively allowing repeats to occur.
+   */
+  static readonly PLAYBACK_RANDOM_NO_REPEATS: int;
+  /**
+   * Pick a stream at random according to the probability weights chosen for each stream. If only 1 sound is present in the pool, the same sound will always play.
+   */
+  static readonly PLAYBACK_RANDOM: int;
+  /**
+   * Play streams in the order they appear in the stream pool. If only 1 sound is present in the pool, the same sound will always play.
+   */
+  static readonly PLAYBACK_SEQUENTIAL: int;
+}

package/typings/classes/AudioStreamWAV.d.ts

@@ -0,0 +1,87 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Stores audio data loaded from WAV files. */
+declare class AudioStreamWAV extends AudioStream {
+  /**
+   * Contains the audio data in bytes.
+   * **Note:** If {@link format} is set to {@link FORMAT_8_BITS}, this property expects signed 8-bit PCM data. To convert from unsigned 8-bit PCM, subtract 128 from each byte.
+   * **Note:** If {@link format} is set to {@link FORMAT_QOA}, this property expects data from a full QOA file.
+   */
+  data: PackedByteArray;
+  /** Audio format. */
+  format: int;
+  /** The loop start point (in number of samples, relative to the beginning of the stream). */
+  loop_begin: int;
+  /** The loop end point (in number of samples, relative to the beginning of the stream). */
+  loop_end: int;
+  /** The loop mode. */
+  loop_mode: int;
+  /**
+   * The sample rate for mixing this audio. Higher values require more storage space, 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 using lower-pitched sounds such as voices, lower sample rates such as `32000` or `22050` may be usable with no loss in quality.
+   */
+  mix_rate: int;
+  /** If `true`, audio is stereo. */
+  stereo: boolean;
+  /**
+   * Contains user-defined tags if found in the WAV data.
+   * Commonly used tags include `title`, `artist`, `album`, `tracknumber`, and `date` (`date` does not have a standard date format).
+   * **Note:** No tag is *guaranteed* to be present in every file, so make sure to account for the keys not always existing.
+   * **Note:** Only WAV files using a `LIST` chunk with an identifier of `INFO` to encode the tags are currently supported.
+   */
+  tags: Dictionary;
+  set_data(value: PackedByteArray | Array<unknown>): void;
+  get_data(): PackedByteArray;
+  set_format(value: int): void;
+  get_format(): int;
+  set_loop_begin(value: int): void;
+  get_loop_begin(): int;
+  set_loop_end(value: int): void;
+  get_loop_end(): int;
+  set_loop_mode(value: int): void;
+  get_loop_mode(): int;
+  set_mix_rate(value: int): void;
+  get_mix_rate(): int;
+  set_stereo(value: boolean): void;
+  is_stereo(): boolean;
+  set_tags(value: Dictionary): void;
+  get_tags(): Dictionary;
+
+  /**
+   * Creates a new {@link AudioStreamWAV} instance from the given buffer. The buffer must contain WAV data.
+   * The keys and values of `options` match the properties of {@link ResourceImporterWAV}. The usage of `options` is identical to {@link AudioStreamWAV.load_from_file}.
+   */
+  static load_from_buffer(stream_data: PackedByteArray | Array<unknown>, options?: Dictionary): AudioStreamWAV | null;
+  /**
+   * Creates a new {@link AudioStreamWAV} instance from the given file path. The file must be in WAV format.
+   * The keys and values of `options` match the properties of {@link ResourceImporterWAV}.
+   * **Example:** Load the first file dropped as a WAV and play it:
+   */
+  static load_from_file(path: string | NodePath, options?: Dictionary): AudioStreamWAV | null;
+  /**
+   * Saves the AudioStreamWAV as a WAV file to `path`. Samples with IMA ADPCM or Quite OK Audio formats can't be saved.
+   * **Note:** A `.wav` extension is automatically appended to `path` if it is missing.
+   */
+  save_to_wav(path: string | NodePath): int;
+
+  // enum Format
+  /** 8-bit PCM audio codec. */
+  static readonly FORMAT_8_BITS: int;
+  /** 16-bit PCM audio codec. */
+  static readonly FORMAT_16_BITS: int;
+  /** Audio is lossily compressed as IMA ADPCM. */
+  static readonly FORMAT_IMA_ADPCM: int;
+  /** Audio is lossily compressed as Quite OK Audio (https://qoaformat.org/). */
+  static readonly FORMAT_QOA: int;
+  // enum LoopMode
+  /** Audio does not loop. */
+  static readonly LOOP_DISABLED: int;
+  /** Audio loops the data between {@link loop_begin} and {@link loop_end}, playing forward only. */
+  static readonly LOOP_FORWARD: int;
+  /** Audio loops the data between {@link loop_begin} and {@link loop_end}, playing back and forth. */
+  static readonly LOOP_PINGPONG: int;
+  /** Audio loops the data between {@link loop_begin} and {@link loop_end}, playing backward only. */
+  static readonly LOOP_BACKWARD: int;
+}

package/typings/classes/AwaitTweener.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Awaits a specified signal. */
+declare class AwaitTweener extends Tweener {
+  /**
+   * Sets the maximum time an {@link AwaitTweener} can wait for the signal. Can be used as a safeguard for signals that may never be emitted. If not specified, the tweener will wait indefinitely.
+   */
+  set_timeout(timeout: float): AwaitTweener;
+}

package/typings/classes/BackBufferCopy.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that copies a region of the screen to a buffer for access in shader code. */
+declare class BackBufferCopy extends Node2D {
+  /** Buffer mode. */
+  copy_mode: int;
+  /**
+   * The area covered by the {@link BackBufferCopy}. Only used if {@link copy_mode} is {@link COPY_MODE_RECT}.
+   */
+  rect: Rect2;
+  set_copy_mode(value: int): void;
+  get_copy_mode(): int;
+  set_rect(value: Rect2 | Rect2i): void;
+  get_rect(): Rect2;
+
+  // enum CopyMode
+  /**
+   * Disables the buffering mode. This means the {@link BackBufferCopy} node will directly use the portion of screen it covers.
+   */
+  static readonly COPY_MODE_DISABLED: int;
+  /** {@link BackBufferCopy} buffers a rectangular region. */
+  static readonly COPY_MODE_RECT: int;
+  /** {@link BackBufferCopy} buffers the entire screen. */
+  static readonly COPY_MODE_VIEWPORT: int;
+}