@ringozz/godot 0.1.0

package/gen/classes/Object.ts

@@ -0,0 +1,583 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import type { Error } from '../global-enums.ts';
+import type { Callable, GodotArray, GodotDictionary, NodePath, Signal, StringName, Variant } from '../heap-types/index.ts';
+
+/**
+ * An advanced {@link Variant} type. All classes in the engine inherit from Object. Each class may define new properties, methods or signals, which are available to all inheriting classes. For example, a {@link Sprite2D} instance is able to call {@link Node.addChild} because it inherits from {@link Node}.
+ * You can create new instances, using `Object.new()` in GDScript, or `new GodotObject` in C#.
+ * To delete an Object instance, call {@link free}. This is necessary for most classes inheriting Object, because they do not manage memory on their own, and will otherwise cause memory leaks when no longer in use. There are a few classes that perform memory management. For example, {@link RefCounted} (and by extension {@link Resource}) deletes itself when no longer referenced, and {@link Node} deletes its children when freed.
+ * Objects can have a {@link Script} attached to them. Once the {@link Script} is instantiated, it effectively acts as an extension to the base class, allowing it to define and inherit new properties, methods and signals.
+ * Inside a {@link Script}, {@link _getPropertyList} may be overridden to customize properties in several ways. This allows them to be available to the editor, display as lists of options, sub-divide into groups, save on disk, etc. Scripting languages offer easier ways to customize properties, such as with the `@export` annotation.
+ * Godot is very dynamic. An object's script, and therefore its properties, methods and signals, can be changed at run-time. Because of this, there can be occasions where, for example, a property required by a method may not exist. To prevent run-time errors, see methods such as {@link set}, {@link get}, {@link call}, {@link hasMethod}, {@link hasSignal}, etc. Note that these methods are **much** slower than direct references.
+ * In GDScript, you can also check if a given property, method, or signal name exists in an object with the `in` operator:
+ *
+ * ```text
+ *
+ * var node = Node.new()
+ * print("name" in node)         # Prints true
+ * print("get_parent" in node)   # Prints true
+ * print("tree_entered" in node) # Prints true
+ * print("unknown" in node)      # Prints false
+ *
+ * ```
+ *
+ * Notifications are {@link int} constants commonly sent and received by objects. For example, on every rendered frame, the {@link SceneTree} notifies nodes inside the tree with a {@link Node.NOTIFICATION_PROCESS}. The nodes receive it and may call {@link Node.Process} to update. To make use of notifications, see {@link notification} and {@link _notification}.
+ * Lastly, every object can also contain metadata (data about data). {@link setMeta} can be useful to store information that the object itself does not depend on. To keep your code clean, making excessive use of metadata is discouraged.
+ * **Note:** Unlike references to a {@link RefCounted}, references to an object stored in a variable can become invalid without being set to `null`. To check if an object has been deleted, do *not* compare it against `null`. Instead, use {@link isInstanceValid}. It's also recommended to inherit from {@link RefCounted} for classes storing data instead of {@link Object}.
+ * **Note:** The `script` is not exposed like most properties. To set or get an object's {@link Script} in code, use {@link setScript} and {@link getScript}, respectively.
+ * **Note:** In a boolean context, an {@link Object} will evaluate to `false` if it is equal to `null` or it has been freed. Otherwise, an {@link Object} will always evaluate to `true`. See also {@link isInstanceValid}.
+ */
+export class Object extends GodotVar {
+    constructor(name = 24) { super(name); }
+
+    /**
+     * Returns the object's built-in class name, as a {@link String}. See also {@link isClass}.
+     * **Note:** This method ignores `class_name` declarations. If this object's script has defined a `class_name`, the base, built-in class name is returned instead.
+     */
+    getClass(): string { return _C(this, 4150) as string; }
+
+    /**
+     * Returns `true` if the object inherits from the given `class`. See also {@link getClass}.
+     *
+     *
+     * ```gdscript
+     *
+     * var sprite2d = Sprite2D.new()
+     * sprite2d.is_class("Sprite2D") # Returns true
+     * sprite2d.is_class("Node")     # Returns true
+     * sprite2d.is_class("Node3D")   # Returns false
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** This method ignores `class_name` declarations in the object's script.
+     */
+    isClass(_class: StringName): boolean { return _C(this, 7829, _class) as boolean; }
+
+    /**
+     * Assigns `value` to the given `property`. If the property does not exist or the given `value`'s type doesn't match, nothing happens.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node2D.new()
+     * node.set("global_scale", Vector2(8, 2.5))
+     * print(node.global_scale) # Prints (8.0, 2.5)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    set(property: StringName, value: Variant): void { _C(this, 10392, property, value); }
+
+    /**
+     * Returns the {@link Variant} value of the given `property`. If the `property` does not exist, this method returns `null`.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node2D.new()
+     * node.rotation = 1.5
+     * var a = node.get("rotation") # a is 1.5
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    get(property: StringName): Variant | null { return _C(this, 3652, property) as Variant | null; }
+
+    /**
+     * Assigns a new `value` to the property identified by the `propertyPath`. The path should be a {@link NodePath} relative to this object, and can use the colon character (`:`) to access nested properties.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node2D.new()
+     * node.set_indexed("position", Vector2(42, 0))
+     * node.set_indexed("position:y", -10)
+     * print(node.position) # Prints (42.0, -10.0)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `propertyPath` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    setIndexed(propertyPath: NodePath, value: Variant): void { _C(this, 11691, propertyPath, value); }
+
+    /**
+     * Gets the object's property indexed by the given `propertyPath`. The path should be a {@link NodePath} relative to the current object and can use the colon character (`:`) to access nested properties.
+     * **Examples:** `"position:x"` or `"material:next_pass:blend_mode"`.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node2D.new()
+     * node.position = Vector2(5, -10)
+     * var a = node.get_indexed("position")   # a is Vector2(5, -10)
+     * var b = node.get_indexed("position:y") # b is -10
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `propertyPath` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+     * **Note:** This method does not support actual paths to nodes in the {@link SceneTree}, only sub-property paths. In the context of nodes, use {@link Node.getNodeAndResource} instead.
+     */
+    getIndexed(propertyPath: NodePath): Variant { return _C(this, 5090, propertyPath) as Variant; }
+
+    /**
+     * Returns the object's property list as an {@link Array} of dictionaries. Each {@link Dictionary} contains the following entries:
+     * - `name` is the property's name, as a {@link String};
+     * - `class_name` is an empty {@link StringName}, unless the property is {@link TYPE_OBJECT} and it inherits from a class;
+     * - `type` is the property's type, as an {@link int} (see {@link Variant.Type});
+     * - `hint` is *how* the property is meant to be edited (see {@link PropertyHint});
+     * - `hint_string` depends on the hint (see {@link PropertyHint});
+     * - `usage` is a combination of {@link PropertyUsageFlags}.
+     * **Note:** In GDScript, all class members are treated as properties. In C# and GDExtension, it may be necessary to explicitly mark class members as Godot properties using decorators or attributes.
+     */
+    getPropertyList(): GodotArray<GodotDictionary> { return _C(this, 6051) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns this object's methods and their signatures as an {@link Array} of dictionaries. Each {@link Dictionary} contains the following entries:
+     * - `name` is the name of the method, as a {@link String};
+     * - `args` is an {@link Array} of dictionaries representing the arguments;
+     * - `default_args` is the default arguments as an {@link Array} of variants;
+     * - `flags` is a combination of {@link MethodFlags};
+     * - `id` is the method's internal identifier {@link int};
+     * - `return` is the returned value, as a {@link Dictionary};
+     * **Note:** The dictionaries of `args` and `return` are formatted identically to the results of {@link getPropertyList}, although not all entries are used.
+     */
+    getMethodList(): GodotArray<GodotDictionary> { return _C(this, 5530) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns `true` if the given `property` has a custom default value. Use {@link propertyGetRevert} to get the `property`'s default value.
+     * **Note:** This method is used by the Inspector dock to display a revert icon. The object must implement {@link _propertyCanRevert} to customize the default value. If {@link _propertyCanRevert} is not implemented, this method returns `false`.
+     */
+    propertyCanRevert(property: StringName): boolean { return _C(this, 9604, property) as boolean; }
+
+    /**
+     * Returns the custom default value of the given `property`. Use {@link propertyCanRevert} to check if the `property` has a custom default value.
+     * **Note:** This method is used by the Inspector dock to display a revert icon. The object must implement {@link _propertyGetRevert} to customize the default value. If {@link _propertyGetRevert} is not implemented, this method returns `null`.
+     */
+    propertyGetRevert(property: StringName): Variant | null { return _C(this, 9607, property) as Variant | null; }
+
+    /**
+     * Sends the given `what` notification to all classes inherited by the object, triggering calls to {@link _notification}, starting from the highest ancestor (the {@link Object} class) and going down to the object's script.
+     * If `reversed` is `true`, the call order is reversed.
+     *
+     *
+     * ```gdscript
+     *
+     * var player = Node2D.new()
+     * player.set_script(load("res://player.gd"))
+     *
+     * player.notification(NOTIFICATION_ENTER_TREE)
+     * # The call order is Object -> Node -> Node2D -> player.gd.
+     *
+     * player.notification(NOTIFICATION_ENTER_TREE, true)
+     * # The call order is player.gd -> Node2D -> Node -> Object.
+     *
+     * ```
+     */
+    notification(what: number, reversed?: boolean /* = false */): void { _C(this, 9105, what, reversed); }
+
+    /**
+     * Returns a {@link String} representing the object. Defaults to `"<ClassName#RID>"`. Override {@link _toString} to customize the string representation of the object.
+     */
+    toString(): string { return _C(this, 14312) as string; }
+
+    /**
+     * Returns the object's unique instance ID. This ID can be saved in {@link EncodedObjectAsID}, and can be used to retrieve this object instance with {@link instanceFromId}.
+     * **Note:** This ID is only useful during the current session. It won't correspond to a similar object if the ID is sent over a network, or loaded from a file at a later time.
+     */
+    getInstanceId(): number { return _C(this, 5133) as number; }
+
+    /**
+     * Attaches `script` to the object, and instantiates it. As a result, the script's {@link _init} is called. A {@link Script} is used to extend the object's functionality.
+     * If a script already exists, its instance is detached, and its property values and state are lost. Built-in property values are still kept.
+     */
+    setScript(script: Variant): void { _C(this, 12631, script); }
+
+    /**
+     * Returns the object's {@link Script} instance, or `null` if no script is attached.
+     */
+    getScript(): Variant | null { return _C(this, 6267) as Variant | null; }
+
+    /**
+     * Adds or changes the entry `name` inside the object's metadata. The metadata `value` can be any {@link Variant}, although some types cannot be serialized correctly.
+     * If `value` is `null`, the entry is removed. This is the equivalent of using {@link removeMeta}. See also {@link hasMeta} and {@link getMeta}.
+     * **Note:** A metadata's name must be a valid identifier as per {@link StringName.isValidIdentifier} method.
+     * **Note:** Metadata that has a name starting with an underscore (`_`) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
+     */
+    setMeta(name: StringName, value: Variant): void { _C(this, 12032, name, value); }
+
+    /**
+     * Removes the given entry `name` from the object's metadata. See also {@link hasMeta}, {@link getMeta} and {@link setMeta}.
+     * **Note:** A metadata's name must be a valid identifier as per {@link StringName.isValidIdentifier} method.
+     * **Note:** Metadata that has a name starting with an underscore (`_`) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
+     */
+    removeMeta(name: StringName): void { _C(this, 9934, name); }
+
+    /**
+     * Returns the object's metadata value for the given entry `name`. If the entry does not exist, returns `default`. If `default` is `null`, an error is also generated.
+     * **Note:** A metadata's name must be a valid identifier as per {@link StringName.isValidIdentifier} method.
+     * **Note:** Metadata that has a name starting with an underscore (`_`) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
+     */
+    getMeta(name: StringName, _default?: Variant /* = null */): Variant { return _C(this, 5521, name, _default) as Variant; }
+
+    /**
+     * Returns `true` if a metadata entry is found with the given `name`. See also {@link getMeta}, {@link setMeta} and {@link removeMeta}.
+     * **Note:** A metadata's name must be a valid identifier as per {@link StringName.isValidIdentifier} method.
+     * **Note:** Metadata that has a name starting with an underscore (`_`) is considered editor-only. Editor-only metadata is not displayed in the Inspector and should not be edited, although it can still be found by this method.
+     */
+    hasMeta(name: StringName): boolean { return _C(this, 7416, name) as boolean; }
+
+    /**
+     * Returns the object's metadata entry names as an {@link Array} of {@link StringName}s.
+     */
+    getMetaList(): GodotArray<StringName> { return _C(this, 5522) as GodotArray<StringName>; }
+
+    /**
+     * Adds a user-defined signal named `signal`. Optional arguments for the signal can be added as an {@link Array} of dictionaries, each defining a `name` {@link String} and a `type` {@link int} (see {@link Variant.Type}). See also {@link hasUserSignal} and {@link removeUserSignal}.
+     *
+     *
+     * ```gdscript
+     *
+     * add_user_signal("hurt", [
+     * 	{ "name": "damage", "type": TYPE_INT },
+     * 	{ "name": "source", "type": TYPE_OBJECT }
+     * ])
+     *
+     * ```
+     */
+    addUserSignal(signal: string, _arguments?: GodotArray /* = [] */): void { _C(this, 1329, signal, _arguments); }
+
+    /**
+     * Returns `true` if the given user-defined `signal` name exists. Only signals added with {@link addUserSignal} are included. See also {@link removeUserSignal}.
+     */
+    hasUserSignal(signal: StringName): boolean { return _C(this, 7480, signal) as boolean; }
+
+    /**
+     * Removes the given user signal `signal` from the object. See also {@link addUserSignal} and {@link hasUserSignal}.
+     */
+    removeUserSignal(signal: StringName): void { _C(this, 9985, signal); }
+
+    /**
+     * Emits the given `signal` by name. The signal must exist, so it should be a built-in signal of this class or one of its inherited classes, or a user-defined signal (see {@link addUserSignal}). This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
+     * Returns {@link ERR_UNAVAILABLE} if `signal` does not exist or the parameters are invalid.
+     *
+     *
+     * ```gdscript
+     *
+     * emit_signal("hit", "sword", 100)
+     * emit_signal("game_over")
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `signal` must be in snake_case when referring to built-in Godot signals. Prefer using the names exposed in the `SignalName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    emitSignal(signal: StringName, ...args: any[]): Error { return _C(this, 3048, signal, ...args) as Error; }
+
+    /**
+     * Calls the `method` on the object and returns the result. This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node3D.new()
+     * node.call("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    call(method: StringName, ...args: any[]): Variant { return _C(this, 1969, method, ...args) as Variant; }
+
+    /**
+     * Calls the `method` on the object during idle time. Always returns `null`, **not** the method's result.
+     * Idle time happens mainly at the end of process and physics frames. In it, deferred calls will be run until there are none left, which means you can defer calls from other deferred calls and they'll still be run in the current idle time cycle. This means you should not call a method deferred from itself (or from a method called by it), as this causes infinite recursion the same way as if you had called the method directly.
+     * This method supports a variable number of arguments, so parameters can be passed as a comma separated list.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node3D.new()
+     * node.call_deferred("rotate", Vector3(1.0, 0.0, 0.0), 1.571)
+     *
+     * ```
+     *
+     *
+     *
+     * For methods that are deferred from the same thread, the order of execution at idle time is identical to the order in which {@link code skip-lint}call_deferred was called.
+     * See also {@link Callable.callDeferred}.
+     * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+     * **Note:** If you're looking to delay the function call by a frame, refer to the {@link SceneTree.process_frame} and {@link SceneTree.physics_frame} signals.
+     *
+     * ```text
+     *
+     * var node = Node3D.new()
+     * # Make a Callable and bind the arguments to the node's rotate() call.
+     * var callable = node.rotate.bind(Vector3(1.0, 0.0, 0.0), 1.571)
+     * # Connect the callable to the process_frame signal, so it gets called in the next process frame.
+     * # CONNECT_ONE_SHOT makes sure it only gets called once instead of every frame.
+     * get_tree().process_frame.connect(callable, CONNECT_ONE_SHOT)
+     *
+     * ```
+     */
+    callDeferred(method: StringName, ...args: any[]): Variant | null { return _C(this, 1970, method, ...args) as Variant | null; }
+
+    /**
+     * Assigns `value` to the given `property`, at the end of the current frame. This is equivalent to calling {@link set} through {@link callDeferred}.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node2D.new()
+     * add_child(node)
+     *
+     * node.rotation = 1.5
+     * node.set_deferred("rotation", 3.0)
+     * print(node.rotation) # Prints 1.5
+     *
+     * await get_tree().process_frame
+     * print(node.rotation) # Prints 3.0
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    setDeferred(property: StringName, value: Variant): void { _C(this, 11071, property, value); }
+
+    /**
+     * Calls the `method` on the object and returns the result. Unlike {@link call}, this method expects all parameters to be contained inside `argArray`.
+     *
+     *
+     * ```gdscript
+     *
+     * var node = Node3D.new()
+     * node.callv("rotate", [Vector3(1.0, 0.0, 0.0), 1.571])
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    callv(method: StringName, argArray: GodotArray): Variant { return _C(this, 1980, method, argArray) as Variant; }
+
+    /**
+     * Returns `true` if the given `method` name exists in the object.
+     * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    hasMethod(method: StringName): boolean { return _C(this, 7417, method) as boolean; }
+
+    /**
+     * Returns the number of arguments of the given `method` by name.
+     * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    getMethodArgumentCount(method: StringName): number { return _C(this, 5528, method) as number; }
+
+    /**
+     * Returns `true` if the given `signal` name exists in the object.
+     * **Note:** In C#, `signal` must be in snake_case when referring to built-in Godot signals. Prefer using the names exposed in the `SignalName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    hasSignal(signal: StringName): boolean { return _C(this, 7447, signal) as boolean; }
+
+    /**
+     * Returns the list of existing signals as an {@link Array} of dictionaries.
+     * **Note:** Due to the implementation, each {@link Dictionary} is formatted very similarly to the returned values of {@link getMethodList}.
+     */
+    getSignalList(): GodotArray<GodotDictionary> { return _C(this, 6391) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns an {@link Array} of connections for the given `signal` name. Each connection is represented as a {@link Dictionary} that contains three entries:
+     * - {@link code skip-lint}signal[/code] is a reference to the {@link Signal};
+     * - `callable` is a reference to the connected {@link Callable};
+     * - `flags` is a combination of {@link ConnectFlags}.
+     */
+    getSignalConnectionList(signal: StringName): GodotArray<GodotDictionary> { return _C(this, 6390, signal) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns an {@link Array} of signal connections received by this object. Each connection is represented as a {@link Dictionary} that contains three entries:
+     * - `signal` is a reference to the {@link Signal};
+     * - `callable` is a reference to the {@link Callable};
+     * - `flags` is a combination of {@link ConnectFlags}.
+     */
+    getIncomingConnections(): GodotArray<GodotDictionary> { return _C(this, 5082) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Connects a `signal` by name to a `callable`. Optional `flags` can be also added to configure the connection's behavior (see {@link ConnectFlags} constants).
+     * A signal can only be connected once to the same {@link Callable}. If the signal is already connected, this method returns {@link ERR_INVALID_PARAMETER} and generates an error, unless the signal is connected with {@link CONNECT_REFERENCE_COUNTED}. To prevent this, use {@link isConnected} first to check for existing connections.
+     * **Note:** If the `callable`'s object is freed, the connection will be lost.
+     * **Note:** In GDScript, it is generally recommended to connect signals with {@link Signal.connect} instead.
+     * **Note:** This method, and all other signal-related methods, are thread-safe.
+     */
+    connect(signal: StringName, callable: Callable, flags?: number /* = 0,  uint32 */): Error { return _C(this, 2433, signal, callable, flags) as Error; }
+
+    /**
+     * Disconnects a `signal` by name from a given `callable`. If the connection does not exist, generates an error. Use {@link isConnected} to make sure that the connection exists.
+     */
+    disconnect(signal: StringName, callable: Callable): void { _C(this, 2821, signal, callable); }
+
+    /**
+     * Returns `true` if a connection exists between the given `signal` name and `callable`.
+     * **Note:** In C#, `signal` must be in snake_case when referring to built-in Godot signals. Prefer using the names exposed in the `SignalName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    isConnected(signal: StringName, callable: Callable): boolean { return _C(this, 7856, signal, callable) as boolean; }
+
+    /**
+     * Returns `true` if any connection exists on the given `signal` name.
+     * **Note:** In C#, `signal` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `SignalName` class to avoid allocating a new {@link StringName} on each call.
+     */
+    hasConnections(signal: StringName): boolean { return _C(this, 7379, signal) as boolean; }
+
+    /**
+     * If set to `true`, the object becomes unable to emit signals. As such, {@link emitSignal} and signal connections will not work, until it is set to `false`.
+     */
+    setBlockSignals(enable: boolean): void { _C(this, 10689, enable); }
+
+    /**
+     * Returns `true` if the object is blocking its signals from being emitted. See {@link setBlockSignals}.
+     */
+    isBlockingSignals(): boolean { return _C(this, 7798) as boolean; }
+
+    /**
+     * Emits the {@link property_list_changed} signal. This is mainly used to refresh the editor, so that the Inspector and editor plugins are properly updated.
+     */
+    notifyPropertyListChanged(): void { _C(this, 9111); }
+
+    /**
+     * If set to `true`, allows the object to translate messages with {@link tr} and {@link trN}. Enabled by default. See also {@link canTranslateMessages}.
+     */
+    setMessageTranslation(enable: boolean): void { _C(this, 12031, enable); }
+
+    /**
+     * Returns `true` if the object is allowed to translate messages with {@link tr} and {@link trN}. See also {@link setMessageTranslation}.
+     */
+    canTranslateMessages(): boolean { return _C(this, 2018) as boolean; }
+
+    /**
+     * Translates a `message`, using the translation catalogs configured in the Project Settings. Further `context` can be specified to help with the translation. Note that most {@link Control} nodes automatically translate their strings, so this method is mostly useful for formatted strings or custom drawn text.
+     * If {@link canTranslateMessages} is `false`, or no translation is available, this method returns the `message` without changes. See {@link setMessageTranslation}.
+     * For detailed examples, see [Internationalizing games]($DOCS_URL/tutorials/i18n/internationalizing_games.html).
+     * **Note:** This method can't be used without an {@link Object} instance, as it requires the {@link canTranslateMessages} method. To translate strings in a static context, use {@link TranslationServer.translate}.
+     */
+    tr(message: StringName, context?: StringName /* = &"" */): string { return _C(this, 14343, message, context) as string; }
+
+    /**
+     * Translates a `message` or `pluralMessage`, using the translation catalogs configured in the Project Settings. Further `context` can be specified to help with the translation.
+     * If {@link canTranslateMessages} is `false`, or no translation is available, this method returns `message` or `pluralMessage`, without changes. See {@link setMessageTranslation}.
+     * The `n` is the number, or amount, of the message's subject. It is used by the translation system to fetch the correct plural form for the current language.
+     * For detailed examples, see [Localization using gettext]($DOCS_URL/tutorials/i18n/localization_using_gettext.html).
+     * **Note:** Negative and {@link float} numbers may not properly apply to some countable subjects. It's recommended to handle these cases with {@link tr}.
+     * **Note:** This method can't be used without an {@link Object} instance, as it requires the {@link canTranslateMessages} method. To translate strings in a static context, use {@link TranslationServer.translatePlural}.
+     */
+    trN(message: StringName, pluralMessage: StringName, n: number, context?: StringName /* = &"" */): string { return _C(this, 14344, message, pluralMessage, n, context) as string; }
+
+    /**
+     * Returns the name of the translation domain used by {@link tr} and {@link trN}. See also {@link TranslationServer}.
+     */
+    getTranslationDomain(): StringName { return _C(this, 6893) as StringName; }
+
+    /**
+     * Sets the name of the translation domain used by {@link tr} and {@link trN}. See also {@link TranslationServer}.
+     */
+    setTranslationDomain(domain: StringName): void { _C(this, 13143, domain); }
+
+    /**
+     * Returns `true` if the methods {@link Node.queueFree} or {@link SceneTree.queueDelete} was called for the object.
+     * **Note:** This method does not return `true` on children of the node that {@link Node.queueFree} has been called on, even though they will be freed together with the parent.
+     */
+    isQueuedForDeletion(): boolean { return _C(this, 8223) as boolean; }
+
+    /**
+     * If this method is called during {@link NOTIFICATION_PREDELETE}, this object will reject being freed and will remain allocated. This is mostly an internal function used for error handling to avoid the user from freeing objects when they are not intended to.
+     */
+    cancelFree(): void { _C(this, 2021); }
+
+    /**
+     * Notification received when the object is initialized, before its script is attached. Used internally.
+     */
+    static readonly NOTIFICATION_POSTINITIALIZE = 0;
+
+    /**
+     * Notification received when the object is about to be deleted. Can be used like destructors in object-oriented programming languages.
+     * This notification is sent in reversed order.
+     */
+    static readonly NOTIFICATION_PREDELETE = 1;
+
+    /**
+     * Notification received when the object finishes hot reloading. This notification is only sent for extensions classes and derived.
+     */
+    static readonly NOTIFICATION_EXTENSION_RELOADED = 2;
+
+    /**
+     * Emitted when the object's script is changed.
+     * **Note:** When this signal is emitted, the new script is not initialized yet. If you need to access the new script, defer connections to this signal with {@link CONNECT_DEFERRED}.
+     */
+    get scriptChanged(): Signal<() => void> { return _G(this, 10270) as Signal<() => void>; }
+    set scriptChanged(v: (() => void) | null) { _G(this, 10270, v); }
+
+    /**
+     * Emitted when {@link notifyPropertyListChanged} is called.
+     */
+    get propertyListChanged(): Signal<() => void> { return _G(this, 9611) as Signal<() => void>; }
+    set propertyListChanged(v: (() => void) | null) { _G(this, 9611, v); }
+
+    static readonly name = _R(24, Object);
+}
+
+export const ConnectFlags = {
+    /**
+     * Deferred connections trigger their {@link Callable}s on idle time (at the end of the frame), rather than instantly.
+     */
+    CONNECT_DEFERRED: 1,
+    /**
+     * Persisting connections are stored when the object is serialized (such as when using {@link PackedScene.pack}). In the editor, connections created through the Signals dock are always persisting.
+     * **Note:** Connections to lambda functions (that is, when the function code is embedded in the {@link connect} call) cannot be made persistent.
+     */
+    CONNECT_PERSIST: 2,
+    /**
+     * One-shot connections disconnect themselves after emission.
+     */
+    CONNECT_ONE_SHOT: 4,
+    /**
+     * Reference-counted connections can be assigned to the same {@link Callable} multiple times. Each disconnection decreases the internal counter. The signal fully disconnects only when the counter reaches 0.
+     */
+    CONNECT_REFERENCE_COUNTED: 8,
+    /**
+     * On signal emission, the source object is automatically appended after the original arguments of the signal, regardless of the connected {@link Callable}'s unbinds which affect only the original arguments of the signal (see {@link Callable.unbind}, {@link Callable.getUnboundArgumentsCount}).
+     *
+     * ```text
+     *
+     * extends Object
+     *
+     * signal test_signal
+     *
+     * func test():
+     * 	print(self) # Prints e.g. <Object#35332818393>
+     * 	test_signal.connect(prints.unbind(1), CONNECT_APPEND_SOURCE_OBJECT)
+     * 	test_signal.emit("emit_arg_1", "emit_arg_2") # Prints emit_arg_1 <Object#35332818393>
+     *
+     * ```
+     */
+    CONNECT_APPEND_SOURCE_OBJECT: 16,
+} as const;
+
+export type ConnectFlags = (typeof ConnectFlags)[keyof typeof ConnectFlags];
+

package/gen/classes/Occluder3D.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 { Resource } from './Resource.ts';
+import type { PackedInt32Array, PackedVector3Array } from '../heap-types/index.ts';
+
+/**
+ * {@link Occluder3D} stores an occluder shape that can be used by the engine's occlusion culling system.
+ * See {@link OccluderInstance3D}'s documentation for instructions on setting up occlusion culling.
+ */
+export class Occluder3D extends Resource {
+
+    /**
+     * Returns the occluder shape's vertex positions.
+     */
+    getVertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
+
+    /**
+     * Returns the occluder shape's vertex indices.
+     */
+    getIndices(): PackedInt32Array { return _C(this, 5091) as PackedInt32Array; }
+
+    static readonly name = _R(465, Occluder3D);
+}