@ringozz/godot 0.1.0

package/gen/classes/HTTPRequest.ts

@@ -0,0 +1,264 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray, PackedStringArray, Signal } from '../heap-types/index.ts';
+import type { Method } from './HTTPClient.ts';
+import type { Status } from './StreamPeerTLS.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * A node with the ability to send HTTP requests. Uses {@link HTTPClient} internally.
+ * Can be used to make HTTP requests, i.e. download or upload files or web content via HTTP.
+ * **Warning:** See the notes and warnings on {@link HTTPClient} for limitations, especially regarding TLS security.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ * **Example:** Contact a REST API and print one of its returned fields:
+ *
+ *
+ * ```gdscript
+ *
+ * func _ready():
+ * 	# Create an HTTP request node and connect its completion signal.
+ * 	var http_request = HTTPRequest.new()
+ * 	add_child(http_request)
+ * 	http_request.request_completed.connect(self._http_request_completed)
+ *
+ * 	# Perform a GET request. The URL below returns JSON as of writing.
+ * 	var error = http_request.request("https://httpbin.org/get")
+ * 	if error != OK:
+ * 		push_error("An error occurred in the HTTP request.")
+ *
+ * 	# Perform a POST request. The URL below returns JSON as of writing.
+ * 	# Note: Don't make simultaneous requests using a single HTTPRequest node.
+ * 	# The snippet below is provided for reference only.
+ * 	var body = JSON.stringify({"name": "Godette"})
+ * 	error = http_request.request("https://httpbin.org/post", [], HTTPClient.METHOD_POST, body)
+ * 	if error != OK:
+ * 		push_error("An error occurred in the HTTP request.")
+ *
+ * # Called when the HTTP request is completed.
+ * func _http_request_completed(result, response_code, headers, body):
+ * 	var json = JSON.new()
+ * 	json.parse(body.get_string_from_utf8())
+ * 	var response = json.get_data()
+ *
+ * 	# Will print the user agent string used by the HTTPRequest node (as recognized by httpbin.org).
+ * 	print(response.headers["User-Agent"])
+ *
+ * ```
+ *
+ *
+ *
+ * **Example:** Load an image using {@link HTTPRequest} and display it:
+ *
+ *
+ * ```gdscript
+ *
+ * func _ready():
+ * 	# Create an HTTP request node and connect its completion signal.
+ * 	var http_request = HTTPRequest.new()
+ * 	add_child(http_request)
+ * 	http_request.request_completed.connect(self._http_request_completed)
+ *
+ * 	# Perform the HTTP request. The URL below returns a PNG image as of writing.
+ * 	var error = http_request.request("https://placehold.co/512.png")
+ * 	if error != OK:
+ * 		push_error("An error occurred in the HTTP request.")
+ *
+ * # Called when the HTTP request is completed.
+ * func _http_request_completed(result, response_code, headers, body):
+ * 	if result != HTTPRequest.RESULT_SUCCESS:
+ * 		push_error("Image couldn't be downloaded. Try a different image.")
+ *
+ * 	var image = Image.new()
+ * 	var error = image.load_png_from_buffer(body)
+ * 	if error != OK:
+ * 		push_error("Couldn't load the image.")
+ *
+ * 	var texture = ImageTexture.create_from_image(image)
+ *
+ * 	# Display the image in a TextureRect node.
+ * 	var texture_rect = TextureRect.new()
+ * 	add_child(texture_rect)
+ * 	texture_rect.texture = texture
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** {@link HTTPRequest} nodes will automatically handle decompression of response bodies. An `Accept-Encoding` header will be automatically added to each of your requests, unless one is already specified. Any response with a `Content-Encoding: gzip` header will automatically be decompressed and delivered to you as uncompressed bytes.
+ */
+export class HTTPRequest extends Node {
+    constructor(name = 332) { super(name); }
+
+    /**
+     * Creates request on the underlying {@link HTTPClient}. If there is no configuration errors, it tries to connect using {@link HTTPClient.connectToHost} and passes parameters onto {@link HTTPClient.request}.
+     * Returns {@link OK} if request is successfully created. (Does not imply that the server has responded), {@link ERR_UNCONFIGURED} if not in the tree, {@link ERR_BUSY} if still processing previous request, {@link ERR_INVALID_PARAMETER} if given string is not a valid URL format, or {@link ERR_CANT_CONNECT} if not using thread and the {@link HTTPClient} cannot connect to host.
+     * **Note:** When `method` is {@link HTTPClient.METHOD_GET}, the payload sent via `requestData` might be ignored by the server or even cause the server to reject the request (check [RFC 7231 section 4.3.1](https://datatracker.ietf.org/doc/html/rfc7231#section-4.3.1) for more details). As a workaround, you can send data as a query string in the URL (see {@link String.uriEncode} for an example).
+     * **Note:** It's recommended to use transport encryption (TLS) and to avoid sending sensitive information (such as login credentials) in HTTP GET URL parameters. Consider using HTTP POST requests or HTTP headers for such information instead.
+     */
+    request(url: string, customHeaders?: PackedStringArray /* = PackedStringArray() */, method?: Method /* = 0 */, requestData?: string /* = "" */): Error { return _C(this, 10050, url, customHeaders, method, requestData) as Error; }
+
+    /**
+     * Creates request on the underlying {@link HTTPClient} using a raw array of bytes for the request body. If there is no configuration errors, it tries to connect using {@link HTTPClient.connectToHost} and passes parameters onto {@link HTTPClient.request}.
+     * Returns {@link OK} if request is successfully created. (Does not imply that the server has responded), {@link ERR_UNCONFIGURED} if not in the tree, {@link ERR_BUSY} if still processing previous request, {@link ERR_INVALID_PARAMETER} if given string is not a valid URL format, or {@link ERR_CANT_CONNECT} if not using thread and the {@link HTTPClient} cannot connect to host.
+     */
+    requestRaw(url: string, customHeaders?: PackedStringArray /* = PackedStringArray() */, method?: Method /* = 0 */, requestDataRaw?: PackedByteArray /* = PackedByteArray() */): Error { return _C(this, 10058, url, customHeaders, method, requestDataRaw) as Error; }
+
+    /**
+     * Cancels the current request.
+     */
+    cancelRequest(): void { _C(this, 2024); }
+
+    /**
+     * Sets the {@link TLSOptions} to be used when connecting to an HTTPS server. See {@link TLSOptions.client}.
+     */
+    setTlsOptions(clientOptions: TLSOptions): void { _C(this, 13104, clientOptions); }
+
+    /**
+     * Returns the current status of the underlying {@link HTTPClient}.
+     */
+    getHttpClientStatus(): Status { return _C(this, 5050) as Status; }
+
+    /**
+     * Returns the number of bytes this HTTPRequest downloaded.
+     */
+    getDownloadedBytes(): number { return _C(this, 4549) as number; }
+
+    /**
+     * Returns the response body length.
+     * **Note:** Some Web servers may not send a body length. In this case, the value returned will be `-1`. If using chunked transfer encoding, the body length will also be `-1`.
+     */
+    getBodySize(): number { return _C(this, 3948) as number; }
+
+    /**
+     * Sets the proxy server for HTTP requests.
+     * The proxy server is unset if `host` is empty or `port` is -1.
+     */
+    setHttpProxy(host: string, port: number): void { _C(this, 11643, host, port); }
+
+    /**
+     * Sets the proxy server for HTTPS requests.
+     * The proxy server is unset if `host` is empty or `port` is -1.
+     */
+    setHttpsProxy(host: string, port: number): void { _C(this, 11644, host, port); }
+
+    /**
+     * The file to download into. Will output any received file into it.
+     */
+    get downloadFile(): string { return _C(this, 4548) as string; }
+    set downloadFile(v: string) { _C(this, 11159, v); }
+
+    /**
+     * The size of the buffer used and maximum bytes to read per iteration. See {@link HTTPClient.readChunkSize}.
+     * Set this to a lower value (e.g. 4096 for 4 KiB) when downloading small files to decrease memory usage at the cost of download speeds.
+     */
+    get downloadChunkSize(): number { return _C(this, 4547) as number; }
+    set downloadChunkSize(v: number) { _C(this, 11158, v); }
+
+    /**
+     * If `true`, multithreading is used to improve performance.
+     */
+    get useThreads(): boolean { return _C(this, 8425) as boolean; }
+    set useThreads(v: boolean) { _C(this, 13243, v); }
+
+    /**
+     * If `true`, this header will be added to each request: `Accept-Encoding: gzip, deflate` telling servers that it's okay to compress response bodies.
+     * Any Response body declaring a `Content-Encoding` of either `gzip` or `deflate` will then be automatically decompressed, and the uncompressed bytes will be delivered via {@link request_completed}.
+     * If the user has specified their own `Accept-Encoding` header, then no header will be added regardless of {@link acceptGzip}.
+     * If `false` no header will be added, and no decompression will be performed on response bodies. The raw bytes of the response body will be returned via {@link request_completed}.
+     */
+    get acceptGzip(): boolean { return _C(this, 7733) as boolean; }
+    set acceptGzip(v: boolean) { _C(this, 10401, v); }
+
+    /**
+     * Maximum allowed size for response bodies. If the response body is compressed, this will be used as the maximum allowed size for the decompressed body.
+     */
+    get bodySizeLimit(): number { return _C(this, 3949) as number; }
+    set bodySizeLimit(v: number) { _C(this, 10694, v); }
+
+    /**
+     * Maximum number of allowed redirects.
+     */
+    get maxRedirects(): number { return _C(this, 5482) as number; }
+    set maxRedirects(v: number) { _C(this, 12005, v); }
+
+    /**
+     * The duration to wait before a request times out, in seconds (independent of {@link Engine.timeScale}). If {@link timeout} is set to `0.0`, the request will never time out.
+     * For simple requests, such as communication with a REST API, it is recommended to set {@link timeout} to a value suitable for the server response time (commonly between `1.0` and `10.0`). This will help prevent unwanted timeouts caused by variation in response times while still allowing the application to detect when a request has timed out. For larger requests such as file downloads, it is recommended to set {@link timeout} to `0.0`, disabling the timeout functionality. This will help prevent large transfers from failing due to exceeding the timeout value.
+     */
+    get timeout(): number { return _C(this, 6820) as number; }
+    set timeout(v: number) { _C(this, 13089, v); }
+
+    /**
+     * Emitted when a request is completed.
+     */
+    get requestCompleted(): Signal<(result: number, responseCode: number, headers: PackedStringArray, body: PackedByteArray) => void> { return _G(this, 10053) as Signal<(result: number, responseCode: number, headers: PackedStringArray, body: PackedByteArray) => void>; }
+    set requestCompleted(v: ((result: number, responseCode: number, headers: PackedStringArray, body: PackedByteArray) => void) | null) { _G(this, 10053, v); }
+
+    static readonly name = _R(332, HTTPRequest);
+}
+
+export const Result = {
+    /**
+     * Request successful.
+     */
+    RESULT_SUCCESS: 0,
+    /**
+     * Request failed due to a mismatch between the expected and actual chunked body size during transfer. Possible causes include network errors, server misconfiguration, or issues with chunked encoding.
+     */
+    RESULT_CHUNKED_BODY_SIZE_MISMATCH: 1,
+    /**
+     * Request failed while connecting.
+     */
+    RESULT_CANT_CONNECT: 2,
+    /**
+     * Request failed while resolving.
+     */
+    RESULT_CANT_RESOLVE: 3,
+    /**
+     * Request failed due to connection (read/write) error.
+     */
+    RESULT_CONNECTION_ERROR: 4,
+    /**
+     * Request failed on TLS handshake.
+     */
+    RESULT_TLS_HANDSHAKE_ERROR: 5,
+    /**
+     * Request does not have a response (yet).
+     */
+    RESULT_NO_RESPONSE: 6,
+    /**
+     * Request exceeded its maximum size limit, see {@link bodySizeLimit}.
+     */
+    RESULT_BODY_SIZE_LIMIT_EXCEEDED: 7,
+    /**
+     * Request failed due to an error while decompressing the response body. Possible causes include unsupported or incorrect compression format, corrupted data, or incomplete transfer.
+     */
+    RESULT_BODY_DECOMPRESS_FAILED: 8,
+    /**
+     * Request failed (currently unused).
+     */
+    RESULT_REQUEST_FAILED: 9,
+    /**
+     * HTTPRequest couldn't open the download file.
+     */
+    RESULT_DOWNLOAD_FILE_CANT_OPEN: 10,
+    /**
+     * HTTPRequest couldn't write to the download file.
+     */
+    RESULT_DOWNLOAD_FILE_WRITE_ERROR: 11,
+    /**
+     * Request reached its maximum redirect limit, see {@link maxRedirects}.
+     */
+    RESULT_REDIRECT_LIMIT_REACHED: 12,
+    /**
+     * Request failed due to a timeout. If you expect requests to take a long time, try increasing the value of {@link timeout} or setting it to `0.0` to remove the timeout completely.
+     */
+    RESULT_TIMEOUT: 13,
+} as const;
+
+export type Result = (typeof Result)[keyof typeof Result];
+

package/gen/classes/HashingContext.ts

@@ -0,0 +1,75 @@
+// 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 } from '../heap-types/index.ts';
+
+/**
+ * The HashingContext class provides an interface for computing cryptographic hashes over multiple iterations. Useful for computing hashes of big files (so you don't have to load them all in memory), network streams, and data streams in general (so you don't have to hold buffers).
+ * The {@link HashType} enum shows the supported hashing algorithms.
+ *
+ *
+ * ```gdscript
+ *
+ * const CHUNK_SIZE = 1024
+ *
+ * func hash_file(path):
+ * 	# Check that file exists.
+ * 	if not FileAccess.file_exists(path):
+ * 		return
+ * 	# Start an SHA-256 context.
+ * 	var ctx = HashingContext.new()
+ * 	ctx.start(HashingContext.HASH_SHA256)
+ * 	# Open the file to hash.
+ * 	var file = FileAccess.open(path, FileAccess.READ)
+ * 	# Update the context after reading each chunk.
+ * 	while file.get_position() < file.get_length():
+ * 		var remaining = file.get_length() - file.get_position()
+ * 		ctx.update(file.get_buffer(min(remaining, CHUNK_SIZE)))
+ * 	# Get the computed hash.
+ * 	var res = ctx.finish()
+ * 	# Print the result as hex string and array.
+ * 	printt(res.hex_encode(), Array(res))
+ *
+ * ```
+ */
+export class HashingContext extends RefCounted {
+    constructor(name = 333) { super(name); }
+
+    /**
+     * Starts a new hash computation of the given `type` (e.g. {@link HASH_SHA256} to start computation of an SHA-256).
+     */
+    start(type: HashType): Error { return _C(this, 13829, type) as Error; }
+
+    /**
+     * Updates the computation with the given `chunk` of data.
+     */
+    update(chunk: PackedByteArray): Error { return _C(this, 14502, chunk) as Error; }
+
+    /**
+     * Closes the current context, and return the computed hash.
+     */
+    finish(): PackedByteArray { return _C(this, 3309) as PackedByteArray; }
+
+    static readonly name = _R(333, HashingContext);
+}
+
+export const HashType = {
+    /**
+     * Hashing algorithm: MD5.
+     */
+    HASH_MD5: 0,
+    /**
+     * Hashing algorithm: SHA-1.
+     */
+    HASH_SHA1: 1,
+    /**
+     * Hashing algorithm: SHA-256.
+     */
+    HASH_SHA256: 2,
+} as const;
+
+export type HashType = (typeof HashType)[keyof typeof HashType];
+

package/gen/classes/HeightMapShape3D.ts

@@ -0,0 +1,73 @@
+// 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 { PackedFloat32Array } from '../heap-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * A 3D heightmap shape, intended for use in physics to provide a shape for a {@link CollisionShape3D}. This type is most commonly used for terrain with vertices placed in a fixed-width grid.
+ * The heightmap is represented as a 2D grid of height values, which represent the position of grid points on the Y axis. Grid points are spaced 1 unit apart on the X and Z axes, and the grid is centered on the origin of the {@link CollisionShape3D} node. Internally, each grid square is divided into two triangles.
+ * Due to the nature of the heightmap, it cannot be used to model overhangs or caves, which would require multiple vertices at the same vertical location. Holes can be punched through the collision by assigning `NAN` to the height of the desired vertices (this is supported in both GodotPhysics3D and Jolt Physics). You could then insert meshes with their own separate collision to provide overhangs, caves, and so on.
+ * **Performance:** {@link HeightMapShape3D} is faster to check collisions against than {@link ConcavePolygonShape3D}, but it is significantly slower than primitive shapes like {@link BoxShape3D}.
+ * A heightmap collision shape can also be built by using an {@link Image} reference:
+ *
+ *
+ * ```gdscript
+ *
+ * var heightmap_texture = ResourceLoader.load("res://heightmap_image.exr")
+ * var heightmap_image = heightmap_texture.get_image()
+ * heightmap_image.convert(Image.FORMAT_RF)
+ *
+ * var height_min = 0.0
+ * var height_max = 10.0
+ *
+ * update_map_data_from_image(heightmap_image, height_min, height_max)
+ *
+ * ```
+ *
+ *
+ * **Note:** If you need to use a spacing different than 1 unit, you can adjust the {@link Node3D.scale} of the shape. However, keep in mind that GodotPhysics3D does not support non-uniform scaling: you'll need to scale the Y axis by the same amount as the X and Z axes, which means the values in {@link mapData} will need to be pre-scaled by the inverse of that scale. Also note that GodotPhysics3D does not support scaling at all for dynamic bodies (that is, non-frozen {@link RigidBody3D} nodes); to use a scaled {@link HeightMapShape3D} with those, you will need to use Jolt Physics.
+ */
+export class HeightMapShape3D extends Shape3D {
+    constructor(name = 334) { super(name); }
+
+    /**
+     * Returns the smallest height value found in {@link mapData}. Recalculates only when {@link mapData} changes.
+     */
+    getMinHeight(): number { return _C(this, 5541) as number; }
+
+    /**
+     * Returns the largest height value found in {@link mapData}. Recalculates only when {@link mapData} changes.
+     */
+    getMaxHeight(): number { return _C(this, 5470) as number; }
+
+    /**
+     * Updates {@link mapData} with data read from an {@link Image} reference. Automatically resizes heightmap {@link mapWidth} and {@link mapDepth} to fit the full image width and height.
+     * The image needs to be in either {@link Image.FORMAT_RF} (32 bit), {@link Image.FORMAT_RH} (16 bit), or {@link Image.FORMAT_R8} (8 bit).
+     * Each image pixel is read in as a float on the range from `0.0` (black pixel) to `1.0` (white pixel). This range value gets remapped to `heightMin` and `heightMax` to form the final height value.
+     * **Note:** Using a heightmap with 16-bit or 32-bit data, stored in EXR or HDR format is recommended. Using 8-bit height data, or a format like PNG that Godot imports as 8-bit, will result in a terraced terrain.
+     */
+    updateMapDataFromImage(image: Image, heightMin: number, heightMax: number): void { _C(this, 14520, image, heightMin, heightMax); }
+
+    /**
+     * Number of vertices in the width of the heightmap. Changing this will resize the {@link mapData}.
+     */
+    get mapWidth(): number { return _C(this, 5439) as number; }
+    set mapWidth(v: number) { _C(this, 11968, v); }
+
+    /**
+     * Number of vertices in the depth of the heightmap. Changing this will resize the {@link mapData}.
+     */
+    get mapDepth(): number { return _C(this, 5438) as number; }
+    set mapDepth(v: number) { _C(this, 11967, v); }
+
+    /**
+     * Heightmap data. The array's size must be equal to {@link mapWidth} multiplied by {@link mapDepth}.
+     */
+    get mapData(): PackedFloat32Array { return _C(this, 5437) as PackedFloat32Array; }
+    set mapData(v: PackedFloat32Array) { _C(this, 11966, v); }
+
+    static readonly name = _R(334, HeightMapShape3D);
+}

package/gen/classes/HingeJoint3D.ts

@@ -0,0 +1,90 @@
+// 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 restricts the rotation of a 3D physics body around an axis relative to another physics body. For example, Body A can be a {@link StaticBody3D} representing a door hinge that a {@link RigidBody3D} rotates around.
+ */
+export class HingeJoint3D extends Joint3D {
+    constructor(name = 335) { super(name); }
+
+    /**
+     * Sets the value of the specified parameter.
+     */
+    setParam(param: Param, value: number): void { _C(this, 12248, param, value); }
+
+    /**
+     * Returns the value of the specified parameter.
+     */
+    getParam(param: Param): number { return _C(this, 5809, param) as number; }
+
+    /**
+     * If `true`, enables the specified flag.
+     */
+    setFlag(flag: Flag, enabled: boolean): void { _C(this, 11408, flag, enabled); }
+
+    /**
+     * Returns the value of the specified flag.
+     */
+    getFlag(flag: Flag): boolean { return _C(this, 4803, flag) as boolean; }
+
+    static readonly name = _R(335, HingeJoint3D);
+}
+
+export const Param = {
+    /**
+     * The speed with which the two bodies get pulled together when they move in different directions.
+     */
+    PARAM_BIAS: 0,
+    /**
+     * The maximum rotation. Only active if {@link angularLimit/enable} is `true`.
+     */
+    PARAM_LIMIT_UPPER: 1,
+    /**
+     * The minimum rotation. Only active if {@link angularLimit/enable} is `true`.
+     */
+    PARAM_LIMIT_LOWER: 2,
+    /**
+     * The speed with which the rotation across the axis perpendicular to the hinge gets corrected.
+     */
+    PARAM_LIMIT_BIAS: 3,
+    PARAM_LIMIT_SOFTNESS: 4,
+    /**
+     * The lower this value, the more the rotation gets slowed down.
+     */
+    PARAM_LIMIT_RELAXATION: 5,
+    /**
+     * Target speed for the motor.
+     */
+    PARAM_MOTOR_TARGET_VELOCITY: 6,
+    /**
+     * Maximum acceleration for the motor.
+     */
+    PARAM_MOTOR_MAX_IMPULSE: 7,
+    /**
+     * Represents the size of the {@link Param} enum.
+     */
+    PARAM_MAX: 8,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+
+export const Flag = {
+    /**
+     * If `true`, the hinges maximum and minimum rotation, defined by {@link angularLimit/lower} and {@link angularLimit/upper} has effects.
+     */
+    FLAG_USE_LIMIT: 0,
+    /**
+     * When activated, a motor turns the hinge.
+     */
+    FLAG_ENABLE_MOTOR: 1,
+    /**
+     * Represents the size of the {@link Flag} enum.
+     */
+    FLAG_MAX: 2,
+} as const;
+
+export type Flag = (typeof Flag)[keyof typeof Flag];
+

package/gen/classes/IKModifier3D.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+
+/**
+ * Base class of {@link SkeletonModifier3D}s that has some joint lists and applies inverse kinematics. This class has some structs, enums, and helper methods which are useful to solve inverse kinematics.
+ */
+export class IKModifier3D extends SkeletonModifier3D {
+
+    /**
+     * Sets the number of settings.
+     */
+    setSettingCount(count: number): void { _C(this, 12700, count); }
+
+    /**
+     * Returns the number of settings.
+     */
+    getSettingCount(): number { return _C(this, 6350) as number; }
+
+    /**
+     * Clears all settings.
+     */
+    clearSettings(): void { _C(this, 2293); }
+
+    /**
+     * Resets a state with respect to the current bone pose.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * If `true`, the solver retrieves the bone axis from the bone pose every frame.
+     * If `false`, the solver retrieves the bone axis from the bone rest and caches it, which increases performance slightly, but position changes in the bone pose made before processing this {@link IKModifier3D} are ignored.
+     */
+    get mutableBoneAxes(): boolean { return _C(this, 1541) as boolean; }
+    set mutableBoneAxes(v: boolean) { _C(this, 12112, v); }
+
+    static readonly name = _R(336, IKModifier3D);
+}

package/gen/classes/IP.ts

@@ -0,0 +1,132 @@
+// 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 { GodotArray, GodotDictionary, PackedStringArray } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 337));
+
+/**
+ * IP contains support functions for the Internet Protocol (IP). TCP/IP support is in different classes (see {@link StreamPeerTCP} and {@link TCPServer}). IP provides DNS hostname resolution support, both blocking and threaded.
+ */
+export class IP extends GodotVar {
+
+    /**
+     * Returns a given hostname's IPv4 or IPv6 address when resolved (blocking-type method). The address type returned depends on the {@link Type} constant given as `ipType`.
+     */
+    static resolveHostname(host: string, ipType?: Type /* = 3 */): string { return _C($(), 10085, host, ipType) as string; }
+
+    /**
+     * Resolves a given hostname in a blocking way. Addresses are returned as an {@link Array} of IPv4 or IPv6 addresses depending on `ipType`.
+     */
+    static resolveHostnameAddresses(host: string, ipType?: Type /* = 3 */): PackedStringArray { return _C($(), 10086, host, ipType) as PackedStringArray; }
+
+    /**
+     * Creates a queue item to resolve a hostname to an IPv4 or IPv6 address depending on the {@link Type} constant given as `ipType`. Returns the queue ID if successful, or {@link RESOLVER_INVALID_ID} on error.
+     */
+    static resolveHostnameQueueItem(host: string, ipType?: Type /* = 3 */): number { return _C($(), 10087, host, ipType) as number; }
+
+    /**
+     * Returns a queued hostname's status as a {@link ResolverStatus} constant, given its queue `id`.
+     */
+    static getResolveItemStatus(id: number): ResolverStatus { return _C($(), 6158, id) as ResolverStatus; }
+
+    /**
+     * Returns a queued hostname's IP address, given its queue `id`. Returns an empty string on error or if resolution hasn't happened yet (see {@link getResolveItemStatus}).
+     */
+    static getResolveItemAddress(id: number): string { return _C($(), 6156, id) as string; }
+
+    /**
+     * Returns resolved addresses, or an empty array if an error happened or resolution didn't happen yet (see {@link getResolveItemStatus}).
+     */
+    static getResolveItemAddresses(id: number): GodotArray { return _C($(), 6157, id) as GodotArray; }
+
+    /**
+     * Removes a given item `id` from the queue. This should be used to free a queue after it has completed to enable more queries to happen.
+     */
+    static eraseResolveItem(id: number): void { _C($(), 3162, id); }
+
+    /**
+     * Returns all the user's current IPv4 and IPv6 addresses as an array.
+     */
+    static getLocalAddresses(): PackedStringArray { return _C($(), 5394) as PackedStringArray; }
+
+    /**
+     * Returns all network adapters as an array.
+     * Each adapter is a dictionary of the form:
+     *
+     * ```text
+     *
+     * {
+     * 	"index": "1", # Interface index.
+     * 	"name": "eth0", # Interface name.
+     * 	"friendly": "Ethernet One", # A friendly name (might be empty).
+     * 	"addresses": ["192.168.1.101"], # An array of IP addresses associated to this interface.
+     * }
+     *
+     * ```
+     */
+    static getLocalInterfaces(): GodotArray<GodotDictionary> { return _C($(), 5395) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Removes all of a `hostname`'s cached references. If no `hostname` is given, all cached IP addresses are removed.
+     */
+    static clearCache(hostname?: string /* = "" */): void { _C($(), 2246, hostname); }
+
+    /**
+     * Maximum number of concurrent DNS resolver queries allowed, {@link RESOLVER_INVALID_ID} is returned if exceeded.
+     */
+    static readonly RESOLVER_MAX_QUERIES = 256;
+
+    /**
+     * Invalid ID constant. Returned if {@link RESOLVER_MAX_QUERIES} is exceeded.
+     */
+    static readonly RESOLVER_INVALID_ID = -1;
+
+    static readonly name = _R(337, IP);
+}
+
+export const ResolverStatus = {
+    /**
+     * DNS hostname resolver status: No status.
+     */
+    RESOLVER_STATUS_NONE: 0,
+    /**
+     * DNS hostname resolver status: Waiting.
+     */
+    RESOLVER_STATUS_WAITING: 1,
+    /**
+     * DNS hostname resolver status: Done.
+     */
+    RESOLVER_STATUS_DONE: 2,
+    /**
+     * DNS hostname resolver status: Error.
+     */
+    RESOLVER_STATUS_ERROR: 3,
+} as const;
+
+export type ResolverStatus = (typeof ResolverStatus)[keyof typeof ResolverStatus];
+
+export const Type = {
+    /**
+     * Address type: None.
+     */
+    TYPE_NONE: 0,
+    /**
+     * Address type: Internet protocol version 4 (IPv4).
+     */
+    TYPE_IPV4: 1,
+    /**
+     * Address type: Internet protocol version 6 (IPv6).
+     */
+    TYPE_IPV6: 2,
+    /**
+     * Address type: Any.
+     */
+    TYPE_ANY: 3,
+} as const;
+
+export type Type = (typeof Type)[keyof typeof Type];
+