@ringozz/godot 0.1.0

package/gen/classes/CompressedCubemapArray.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CompressedTextureLayered } from './CompressedTextureLayered.ts';
+
+/**
+ * A cubemap array that is loaded from a `.ccubearray` file. This file format is internal to Godot; it is created by importing other image formats with the import system. {@link CompressedCubemapArray} can use one of 4 compression methods:
+ * - Lossless (WebP or PNG, uncompressed on the GPU)
+ * - Lossy (WebP, uncompressed on the GPU)
+ * - VRAM Compressed (compressed on the GPU)
+ * - VRAM Uncompressed (uncompressed on the GPU)
+ * - Basis Universal (compressed on the GPU. Lower file sizes than VRAM Compressed, but slower to compress and lower quality than VRAM Compressed)
+ * Only **VRAM Compressed** actually reduces the memory usage on the GPU. The **Lossless** and **Lossy** compression methods will reduce the required storage on disk, but they will not reduce memory usage on the GPU as the texture is sent to the GPU uncompressed.
+ * Using **VRAM Compressed** also improves loading times, as VRAM-compressed textures are faster to load compared to textures using lossless or lossy compression. VRAM compression can exhibit noticeable artifacts and is intended to be used for 3D rendering, not 2D.
+ * See {@link CubemapArray} for a general description of cubemap arrays.
+ */
+export class CompressedCubemapArray extends CompressedTextureLayered {
+    constructor(name = 215) { super(name); }
+
+    static readonly name = _R(215, CompressedCubemapArray);
+}

package/gen/classes/CompressedTexture2D.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 { Texture2D } from './Texture2D.ts';
+
+/**
+ * A texture that is loaded from a `.ctex` file. This file format is internal to Godot; it is created by importing other image formats with the import system. {@link CompressedTexture2D} can use one of 4 compression methods (including a lack of any compression):
+ * - Lossless (WebP or PNG, uncompressed on the GPU)
+ * - Lossy (WebP, uncompressed on the GPU)
+ * - VRAM Compressed (compressed on the GPU)
+ * - VRAM Uncompressed (uncompressed on the GPU)
+ * - Basis Universal (compressed on the GPU. Lower file sizes than VRAM Compressed, but slower to compress and lower quality than VRAM Compressed)
+ * Only **VRAM Compressed** actually reduces the memory usage on the GPU. The **Lossless** and **Lossy** compression methods will reduce the required storage on disk, but they will not reduce memory usage on the GPU as the texture is sent to the GPU uncompressed.
+ * Using **VRAM Compressed** also improves loading times, as VRAM-compressed textures are faster to load compared to textures using lossless or lossy compression. VRAM compression can exhibit noticeable artifacts and is intended to be used for 3D rendering, not 2D.
+ */
+export class CompressedTexture2D extends Texture2D {
+    constructor(name = 216) { super(name); }
+
+    /**
+     * The {@link CompressedTexture2D}'s file path to a `.ctex` file.
+     */
+    get loadPath(): string { return _C(this, 5391) as string; }
+    set loadPath(v: string) { _C(this, 8665, v); }
+
+    static readonly name = _R(216, CompressedTexture2D);
+}

package/gen/classes/CompressedTexture2DArray.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CompressedTextureLayered } from './CompressedTextureLayered.ts';
+
+/**
+ * A texture array that is loaded from a `.ctexarray` file. This file format is internal to Godot; it is created by importing other image formats with the import system. {@link CompressedTexture2DArray} can use one of 4 compression methods:
+ * - Lossless (WebP or PNG, uncompressed on the GPU)
+ * - Lossy (WebP, uncompressed on the GPU)
+ * - VRAM Compressed (compressed on the GPU)
+ * - VRAM Uncompressed (uncompressed on the GPU)
+ * - Basis Universal (compressed on the GPU. Lower file sizes than VRAM Compressed, but slower to compress and lower quality than VRAM Compressed)
+ * Only **VRAM Compressed** actually reduces the memory usage on the GPU. The **Lossless** and **Lossy** compression methods will reduce the required storage on disk, but they will not reduce memory usage on the GPU as the texture is sent to the GPU uncompressed.
+ * Using **VRAM Compressed** also improves loading times, as VRAM-compressed textures are faster to load compared to textures using lossless or lossy compression. VRAM compression can exhibit noticeable artifacts and is intended to be used for 3D rendering, not 2D.
+ * See {@link Texture2DArray} for a general description of texture arrays.
+ */
+export class CompressedTexture2DArray extends CompressedTextureLayered {
+    constructor(name = 217) { super(name); }
+
+    static readonly name = _R(217, CompressedTexture2DArray);
+}

package/gen/classes/CompressedTexture3D.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture3D } from './Texture3D.ts';
+
+/**
+ * {@link CompressedTexture3D} is the VRAM-compressed counterpart of {@link ImageTexture3D}. The file extension for {@link CompressedTexture3D} files is `.ctex3d`. This file format is internal to Godot; it is created by importing other image formats with the import system.
+ * {@link CompressedTexture3D} uses VRAM compression, which allows to reduce memory usage on the GPU when rendering the texture. This also improves loading times, as VRAM-compressed textures are faster to load compared to textures using lossless compression. VRAM compression can exhibit noticeable artifacts and is intended to be used for 3D rendering, not 2D.
+ * See {@link Texture3D} for a general description of 3D textures.
+ */
+export class CompressedTexture3D extends Texture3D {
+    constructor(name = 218) { super(name); }
+
+    /**
+     * The {@link CompressedTexture3D}'s file path to a `.ctex3d` file.
+     */
+    get loadPath(): string { return _C(this, 5391) as string; }
+    set loadPath(v: string) { _C(this, 8665, v); }
+
+    static readonly name = _R(218, CompressedTexture3D);
+}

package/gen/classes/CompressedTextureLayered.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 { TextureLayered } from './TextureLayered.ts';
+
+/**
+ * Base class for {@link CompressedTexture2DArray} and {@link CompressedTexture3D}. Cannot be used directly, but contains all the functions necessary for accessing the derived resource types. See also {@link TextureLayered}.
+ */
+export class CompressedTextureLayered extends TextureLayered {
+
+    /**
+     * The path the texture should be loaded from.
+     */
+    get loadPath(): string { return _C(this, 5391) as string; }
+    set loadPath(v: string) { _C(this, 8665, v); }
+
+    static readonly name = _R(219, CompressedTextureLayered);
+}

package/gen/classes/ConcavePolygonShape2D.ts

@@ -0,0 +1,25 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape2D } from './Shape2D.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+
+/**
+ * A 2D polyline shape, intended for use in physics. Used internally in {@link CollisionPolygon2D} when it's in {@link CollisionPolygon2D.BUILD_SEGMENTS} mode.
+ * Being just a collection of interconnected line segments, {@link ConcavePolygonShape2D} is the most freely configurable single 2D shape. It can be used to form polygons of any nature, or even shapes that don't enclose an area. However, {@link ConcavePolygonShape2D} is *hollow* even if the interconnected line segments do enclose an area, which often makes it unsuitable for physics or detection.
+ * **Note:** When used for collision, {@link ConcavePolygonShape2D} is intended to work with static {@link CollisionShape2D} nodes like {@link StaticBody2D} and will likely not behave well for {@link CharacterBody2D}s or {@link RigidBody2D}s in a mode other than Static.
+ * **Warning:** Physics bodies that are small have a chance to clip through this shape when moving fast. This happens because on one frame, the physics body may be on the "outside" of the shape, and on the next frame it may be "inside" it. {@link ConcavePolygonShape2D} is hollow, so it won't detect a collision.
+ * **Performance:** Due to its complexity, {@link ConcavePolygonShape2D} is the slowest 2D collision shape to check collisions against. Its use should generally be limited to level geometry. If the polyline is closed, {@link CollisionPolygon2D}'s {@link CollisionPolygon2D.BUILD_SOLIDS} mode can be used, which decomposes the polygon into convex ones; see {@link ConvexPolygonShape2D}'s documentation for instructions.
+ */
+export class ConcavePolygonShape2D extends Shape2D {
+    constructor(name = 220) { super(name); }
+
+    /**
+     * The array of points that make up the {@link ConcavePolygonShape2D}'s line segments. The array (of length divisible by two) is naturally divided into pairs (one pair for each segment); each pair consists of the starting point of a segment and the endpoint of a segment.
+     */
+    get segments(): PackedVector2Array { return _C(this, 6318) as PackedVector2Array; }
+    set segments(v: PackedVector2Array) { _C(this, 12683, v); }
+
+    static readonly name = _R(220, ConcavePolygonShape2D);
+}

package/gen/classes/ConcavePolygonShape3D.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape3D } from './Shape3D.ts';
+import type { PackedVector3Array } from '../heap-types/index.ts';
+
+/**
+ * A 3D trimesh shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
+ * Being just a collection of interconnected triangles, {@link ConcavePolygonShape3D} is the most freely configurable single 3D shape. It can be used to form polyhedra of any nature, or even shapes that don't enclose a volume. However, {@link ConcavePolygonShape3D} is *hollow* even if the interconnected triangles do enclose a volume, which often makes it unsuitable for physics or detection.
+ * **Note:** When used for collision, {@link ConcavePolygonShape3D} is intended to work with static {@link CollisionShape3D} nodes like {@link StaticBody3D} and will likely not behave well for {@link CharacterBody3D}s or {@link RigidBody3D}s in a mode other than Static.
+ * **Warning:** Physics bodies that are small have a chance to clip through this shape when moving fast. This happens because on one frame, the physics body may be on the "outside" of the shape, and on the next frame it may be "inside" it. {@link ConcavePolygonShape3D} is hollow, so it won't detect a collision.
+ * **Performance:** Due to its complexity, {@link ConcavePolygonShape3D} is the slowest 3D collision shape to check collisions against. Its use should generally be limited to level geometry. For convex geometry, {@link ConvexPolygonShape3D} should be used. For dynamic physics bodies that need concave collision, several {@link ConvexPolygonShape3D}s can be used to represent its collision by using convex decomposition; see {@link ConvexPolygonShape3D}'s documentation for instructions.
+ */
+export class ConcavePolygonShape3D extends Shape3D {
+    constructor(name = 221) { super(name); }
+
+    get data(): PackedVector3Array { return _C(this, 4736) as PackedVector3Array; }
+    set data(v: PackedVector3Array) { _C(this, 11352, v); }
+
+    /**
+     * If set to `true`, collisions occur on both sides of the concave shape faces. Otherwise they occur only along the face normals.
+     */
+    get backfaceCollision(): boolean { return _C(this, 7787) as boolean; }
+    set backfaceCollision(v: boolean) { _C(this, 10623, v); }
+
+    static readonly name = _R(221, ConcavePolygonShape3D);
+}

package/gen/classes/ConeTwistJoint3D.ts

@@ -0,0 +1,84 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Joint3D } from './Joint3D.ts';
+
+/**
+ * A physics joint that connects two 3D physics bodies in a way that simulates a ball-and-socket joint. The twist axis is initiated as the X axis of the {@link ConeTwistJoint3D}. Once the physics bodies swing, the twist axis is calculated as the middle of the X axes of the joint in the local space of the two physics bodies. Useful for limbs like shoulders and hips, lamps hanging off a ceiling, etc.
+ */
+export class ConeTwistJoint3D extends Joint3D {
+    constructor(name = 222) { super(name); }
+
+    /**
+     * Swing is rotation from side to side, around the axis perpendicular to the twist axis.
+     * The swing span defines, how much rotation will not get corrected along the swing axis.
+     * Could be defined as looseness in the {@link ConeTwistJoint3D}.
+     * If below 0.05, this behavior is locked.
+     */
+    get swingSpan(): number { return _C(this, 5809, 0) as number; }
+    set swingSpan(v: number) { _C(this, 12248, 0, v); }
+
+    /**
+     * Twist is the rotation around the twist axis, this value defined how far the joint can twist.
+     * Twist is locked if below 0.05.
+     */
+    get twistSpan(): number { return _C(this, 5809, 1) as number; }
+    set twistSpan(v: number) { _C(this, 12248, 1, v); }
+
+    /**
+     * The speed with which the swing or twist will take place.
+     * The higher, the faster.
+     */
+    get bias(): number { return _C(this, 5809, 2) as number; }
+    set bias(v: number) { _C(this, 12248, 2, v); }
+
+    /**
+     * The ease with which the joint starts to twist. If it's too low, it takes more force to start twisting the joint.
+     */
+    get softness(): number { return _C(this, 5809, 3) as number; }
+    set softness(v: number) { _C(this, 12248, 3, v); }
+
+    /**
+     * Defines, how fast the swing- and twist-speed-difference on both sides gets synced.
+     */
+    get relaxation(): number { return _C(this, 5809, 4) as number; }
+    set relaxation(v: number) { _C(this, 12248, 4, v); }
+
+    static readonly name = _R(222, ConeTwistJoint3D);
+}
+
+export const Param = {
+    /**
+     * Swing is rotation from side to side, around the axis perpendicular to the twist axis.
+     * The swing span defines, how much rotation will not get corrected along the swing axis.
+     * Could be defined as looseness in the {@link ConeTwistJoint3D}.
+     * If below 0.05, this behavior is locked.
+     */
+    PARAM_SWING_SPAN: 0,
+    /**
+     * Twist is the rotation around the twist axis, this value defined how far the joint can twist.
+     * Twist is locked if below 0.05.
+     */
+    PARAM_TWIST_SPAN: 1,
+    /**
+     * The speed with which the swing or twist will take place.
+     * The higher, the faster.
+     */
+    PARAM_BIAS: 2,
+    /**
+     * The ease with which the joint starts to twist. If it's too low, it takes more force to start twisting the joint.
+     */
+    PARAM_SOFTNESS: 3,
+    /**
+     * Defines, how fast the swing- and twist-speed-difference on both sides gets synced.
+     */
+    PARAM_RELAXATION: 4,
+    /**
+     * Represents the size of the {@link Param} enum.
+     */
+    PARAM_MAX: 5,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+

package/gen/classes/ConfigFile.ts

@@ -0,0 +1,170 @@
+// 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 { Error } from '../global-enums.ts';
+import type { PackedByteArray, PackedStringArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * This helper class can be used to store {@link Variant} values on the filesystem using INI-style formatting. The stored values are identified by a section and a key:
+ *
+ * ```text
+ *
+ * [section]
+ * some_key=42
+ * string_example="Hello World3D!"
+ * a_vector=Vector3(1, 0, 2)
+ *
+ * ```
+ *
+ * The stored data can be saved to or parsed from a file, though ConfigFile objects can also be used directly without accessing the filesystem.
+ * The following example shows how to create a simple {@link ConfigFile} and save it on disc:
+ *
+ *
+ * ```gdscript
+ *
+ * # Create new ConfigFile object.
+ * var config = ConfigFile.new()
+ *
+ * # Store some values.
+ * config.set_value("Player1", "player_name", "Steve")
+ * config.set_value("Player1", "best_score", 10)
+ * config.set_value("Player2", "player_name", "V3geta")
+ * config.set_value("Player2", "best_score", 9001)
+ *
+ * # Save it to a file (overwrite if already exists).
+ * config.save("user://scores.cfg")
+ *
+ * ```
+ *
+ *
+ *
+ * This example shows how the above file could be loaded:
+ *
+ *
+ * ```gdscript
+ *
+ * var score_data = {}
+ * var config = ConfigFile.new()
+ *
+ * # Load data from a file.
+ * var err = config.load("user://scores.cfg")
+ *
+ * # If the file didn't load, ignore it.
+ * if err != OK:
+ * 	return
+ *
+ * # Iterate over all sections.
+ * for player in config.get_sections():
+ * 	# Fetch the data for each section.
+ * 	var player_name = config.get_value(player, "player_name")
+ * 	var player_score = config.get_value(player, "best_score")
+ * 	score_data[player_name] = player_score
+ *
+ * ```
+ *
+ *
+ *
+ * Any operation that mutates the ConfigFile such as {@link setValue}, {@link clear}, or {@link eraseSection}, only changes what is loaded in memory. If you want to write the change to a file, you have to save the changes with {@link save}, {@link saveEncrypted}, or {@link saveEncryptedPass}.
+ * Keep in mind that section and property names can't contain spaces. Anything after a space will be ignored on save and on load.
+ * ConfigFiles can also contain manually written comment lines starting with a semicolon (`;`). Those lines will be ignored when parsing the file. Note that comments will be lost when saving the ConfigFile. This can still be useful for dedicated server configuration files, which are typically never overwritten without explicit user action.
+ * **Note:** The file extension given to a ConfigFile does not have any impact on its formatting or behavior. By convention, the `.cfg` extension is used here, but any other extension such as `.ini` is also valid. Since neither `.cfg` nor `.ini` are standardized, Godot's ConfigFile formatting may differ from files written by other programs.
+ */
+export class ConfigFile extends RefCounted {
+    constructor(name = 223) { super(name); }
+
+    /**
+     * Assigns a value to the specified key of the specified section. If either the section or the key do not exist, they are created. Passing a `null` value deletes the specified key if it exists, and deletes the section if it ends up empty once the key has been removed.
+     */
+    setValue(section: string, key: string, value: Variant): void { _C(this, 13268, section, key, value); }
+
+    /**
+     * Returns the current value for the specified section and key. If either the section or the key do not exist, the method returns the fallback `default` value. If `default` is not specified or set to `null`, an error is also raised.
+     */
+    getValue(section: string, key: string, _default?: Variant /* = null */): Variant { return _C(this, 7018, section, key, _default) as Variant; }
+
+    /**
+     * Returns `true` if the specified section exists.
+     */
+    hasSection(section: string): boolean { return _C(this, 7441, section) as boolean; }
+
+    /**
+     * Returns `true` if the specified section-key pair exists.
+     */
+    hasSectionKey(section: string, key: string): boolean { return _C(this, 7442, section, key) as boolean; }
+
+    /**
+     * Returns an array of all defined section identifiers.
+     */
+    getSections(): PackedStringArray { return _C(this, 6316) as PackedStringArray; }
+
+    /**
+     * Returns an array of all defined key identifiers in the specified section. Raises an error and returns an empty array if the section does not exist.
+     */
+    getSectionKeys(section: string): PackedStringArray { return _C(this, 6311, section) as PackedStringArray; }
+
+    /**
+     * Deletes the specified section along with all the key-value pairs inside. Raises an error if the section does not exist.
+     */
+    eraseSection(section: string): void { _C(this, 3163, section); }
+
+    /**
+     * Deletes the specified key in a section. Raises an error if either the section or the key do not exist.
+     */
+    eraseSectionKey(section: string, key: string): void { _C(this, 3164, section, key); }
+
+    /**
+     * Loads the config file specified as a parameter. The file's contents are parsed and loaded in the {@link ConfigFile} object which the method was called on.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    load(path: string): Error { return _C(this, 8665, path) as Error; }
+
+    /**
+     * Parses the passed string as the contents of a config file. The string is parsed and loaded in the ConfigFile object which the method was called on.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    parse(data: string): Error { return _C(this, 9277, data) as Error; }
+
+    /**
+     * Saves the contents of the {@link ConfigFile} object to the file specified as a parameter. The output file uses an INI-style structure.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    save(path: string): Error { return _C(this, 10195, path) as Error; }
+
+    /**
+     * Obtain the text version of this config file (the same text that would be written to a file).
+     */
+    encodeToText(): string { return _C(this, 3086) as string; }
+
+    /**
+     * Loads the encrypted config file specified as a parameter, using the provided `key` to decrypt it. The file's contents are parsed and loaded in the {@link ConfigFile} object which the method was called on.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    loadEncrypted(path: string, key: PackedByteArray): Error { return _C(this, 8671, path, key) as Error; }
+
+    /**
+     * Loads the encrypted config file specified as a parameter, using the provided `password` to decrypt it. The file's contents are parsed and loaded in the {@link ConfigFile} object which the method was called on.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    loadEncryptedPass(path: string, password: string): Error { return _C(this, 8672, path, password) as Error; }
+
+    /**
+     * Saves the contents of the {@link ConfigFile} object to the AES-256 encrypted file specified as a parameter, using the provided `key` to encrypt it. The output file uses an INI-style structure.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    saveEncrypted(path: string, key: PackedByteArray): Error { return _C(this, 10199, path, key) as Error; }
+
+    /**
+     * Saves the contents of the {@link ConfigFile} object to the AES-256 encrypted file specified as a parameter, using the provided `password` to encrypt it. The output file uses an INI-style structure.
+     * Returns {@link OK} on success, or one of the other {@link Error} values if the operation failed.
+     */
+    saveEncryptedPass(path: string, password: string): Error { return _C(this, 10200, path, password) as Error; }
+
+    /**
+     * Removes the entire contents of the config.
+     */
+    clear(): void { _C(this, 2232); }
+
+    static readonly name = _R(223, ConfigFile);
+}

package/gen/classes/ConfirmationDialog.ts

@@ -0,0 +1,39 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { AcceptDialog } from './AcceptDialog.ts';
+import type { Button } from './Button.ts';
+
+/**
+ * A dialog used for confirmation of actions. This window is similar to {@link AcceptDialog}, but pressing its Cancel button can have a different outcome from pressing the OK button. The order of the two buttons varies depending on the host OS.
+ * To get cancel action, you can use:
+ *
+ *
+ * ```gdscript
+ *
+ * get_cancel_button().pressed.connect(_on_canceled)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** {@link AcceptDialog} is invisible by default. To make it visible, call one of the `popup_*` methods from {@link Window} on the node, such as {@link Window.popupCenteredClamped}.
+ */
+export class ConfirmationDialog extends AcceptDialog {
+    constructor(name = 224) { super(name); }
+
+    /**
+     * Returns the cancel button.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getCancelButton(): Button { return _C(this, 4069) as Button; }
+
+    /**
+     * The text displayed by the cancel button (see {@link getCancelButton}).
+     */
+    get cancelButtonText(): string { return _C(this, 4070) as string; }
+    set cancelButtonText(v: string) { _C(this, 10791, v); }
+
+    static readonly name = _R(224, ConfirmationDialog);
+}

package/gen/classes/Container.ts

@@ -0,0 +1,54 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { PackedInt32Array, Signal } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+
+/**
+ * Base class for all GUI containers. A {@link Container} automatically arranges its child controls in a certain way. This class can be inherited to make custom container types.
+ */
+export class Container extends Control {
+    constructor(name = 225) { super(name); }
+
+    /**
+     * Queue resort of the contained children. This is called automatically anyway, but can be called upon request.
+     */
+    queueSort(): void { _C(this, 9697); }
+
+    /**
+     * Fit a child control in a given rect. This is mainly a helper for creating custom container classes.
+     */
+    fitChildInRect(child: Control, rect: Rect2): void { _C(this, 3311, child, rect); }
+
+    /**
+     * If `true`, this container is marked as a region for accessibility. Use {@link Control.accessibilityName} to give the region a descriptive name. Screen readers can navigate between regions using landmark navigation.
+     */
+    get accessibilityRegion(): boolean { return _C(this, 7735) as boolean; }
+    set accessibilityRegion(v: boolean) { _C(this, 10412, v); }
+
+    /**
+     * Notification just before children are going to be sorted, in case there's something to process beforehand.
+     */
+    static readonly NOTIFICATION_PRE_SORT_CHILDREN = 50;
+
+    /**
+     * Notification for when sorting the children, it must be obeyed immediately.
+     */
+    static readonly NOTIFICATION_SORT_CHILDREN = 51;
+
+    /**
+     * Emitted when children are going to be sorted.
+     */
+    get preSortChildren(): Signal<() => void> { return _G(this, 9526) as Signal<() => void>; }
+    set preSortChildren(v: (() => void) | null) { _G(this, 9526, v); }
+
+    /**
+     * Emitted when sorting the children is needed.
+     */
+    get sortChildren(): Signal<() => void> { return _G(this, 13724) as Signal<() => void>; }
+    set sortChildren(v: (() => void) | null) { _G(this, 13724, v); }
+
+    static readonly name = _R(225, Container);
+}