@ringozz/godot 0.1.0

package/gen/classes/ArrayMesh.ts

@@ -0,0 +1,177 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Mesh } from './Mesh.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedByteArray, StringName } from '../heap-types/index.ts';
+import type { AABB, Transform3D } from '../value-types/index.ts';
+import type { ArrayFormat, BlendShapeMode, PrimitiveType } from './Mesh.ts';
+
+/**
+ * The {@link ArrayMesh} is used to construct a {@link Mesh} by specifying the attributes as arrays.
+ * The most basic example is the creation of a single triangle:
+ *
+ *
+ * ```gdscript
+ *
+ * var vertices = PackedVector3Array()
+ * vertices.push_back(Vector3(0, 1, 0))
+ * vertices.push_back(Vector3(1, 0, 0))
+ * vertices.push_back(Vector3(0, 0, 1))
+ *
+ * # Initialize the ArrayMesh.
+ * var arr_mesh = ArrayMesh.new()
+ * var arrays = []
+ * arrays.resize(Mesh.ARRAY_MAX)
+ * arrays[Mesh.ARRAY_VERTEX] = vertices
+ *
+ * # Create the Mesh.
+ * arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
+ * var m = MeshInstance3D.new()
+ * m.mesh = arr_mesh
+ *
+ * ```
+ *
+ *
+ *
+ * The {@link MeshInstance3D} is ready to be added to the {@link SceneTree} to be shown.
+ * See also {@link ImmediateMesh}, {@link MeshDataTool} and {@link SurfaceTool} for procedural geometry generation.
+ * **Note:** Godot uses clockwise [winding order](https://learnopengl.com/Advanced-OpenGL/Face-culling) for front faces of triangle primitive modes.
+ */
+export class ArrayMesh extends Mesh {
+    constructor(name = 82) { super(name); }
+
+    /**
+     * Adds name for a blend shape that will be added with {@link addSurfaceFromArrays}. Must be called before surface is added.
+     */
+    addBlendShape(name: StringName): void { _C(this, 1185, name); }
+
+    /**
+     * Returns the number of blend shapes that the {@link ArrayMesh} holds.
+     */
+    getBlendShapeCount(): number { return _C(this, 3938) as number; }
+
+    /**
+     * Returns the name of the blend shape at this index.
+     */
+    getBlendShapeName(index: number): StringName { return _C(this, 3940, index) as StringName; }
+
+    /**
+     * Sets the name of the blend shape at this index.
+     */
+    setBlendShapeName(index: number, name: StringName): void { _C(this, 10683, index, name); }
+
+    /**
+     * Removes all blend shapes from this {@link ArrayMesh}.
+     */
+    clearBlendShapes(): void { _C(this, 2237); }
+
+    /**
+     * Creates a new surface. {@link Mesh.getSurfaceCount} will become the `surf_idx` for this new surface.
+     * Surfaces are created to be rendered using a `primitive`, which may be any of the values defined in {@link Mesh.PrimitiveType}.
+     * The `arrays` argument is an array of arrays. Each of the {@link Mesh.ARRAY_MAX} elements contains an array with some of the mesh data for this surface as described by the corresponding member of {@link Mesh.ArrayType} or `null` if it is not used by the surface. For example, `arrays[0]` is the array of vertices. That first vertex sub-array is always required; the others are optional. Adding an index array puts this surface into "index mode" where the vertex and other arrays become the sources of data and the index array defines the vertex order. All sub-arrays must have the same length as the vertex array (or be an exact multiple of the vertex array's length, when multiple elements of a sub-array correspond to a single vertex) or be empty, except for {@link Mesh.ARRAY_INDEX} if it is used.
+     * The `blendShapes` argument is an array of vertex data for each blend shape. Each element is an array of the same structure as `arrays`, but {@link Mesh.ARRAY_VERTEX}, {@link Mesh.ARRAY_NORMAL}, and {@link Mesh.ARRAY_TANGENT} are set if and only if they are set in `arrays` and all other entries are `null`.
+     * The `lods` argument is a dictionary with {@link float} keys and {@link PackedInt32Array} values. Each entry in the dictionary represents an LOD level of the surface, where the value is the {@link Mesh.ARRAY_INDEX} array to use for the LOD level and the key is roughly proportional to the distance at which the LOD stats being used. I.e., increasing the key of an LOD also increases the distance that the objects has to be from the camera before the LOD is used.
+     * The `flags` argument is the bitwise OR of, as required: One value of {@link Mesh.ArrayCustomFormat} left shifted by `ARRAY_FORMAT_CUSTOMn_SHIFT` for each custom channel in use, {@link Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE}, {@link Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS}, or {@link Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY}.
+     * **Note:** When using indices, it is recommended to only use points, lines, or triangles.
+     */
+    addSurfaceFromArrays(primitive: PrimitiveType, arrays: GodotArray, blendShapes?: GodotArray<GodotArray> /* = [] */, lods?: GodotDictionary /* = {} */, flags?: ArrayFormat /* = 0 */): void { _C(this, 1302, primitive, arrays, blendShapes, lods, flags); }
+
+    /**
+     * Removes all surfaces from this {@link ArrayMesh}.
+     */
+    clearSurfaces(): void { _C(this, 2300); }
+
+    /**
+     * Removes the surface at the given index from the Mesh, shifting surfaces with higher index down by one.
+     */
+    surfaceRemove(surfIdx: number): void { _C(this, 14037, surfIdx); }
+
+    /**
+     * Updates the vertex buffer of this mesh's surface with the given `data`. The expected data per vertex is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.meshSurfaceGetFormatVertexStride}.
+     * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each vertex.
+     * A {@link PackedVector3Array} of vertex locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.toByteArray} for use in `data`.
+     */
+    surfaceUpdateVertexRegion(surfIdx: number, offset: number, data: PackedByteArray): void { _C(this, 14047, surfIdx, offset, data); }
+
+    /**
+     * Updates the attribute buffer of this mesh's surface with the given `data`. The expected data per attribute is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.meshSurfaceGetFormatAttributeStride}.
+     * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each attribute.
+     * A {@link PackedVector3Array} of attribute locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.toByteArray} for use in `data`.
+     */
+    surfaceUpdateAttributeRegion(surfIdx: number, offset: number, data: PackedByteArray): void { _C(this, 14045, surfIdx, offset, data); }
+
+    /**
+     * Updates the skin buffer of this mesh's surface with the given `data`. The expected data per skin is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.meshSurfaceGetFormatSkinStride}.
+     * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each skin.
+     * A {@link PackedVector3Array} of skin locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.toByteArray} for use in `data`.
+     */
+    surfaceUpdateSkinRegion(surfIdx: number, offset: number, data: PackedByteArray): void { _C(this, 14046, surfIdx, offset, data); }
+
+    /**
+     * Returns the length in vertices of the vertex array in the requested surface (see {@link addSurfaceFromArrays}).
+     */
+    surfaceGetArrayLen(surfIdx: number): number { return _C(this, 14029, surfIdx) as number; }
+
+    /**
+     * Returns the length in indices of the index array in the requested surface (see {@link addSurfaceFromArrays}).
+     */
+    surfaceGetArrayIndexLen(surfIdx: number): number { return _C(this, 14028, surfIdx) as number; }
+
+    /**
+     * Returns the format mask of the requested surface (see {@link addSurfaceFromArrays}).
+     */
+    surfaceGetFormat(surfIdx: number): ArrayFormat { return _C(this, 14032, surfIdx) as ArrayFormat; }
+
+    /**
+     * Returns the primitive type of the requested surface (see {@link addSurfaceFromArrays}).
+     */
+    surfaceGetPrimitiveType(surfIdx: number): PrimitiveType { return _C(this, 14035, surfIdx) as PrimitiveType; }
+
+    /**
+     * Returns the index of the first surface with this name held within this {@link ArrayMesh}. If none are found, -1 is returned.
+     */
+    surfaceFindByName(name: string): number { return _C(this, 14027, name) as number; }
+
+    /**
+     * Sets a name for a given surface.
+     */
+    surfaceSetName(surfIdx: number, name: string): void { _C(this, 14040, surfIdx, name); }
+
+    /**
+     * Gets the name assigned to this surface.
+     */
+    surfaceGetName(surfIdx: number): string { return _C(this, 14034, surfIdx) as string; }
+
+    /**
+     * Regenerates tangents for each of the {@link ArrayMesh}'s surfaces.
+     */
+    regenNormalMaps(): void { _C(this, 9802); }
+
+    /**
+     * Performs a UV unwrap on the {@link ArrayMesh} to prepare the mesh for lightmapping.
+     */
+    lightmapUnwrap(transform: Transform3D, texelSize: number): Error { return _C(this, 8606, transform, texelSize) as Error; }
+
+    /**
+     * The blend shape mode.
+     */
+    get blendShapeMode(): BlendShapeMode { return _C(this, 3939) as BlendShapeMode; }
+    set blendShapeMode(v: BlendShapeMode) { _C(this, 10682, v); }
+
+    /**
+     * Overrides the {@link AABB} with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices.
+     */
+    get customAabb(): AABB { return _C(this, 4375) as AABB; }
+    set customAabb(v: AABB) { _C(this, 10999, v); }
+
+    /**
+     * An optional mesh which can be used for rendering shadows and the depth prepass. Can be used to increase performance by supplying a mesh with fused vertices and only vertex position data (without normals, UVs, colors, etc.).
+     * **Note:** This mesh must have exactly the same vertex positions as the source mesh (including the source mesh's LODs, if present). If vertex positions differ, then the mesh will not draw correctly.
+     */
+    get shadowMesh(): ArrayMesh { return _C(this, 6362) as ArrayMesh; }
+    set shadowMesh(v: ArrayMesh) { _C(this, 12709, v); }
+
+    static readonly name = _R(82, ArrayMesh);
+}

package/gen/classes/ArrayOccluder3D.ts

@@ -0,0 +1,35 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Occluder3D } from './Occluder3D.ts';
+import type { PackedInt32Array, PackedVector3Array } from '../heap-types/index.ts';
+
+/**
+ * {@link ArrayOccluder3D} stores an arbitrary 3D polygon shape that can be used by the engine's occlusion culling system. This is analogous to {@link ArrayMesh}, but for occluders.
+ * See {@link OccluderInstance3D}'s documentation for instructions on setting up occlusion culling.
+ */
+export class ArrayOccluder3D extends Occluder3D {
+    constructor(name = 83) { super(name); }
+
+    /**
+     * Sets {@link indices} and {@link vertices}, while updating the final occluder only once after both values are set.
+     */
+    setArrays(vertices: PackedVector3Array, indices: PackedInt32Array): void { _C(this, 10532, vertices, indices); }
+
+    /**
+     * The occluder's vertex positions in local 3D coordinates.
+     * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link setArrays} instead to avoid updating the occluder twice when it's created.
+     */
+    get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
+    set vertices(v: PackedVector3Array) { _C(this, 13308, v); }
+
+    /**
+     * The occluder's index position. Indices determine which points from the {@link vertices} array should be drawn, and in which order.
+     * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link setArrays} instead to avoid updating the occluder twice when it's created.
+     */
+    get indices(): PackedInt32Array { return _C(this, 5091) as PackedInt32Array; }
+    set indices(v: PackedInt32Array) { _C(this, 11692, v); }
+
+    static readonly name = _R(83, ArrayOccluder3D);
+}

package/gen/classes/AspectRatioContainer.ts

@@ -0,0 +1,78 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Container } from './Container.ts';
+
+/**
+ * A container type that arranges its child controls in a way that preserves their proportions automatically when the container is resized. Useful when a container has a dynamic size and the child nodes must adjust their sizes accordingly without losing their aspect ratios.
+ */
+export class AspectRatioContainer extends Container {
+    constructor(name = 84) { super(name); }
+
+    /**
+     * The aspect ratio to enforce on child controls. This is the width divided by the height. The ratio depends on the {@link stretchMode}.
+     */
+    get ratio(): number { return _C(this, 6079) as number; }
+    set ratio(v: number) { _C(this, 12478, v); }
+
+    /**
+     * The stretch mode used to align child controls.
+     */
+    get stretchMode(): StretchMode { return _C(this, 6569) as StretchMode; }
+    set stretchMode(v: StretchMode) { _C(this, 12907, v); }
+
+    /**
+     * Specifies the horizontal relative position of child controls.
+     */
+    get alignmentHorizontal(): AlignmentMode { return _C(this, 3713) as AlignmentMode; }
+    set alignmentHorizontal(v: AlignmentMode) { _C(this, 10449, v); }
+
+    /**
+     * Specifies the vertical relative position of child controls.
+     */
+    get alignmentVertical(): AlignmentMode { return _C(this, 3714) as AlignmentMode; }
+    set alignmentVertical(v: AlignmentMode) { _C(this, 10450, v); }
+
+    static readonly name = _R(84, AspectRatioContainer);
+}
+
+export const StretchMode = {
+    /**
+     * The height of child controls is automatically adjusted based on the width of the container.
+     */
+    STRETCH_WIDTH_CONTROLS_HEIGHT: 0,
+    /**
+     * The width of child controls is automatically adjusted based on the height of the container.
+     */
+    STRETCH_HEIGHT_CONTROLS_WIDTH: 1,
+    /**
+     * The bounding rectangle of child controls is automatically adjusted to fit inside the container while keeping the aspect ratio.
+     */
+    STRETCH_FIT: 2,
+    /**
+     * The width and height of child controls is automatically adjusted to make their bounding rectangle cover the entire area of the container while keeping the aspect ratio.
+     * When the bounding rectangle of child controls exceed the container's size and {@link Control.clipContents} is enabled, this allows to show only the container's area restricted by its own bounding rectangle.
+     */
+    STRETCH_COVER: 3,
+} as const;
+
+export type StretchMode = (typeof StretchMode)[keyof typeof StretchMode];
+
+export const AlignmentMode = {
+    /**
+     * Aligns child controls with the beginning (left or top) of the container.
+     */
+    ALIGNMENT_BEGIN: 0,
+    /**
+     * Aligns child controls with the center of the container.
+     */
+    ALIGNMENT_CENTER: 1,
+    /**
+     * Aligns child controls with the end (right or bottom) of the container.
+     */
+    ALIGNMENT_END: 2,
+} as const;
+
+export type AlignmentMode = (typeof AlignmentMode)[keyof typeof AlignmentMode];
+

package/gen/classes/AtlasTexture.ts

@@ -0,0 +1,42 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { Rect2 } from '../value-types/index.ts';
+
+/**
+ * {@link Texture2D} resource that draws only part of its {@link atlas} texture, as defined by the {@link region}. An additional {@link margin} can also be set, which is useful for small adjustments.
+ * Multiple {@link AtlasTexture} resources can be cropped from the same {@link atlas}. Packing many smaller textures into a singular large texture helps to optimize video memory costs and render calls.
+ * **Note:** {@link AtlasTexture} cannot be used in an {@link AnimatedTexture}, and will not tile properly in nodes such as {@link TextureRect} or {@link Sprite2D}. To tile an {@link AtlasTexture}, modify its {@link region} instead.
+ */
+export class AtlasTexture extends Texture2D {
+    constructor(name = 85) { super(name); }
+
+    /**
+     * The texture that contains the atlas. Can be any type inheriting from {@link Texture2D}, including another {@link AtlasTexture}.
+     */
+    get atlas(): Texture2D { return _C(this, 3803) as Texture2D; }
+    set atlas(v: Texture2D) { _C(this, 10546, v); }
+
+    /**
+     * The region used to draw the {@link atlas}. If either dimension of the region's size is `0`, the value from {@link atlas} size will be used for that axis instead.
+     * **Note:** The image size is always an integer, so the actual region size is rounded down.
+     */
+    get region(): Rect2 { return _C(this, 6112) as Rect2; }
+    set region(v: Rect2) { _C(this, 12505, v); }
+
+    /**
+     * The margin around the {@link region}. Useful for small adjustments. If the {@link Rect2.size} of this property ("w" and "h" in the editor) is set, the drawn texture is resized to fit within the margin.
+     */
+    get margin(): Rect2 { return _C(this, 5441) as Rect2; }
+    set margin(v: Rect2) { _C(this, 11969, v); }
+
+    /**
+     * If `true`, the area outside of the {@link region} is clipped to avoid bleeding of the surrounding texture pixels.
+     */
+    get filterClip(): boolean { return _C(this, 7396) as boolean; }
+    set filterClip(v: boolean) { _C(this, 11389, v); }
+
+    static readonly name = _R(85, AtlasTexture);
+}

package/gen/classes/AudioBusLayout.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 { Resource } from './Resource.ts';
+
+/**
+ * Stores position, muting, solo, bypass, effects, effect position, volume, and the connections between buses. See {@link AudioServer} for usage.
+ */
+export class AudioBusLayout extends Resource {
+    constructor(name = 86) { super(name); }
+
+    static readonly name = _R(86, AudioBusLayout);
+}

package/gen/classes/AudioEffect.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { AudioEffectInstance } from './AudioEffectInstance.ts';
+
+/**
+ * The base {@link Resource} for every audio effect. In the editor, an audio effect can be added to the current bus layout through the Audio panel. At run-time, it is also possible to manipulate audio effects through {@link AudioServer.addBusEffect}, {@link AudioServer.removeBusEffect}, and {@link AudioServer.getBusEffect}.
+ * When applied on a bus, an audio effect creates a corresponding {@link AudioEffectInstance}. The instance is directly responsible for manipulating sound, based on the original audio effect's properties.
+ */
+export class AudioEffect extends Resource {
+    constructor(name = 87) { super(name); }
+
+    static readonly name = _R(87, AudioEffect);
+}

package/gen/classes/AudioEffectAmplify.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * Increases or decreases the volume being routed through the audio bus.
+ */
+export class AudioEffectAmplify extends AudioEffect {
+    constructor(name = 88) { super(name); }
+
+    /**
+     * Amount of amplification in dB. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24.
+     */
+    get volumeDb(): number { return _C(this, 7121) as number; }
+    set volumeDb(v: number) { _C(this, 13344, v); }
+
+    /**
+     * Amount of amplification as a linear value.
+     * **Note:** This member modifies {@link volumeDb} for convenience. The returned value is equivalent to the result of {@link dbToLinear} on {@link volumeDb}. Setting this member is equivalent to setting {@link volumeDb} to the result of {@link linearToDb} on a value.
+     */
+    get volumeLinear(): number { return _C(this, 7122) as number; }
+    set volumeLinear(v: number) { _C(this, 13345, v); }
+
+    static readonly name = _R(88, AudioEffectAmplify);
+}

package/gen/classes/AudioEffectBandLimitFilter.ts

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

package/gen/classes/AudioEffectBandPassFilter.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffectFilter } from './AudioEffectFilter.ts';
+
+/**
+ * A "band-pass" filter allows the frequencies at {@link AudioEffectFilter.cutoffHz} to pass unchanged, and attenuates frequencies outside the frequency threshold. It is the opposite of {@link AudioEffectBandLimitFilter} and {@link AudioEffectNotchFilter}.
+ * This filter can be used to emulate sounds coming from weak speakers.
+ */
+export class AudioEffectBandPassFilter extends AudioEffectFilter {
+    constructor(name = 90) { super(name); }
+
+    static readonly name = _R(90, AudioEffectBandPassFilter);
+}

package/gen/classes/AudioEffectCapture.ts

@@ -0,0 +1,62 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+
+/**
+ * Copies all audio frames, also known as "samples" or "audio samples", from the attached audio bus into its internal ring buffer. This effect does not alter the audio. Can be used for storing real-time audio data for playback, and for creating real-time audio visualizations, like an oscilloscope.
+ * Application code should consume these audio frames from this ring buffer using {@link getBuffer} and process it as needed, for example to capture data from an {@link AudioStreamMicrophone}, implement application-defined effects, or to transmit audio over the network. When capturing audio data from a microphone, the format of the samples will be stereo 32-bit floating-point PCM.
+ * Unlike {@link AudioEffectRecord}, this effect only returns the raw audio samples instead of encoding them into an {@link AudioStream}.
+ */
+export class AudioEffectCapture extends AudioEffect {
+    constructor(name = 91) { super(name); }
+
+    /**
+     * Returns `true` if at least `frames` samples are available to read in the internal ring buffer.
+     */
+    canGetBuffer(frames: number): boolean { return _C(this, 2012, frames) as boolean; }
+
+    /**
+     * Gets the next `frames` samples from the internal ring buffer.
+     * Returns a {@link PackedVector2Array} containing exactly `frames` samples if available, or an empty {@link PackedVector2Array} if insufficient data was available.
+     * The samples are signed floating-point PCM between `-1` and `1`. You will have to scale them if you want to use them as 8 or 16-bit integer samples. (`v = 0x7fff * samples[0].x`)
+     */
+    getBuffer(frames: number): PackedVector2Array { return _C(this, 4003, frames) as PackedVector2Array; }
+
+    /**
+     * Clears the internal ring buffer.
+     * **Note:** Calling this during a capture can cause the loss of samples which causes popping in the playback.
+     */
+    clearBuffer(): void { _C(this, 2243); }
+
+    /**
+     * Returns the number of samples available to read using {@link getBuffer}.
+     */
+    getFramesAvailable(): number { return _C(this, 4890) as number; }
+
+    /**
+     * Returns the number of samples discarded from the audio bus due to full buffer.
+     */
+    getDiscardedFrames(): number { return _C(this, 4513) as number; }
+
+    /**
+     * Returns the total size of the internal ring buffer in number of samples.
+     */
+    getBufferLengthFrames(): number { return _C(this, 4005) as number; }
+
+    /**
+     * Returns the number of samples inserted from the audio bus.
+     */
+    getPushedFrames(): number { return _C(this, 6057) as number; }
+
+    /**
+     * Length of the internal ring buffer, in seconds. Higher values keep data around for longer, but require more memory. Value can range from 0.01 to 10.
+     * **Note:** Setting the buffer length will have no effect if already initialized.
+     */
+    get bufferLength(): number { return _C(this, 4004) as number; }
+    set bufferLength(v: number) { _C(this, 10742, v); }
+
+    static readonly name = _R(91, AudioEffectCapture);
+}

package/gen/classes/AudioEffectChorus.ts

@@ -0,0 +1,95 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+
+/**
+ * A "chorus" effect creates multiple copies of the original audio (called "voices") with variations in pitch, and layers on top of the original, giving the impression that the sound comes from multiple sources. This creates spectral and spatial movement.
+ * Each voice is played a short period of time after the original audio, controlled by `delay`. An internal low-frequency oscillator (LFO) controls their pitch, and `depth` controls the LFO's maximum amount.
+ * In the real world, this kind of effect is found in pianos, choirs, and instrument ensembles.
+ * This effect can also be used to widen mono audio and make digital sounds have a more natural or analog quality.
+ */
+export class AudioEffectChorus extends AudioEffect {
+    constructor(name = 92) { super(name); }
+
+    /**
+     * Sets the delay of a given `voiceIdx` in milliseconds, compared to the original audio. Value can range from 0 to 50.
+     */
+    setVoiceDelayMs(voiceIdx: number, delayMs: number): void { _C(this, 13338, voiceIdx, delayMs); }
+
+    /**
+     * Returns the delay of a given `voiceIdx` in milliseconds, compared to the original audio.
+     */
+    getVoiceDelayMs(voiceIdx: number): number { return _C(this, 7115, voiceIdx) as number; }
+
+    /**
+     * Sets the rate of a given `voiceIdx`'s low-frequency oscillator in Hz. Value can range from 0.1 to 20.
+     */
+    setVoiceRateHz(voiceIdx: number, rateHz: number): void { _C(this, 13342, voiceIdx, rateHz); }
+
+    /**
+     * Returns the rate of a given `voiceIdx`'s low-frequency oscillator in Hz.
+     */
+    getVoiceRateHz(voiceIdx: number): number { return _C(this, 7119, voiceIdx) as number; }
+
+    /**
+     * Sets the depth of a given `voiceIdx`'s low-frequency oscillator in milliseconds. Value can range from 0 to 20.
+     */
+    setVoiceDepthMs(voiceIdx: number, depthMs: number): void { _C(this, 13339, voiceIdx, depthMs); }
+
+    /**
+     * Returns the depth of a given `voiceIdx`'s low-frequency oscillator in milliseconds.
+     */
+    getVoiceDepthMs(voiceIdx: number): number { return _C(this, 7116, voiceIdx) as number; }
+
+    /**
+     * Sets the gain of a given `voiceIdx` in dB. Value can range from -60 to 24.
+     */
+    setVoiceLevelDb(voiceIdx: number, levelDb: number): void { _C(this, 13340, voiceIdx, levelDb); }
+
+    /**
+     * Returns the gain of a given `voiceIdx` in dB.
+     */
+    getVoiceLevelDb(voiceIdx: number): number { return _C(this, 7117, voiceIdx) as number; }
+
+    /**
+     * Sets the frequency threshold of a given `voiceIdx`'s low-pass filter in Hz. Frequencies above `cutoffHz` are removed from `voiceIdx`. Value can range from 1 to 20500.
+     */
+    setVoiceCutoffHz(voiceIdx: number, cutoffHz: number): void { _C(this, 13337, voiceIdx, cutoffHz); }
+
+    /**
+     * Returns the frequency threshold of a given `voiceIdx`'s low-pass filter in Hz. Frequencies above this value are removed from the voice.
+     */
+    getVoiceCutoffHz(voiceIdx: number): number { return _C(this, 7114, voiceIdx) as number; }
+
+    /**
+     * Sets the pan position of a given `voiceIdx`. Negative values pan the sound to the left, positive pan to the right. Value can range from -1 to 1.
+     */
+    setVoicePan(voiceIdx: number, pan: number): void { _C(this, 13341, voiceIdx, pan); }
+
+    /**
+     * Returns the pan position of a given `voiceIdx`. Negative values mean the left channel, positive mean the right.
+     */
+    getVoicePan(voiceIdx: number): number { return _C(this, 7118, voiceIdx) as number; }
+
+    /**
+     * The number of voices in the effect. Value can range from 1 to 4.
+     */
+    get voiceCount(): number { return _C(this, 7113) as number; }
+    set voiceCount(v: number) { _C(this, 13336, v); }
+
+    /**
+     * The volume ratio of the original audio. Value can range from 0 to 1.
+     */
+    get dry(): number { return _C(this, 4587) as number; }
+    set dry(v: number) { _C(this, 11201, v); }
+
+    /**
+     * The volume ratio of all voices. Value can range from 0 to 1.
+     */
+    get wet(): number { return _C(this, 7145) as number; }
+    set wet(v: number) { _C(this, 13370, v); }
+
+    static readonly name = _R(92, AudioEffectChorus);
+}

package/gen/classes/AudioEffectCompressor.ts

@@ -0,0 +1,62 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AudioEffect } from './AudioEffect.ts';
+import type { StringName } from '../heap-types/index.ts';
+
+/**
+ * A "compressor" decreases the volume of sounds when it exceeds a certain volume threshold level.
+ * A compressor can have many uses in a mix:
+ * - To compress the whole volume in the Master bus (although an {@link AudioEffectHardLimiter} is probably better).
+ * - To ensure balance of voice audio clips.
+ * - To sidechain, using another bus as a trigger. This decreases the volume of the bus it is attached to, by using the volume from another audio bus for threshold detection. This technique is common in video game mixing to decrease the volume of music and SFX while voices are being heard. This effect is also known as "ducking".
+ * - To accentuate transients by using a long attack, letting sounds exceed the volume threshold level for a short period before compressing them. This can be used to make SFX more punchy.
+ */
+export class AudioEffectCompressor extends AudioEffect {
+    constructor(name = 93) { super(name); }
+
+    /**
+     * The volume level above which compression is applied to the audio, in dB. Value can range from -60 to 0.
+     */
+    get threshold(): number { return _C(this, 6775) as number; }
+    set threshold(v: number) { _C(this, 13059, v); }
+
+    /**
+     * Amount of compression applied to the audio once it passes the volume threshold level. The higher the ratio, the stronger the compression applied to audio signals that pass the volume threshold level. Value can range from 1 to 48.
+     */
+    get ratio(): number { return _C(this, 6079) as number; }
+    set ratio(v: number) { _C(this, 12478, v); }
+
+    /**
+     * Gain of the audio signal, in dB. Value can range from -20 to 20.
+     */
+    get gain(): number { return _C(this, 4914) as number; }
+    set gain(v: number) { _C(this, 11506, v); }
+
+    /**
+     * Compressor's reaction time when the audio exceeds the volume threshold level, in microseconds. Value can range from 20 to 2000.
+     */
+    get attackUs(): number { return _C(this, 3808) as number; }
+    set attackUs(v: number) { _C(this, 10549, v); }
+
+    /**
+     * Compressor's delay time to stop decreasing the volume after the it falls below the volume threshold level, in milliseconds. Value can range from 20 to 2000.
+     */
+    get releaseMs(): number { return _C(this, 6122) as number; }
+    set releaseMs(v: number) { _C(this, 12515, v); }
+
+    /**
+     * Balance between the original audio and the compressed audio. Value can range from 0 (totally dry) to 1 (totally wet).
+     */
+    get mix(): number { return _C(this, 5563) as number; }
+    set mix(v: number) { _C(this, 12068, v); }
+
+    /**
+     * Audio bus to use for the volume threshold detection.
+     */
+    get sidechain(): StringName { return _C(this, 6388) as StringName; }
+    set sidechain(v: StringName) { _C(this, 12746, v); }
+
+    static readonly name = _R(93, AudioEffectCompressor);
+}