@ringozz/godot 0.1.0

package/gen/classes/AudioStreamInteractive.ts

@@ -0,0 +1,216 @@
+// 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';
+import type { PackedInt32Array, StringName } from '../heap-types/index.ts';
+
+/**
+ * This is an audio stream that can playback music interactively, combining clips and a transition table. Clips must be added first, and then the transition rules via the {@link addTransition}. Additionally, this stream exports a property parameter to control the playback via {@link AudioStreamPlayer}, {@link AudioStreamPlayer2D}, or {@link AudioStreamPlayer3D}.
+ * The way this is used is by filling a number of clips, then configuring the transition table. From there, clips are selected for playback and the music will smoothly go from the current to the new one while using the corresponding transition rule defined in the transition table.
+ */
+export class AudioStreamInteractive extends AudioStream {
+    constructor(name = 125) { super(name); }
+
+    /**
+     * Set the name of the current clip (for easier identification).
+     */
+    setClipName(clipIndex: number, name: StringName): void { _C(this, 10866, clipIndex, name); }
+
+    /**
+     * Return the name of a clip.
+     */
+    getClipName(clipIndex: number): StringName { return _C(this, 4161, clipIndex) as StringName; }
+
+    /**
+     * Set the {@link AudioStream} associated with the current clip.
+     */
+    setClipStream(clipIndex: number, stream: AudioStream): void { _C(this, 10867, clipIndex, stream); }
+
+    /**
+     * Return the {@link AudioStream} associated with a clip.
+     */
+    getClipStream(clipIndex: number): AudioStream { return _C(this, 4162, clipIndex) as AudioStream; }
+
+    /**
+     * Set whether a clip will auto-advance by changing the auto-advance mode.
+     */
+    setClipAutoAdvance(clipIndex: number, mode: AutoAdvanceMode): void { _C(this, 10861, clipIndex, mode); }
+
+    /**
+     * Return whether a clip has auto-advance enabled. See {@link setClipAutoAdvance}.
+     */
+    getClipAutoAdvance(clipIndex: number): AutoAdvanceMode { return _C(this, 4157, clipIndex) as AutoAdvanceMode; }
+
+    /**
+     * Set the index of the next clip towards which this clip will auto advance to when finished. If the clip being played loops, then auto-advance will be ignored.
+     */
+    setClipAutoAdvanceNextClip(clipIndex: number, autoAdvanceNextClip: number): void { _C(this, 10862, clipIndex, autoAdvanceNextClip); }
+
+    /**
+     * Return the clip towards which the clip referenced by `clipIndex` will auto-advance to.
+     */
+    getClipAutoAdvanceNextClip(clipIndex: number): number { return _C(this, 4158, clipIndex) as number; }
+
+    /**
+     * Add a transition between two clips. Provide the indices of the source and destination clips, or use the {@link CLIP_ANY} constant to indicate that transition happens to/from any clip to this one.
+     * * `fromTime` indicates the moment in the current clip the transition will begin after triggered.
+     * * `toTime` indicates the time in the next clip that the playback will start from.
+     * * `fadeMode` indicates how the fade will happen between clips. If unsure, just use {@link FADE_AUTOMATIC} which uses the most common type of fade for each situation.
+     * * `fadeBeats` indicates how many beats the fade will take. Using decimals is allowed.
+     * * `useFillerClip` indicates that there will be a filler clip used between the source and destination clips.
+     * * `fillerClip` the index of the filler clip.
+     * * If `holdPrevious` is used, then this clip will be remembered. This can be used together with {@link AUTO_ADVANCE_RETURN_TO_HOLD} to return to this clip after another is done playing.
+     */
+    addTransition(fromClip: number, toClip: number, fromTime: TransitionFromTime, toTime: TransitionToTime, fadeMode: FadeMode, fadeBeats: number, useFillerClip?: boolean /* = false */, fillerClip?: number /* = -1 */, holdPrevious?: boolean /* = false */): void { _C(this, 1318, fromClip, toClip, fromTime, toTime, fadeMode, fadeBeats, useFillerClip, fillerClip, holdPrevious); }
+
+    /**
+     * Returns `true` if a given transition exists (was added via {@link addTransition}).
+     */
+    hasTransition(fromClip: number, toClip: number): boolean { return _C(this, 7474, fromClip, toClip) as boolean; }
+
+    /**
+     * Erase a transition by providing `fromClip` and `toClip` clip indices. {@link CLIP_ANY} can be used for either argument or both.
+     */
+    eraseTransition(fromClip: number, toClip: number): void { _C(this, 3165, fromClip, toClip); }
+
+    /**
+     * Return the list of transitions (from, to interleaved).
+     */
+    getTransitionList(): PackedInt32Array { return _C(this, 6887) as PackedInt32Array; }
+
+    /**
+     * Return the source time position for a transition (see {@link addTransition}).
+     */
+    getTransitionFromTime(fromClip: number, toClip: number): TransitionFromTime { return _C(this, 6886, fromClip, toClip) as TransitionFromTime; }
+
+    /**
+     * Return the destination time position for a transition (see {@link addTransition}).
+     */
+    getTransitionToTime(fromClip: number, toClip: number): TransitionToTime { return _C(this, 6889, fromClip, toClip) as TransitionToTime; }
+
+    /**
+     * Return the mode for a transition (see {@link addTransition}).
+     */
+    getTransitionFadeMode(fromClip: number, toClip: number): FadeMode { return _C(this, 6883, fromClip, toClip) as FadeMode; }
+
+    /**
+     * Return the time (in beats) for a transition (see {@link addTransition}).
+     */
+    getTransitionFadeBeats(fromClip: number, toClip: number): number { return _C(this, 6882, fromClip, toClip) as number; }
+
+    /**
+     * Return whether a transition uses the *filler clip* functionality (see {@link addTransition}).
+     */
+    isTransitionUsingFillerClip(fromClip: number, toClip: number): boolean { return _C(this, 8375, fromClip, toClip) as boolean; }
+
+    /**
+     * Return the filler clip for a transition (see {@link addTransition}).
+     */
+    getTransitionFillerClip(fromClip: number, toClip: number): number { return _C(this, 6884, fromClip, toClip) as number; }
+
+    /**
+     * Return whether a transition uses the *hold previous* functionality (see {@link addTransition}).
+     */
+    isTransitionHoldingPrevious(fromClip: number, toClip: number): boolean { return _C(this, 8374, fromClip, toClip) as boolean; }
+
+    /**
+     * Amount of clips contained in this interactive player.
+     */
+    get clipCount(): number { return _C(this, 4160) as number; }
+    set clipCount(v: number) { _C(this, 10865, v); }
+
+    /**
+     * Index of the initial clip, which will be played first when this stream is played.
+     */
+    get initialClip(): number { return _C(this, 5100) as number; }
+    set initialClip(v: number) { _C(this, 11700, v); }
+
+    /**
+     * This constant describes that any clip is valid for a specific transition as either source or destination.
+     */
+    static readonly CLIP_ANY = -1;
+
+    static readonly name = _R(125, AudioStreamInteractive);
+}
+
+export const TransitionFromTime = {
+    /**
+     * Start transition as soon as possible, don't wait for any specific time position.
+     */
+    TRANSITION_FROM_TIME_IMMEDIATE: 0,
+    /**
+     * Transition when the clip playback position reaches the next beat.
+     */
+    TRANSITION_FROM_TIME_NEXT_BEAT: 1,
+    /**
+     * Transition when the clip playback position reaches the next bar.
+     */
+    TRANSITION_FROM_TIME_NEXT_BAR: 2,
+    /**
+     * Transition when the current clip finished playing.
+     */
+    TRANSITION_FROM_TIME_END: 3,
+} as const;
+
+export type TransitionFromTime = (typeof TransitionFromTime)[keyof typeof TransitionFromTime];
+
+export const TransitionToTime = {
+    /**
+     * Transition to the same position in the destination clip. This is useful when both clips have exactly the same length and the music should fade between them.
+     */
+    TRANSITION_TO_TIME_SAME_POSITION: 0,
+    /**
+     * Transition to the start of the destination clip.
+     */
+    TRANSITION_TO_TIME_START: 1,
+    /**
+     * Transition to the last played position in the destination clip, if there was a previous transition from that clip. Otherwise, plays from the start of the destination clip.
+     */
+    TRANSITION_TO_TIME_PREVIOUS_POSITION: 2,
+} as const;
+
+export type TransitionToTime = (typeof TransitionToTime)[keyof typeof TransitionToTime];
+
+export const FadeMode = {
+    /**
+     * Do not use fade for the transition. This is useful when transitioning from a clip-end to clip-beginning, and each clip has their begin/end.
+     */
+    FADE_DISABLED: 0,
+    /**
+     * Use a fade-in in the next clip, let the current clip finish.
+     */
+    FADE_IN: 1,
+    /**
+     * Use a fade-out in the current clip, the next clip will start by itself.
+     */
+    FADE_OUT: 2,
+    /**
+     * Use a cross-fade between clips.
+     */
+    FADE_CROSS: 3,
+    /**
+     * Use automatic fade logic depending on the transition from/to. It is recommended to use this by default.
+     */
+    FADE_AUTOMATIC: 4,
+} as const;
+
+export type FadeMode = (typeof FadeMode)[keyof typeof FadeMode];
+
+export const AutoAdvanceMode = {
+    /**
+     * Disable auto-advance (default).
+     */
+    AUTO_ADVANCE_DISABLED: 0,
+    /**
+     * Enable auto-advance, a clip must be specified.
+     */
+    AUTO_ADVANCE_ENABLED: 1,
+    /**
+     * Enable auto-advance, but instead of specifying a clip, the playback will return to hold (see {@link addTransition}).
+     */
+    AUTO_ADVANCE_RETURN_TO_HOLD: 2,
+} as const;
+
+export type AutoAdvanceMode = (typeof AutoAdvanceMode)[keyof typeof AutoAdvanceMode];
+

package/gen/classes/AudioStreamMP3.ts

@@ -0,0 +1,74 @@
+// 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';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * MP3 audio stream driver. See {@link data} if you want to load an MP3 file at run-time. More info can be found in {@link ResourceImporterMP3}.
+ * **Note:** This class can optionally support legacy MP1 and MP2 formats, provided that the engine is compiled with the `minimp3_extra_formats=yes` SCons option. These extra formats are not enabled by default.
+ */
+export class AudioStreamMP3 extends AudioStream {
+    constructor(name = 126) { super(name); }
+
+    /**
+     * Creates a new {@link AudioStreamMP3} instance from the given buffer. The buffer must contain MP3 data.
+     */
+    static loadFromBuffer(streamData: PackedByteArray): AudioStreamMP3 { return _C(126, 8676, streamData) as AudioStreamMP3; }
+
+    /**
+     * Creates a new {@link AudioStreamMP3} instance from the given file path. The file must be in MP3 format.
+     */
+    static loadFromFile(path: string): AudioStreamMP3 { return _C(126, 8677, path) as AudioStreamMP3; }
+
+    /**
+     * Contains the audio data in bytes.
+     * You can load a file without having to import it beforehand using the code snippet below. Keep in mind that this snippet loads the whole file into memory and may not be ideal for huge files (hundreds of megabytes or more).
+     *
+     *
+     * ```gdscript
+     *
+     * func load_mp3(path):
+     * 	var file = FileAccess.open(path, FileAccess.READ)
+     * 	var sound = AudioStreamMP3.new()
+     * 	sound.data = file.get_buffer(file.get_length())
+     * 	return sound
+     *
+     * ```
+     */
+    get data(): PackedByteArray { return _C(this, 4410) as PackedByteArray; }
+    set data(v: PackedByteArray) { _C(this, 11034, v); }
+
+    /**
+     * The tempo of the audio track, measured in beats per minute.
+     */
+    get bpm(): number { return _C(this, 3999) as number; }
+    set bpm(v: number) { _C(this, 10735, v); }
+
+    /**
+     * The length of the audio track, in beats. The actual duration of the audio file might be longer than what is indicated by this property. It defines the end of the audio for looping, {@link AudioStreamPlaylist}, and {@link AudioStreamInteractive}.
+     */
+    get beatCount(): number { return _C(this, 3906) as number; }
+    set beatCount(v: number) { _C(this, 10649, v); }
+
+    /**
+     * The number of beats within a single bar in the audio track.
+     */
+    get barBeats(): number { return _C(this, 3891) as number; }
+    set barBeats(v: number) { _C(this, 10639, v); }
+
+    /**
+     * If `true`, the stream will play again from the specified {@link loopOffset} once it reaches the end of the audio track, or once it reaches the end of the last beat according to the amount specified in {@link beatCount}. Useful for ambient sounds and background music.
+     */
+    get loop(): boolean { return _C(this, 7412) as boolean; }
+    set loop(v: boolean) { _C(this, 11949, v); }
+
+    /**
+     * Time in seconds at which the stream starts after being looped.
+     */
+    get loopOffset(): number { return _C(this, 5421) as number; }
+    set loopOffset(v: number) { _C(this, 11953, v); }
+
+    static readonly name = _R(126, AudioStreamMP3);
+}

package/gen/classes/AudioStreamMicrophone.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStream } from './AudioStream.ts';
+
+/**
+ * When used directly in an {@link AudioStreamPlayer} node, {@link AudioStreamMicrophone} plays back microphone input in real-time. This can be used in conjunction with {@link AudioEffectCapture} to process the data or save it.
+ * **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.
+ */
+export class AudioStreamMicrophone extends AudioStream {
+    constructor(name = 127) { super(name); }
+
+    static readonly name = _R(127, AudioStreamMicrophone);
+}

package/gen/classes/AudioStreamOggVorbis.ts

@@ -0,0 +1,71 @@
+// 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';
+import type { GodotDictionary, PackedByteArray } from '../heap-types/index.ts';
+import type { OggPacketSequence } from './OggPacketSequence.ts';
+
+/**
+ * The AudioStreamOggVorbis class is a specialized {@link AudioStream} for handling Ogg Vorbis file formats. It offers functionality for loading and playing back Ogg Vorbis files, as well as managing looping and other playback properties. More info can be found in {@link ResourceImporterOggVorbis}.
+ * This class is part of the audio stream system, which also supports WAV files through the {@link AudioStreamWAV} class, and MP3 files through the {@link AudioStreamMP3} class.
+ */
+export class AudioStreamOggVorbis extends AudioStream {
+    constructor(name = 128) { super(name); }
+
+    /**
+     * Creates a new {@link AudioStreamOggVorbis} instance from the given buffer. The buffer must contain Ogg Vorbis data.
+     */
+    static loadFromBuffer(streamData: PackedByteArray): AudioStreamOggVorbis { return _C(128, 8676, streamData) as AudioStreamOggVorbis; }
+
+    /**
+     * Creates a new {@link AudioStreamOggVorbis} instance from the given file path. The file must be in Ogg Vorbis format.
+     */
+    static loadFromFile(path: string): AudioStreamOggVorbis { return _C(128, 8677, path) as AudioStreamOggVorbis; }
+
+    /**
+     * Contains the raw Ogg data for this stream.
+     */
+    get packetSequence(): OggPacketSequence { return _C(this, 5793) as OggPacketSequence; }
+    set packetSequence(v: OggPacketSequence) { _C(this, 12236, v); }
+
+    /**
+     * The tempo of the audio track, measured in beats per minute.
+     */
+    get bpm(): number { return _C(this, 3999) as number; }
+    set bpm(v: number) { _C(this, 10735, v); }
+
+    /**
+     * The length of the audio track, in beats. The actual duration of the audio file might be longer than what is indicated by this property. It defines the end of the audio for looping, {@link AudioStreamPlaylist}, and {@link AudioStreamInteractive}.
+     */
+    get beatCount(): number { return _C(this, 3906) as number; }
+    set beatCount(v: number) { _C(this, 10649, v); }
+
+    /**
+     * The number of beats within a single bar in the audio track.
+     */
+    get barBeats(): number { return _C(this, 3891) as number; }
+    set barBeats(v: number) { _C(this, 10639, v); }
+
+    /**
+     * Contains user-defined tags if found in the Ogg Vorbis 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.
+     */
+    get tags(): GodotDictionary { return _C(this, 6689) as GodotDictionary; }
+    set tags(v: GodotDictionary) { _C(this, 12990, v); }
+
+    /**
+     * If `true`, the stream will play again from the specified {@link loopOffset} once it reaches the end of the audio track, or once it reaches the end of the last beat according to the amount specified in {@link beatCount}. Useful for ambient sounds and background music.
+     */
+    get loop(): boolean { return _C(this, 7412) as boolean; }
+    set loop(v: boolean) { _C(this, 11949, v); }
+
+    /**
+     * Time in seconds at which the stream starts after being looped.
+     */
+    get loopOffset(): number { return _C(this, 5421) as number; }
+    set loopOffset(v: number) { _C(this, 11953, v); }
+
+    static readonly name = _R(128, AudioStreamOggVorbis);
+}

package/gen/classes/AudioStreamPlayback.ts

@@ -0,0 +1,63 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { PackedVector2Array, StringName, Variant } from '../heap-types/index.ts';
+import type { AudioSamplePlayback } from './AudioSamplePlayback.ts';
+
+/**
+ * Can play, loop, pause a scroll through audio. See {@link AudioStream} and {@link AudioStreamOggVorbis} for usage.
+ */
+export class AudioStreamPlayback extends RefCounted {
+    constructor(name = 129) { super(name); }
+
+    /**
+     * Associates {@link AudioSamplePlayback} to this {@link AudioStreamPlayback} for playing back the audio sample of this stream.
+     */
+    setSamplePlayback(playbackSample: AudioSamplePlayback): void { _C(this, 12602, playbackSample); }
+
+    /**
+     * Returns the {@link AudioSamplePlayback} associated with this {@link AudioStreamPlayback} for playing back the audio sample of this stream.
+     */
+    getSamplePlayback(): AudioSamplePlayback { return _C(this, 6230) as AudioSamplePlayback; }
+
+    /**
+     * Mixes up to `frames` of audio from the stream from the current position, at a rate of `rateScale`, 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.
+     */
+    mixAudio(rateScale: number, frames: number): PackedVector2Array { return _C(this, 8934, rateScale, frames) as PackedVector2Array; }
+
+    /**
+     * Starts the stream from the given `fromPos`, in seconds.
+     */
+    start(fromPos?: number /* = 0.0,  double */): void { _C(this, 13829, fromPos); }
+
+    /**
+     * Seeks the stream at the given `time`, in seconds.
+     */
+    seek(time?: number /* = 0.0,  double */): void { _C(this, 10343, time); }
+
+    /**
+     * Stops the stream.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * Returns the number of times the stream has looped.
+     */
+    getLoopCount(): number { return _C(this, 5418) as number; }
+
+    /**
+     * Returns the current position in the stream, in seconds.
+     */
+    getPlaybackPosition(): number { return _C(this, 5933) as number; }
+
+    /**
+     * Returns `true` if the stream is playing.
+     */
+    isPlaying(): boolean { return _C(this, 8183) as boolean; }
+
+    static readonly name = _R(129, AudioStreamPlayback);
+}

package/gen/classes/AudioStreamPlaybackInteractive.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+import type { StringName } from '../heap-types/index.ts';
+
+/**
+ * Playback component of {@link AudioStreamInteractive}. Contains functions to change the currently played clip.
+ */
+export class AudioStreamPlaybackInteractive extends AudioStreamPlayback {
+
+    /**
+     * Switch to a clip (by name).
+     */
+    switchToClipByName(clipName: StringName): void { _C(this, 14070, clipName); }
+
+    /**
+     * Switch to a clip (by index).
+     */
+    switchToClip(clipIndex: number): void { _C(this, 14069, clipIndex); }
+
+    /**
+     * Return the index of the currently playing clip. You can use this to get the name of the currently playing clip with {@link AudioStreamInteractive.getClipName}.
+     * **Example:** Get the currently playing clip name from inside an {@link AudioStreamPlayer} node.
+     *
+     *
+     * ```gdscript
+     *
+     * var playing_clip_name = stream.get_clip_name(get_stream_playback().get_current_clip_index())
+     *
+     * ```
+     */
+    getCurrentClipIndex(): number { return _C(this, 4347) as number; }
+
+    static readonly name = _R(130, AudioStreamPlaybackInteractive);
+}

package/gen/classes/AudioStreamPlaybackOggVorbis.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlaybackResampled } from './AudioStreamPlaybackResampled.ts';
+
+/**
+ * Playback component of {@link AudioStreamOggVorbis}. Uses {@link OggPacketSequencePlayback} for playback data.
+ */
+export class AudioStreamPlaybackOggVorbis extends AudioStreamPlaybackResampled {
+    constructor(name = 131) { super(name); }
+
+    static readonly name = _R(131, AudioStreamPlaybackOggVorbis);
+}

package/gen/classes/AudioStreamPlaybackPlaylist.ts

@@ -0,0 +1,13 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+
+/**
+ * Playback component of {@link AudioStreamPlaylist}. Handles the playback of multiple {@link AudioStream}s in sequence.
+ */
+export class AudioStreamPlaybackPlaylist extends AudioStreamPlayback {
+
+    static readonly name = _R(132, AudioStreamPlaybackPlaylist);
+}

package/gen/classes/AudioStreamPlaybackPolyphonic.ts

@@ -0,0 +1,49 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+import type { StringName } from '../heap-types/index.ts';
+import type { PlaybackType } from './AudioServer.ts';
+import type { AudioStream } from './AudioStream.ts';
+
+/**
+ * Playback instance for {@link AudioStreamPolyphonic}. After setting the `stream` property of {@link AudioStreamPlayer}, {@link AudioStreamPlayer2D}, or {@link AudioStreamPlayer3D}, the playback instance can be obtained by calling {@link AudioStreamPlayer.getStreamPlayback}, {@link AudioStreamPlayer2D.getStreamPlayback} or {@link AudioStreamPlayer3D.getStreamPlayback} methods.
+ */
+export class AudioStreamPlaybackPolyphonic extends AudioStreamPlayback {
+
+    /**
+     * 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 stopStream} 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.
+     */
+    playStream(stream: AudioStream, fromOffset?: number /* = 0 */, volumeDb?: number /* = 0 */, pitchScale?: number /* = 1.0 */, playbackType?: PlaybackType /* = 0 */, bus?: StringName /* = &"Master" */): number { return _C(this, 9455, stream, fromOffset, volumeDb, pitchScale, playbackType, bus) as number; }
+
+    /**
+     * Change the stream volume (in db). The `stream` argument is an integer ID returned by {@link playStream}.
+     */
+    setStreamVolume(stream: number /* int64 */, volumeDb: number): void { _C(this, 12902, stream, volumeDb); }
+
+    /**
+     * Change the stream pitch scale. The `stream` argument is an integer ID returned by {@link playStream}.
+     */
+    setStreamPitchScale(stream: number /* int64 */, pitchScale: number): void { _C(this, 12899, stream, pitchScale); }
+
+    /**
+     * Returns `true` if the stream associated with the given integer ID is still playing. Check {@link playStream} for information on when this ID becomes invalid.
+     */
+    isStreamPlaying(stream: number /* int64 */): boolean { return _C(this, 8342, stream) as boolean; }
+
+    /**
+     * Stop a stream. The `stream` argument is an integer ID returned by {@link playStream}, which becomes invalid after calling this function.
+     */
+    stopStream(stream: number /* int64 */): void { _C(this, 13871, stream); }
+
+    /**
+     * Returned by {@link playStream} in case it could not allocate a stream for playback.
+     */
+    static readonly INVALID_ID = -1;
+
+    static readonly name = _R(133, AudioStreamPlaybackPolyphonic);
+}

package/gen/classes/AudioStreamPlaybackResampled.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+
+/**
+ * Playback class used to mix an {@link AudioStream}'s audio samples to {@link AudioServer.getMixRate} using cubic interpolation.
+ */
+export class AudioStreamPlaybackResampled extends AudioStreamPlayback {
+    constructor(name = 134) { super(name); }
+
+    /**
+     * Called when an {@link AudioStream} is played. Clears the cubic interpolation history and starts mixing by calling {@link _mixResampled}.
+     */
+    beginResample(): void { _C(this, 1752); }
+
+    static readonly name = _R(134, AudioStreamPlaybackResampled);
+}

package/gen/classes/AudioStreamPlaybackSynchronized.ts

@@ -0,0 +1,13 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioStreamPlayback } from './AudioStreamPlayback.ts';
+
+/**
+ * Playback component of {@link AudioStreamSynchronized}. Handles the playback of multiple {@link AudioStream}s in synchrony.
+ */
+export class AudioStreamPlaybackSynchronized extends AudioStreamPlayback {
+
+    static readonly name = _R(135, AudioStreamPlaybackSynchronized);
+}