@ringozz/godot 0.1.0

package/gen/classes/AudioServer.ts

@@ -0,0 +1,360 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray, PackedVector2Array, Signal, StringName } from '../heap-types/index.ts';
+import type { AudioBusLayout } from './AudioBusLayout.ts';
+import type { AudioEffect } from './AudioEffect.ts';
+import type { AudioEffectInstance } from './AudioEffectInstance.ts';
+import type { AudioStream } from './AudioStream.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 121));
+
+/**
+ * {@link AudioServer} is a low-level server interface for audio access. It is in charge of creating sample data (playable audio) as well as its playback via a voice interface.
+ */
+export class AudioServer extends GodotVar {
+
+    /**
+     * Removes the bus at index `index`.
+     */
+    static removeBus(index: number): void { _C($(), 9890, index); }
+
+    /**
+     * Adds a bus at `atPosition`.
+     */
+    static addBus(atPosition?: number /* = -1 */): void { _C($(), 1188, atPosition); }
+
+    /**
+     * Moves the bus from index `index` to index `toIndex`.
+     */
+    static moveBus(index: number, toIndex: number): void { _C($(), 8981, index, toIndex); }
+
+    /**
+     * Sets the name of the bus at index `busIdx` to `name`.
+     */
+    static setBusName(busIdx: number, name: string): void { _C($(), 10755, busIdx, name); }
+
+    /**
+     * Returns the name of the bus with the index `busIdx`.
+     */
+    static getBusName(busIdx: number): string { return _C($(), 4021, busIdx) as string; }
+
+    /**
+     * Returns the index of the bus with the name `busName`. Returns `-1` if no bus with the specified name exist.
+     */
+    static getBusIndex(busName: StringName): number { return _C($(), 4020, busName) as number; }
+
+    /**
+     * Returns the number of channels of the bus at index `busIdx`.
+     */
+    static getBusChannels(busIdx: number): number { return _C($(), 4015, busIdx) as number; }
+
+    /**
+     * Sets the volume in decibels of the bus at index `busIdx` to `volumeDb`.
+     */
+    static setBusVolumeDb(busIdx: number, volumeDb: number): void { _C($(), 10758, busIdx, volumeDb); }
+
+    /**
+     * Returns the volume of the bus at index `busIdx` in dB.
+     */
+    static getBusVolumeDb(busIdx: number): number { return _C($(), 4025, busIdx) as number; }
+
+    /**
+     * Sets the volume as a linear value of the bus at index `busIdx` to `volumeLinear`.
+     * **Note:** Using this method is equivalent to calling {@link setBusVolumeDb} with the result of {@link linearToDb} on a value.
+     */
+    static setBusVolumeLinear(busIdx: number, volumeLinear: number): void { _C($(), 10759, busIdx, volumeLinear); }
+
+    /**
+     * Returns the volume of the bus at index `busIdx` as a linear value.
+     * **Note:** The returned value is equivalent to the result of {@link dbToLinear} on the result of {@link getBusVolumeDb}.
+     */
+    static getBusVolumeLinear(busIdx: number): number { return _C($(), 4026, busIdx) as number; }
+
+    /**
+     * Connects the output of the bus at `busIdx` to the bus named `send`.
+     */
+    static setBusSend(busIdx: number, send: StringName): void { _C($(), 10756, busIdx, send); }
+
+    /**
+     * Returns the name of the bus that the bus at index `busIdx` sends to.
+     */
+    static getBusSend(busIdx: number): StringName { return _C($(), 4024, busIdx) as StringName; }
+
+    /**
+     * If `true`, the bus at index `busIdx` is in solo mode.
+     */
+    static setBusSolo(busIdx: number, enable: boolean): void { _C($(), 10757, busIdx, enable); }
+
+    /**
+     * If `true`, the bus at index `busIdx` is in solo mode.
+     */
+    static isBusSolo(busIdx: number): boolean { return _C($(), 7809, busIdx) as boolean; }
+
+    /**
+     * If `true`, the bus at index `busIdx` is muted.
+     */
+    static setBusMute(busIdx: number, enable: boolean): void { _C($(), 10754, busIdx, enable); }
+
+    /**
+     * If `true`, the bus at index `busIdx` is muted.
+     */
+    static isBusMute(busIdx: number): boolean { return _C($(), 7808, busIdx) as boolean; }
+
+    /**
+     * If `true`, the bus at index `busIdx` is bypassing effects.
+     */
+    static setBusBypassEffects(busIdx: number, enable: boolean): void { _C($(), 10750, busIdx, enable); }
+
+    /**
+     * If `true`, the bus at index `busIdx` is bypassing effects.
+     */
+    static isBusBypassingEffects(busIdx: number): boolean { return _C($(), 7806, busIdx) as boolean; }
+
+    /**
+     * Adds an {@link AudioEffect} effect to the bus `busIdx` at `atPosition`.
+     */
+    static addBusEffect(busIdx: number, effect: AudioEffect, atPosition?: number /* = -1 */): void { _C($(), 1189, busIdx, effect, atPosition); }
+
+    /**
+     * Removes the effect at index `effectIdx` from the bus at index `busIdx`.
+     */
+    static removeBusEffect(busIdx: number, effectIdx: number): void { _C($(), 9891, busIdx, effectIdx); }
+
+    /**
+     * Returns the number of effects on the bus at `busIdx`.
+     */
+    static getBusEffectCount(busIdx: number): number { return _C($(), 4018, busIdx) as number; }
+
+    /**
+     * Returns the {@link AudioEffect} at position `effectIdx` in bus `busIdx`.
+     */
+    static getBusEffect(busIdx: number, effectIdx: number): AudioEffect { return _C($(), 4017, busIdx, effectIdx) as AudioEffect; }
+
+    /**
+     * Returns the {@link AudioEffectInstance} assigned to the given bus and effect indices (and optionally channel).
+     */
+    static getBusEffectInstance(busIdx: number, effectIdx: number, channel?: number /* = 0 */): AudioEffectInstance { return _C($(), 4019, busIdx, effectIdx, channel) as AudioEffectInstance; }
+
+    /**
+     * Swaps the position of two effects in bus `busIdx`.
+     */
+    static swapBusEffects(busIdx: number, effectIdx: number, byEffectIdx: number): void { _C($(), 14052, busIdx, effectIdx, byEffectIdx); }
+
+    /**
+     * If `true`, the effect at index `effectIdx` on the bus at index `busIdx` is enabled.
+     */
+    static setBusEffectEnabled(busIdx: number, effectIdx: number, enabled: boolean): void { _C($(), 10752, busIdx, effectIdx, enabled); }
+
+    /**
+     * If `true`, the effect at index `effectIdx` on the bus at index `busIdx` is enabled.
+     */
+    static isBusEffectEnabled(busIdx: number, effectIdx: number): boolean { return _C($(), 7807, busIdx, effectIdx) as boolean; }
+
+    /**
+     * Returns the peak volume of the left speaker at bus index `busIdx` and channel index `channel`.
+     */
+    static getBusPeakVolumeLeftDb(busIdx: number, channel: number): number { return _C($(), 4022, busIdx, channel) as number; }
+
+    /**
+     * Returns the peak volume of the right speaker at bus index `busIdx` and channel index `channel`.
+     */
+    static getBusPeakVolumeRightDb(busIdx: number, channel: number): number { return _C($(), 4023, busIdx, channel) as number; }
+
+    /**
+     * Locks the audio driver's main loop.
+     * **Note:** Remember to unlock it afterwards.
+     */
+    static lock(): void { _C($(), 8701); }
+
+    /**
+     * Unlocks the audio driver's main loop. (After locking it, you should always unlock it.)
+     */
+    static unlock(): void { _C($(), 14481); }
+
+    /**
+     * Returns the speaker configuration.
+     */
+    static getSpeakerMode(): SpeakerMode { return _C($(), 6486) as SpeakerMode; }
+
+    /**
+     * Returns the sample rate at the output of the {@link AudioServer}.
+     */
+    static getMixRate(): number { return _C($(), 5565) as number; }
+
+    /**
+     * Returns the sample rate at the input of the {@link AudioServer}.
+     */
+    static getInputMixRate(): number { return _C($(), 5115) as number; }
+
+    /**
+     * 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}.
+     */
+    static getDriverName(): string { return _C($(), 4579) as string; }
+
+    /**
+     * Returns the names of all audio output devices detected on the system.
+     */
+    static getOutputDeviceList(): PackedStringArray { return _C($(), 5763) as PackedStringArray; }
+
+    /**
+     * Returns the relative time until the next mix occurs, in seconds.
+     */
+    static getTimeToNextMix(): number { return _C($(), 6817) as number; }
+
+    /**
+     * Returns the relative time since the last mix occurred, in seconds.
+     */
+    static getTimeSinceLastMix(): number { return _C($(), 6814) as number; }
+
+    /**
+     * Returns the audio driver's effective output latency. This is based on {@link ProjectSettings.audio/driver/outputLatency}, 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 getOutputLatency} every frame.
+     */
+    static getOutputLatency(): number { return _C($(), 5764) as number; }
+
+    /**
+     * Returns the names of all audio input devices detected on the system.
+     * **Note:** {@link ProjectSettings.audio/driver/enableInput} must be `true` for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.
+     */
+    static getInputDeviceList(): PackedStringArray { return _C($(), 5112) as PackedStringArray; }
+
+    /**
+     * If `active` is `true`, starts the microphone input stream specified by {@link inputDevice} or returns an error if it failed.
+     * If `active` is `false`, stops the input stream if it is running.
+     */
+    static setInputDeviceActive(active: boolean): Error { return _C($(), 11715, active) as Error; }
+
+    /**
+     * Returns the number of frames available to read using {@link getInputFrames}.
+     */
+    static getInputFramesAvailable(): number { return _C($(), 5114) as number; }
+
+    /**
+     * 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.
+     */
+    static getInputBufferLengthFrames(): number { return _C($(), 5108) as number; }
+
+    /**
+     * 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 getInputMixRate} frames per second when {@link setInputDeviceActive} has successfully been set to `true`.
+     * The samples are signed floating-point PCM values between `-1` and `1`.
+     */
+    static getInputFrames(frames: number): PackedVector2Array { return _C($(), 5113, frames) as PackedVector2Array; }
+
+    /**
+     * Overwrites the currently used {@link AudioBusLayout}.
+     */
+    static setBusLayout(busLayout: AudioBusLayout): void { _C($(), 10753, busLayout); }
+
+    /**
+     * Generates an {@link AudioBusLayout} using the available buses and effects.
+     */
+    static generateBusLayout(): AudioBusLayout { return _C($(), 3629) as AudioBusLayout; }
+
+    /**
+     * If set to `true`, all instances of {@link AudioStreamPlayback} will call {@link AudioStreamPlayback.TagUsedStreams} every mix step.
+     * **Note:** This is enabled by default in the editor, as it is used by editor plugins for the audio stream previews.
+     */
+    static setEnableTaggingUsedAudioStreams(enable: boolean): void { _C($(), 11285, enable); }
+
+    /**
+     * 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 registerStreamAsSample}.
+     */
+    static isStreamRegisteredAsSample(stream: AudioStream): boolean { return _C($(), 8343, stream) as boolean; }
+
+    /**
+     * 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.
+     */
+    static registerStreamAsSample(stream: AudioStream): void { _C($(), 9859, stream); }
+
+    /**
+     * Number of available audio buses.
+     */
+    static get busCount(): number { return _C($(), 4016) as number; }
+    static set busCount(v: number) { _C($(), 10751, v); }
+
+    /**
+     * Name of the current device for audio output (see {@link getOutputDeviceList}). 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"`.
+     */
+    static get outputDevice(): string { return _C($(), 5762) as string; }
+    static set outputDevice(v: string) { _C($(), 12220, v); }
+
+    /**
+     * Name of the current device for audio input (see {@link getInputDeviceList}). 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/enableInput} must be `true` for audio input to work. See also that setting's description for caveats related to permissions and operating system privacy settings.
+     */
+    static get inputDevice(): string { return _C($(), 5111) as string; }
+    static set inputDevice(v: string) { _C($(), 11714, v); }
+
+    /**
+     * 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.timeScale} to affect the general simulation speed, which is independent from {@link AudioServer.playbackSpeedScale}.
+     */
+    static get playbackSpeedScale(): number { return _C($(), 5934) as number; }
+    static set playbackSpeedScale(v: number) { _C($(), 12347, v); }
+
+    /**
+     * Emitted when an audio bus is added, deleted, or moved.
+     */
+    static get busLayoutChanged(): Signal<() => void> { return _G($(), 1940) as Signal<() => void>; }
+    static set busLayoutChanged(v: (() => void) | null) { _G($(), 1940, v); }
+
+    /**
+     * Emitted when the audio bus at `busIndex` is renamed from `oldName` to `newName`.
+     */
+    static get busRenamed(): Signal<(busIndex: number, oldName: StringName, newName: StringName) => void> { return _G($(), 1941) as Signal<(busIndex: number, oldName: StringName, newName: StringName) => void>; }
+    static set busRenamed(v: ((busIndex: number, oldName: StringName, newName: StringName) => void) | null) { _G($(), 1941, v); }
+
+    static readonly name = _R(121, AudioServer);
+}
+
+export const SpeakerMode = {
+    /**
+     * Two or fewer speakers were detected.
+     */
+    SPEAKER_MODE_STEREO: 0,
+    /**
+     * A 3.1 channel surround setup was detected.
+     */
+    SPEAKER_SURROUND_31: 1,
+    /**
+     * A 5.1 channel surround setup was detected.
+     */
+    SPEAKER_SURROUND_51: 2,
+    /**
+     * A 7.1 channel surround setup was detected.
+     */
+    SPEAKER_SURROUND_71: 3,
+} as const;
+
+export type SpeakerMode = (typeof SpeakerMode)[keyof typeof SpeakerMode];
+
+export const PlaybackType = {
+    /**
+     * The playback will be considered of the type declared at {@link ProjectSettings.audio/general/defaultPlaybackType}.
+     */
+    PLAYBACK_TYPE_DEFAULT: 0,
+    /**
+     * Force the playback to be considered as a stream.
+     */
+    PLAYBACK_TYPE_STREAM: 1,
+    /**
+     * 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.
+     */
+    PLAYBACK_TYPE_SAMPLE: 2,
+    /**
+     * Represents the size of the {@link PlaybackType} enum.
+     */
+    PLAYBACK_TYPE_MAX: 3,
+} as const;
+
+export type PlaybackType = (typeof PlaybackType)[keyof typeof PlaybackType];
+

package/gen/classes/AudioStream.ts

@@ -0,0 +1,53 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, GodotDictionary, Signal } from '../heap-types/index.ts';
+import type { AudioSample } from './AudioSample.ts';
+import type { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+
+/**
+ * Base class for audio streams. Audio streams are used for sound effects and music playback, and support WAV (via {@link AudioStreamWAV}), Ogg (via {@link AudioStreamOggVorbis}), and MP3 (via {@link AudioStreamMP3}) file formats.
+ */
+export class AudioStream extends Resource {
+    constructor(name = 122) { super(name); }
+
+    /**
+     * 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`.
+     */
+    getLength(): number { return _C(this, 5331) as number; }
+
+    /**
+     * Returns `true` if this audio stream only supports one channel (*monophony*), or `false` if the audio stream supports two or more channels (*polyphony*).
+     */
+    isMonophonic(): boolean { return _C(this, 8114) as boolean; }
+
+    /**
+     * Returns a newly created {@link AudioStreamPlayback} intended to play this audio stream. Useful for when you want to extend {@link _instantiatePlayback} but call {@link instantiatePlayback} from an internally held AudioStream subresource. An example of this can be found in the source code for `AudioStreamRandomPitch::instantiate_playback`.
+     */
+    instantiatePlayback(): AudioStreamPlayback { return _C(this, 7679) as AudioStreamPlayback; }
+
+    /**
+     * Returns if the current {@link AudioStream} can be used as a sample. Only static streams can be sampled.
+     */
+    canBeSampled(): boolean { return _C(this, 2008) as boolean; }
+
+    /**
+     * Generates an {@link AudioSample} based on the current stream.
+     */
+    generateSample(): AudioSample { return _C(this, 3637) as AudioSample; }
+
+    /**
+     * Returns `true` if the stream is a collection of other streams, `false` otherwise.
+     */
+    isMetaStream(): boolean { return _C(this, 8103) as boolean; }
+
+    /**
+     * Signal to be emitted to notify when the parameter list changed.
+     */
+    get parameterListChanged(): Signal<() => void> { return _G(this, 9273) as Signal<() => void>; }
+    set parameterListChanged(v: (() => void) | null) { _G(this, 9273, v); }
+
+    static readonly name = _R(122, AudioStream);
+}

package/gen/classes/AudioStreamGenerator.ts

@@ -0,0 +1,88 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStream } from './AudioStream.ts';
+
+/**
+ * {@link AudioStreamGenerator} is a type of audio stream that does not play back sounds on its own; instead, it expects a script to generate audio data for it. See also {@link AudioStreamGeneratorPlayback}.
+ * Here's a sample on how to use it to generate a sine wave:
+ *
+ *
+ * ```gdscript
+ *
+ * var playback # Will hold the AudioStreamGeneratorPlayback.
+ * @onready var sample_hz = $AudioStreamPlayer.stream.mix_rate
+ * var pulse_hz = 440.0 # The frequency of the sound wave.
+ * var phase = 0.0
+ *
+ * func _ready():
+ * 	$AudioStreamPlayer.play()
+ * 	playback = $AudioStreamPlayer.get_stream_playback()
+ * 	fill_buffer()
+ *
+ * func fill_buffer():
+ * 	var increment = pulse_hz / sample_hz
+ * 	var frames_available = playback.get_frames_available()
+ *
+ * 	for i in range(frames_available):
+ * 		playback.push_frame(Vector2.ONE * sin(phase * TAU))
+ * 		phase = fmod(phase + increment, 1.0)
+ *
+ * ```
+ *
+ *
+ *
+ * In the example above, the "AudioStreamPlayer" node must use an {@link AudioStreamGenerator} as its stream. The `fill_buffer` function provides audio data for approximating a sine wave.
+ * See also {@link AudioEffectSpectrumAnalyzer} for performing real-time audio spectrum analysis.
+ * **Note:** Due to performance constraints, this class is best used from C# or from a compiled language via GDExtension. If you still want to use this class from GDScript, consider using a lower {@link mixRate} such as 11,025 Hz or 22,050 Hz.
+ */
+export class AudioStreamGenerator extends AudioStream {
+    constructor(name = 123) { super(name); }
+
+    /**
+     * Mixing rate mode. If set to {@link MIX_RATE_CUSTOM}, {@link mixRate} is used, otherwise current {@link AudioServer} mixing rate is used.
+     */
+    get mixRateMode(): AudioStreamGeneratorMixRate { return _C(this, 5566) as AudioStreamGeneratorMixRate; }
+    set mixRateMode(v: AudioStreamGeneratorMixRate) { _C(this, 12071, v); }
+
+    /**
+     * 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 mixRateMode} should match the sampling rate of input data.
+     * **Note:** If you are using {@link AudioEffectCapture} as the source of your data, set {@link mixRateMode} to {@link MIX_RATE_INPUT} or {@link MIX_RATE_OUTPUT} to automatically match current {@link AudioServer} mixing rate.
+     */
+    get mixRate(): number { return _C(this, 5565) as number; }
+    set mixRate(v: number) { _C(this, 12070, v); }
+
+    /**
+     * 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.
+     */
+    get bufferLength(): number { return _C(this, 4004) as number; }
+    set bufferLength(v: number) { _C(this, 10742, v); }
+
+    static readonly name = _R(123, AudioStreamGenerator);
+}
+
+export const AudioStreamGeneratorMixRate = {
+    /**
+     * Current {@link AudioServer} output mixing rate.
+     */
+    MIX_RATE_OUTPUT: 0,
+    /**
+     * Current {@link AudioServer} input mixing rate.
+     */
+    MIX_RATE_INPUT: 1,
+    /**
+     * Custom mixing rate, specified by {@link mixRate}.
+     */
+    MIX_RATE_CUSTOM: 2,
+    /**
+     * Maximum value for the mixing rate mode enum.
+     */
+    MIX_RATE_MAX: 3,
+} as const;
+
+export type AudioStreamGeneratorMixRate = (typeof AudioStreamGeneratorMixRate)[keyof typeof AudioStreamGeneratorMixRate];
+

package/gen/classes/AudioStreamGeneratorPlayback.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 { AudioStreamPlaybackResampled } from './AudioStreamPlaybackResampled.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * This class is meant to be used with {@link AudioStreamGenerator} to play back the generated audio in real-time.
+ */
+export class AudioStreamGeneratorPlayback extends AudioStreamPlaybackResampled {
+
+    /**
+     * Pushes a single audio data frame to the buffer. This is usually less efficient than {@link pushBuffer} in C# and compiled languages via GDExtension, but {@link pushFrame} may be *more* efficient in GDScript.
+     */
+    pushFrame(frame: Vector2): boolean { return _C(this, 9644, frame) as boolean; }
+
+    /**
+     * Returns `true` if a buffer of the size `amount` can be pushed to the audio sample data buffer without overflowing it, `false` otherwise.
+     */
+    canPushBuffer(amount: number): boolean { return _C(this, 2015, amount) as boolean; }
+
+    /**
+     * Pushes several audio data frames to the buffer. This is usually more efficient than {@link pushFrame} in C# and compiled languages via GDExtension, but {@link pushBuffer} may be *less* efficient in GDScript.
+     */
+    pushBuffer(frames: PackedVector2Array): boolean { return _C(this, 9634, frames) as boolean; }
+
+    /**
+     * 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.
+     */
+    getFramesAvailable(): number { return _C(this, 4890) as number; }
+
+    /**
+     * 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.
+     */
+    getSkips(): number { return _C(this, 6418) as number; }
+
+    /**
+     * Clears the audio sample data buffer.
+     */
+    clearBuffer(): void { _C(this, 2243); }
+
+    static readonly name = _R(124, AudioStreamGeneratorPlayback);
+}