@ringozz/godot 0.1.0

package/gen/classes/JSON.ts

@@ -0,0 +1,163 @@
+// 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 { Error } from '../global-enums.ts';
+import type { Variant } from '../heap-types/index.ts';
+
+/**
+ * The {@link JSON} class enables all data types to be converted to and from a JSON string. This is useful for serializing data, e.g. to save to a file or send over the network.
+ * {@link stringify} is used to convert any data type into a JSON string.
+ * {@link parse} is used to convert any existing JSON data into a {@link Variant} that can be used within Godot. If successfully parsed, use {@link data} to retrieve the {@link Variant}, and use {@link typeof} to check if the Variant's type is what you expect. JSON Objects are converted into a {@link Dictionary}, but JSON data can be used to store {@link Array}s, numbers, {@link String}s and even just a boolean.
+ *
+ * ```text
+ *
+ * var data_to_send = ["a", "b", "c"]
+ * var json_string = JSON.stringify(data_to_send)
+ * # Save data
+ * # ...
+ * # Retrieve data
+ * var json = JSON.new()
+ * var error = json.parse(json_string)
+ * if error == OK:
+ * 	var data_received = json.data
+ * 	if typeof(data_received) == TYPE_ARRAY:
+ * 		print(data_received) # Prints the array.
+ * 	else:
+ * 		print("Unexpected data")
+ * else:
+ * 	print("JSON Parse Error: ", json.get_error_message(), " in ", json_string, " at line ", json.get_error_line())
+ *
+ * ```
+ *
+ * Alternatively, you can parse strings using the static {@link parseString} method, but it doesn't handle errors.
+ *
+ * ```text
+ *
+ * var data = JSON.parse_string(json_string) # Returns null if parsing failed.
+ *
+ * ```
+ *
+ * **Note:** Both parse methods do not fully comply with the JSON specification:
+ * - Trailing commas in arrays or objects are ignored, instead of causing a parser error.
+ * - New line and tab characters are accepted in string literals, and are treated like their corresponding escape sequences `\n` and `\t`.
+ * - Numbers are parsed using {@link String.toFloat} which is generally more lax than the JSON specification.
+ * - Certain errors, such as invalid Unicode sequences, do not cause a parser error. Instead, the string is cleaned up and an error is logged to the console.
+ */
+export class JSON extends Resource {
+    constructor(name = 371) { super(name); }
+
+    /**
+     * Converts a {@link Variant} var to JSON text and returns the result. Useful for serializing data to store or send over the network.
+     * **Note:** The JSON specification does not define integer or float types, but only a *number* type. Therefore, converting a Variant to JSON text will convert all numerical values to {@link float} types.
+     * **Note:** If `fullPrecision` is `true`, when stringifying floats, the unreliable digits are stringified in addition to the reliable digits to guarantee exact decoding.
+     * The `indent` parameter controls if and how something is indented; its contents will be used where there should be an indent in the output. Even spaces like `"   "` will work. `\t` and `\n` can also be used for a tab indent, or to make a newline for each indent respectively.
+     * **Warning:** Non-finite numbers are not supported in JSON. Any occurrences of `INF` will be replaced with `1e99999`, and negative `INF` will be replaced with `-1e99999`, but they will be interpreted correctly as infinity by most JSON parsers. `NAN` will be replaced with `null`, and it will not be interpreted as NaN in JSON parsers. If you expect non-finite numbers, consider passing your data through {@link fromNative} first.
+     * **Example output:**
+     *
+     * ```text
+     *
+     * ## JSON.stringify(my_dictionary)
+     * {"name":"my_dictionary","version":"1.0.0","entities":[{"name":"entity_0","value":"value_0"},{"name":"entity_1","value":"value_1"}]}
+     *
+     * ## JSON.stringify(my_dictionary, "\t")
+     * {
+     * 	"name": "my_dictionary",
+     * 	"version": "1.0.0",
+     * 	"entities": [
+     * 		{
+     * 			"name": "entity_0",
+     * 			"value": "value_0"
+     * 		},
+     * 		{
+     * 			"name": "entity_1",
+     * 			"value": "value_1"
+     * 		}
+     * 	]
+     * }
+     *
+     * ## JSON.stringify(my_dictionary, "...")
+     * {
+     * ..."name": "my_dictionary",
+     * ..."version": "1.0.0",
+     * ..."entities": [
+     * ......{
+     * ........."name": "entity_0",
+     * ........."value": "value_0"
+     * ......},
+     * ......{
+     * ........."name": "entity_1",
+     * ........."value": "value_1"
+     * ......}
+     * ...]
+     * }
+     *
+     * ```
+     */
+    static stringify(data: Variant, indent?: string /* = "" */, sortKeys?: boolean /* = true */, fullPrecision?: boolean /* = false */): string { return _C(371, 13974, data, indent, sortKeys, fullPrecision) as string; }
+
+    /**
+     * Attempts to parse the `jsonString` provided and returns the parsed data. Returns `null` if parse failed.
+     */
+    static parseString(jsonString: string): Variant | null { return _C(371, 9283, jsonString) as Variant | null; }
+
+    /**
+     * Attempts to parse the `jsonText` provided.
+     * Returns an {@link Error}. If the parse was successful, it returns {@link OK} and the result can be retrieved using {@link data}. If unsuccessful, use {@link getErrorLine} and {@link getErrorMessage} to identify the source of the failure.
+     * Non-static variant of {@link parseString}, if you want custom error handling.
+     * The optional `keepText` argument instructs the parser to keep a copy of the original text. This text can be obtained later by using the {@link getParsedText} function and is used when saving the resource (instead of generating new text from {@link data}).
+     */
+    parse(jsonText: string, keepText?: boolean /* = false */): Error { return _C(this, 9277, jsonText, keepText) as Error; }
+
+    /**
+     * Return the text parsed by {@link parse} (requires passing `keep_text` to {@link parse}).
+     */
+    getParsedText(): string { return _C(this, 5830) as string; }
+
+    /**
+     * Returns `0` if the last call to {@link parse} was successful, or the line number where the parse failed.
+     */
+    getErrorLine(): number { return _C(this, 4685) as number; }
+
+    /**
+     * Returns an empty string if the last call to {@link parse} was successful, or the error message if it failed.
+     */
+    getErrorMessage(): string { return _C(this, 4686) as string; }
+
+    /**
+     * Converts a native engine type to a JSON-compliant value.
+     * By default, objects are ignored for security reasons, unless `fullObjects` is `true`.
+     * You can convert a native value to a JSON string like this:
+     *
+     * ```text
+     *
+     * func encode_data(value, full_objects = false):
+     * 	return JSON.stringify(JSON.from_native(value, full_objects))
+     *
+     * ```
+     */
+    static fromNative(variant: Variant, fullObjects?: boolean /* = false */): Variant { return _C(371, 3598, variant, fullObjects) as Variant; }
+
+    /**
+     * Converts a JSON-compliant value that was created with {@link fromNative} back to native engine types.
+     * By default, objects are ignored for security reasons, unless `allowObjects` is `true`.
+     * You can convert a JSON string back to a native value like this:
+     *
+     * ```text
+     *
+     * func decode_data(string, allow_objects = false):
+     * 	return JSON.to_native(JSON.parse_string(string), allow_objects)
+     *
+     * ```
+     */
+    static toNative(json: Variant, allowObjects?: boolean /* = false */): Variant { return _C(371, 14305, json, allowObjects) as Variant; }
+
+    /**
+     * Contains the parsed JSON data in {@link Variant} form.
+     */
+    get data(): Variant { return _C(this, 4410) as Variant; }
+    set data(v: Variant) { _C(this, 11034, v); }
+
+    static readonly name = _R(371, JSON);
+}

package/gen/classes/JSONRPC.ts

@@ -0,0 +1,87 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Callable, GodotDictionary, Variant } from '../heap-types/index.ts';
+
+/**
+ * [JSON-RPC](https://www.jsonrpc.org/) is a standard which wraps a method call in a {@link JSON} object. The object has a particular structure and identifies which method is called, the parameters to that function, and carries an ID to keep track of responses. This class implements that standard on top of {@link Dictionary}; you will have to convert between a {@link Dictionary} and {@link JSON} with other functions.
+ */
+export class JSONRPC extends Object {
+    constructor(name = 372) { super(name); }
+
+    /**
+     * Registers a callback for the given method name.
+     * - `name`: The name that clients can use to access the callback.
+     * - `callback`: The callback which will handle the specified method.
+     */
+    setMethod(name: string, callback: Callable): void { _C(this, 12039, name, callback); }
+
+    /**
+     * Given a Dictionary which takes the form of a JSON-RPC request: unpack the request and run it. Methods are resolved by looking at the field called "method" and looking for an equivalently named function in the JSONRPC object. If one is found that method is called.
+     * To add new supported methods extend the JSONRPC class and call {@link processAction} on your subclass.
+     * `action`: The action to be run, as a Dictionary in the form of a JSON-RPC request or notification.
+     */
+    processAction(action: Variant, recurse?: boolean /* = false */): Variant { return _C(this, 9569, action, recurse) as Variant; }
+
+    processString(action: string): string { return _C(this, 9577, action) as string; }
+
+    /**
+     * Returns a dictionary in the form of a JSON-RPC request. Requests are sent to a server with the expectation of a response. The ID field is used for the server to specify which exact request it is responding to.
+     * - `method`: Name of the method being called.
+     * - `params`: An array or dictionary of parameters being passed to the method.
+     * - `id`: Uniquely identifies this request. The server is expected to send a response with the same ID.
+     */
+    makeRequest(method: string, params: Variant, id: Variant): GodotDictionary { return _C(this, 8739, method, params, id) as GodotDictionary; }
+
+    /**
+     * When a server has received and processed a request, it is expected to send a response. If you did not want a response then you need to have sent a Notification instead.
+     * - `result`: The return value of the function which was called.
+     * - `id`: The ID of the request this response is targeted to.
+     */
+    makeResponse(result: Variant, id: Variant): GodotDictionary { return _C(this, 8740, result, id) as GodotDictionary; }
+
+    /**
+     * Returns a dictionary in the form of a JSON-RPC notification. Notifications are one-shot messages which do not expect a response.
+     * - `method`: Name of the method being called.
+     * - `params`: An array or dictionary of parameters being passed to the method.
+     */
+    makeNotification(method: string, params: Variant): GodotDictionary { return _C(this, 8736, method, params) as GodotDictionary; }
+
+    /**
+     * Creates a response which indicates a previous reply has failed in some way.
+     * - `code`: The error code corresponding to what kind of error this is. See the {@link ErrorCode} constants.
+     * - `message`: A custom message about this error.
+     * - `id`: The request this error is a response to.
+     */
+    makeResponseError(code: number, message: string, id?: Variant /* = null */): GodotDictionary { return _C(this, 8741, code, message, id) as GodotDictionary; }
+
+    static readonly name = _R(372, JSONRPC);
+}
+
+export const ErrorCode = {
+    /**
+     * The request could not be parsed as it was not valid by JSON standard ({@link JSON.parse} failed).
+     */
+    PARSE_ERROR: -32700,
+    /**
+     * A method call was requested but the request's format is not valid.
+     */
+    INVALID_REQUEST: -32600,
+    /**
+     * A method call was requested but no function of that name existed in the JSONRPC subclass.
+     */
+    METHOD_NOT_FOUND: -32601,
+    /**
+     * A method call was requested but the given method parameters are not valid. Not used by the built-in JSONRPC.
+     */
+    INVALID_PARAMS: -32602,
+    /**
+     * An internal error occurred while processing the request. Not used by the built-in JSONRPC.
+     */
+    INTERNAL_ERROR: -32603,
+} as const;
+
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+

package/gen/classes/JacobianIK3D.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 { IterateIK3D } from './IterateIK3D.ts';
+
+/**
+ * {@link JacobianIK3D} calculates rotations for all joints simultaneously, producing natural and smooth movement. It is particularly suited for biological animations.
+ * The resulting twist around the forward vector will always be kept from the previous pose.
+ * **Note:** It converges more slowly than other IK solvers, leading to gentler and less immediate tracking of targets.
+ */
+export class JacobianIK3D extends IterateIK3D {
+    constructor(name = 373) { super(name); }
+
+    static readonly name = _R(373, JacobianIK3D);
+}

package/gen/classes/JavaClass.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, GodotDictionary, StringName } from '../heap-types/index.ts';
+
+/**
+ * Represents a class from the Java Native Interface. It is returned from {@link JavaClassWrapper.wrap}.
+ * **Note:** This class only works on Android. On any other platform, this class does nothing.
+ * **Note:** This class is not to be confused with {@link JavaScriptObject}.
+ */
+export class JavaClass extends RefCounted {
+    constructor(name = 374) { super(name); }
+
+    /**
+     * Returns the Java class name.
+     */
+    getJavaClassName(): string { return _C(this, 5221) as string; }
+
+    /**
+     * Returns the object's Java methods and their signatures as an {@link Array} of dictionaries, in the same format as {@link Object.getMethodList}.
+     */
+    getJavaMethodList(): GodotArray<GodotDictionary> { return _C(this, 5222) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns a {@link JavaClass} representing the Java parent class of this class.
+     */
+    getJavaParentClass(): JavaClass { return _C(this, 5223) as JavaClass; }
+
+    /**
+     * Returns `true` if the given `method` name exists in the object's Java methods.
+     */
+    hasJavaMethod(method: StringName): boolean { return _C(this, 7406, method) as boolean; }
+
+    static readonly name = _R(374, JavaClass);
+}

package/gen/classes/JavaClassWrapper.ts

@@ -0,0 +1,94 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Callable, PackedStringArray } from '../heap-types/index.ts';
+import type { JavaClass } from './JavaClass.ts';
+import type { JavaObject } from './JavaObject.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 375));
+
+/**
+ * The JavaClassWrapper singleton provides a way for the Godot application to send and receive data through the [Java Native Interface](https://developer.android.com/training/articles/perf-jni) (JNI).
+ * **Note:** This singleton is only available in Android builds.
+ *
+ * ```text
+ *
+ * var LocalDateTime = JavaClassWrapper.wrap("java.time.LocalDateTime")
+ * var DateTimeFormatter = JavaClassWrapper.wrap("java.time.format.DateTimeFormatter")
+ *
+ * var datetime = LocalDateTime.now()
+ * var formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss")
+ *
+ * print(datetime.format(formatter))
+ *
+ * ```
+ *
+ * **Warning:** When calling Java methods, be sure to check {@link JavaClassWrapper.getException} to check if the method threw an exception.
+ */
+export class JavaClassWrapper extends GodotVar {
+
+    /**
+     * Wraps a class defined in Java, and returns it as a {@link JavaClass} {@link Object} type that Godot can interact with.
+     * When wrapping inner (nested) classes, use `$` instead of `.` to separate them. For example, `JavaClassWrapper.wrap("android.view.WindowManager$LayoutParams")` wraps the **WindowManager.LayoutParams** class.
+     * **Note:** To invoke a constructor, call a method with the same name as the class. For example:
+     *
+     * ```text
+     *
+     * var Intent = JavaClassWrapper.wrap("android.content.Intent")
+     * var intent = Intent.Intent()
+     *
+     * ```
+     *
+     * **Note:** This method only works on Android. On every other platform, this method does nothing and returns an empty {@link JavaClass}.
+     */
+    static wrap(name: string): JavaClass { return _C($(), 14926, name) as JavaClass; }
+
+    /**
+     * Returns the Java exception from the last call into a Java class. If there was no exception, it will return `null`.
+     * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+     */
+    static getException(): JavaObject { return _C($(), 4692) as JavaObject; }
+
+    /**
+     * Creates a {@link JavaObject} implementing the Java Single Abstract Method (SAM) interface using the Godot {@link Callable} as the implementation.
+     * The `samInterface` **must be** a Java SAM interface, meaning it must only have a single abstract method to implement.
+     * The `callable` must be able to handle the same parameter types as the SAM interface method, and must provide the same return type. The `callable` will be invoked as a callback, passing the arguments from the Java SAM interface method.
+     *
+     * ```text
+     *
+     * var cb = func (content: String) -> void:
+     * 	print(content)
+     * var callback = JavaClassWrapper.create_sam_callback("android.util.Printer", cb)
+     * callback.println("Hello Godot World!")
+     *
+     * ```
+     *
+     * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+     */
+    static createSamCallback(samInterface: string, callable: Callable): JavaObject { return _C($(), 2566, samInterface, callable) as JavaObject; }
+
+    /**
+     * Creates a {@link JavaObject} implementing the given Java interfaces using the given {@link Object} as the implementation.
+     * The `object` must contain methods signatures matching the methods signatures from the passed Java `interfaces`. Invoking methods from the Java `interfaces` will route to the matching `object` method.
+     *
+     * ```text
+     *
+     * class PrintProxy:
+     * 	func println(content: String) -> void:
+     * 		print(content)
+     *
+     * var print_proxy = PrintProxy.new()
+     * var printer_object = JavaClassWrapper.create_proxy(print_proxy, ["android.util.Printer"])
+     * printer_object.println("Hello Godot World!")
+     *
+     * ```
+     *
+     * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+     */
+    static createProxy(object: Object, interfaces: PackedStringArray): JavaObject { return _C($(), 2565, object, interfaces) as JavaObject; }
+
+    static readonly name = _R(375, JavaClassWrapper);
+}

package/gen/classes/JavaObject.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 { RefCounted } from './RefCounted.ts';
+import type { StringName } from '../heap-types/index.ts';
+import type { JavaClass } from './JavaClass.ts';
+
+/**
+ * Represents an object from the Java Native Interface. It can be returned from Java methods called on {@link JavaClass} or other {@link JavaObject}s. See {@link JavaClassWrapper} for an example.
+ * **Note:** This class only works on Android. On any other platform, this class does nothing.
+ * **Note:** This class is not to be confused with {@link JavaScriptObject}.
+ */
+export class JavaObject extends RefCounted {
+    constructor(name = 376) { super(name); }
+
+    /**
+     * Returns the {@link JavaClass} that this object is an instance of.
+     */
+    getJavaClass(): JavaClass { return _C(this, 5220) as JavaClass; }
+
+    /**
+     * Returns `true` if the given `method` name exists in the object's Java methods.
+     */
+    hasJavaMethod(method: StringName): boolean { return _C(this, 7406, method) as boolean; }
+
+    static readonly name = _R(376, JavaObject);
+}

package/gen/classes/JavaScriptBridge.ts

@@ -0,0 +1,85 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { Callable, PackedByteArray, Signal, Variant } from '../heap-types/index.ts';
+import type { JavaScriptObject } from './JavaScriptObject.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 377));
+
+/**
+ * The JavaScriptBridge singleton is implemented only in the Web export. It's used to access the browser's JavaScript context. This allows interaction with embedding pages or calling third-party JavaScript APIs.
+ * **Note:** This singleton can be disabled at build-time to improve security. By default, the JavaScriptBridge singleton is enabled. Official export templates also have the JavaScriptBridge singleton enabled. See [Compiling for the Web]($DOCS_URL/engine_details/development/compiling/compiling_for_web.html) in the documentation for more information.
+ */
+export class JavaScriptBridge extends GodotVar {
+
+    /**
+     * Execute the string `code` as JavaScript code within the browser window. This is a call to the actual global JavaScript function {@link code skip-lint}eval()[/code].
+     * If `useGlobalExecutionContext` is `true`, the code will be evaluated in the global execution context. Otherwise, it is evaluated in the execution context of a function within the engine's runtime environment.
+     */
+    static _eval(code: string, useGlobalExecutionContext?: boolean /* = false */): Variant { return _C($(), 3167, code, useGlobalExecutionContext) as Variant; }
+
+    /**
+     * Returns an interface to a JavaScript object that can be used by scripts. The `interface` must be a valid property of the JavaScript `window`. The callback must accept a single {@link Array} argument, which will contain the JavaScript `arguments`. See {@link JavaScriptObject} for usage.
+     */
+    static getInterface(_interface: string): JavaScriptObject { return _C($(), 5147, _interface) as JavaScriptObject; }
+
+    /**
+     * Creates a reference to a {@link Callable} that can be used as a callback by JavaScript. The reference must be kept until the callback happens, or it won't be called at all. See {@link JavaScriptObject} for usage.
+     * **Note:** The callback function must take exactly one {@link Array} argument, which is going to be the JavaScript [arguments object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments) converted to an array.
+     */
+    static createCallback(callable: Callable): JavaScriptObject { return _C($(), 2510, callable) as JavaScriptObject; }
+
+    /**
+     * Returns `true` if the given `javascriptObject` is of type [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView), or one of the many [typed array objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
+     */
+    static isJsBuffer(javascriptObject: JavaScriptObject): boolean { return _C($(), 8054, javascriptObject) as boolean; }
+
+    /**
+     * Returns a copy of `javascriptBuffer`'s contents as a {@link PackedByteArray}. See also {@link isJsBuffer}.
+     */
+    static jsBufferToPackedByteArray(javascriptBuffer: JavaScriptObject): PackedByteArray { return _C($(), 8504, javascriptBuffer) as PackedByteArray; }
+
+    /**
+     * Creates a new JavaScript object using the `new` constructor. The `object` must a valid property of the JavaScript `window`. See {@link JavaScriptObject} for usage.
+     */
+    static createObject(object: string, ...args: any[]): Variant { return _C($(), 2555, object, ...args) as Variant; }
+
+    /**
+     * Prompts the user to download a file containing the specified `buffer`. The file will have the given `name` and `mime` type.
+     * **Note:** The browser may override the [MIME type](https://en.wikipedia.org/wiki/Media_type) provided based on the file `name`'s extension.
+     * **Note:** Browsers might block the download if {@link downloadBuffer} is not being called from a user interaction (e.g. button click).
+     * **Note:** Browsers might ask the user for permission or block the download if multiple download requests are made in a quick succession.
+     */
+    static downloadBuffer(buffer: PackedByteArray, name: string, mime?: string /* = "application/octet-stream" */): void { _C($(), 2875, buffer, name, mime); }
+
+    /**
+     * Returns `true` if a new version of the progressive web app is waiting to be activated.
+     * **Note:** Only relevant when exported as a Progressive Web App.
+     */
+    static pwaNeedsUpdate(): boolean { return _C($(), 9681) as boolean; }
+
+    /**
+     * Performs the live update of the progressive web app. Forcing the new version to be installed and the page to be reloaded.
+     * **Note:** Your application will be **reloaded in all browser tabs**.
+     * **Note:** Only relevant when exported as a Progressive Web App and {@link pwaNeedsUpdate} returns `true`.
+     */
+    static pwaUpdate(): Error { return _C($(), 9682) as Error; }
+
+    /**
+     * Force synchronization of the persistent file system (when enabled).
+     * **Note:** This is only useful for modules or extensions that can't use {@link FileAccess} to write files.
+     */
+    static forceFsSync(): void { _C($(), 3531); }
+
+    /**
+     * Emitted when an update for this progressive web app has been detected but is waiting to be activated because a previous version is active. See {@link pwaUpdate} to force the update to take place immediately.
+     */
+    static get pwaUpdateAvailable(): Signal<() => void> { return _G($(), 9683) as Signal<() => void>; }
+    static set pwaUpdateAvailable(v: (() => void) | null) { _G($(), 9683, v); }
+
+    static readonly name = _R(377, JavaScriptBridge);
+}

package/gen/classes/JavaScriptObject.ts

@@ -0,0 +1,45 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * JavaScriptObject is used to interact with JavaScript objects retrieved or created via {@link JavaScriptBridge.getInterface}, {@link JavaScriptBridge.createObject}, or {@link JavaScriptBridge.createCallback}.
+ *
+ * ```text
+ *
+ * extends Node
+ *
+ * var _my_js_callback = JavaScriptBridge.create_callback(myCallback) # This reference must be kept
+ * var console = JavaScriptBridge.get_interface("console")
+ *
+ * func _init():
+ * 	var buf = JavaScriptBridge.create_object("ArrayBuffer", 10) # new ArrayBuffer(10)
+ * 	print(buf) # Prints [JavaScriptObject:OBJECT_ID]
+ * 	var uint8arr = JavaScriptBridge.create_object("Uint8Array", buf) # new Uint8Array(buf)
+ * 	uint8arr[1] = 255
+ * 	prints(uint8arr[1], uint8arr.byteLength) # Prints "255 10"
+ *
+ * 	# Prints "Uint8Array(10) [ 0, 255, 0, 0, 0, 0, 0, 0, 0, 0 ]" in the browser's console.
+ * 	console.log(uint8arr)
+ *
+ * 	# Equivalent of JavaScriptBridge: Array.from(uint8arr).forEach(myCallback)
+ * 	JavaScriptBridge.get_interface("Array").from(uint8arr).forEach(_my_js_callback)
+ *
+ * func myCallback(args):
+ * 	# Will be called with the parameters passed to the "forEach" callback
+ * 	# [0, 0, [JavaScriptObject:1173]]
+ * 	# [255, 1, [JavaScriptObject:1173]]
+ * 	# ...
+ * 	# [0, 9, [JavaScriptObject:1180]]
+ * 	print(args)
+ *
+ * ```
+ *
+ * **Note:** Only available in the Web platform.
+ */
+export class JavaScriptObject extends RefCounted {
+
+    static readonly name = _R(378, JavaScriptObject);
+}

package/gen/classes/Joint2D.ts

@@ -0,0 +1,44 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { NodePath, RID } from '../heap-types/index.ts';
+
+/**
+ * Abstract base class for all joints in 2D physics. 2D joints bind together two physics bodies ({@link nodeA} and {@link nodeB}) and apply a constraint.
+ */
+export class Joint2D extends Node2D {
+
+    /**
+     * Returns the joint's internal {@link RID} from the {@link PhysicsServer2D}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Path to the first body (A) attached to the joint. The node must inherit {@link PhysicsBody2D}.
+     */
+    get nodeA(): NodePath { return _C(this, 5639) as NodePath; }
+    set nodeA(v: NodePath) { _C(this, 12136, v); }
+
+    /**
+     * Path to the second body (B) attached to the joint. The node must inherit {@link PhysicsBody2D}.
+     */
+    get nodeB(): NodePath { return _C(this, 5641) as NodePath; }
+    set nodeB(v: NodePath) { _C(this, 12137, v); }
+
+    /**
+     * When {@link nodeA} and {@link nodeB} move in different directions the {@link bias} controls how fast the joint pulls them back to their original position. The lower the {@link bias} the more the two bodies can pull on the joint.
+     * When set to `0`, the default value from {@link ProjectSettings.physics/2d/solver/defaultConstraintBias} is used.
+     */
+    get bias(): number { return _C(this, 3912) as number; }
+    set bias(v: number) { _C(this, 10655, v); }
+
+    /**
+     * If `true`, the two bodies bound together do not collide with each other.
+     */
+    get disableCollision(): boolean { return _C(this, 4697) as boolean; }
+    set disableCollision(v: boolean) { _C(this, 11313, v); }
+
+    static readonly name = _R(379, Joint2D);
+}

package/gen/classes/Joint3D.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { NodePath, RID } from '../heap-types/index.ts';
+
+/**
+ * Abstract base class for all joints in 3D physics. 3D joints bind together two physics bodies ({@link nodeA} and {@link nodeB}) and apply a constraint. If only one body is defined, it is attached to a fixed {@link StaticBody3D} without collision shapes.
+ */
+export class Joint3D extends Node3D {
+
+    /**
+     * Returns the joint's internal {@link RID} from the {@link PhysicsServer3D}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Path to the first node (A) attached to the joint. The node must inherit {@link PhysicsBody3D}.
+     * If left empty and {@link nodeB} is set, the body is attached to a fixed {@link StaticBody3D} without collision shapes.
+     */
+    get nodeA(): NodePath { return _C(this, 5639) as NodePath; }
+    set nodeA(v: NodePath) { _C(this, 12136, v); }
+
+    /**
+     * Path to the second node (B) attached to the joint. The node must inherit {@link PhysicsBody3D}.
+     * If left empty and {@link nodeA} is set, the body is attached to a fixed {@link StaticBody3D} without collision shapes.
+     */
+    get nodeB(): NodePath { return _C(this, 5641) as NodePath; }
+    set nodeB(v: NodePath) { _C(this, 12137, v); }
+
+    /**
+     * The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority.
+     * **Note:** Only supported when using GodotPhysics3D. This property is ignored when using Jolt Physics.
+     */
+    get solverPriority(): number { return _C(this, 6451) as number; }
+    set solverPriority(v: number) { _C(this, 12808, v); }
+
+    /**
+     * If `true`, the two bodies bound together do not collide with each other.
+     */
+    get excludeNodesFromCollision(): boolean { return _C(this, 4697) as boolean; }
+    set excludeNodesFromCollision(v: boolean) { _C(this, 11313, v); }
+
+    static readonly name = _R(380, Joint3D);
+}