@ringozz/godot 0.1.0

package/gen/classes/ConvertTransformModifier3D.ts

@@ -0,0 +1,153 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BoneConstraint3D } from './BoneConstraint3D.ts';
+
+/**
+ * Apply the copied transform of the bone set by {@link BoneConstraint3D.setReferenceBone} to the bone set by {@link BoneConstraint3D.setApplyBone} about the specific axis with remapping it with some options.
+ * There are 4 ways to apply the transform, depending on the combination of {@link setRelative} and {@link setAdditive}.
+ * **Relative + Additive:**
+ * - Extract reference pose relative to the rest and add it to the apply bone's pose.
+ * **Relative + Not Additive:**
+ * - Extract reference pose relative to the rest and add it to the apply bone's rest.
+ * **Not Relative + Additive:**
+ * - Extract reference pose absolutely and add it to the apply bone's pose.
+ * **Not Relative + Not Additive:**
+ * - Extract reference pose absolutely and the apply bone's pose is replaced with it.
+ * **Note:** Relative option is available only in the case {@link BoneConstraint3D.getReferenceType} is {@link BoneConstraint3D.REFERENCE_TYPE_BONE}. See also {@link BoneConstraint3D.ReferenceType}.
+ * **Note:** If there is a rotation greater than `180` degrees with constrained axes, flipping may occur.
+ */
+export class ConvertTransformModifier3D extends BoneConstraint3D {
+    constructor(name = 227) { super(name); }
+
+    /**
+     * Sets the operation of the remapping destination transform.
+     */
+    setApplyTransformMode(index: number, transformMode: TransformMode): void { _C(this, 10525, index, transformMode); }
+
+    /**
+     * Returns the operation of the remapping destination transform.
+     */
+    getApplyTransformMode(index: number): TransformMode { return _C(this, 3786, index) as TransformMode; }
+
+    /**
+     * Sets the axis of the remapping destination transform.
+     */
+    setApplyAxis(index: number, axis: number): void { _C(this, 10520, index, axis); }
+
+    /**
+     * Returns the axis of the remapping destination transform.
+     */
+    getApplyAxis(index: number): number { return _C(this, 3781, index) as number; }
+
+    /**
+     * Sets the minimum value of the remapping destination range.
+     */
+    setApplyRangeMin(index: number, rangeMin: number): void { _C(this, 10524, index, rangeMin); }
+
+    /**
+     * Returns the minimum value of the remapping destination range.
+     */
+    getApplyRangeMin(index: number): number { return _C(this, 3785, index) as number; }
+
+    /**
+     * Sets the maximum value of the remapping destination range.
+     */
+    setApplyRangeMax(index: number, rangeMax: number): void { _C(this, 10523, index, rangeMax); }
+
+    /**
+     * Returns the maximum value of the remapping destination range.
+     */
+    getApplyRangeMax(index: number): number { return _C(this, 3784, index) as number; }
+
+    /**
+     * Sets the operation of the remapping source transform.
+     */
+    setReferenceTransformMode(index: number, transformMode: TransformMode): void { _C(this, 12498, index, transformMode); }
+
+    /**
+     * Returns the operation of the remapping source transform.
+     */
+    getReferenceTransformMode(index: number): TransformMode { return _C(this, 6106, index) as TransformMode; }
+
+    /**
+     * Sets the axis of the remapping source transform.
+     */
+    setReferenceAxis(index: number, axis: number): void { _C(this, 12491, index, axis); }
+
+    /**
+     * Returns the axis of the remapping source transform.
+     */
+    getReferenceAxis(index: number): number { return _C(this, 6096, index) as number; }
+
+    /**
+     * Sets the minimum value of the remapping source range.
+     */
+    setReferenceRangeMin(index: number, rangeMin: number): void { _C(this, 12497, index, rangeMin); }
+
+    /**
+     * Returns the minimum value of the remapping source range.
+     */
+    getReferenceRangeMin(index: number): number { return _C(this, 6104, index) as number; }
+
+    /**
+     * Sets the maximum value of the remapping source range.
+     */
+    setReferenceRangeMax(index: number, rangeMax: number): void { _C(this, 12496, index, rangeMax); }
+
+    /**
+     * Returns the maximum value of the remapping source range.
+     */
+    getReferenceRangeMax(index: number): number { return _C(this, 6103, index) as number; }
+
+    /**
+     * Sets relative option in the setting at `index` to `enabled`.
+     * If sets `enabled` to `true`, the extracted and applying transform is relative to the rest.
+     * If sets `enabled` to `false`, the extracted transform is absolute.
+     */
+    setRelative(index: number, enabled: boolean): void { _C(this, 12511, index, enabled); }
+
+    /**
+     * Returns `true` if the relative option is enabled in the setting at `index`.
+     */
+    isRelative(index: number): boolean { return _C(this, 8237, index) as boolean; }
+
+    /**
+     * Sets additive option in the setting at `index` to `enabled`. This mainly affects the process of applying transform to the {@link BoneConstraint3D.setApplyBone}.
+     * If sets `enabled` to `true`, the processed transform is added to the pose of the current apply bone.
+     * If sets `enabled` to `false`, the pose of the current apply bone is replaced with the processed transform. However, if set {@link setRelative} to `true`, the transform is relative to rest.
+     */
+    setAdditive(index: number, enabled: boolean): void { _C(this, 10430, index, enabled); }
+
+    /**
+     * Returns `true` if the additive option is enabled in the setting at `index`.
+     */
+    isAdditive(index: number): boolean { return _C(this, 7747, index) as boolean; }
+
+    /**
+     * The number of settings in the modifier.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(227, ConvertTransformModifier3D);
+}
+
+export const TransformMode = {
+    /**
+     * Convert with position. Transfer the difference.
+     */
+    TRANSFORM_MODE_POSITION: 0,
+    /**
+     * Convert with rotation. The angle is the roll for the specified axis.
+     */
+    TRANSFORM_MODE_ROTATION: 1,
+    /**
+     * Convert with scale. Transfers the ratio, not the difference.
+     */
+    TRANSFORM_MODE_SCALE: 2,
+} as const;
+
+export type TransformMode = (typeof TransformMode)[keyof typeof TransformMode];
+

package/gen/classes/ConvexPolygonShape2D.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape2D } from './Shape2D.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+
+/**
+ * A 2D convex polygon shape, intended for use in physics. Used internally in {@link CollisionPolygon2D} when it's in {@link CollisionPolygon2D.BUILD_SOLIDS} mode.
+ * {@link ConvexPolygonShape2D} is *solid*, which means it detects collisions from objects that are fully inside it, unlike {@link ConcavePolygonShape2D} which is hollow. This makes it more suitable for both detection and physics.
+ * **Convex decomposition:** A concave polygon can be split up into several convex polygons. This allows dynamic physics bodies to have complex concave collisions (at a performance cost) and can be achieved by using several {@link ConvexPolygonShape2D} nodes or by using the {@link CollisionPolygon2D} node in {@link CollisionPolygon2D.BUILD_SOLIDS} mode. To generate a collision polygon from a sprite, select the {@link Sprite2D} node, go to the **Sprite2D** menu that appears above the viewport, and choose **Create Polygon2D Sibling**.
+ * **Performance:** {@link ConvexPolygonShape2D} is faster to check collisions against compared to {@link ConcavePolygonShape2D}, but it is slower than primitive collision shapes such as {@link CircleShape2D} and {@link RectangleShape2D}. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
+ */
+export class ConvexPolygonShape2D extends Shape2D {
+    constructor(name = 228) { super(name); }
+
+    /**
+     * Based on the set of points provided, this assigns the {@link points} property using the convex hull algorithm, removing all unneeded points. See {@link Geometry2D.convexHull} for details.
+     */
+    setPointCloud(pointCloud: PackedVector2Array): void { _C(this, 12351, pointCloud); }
+
+    /**
+     * The polygon's list of vertices that form a convex hull. Can be in either clockwise or counterclockwise order.
+     * **Warning:** Only set this property to a list of points that actually form a convex hull. Use {@link setPointCloud} to generate the convex hull of an arbitrary set of points.
+     */
+    get points(): PackedVector2Array { return _C(this, 5958) as PackedVector2Array; }
+    set points(v: PackedVector2Array) { _C(this, 12369, v); }
+
+    static readonly name = _R(228, ConvexPolygonShape2D);
+}

package/gen/classes/ConvexPolygonShape3D.ts

@@ -0,0 +1,24 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape3D } from './Shape3D.ts';
+import type { PackedVector3Array } from '../heap-types/index.ts';
+
+/**
+ * A 3D convex polyhedron shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
+ * {@link ConvexPolygonShape3D} is *solid*, which means it detects collisions from objects that are fully inside it, unlike {@link ConcavePolygonShape3D} which is hollow. This makes it more suitable for both detection and physics.
+ * **Convex decomposition:** A concave polyhedron can be split up into several convex polyhedra. This allows dynamic physics bodies to have complex concave collisions (at a performance cost) and can be achieved by using several {@link ConvexPolygonShape3D} nodes. To generate a convex decomposition from a mesh, select the {@link MeshInstance3D} node, go to the **Mesh** menu that appears above the viewport, and choose **Create Multiple Convex Collision Siblings**. Alternatively, {@link MeshInstance3D.createMultipleConvexCollisions} can be called in a script to perform this decomposition at run-time.
+ * **Performance:** {@link ConvexPolygonShape3D} is faster to check collisions against compared to {@link ConcavePolygonShape3D}, but it is slower than primitive collision shapes such as {@link SphereShape3D} and {@link BoxShape3D}. Its use should generally be limited to medium-sized objects that cannot have their collision accurately represented by primitive shapes.
+ */
+export class ConvexPolygonShape3D extends Shape3D {
+    constructor(name = 229) { super(name); }
+
+    /**
+     * The list of 3D points forming the convex polygon shape.
+     */
+    get points(): PackedVector3Array { return _C(this, 5958) as PackedVector3Array; }
+    set points(v: PackedVector3Array) { _C(this, 12369, v); }
+
+    static readonly name = _R(229, ConvexPolygonShape3D);
+}

package/gen/classes/CopyTransformModifier3D.ts

@@ -0,0 +1,220 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { BoneConstraint3D } from './BoneConstraint3D.ts';
+
+/**
+ * Apply the copied transform of the bone set by {@link BoneConstraint3D.setReferenceBone} to the bone set by {@link BoneConstraint3D.setApplyBone} with processing it with some masks and options.
+ * There are 4 ways to apply the transform, depending on the combination of {@link setRelative} and {@link setAdditive}.
+ * **Relative + Additive:**
+ * - Extract reference pose relative to the rest and add it to the apply bone's pose.
+ * **Relative + Not Additive:**
+ * - Extract reference pose relative to the rest and add it to the apply bone's rest.
+ * **Not Relative + Additive:**
+ * - Extract reference pose absolutely and add it to the apply bone's pose.
+ * **Not Relative + Not Additive:**
+ * - Extract reference pose absolutely and the apply bone's pose is replaced with it.
+ * **Note:** Relative option is available only in the case {@link BoneConstraint3D.getReferenceType} is {@link BoneConstraint3D.REFERENCE_TYPE_BONE}. See also {@link BoneConstraint3D.ReferenceType}.
+ */
+export class CopyTransformModifier3D extends BoneConstraint3D {
+    constructor(name = 230) { super(name); }
+
+    /**
+     * Sets the flags to process the transform operations. If the flag is valid, the transform operation is processed.
+     * **Note:** If the rotation is valid for only one axis, it respects the roll of the valid axis. If the rotation is valid for two axes, it discards the roll of the invalid axis.
+     */
+    setCopyFlags(index: number, copyFlags: TransformFlag): void { _C(this, 10966, index, copyFlags); }
+
+    /**
+     * Returns the copy flags of the setting at `index`.
+     */
+    getCopyFlags(index: number): TransformFlag { return _C(this, 4326, index) as TransformFlag; }
+
+    /**
+     * Sets the flags to copy axes. If the flag is valid, the axis is copied.
+     */
+    setAxisFlags(index: number, axisFlags: AxisFlag): void { _C(this, 10605, index, axisFlags); }
+
+    /**
+     * Returns the axis flags of the setting at `index`.
+     */
+    getAxisFlags(index: number): AxisFlag { return _C(this, 3860, index) as AxisFlag; }
+
+    /**
+     * Sets the flags to inverte axes. If the flag is valid, the axis is copied.
+     * **Note:** An inverted scale means an inverse number, not a negative scale. For example, inverting `2.0` means `0.5`.
+     * **Note:** An inverted rotation flips the elements of the quaternion. For example, a two-axis inversion will flip the roll of each axis, and a three-axis inversion will flip the final orientation. However, be aware that flipping only one axis may cause unintended rotation by the unflipped axes, due to the characteristics of the quaternion.
+     */
+    setInvertFlags(index: number, axisFlags: AxisFlag): void { _C(this, 11750, index, axisFlags); }
+
+    /**
+     * Returns the invert flags of the setting at `index`.
+     */
+    getInvertFlags(index: number): AxisFlag { return _C(this, 5167, index) as AxisFlag; }
+
+    /**
+     * If sets `enabled` to `true`, the position will be copied.
+     */
+    setCopyPosition(index: number, enabled: boolean): void { _C(this, 10968, index, enabled); }
+
+    /**
+     * Returns `true` if the copy flags has the flag for the position in the setting at `index`. See also {@link setCopyFlags}.
+     */
+    isPositionCopying(index: number): boolean { return _C(this, 8193, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the rotation will be copied.
+     */
+    setCopyRotation(index: number, enabled: boolean): void { _C(this, 10969, index, enabled); }
+
+    /**
+     * Returns `true` if the copy flags has the flag for the rotation in the setting at `index`. See also {@link setCopyFlags}.
+     */
+    isRotationCopying(index: number): boolean { return _C(this, 8254, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the scale will be copied.
+     */
+    setCopyScale(index: number, enabled: boolean): void { _C(this, 10970, index, enabled); }
+
+    /**
+     * Returns `true` if the copy flags has the flag for the scale in the setting at `index`. See also {@link setCopyFlags}.
+     */
+    isScaleCopying(index: number): boolean { return _C(this, 8266, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the X-axis will be copied.
+     */
+    setAxisXEnabled(index: number, enabled: boolean): void { _C(this, 10609, index, enabled); }
+
+    /**
+     * Returns `true` if the enable flags has the flag for the X-axis in the setting at `index`. See also {@link setAxisFlags}.
+     */
+    isAxisXEnabled(index: number): boolean { return _C(this, 7781, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the Y-axis will be copied.
+     */
+    setAxisYEnabled(index: number, enabled: boolean): void { _C(this, 10611, index, enabled); }
+
+    /**
+     * Returns `true` if the enable flags has the flag for the Y-axis in the setting at `index`. See also {@link setAxisFlags}.
+     */
+    isAxisYEnabled(index: number): boolean { return _C(this, 7783, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the Z-axis will be copied.
+     */
+    setAxisZEnabled(index: number, enabled: boolean): void { _C(this, 10613, index, enabled); }
+
+    /**
+     * Returns `true` if the enable flags has the flag for the Z-axis in the setting at `index`. See also {@link setAxisFlags}.
+     */
+    isAxisZEnabled(index: number): boolean { return _C(this, 7785, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the X-axis will be inverted.
+     */
+    setAxisXInverted(index: number, enabled: boolean): void { _C(this, 10610, index, enabled); }
+
+    /**
+     * Returns `true` if the invert flags has the flag for the X-axis in the setting at `index`. See also {@link setInvertFlags}.
+     */
+    isAxisXInverted(index: number): boolean { return _C(this, 7782, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the Y-axis will be inverted.
+     */
+    setAxisYInverted(index: number, enabled: boolean): void { _C(this, 10612, index, enabled); }
+
+    /**
+     * Returns `true` if the invert flags has the flag for the Y-axis in the setting at `index`. See also {@link setInvertFlags}.
+     */
+    isAxisYInverted(index: number): boolean { return _C(this, 7784, index) as boolean; }
+
+    /**
+     * If sets `enabled` to `true`, the Z-axis will be inverted.
+     */
+    setAxisZInverted(index: number, enabled: boolean): void { _C(this, 10614, index, enabled); }
+
+    /**
+     * Returns `true` if the invert flags has the flag for the Z-axis in the setting at `index`. See also {@link setInvertFlags}.
+     */
+    isAxisZInverted(index: number): boolean { return _C(this, 7786, index) as boolean; }
+
+    /**
+     * Sets relative option in the setting at `index` to `enabled`.
+     * If sets `enabled` to `true`, the extracted and applying transform is relative to the rest.
+     * If sets `enabled` to `false`, the extracted transform is absolute.
+     */
+    setRelative(index: number, enabled: boolean): void { _C(this, 12511, index, enabled); }
+
+    /**
+     * Returns `true` if the relative option is enabled in the setting at `index`.
+     */
+    isRelative(index: number): boolean { return _C(this, 8237, index) as boolean; }
+
+    /**
+     * Sets additive option in the setting at `index` to `enabled`. This mainly affects the process of applying transform to the {@link BoneConstraint3D.setApplyBone}.
+     * If sets `enabled` to `true`, the processed transform is added to the pose of the current apply bone.
+     * If sets `enabled` to `false`, the pose of the current apply bone is replaced with the processed transform. However, if set {@link setRelative} to `true`, the transform is relative to rest.
+     */
+    setAdditive(index: number, enabled: boolean): void { _C(this, 10430, index, enabled); }
+
+    /**
+     * Returns `true` if the additive option is enabled in the setting at `index`.
+     */
+    isAdditive(index: number): boolean { return _C(this, 7747, index) as boolean; }
+
+    /**
+     * The number of settings in the modifier.
+     */
+    get settingCount(): number { return _C(this, 6350) as number; }
+    set settingCount(v: number) { _C(this, 12700, v); }
+
+    static readonly name = _R(230, CopyTransformModifier3D);
+}
+
+export const TransformFlag = {
+    /**
+     * If set, allows to copy the position.
+     */
+    TRANSFORM_FLAG_POSITION: 1,
+    /**
+     * If set, allows to copy the rotation.
+     */
+    TRANSFORM_FLAG_ROTATION: 2,
+    /**
+     * If set, allows to copy the scale.
+     */
+    TRANSFORM_FLAG_SCALE: 4,
+    /**
+     * If set, allows to copy the position/rotation/scale.
+     */
+    TRANSFORM_FLAG_ALL: 7,
+} as const;
+
+export type TransformFlag = (typeof TransformFlag)[keyof typeof TransformFlag];
+
+export const AxisFlag = {
+    /**
+     * If set, allows to process the X-axis.
+     */
+    AXIS_FLAG_X: 1,
+    /**
+     * If set, allows to process the Y-axis.
+     */
+    AXIS_FLAG_Y: 2,
+    /**
+     * If set, allows to process the Z-axis.
+     */
+    AXIS_FLAG_Z: 4,
+    /**
+     * If set, allows to process the all axes.
+     */
+    AXIS_FLAG_ALL: 7,
+} as const;
+
+export type AxisFlag = (typeof AxisFlag)[keyof typeof AxisFlag];
+

package/gen/classes/Crypto.ts

@@ -0,0 +1,114 @@
+// 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 { PackedByteArray } from '../heap-types/index.ts';
+import type { CryptoKey } from './CryptoKey.ts';
+import type { HashType } from './HashingContext.ts';
+import type { X509Certificate } from './X509Certificate.ts';
+
+/**
+ * The Crypto class provides access to advanced cryptographic functionalities.
+ * Currently, this includes asymmetric key encryption/decryption, signing/verification, and generating cryptographically secure random bytes, RSA keys, HMAC digests, and self-signed {@link X509Certificate}s.
+ *
+ *
+ * ```gdscript
+ *
+ * var crypto = Crypto.new()
+ *
+ * # Generate new RSA key.
+ * var key = crypto.generate_rsa(4096)
+ *
+ * # Generate new self-signed certificate with the given key.
+ * var cert = crypto.generate_self_signed_certificate(key, "CN=mydomain.com,O=My Game Company,C=IT")
+ *
+ * # Save key and certificate in the user folder.
+ * key.save("user://generated.key")
+ * cert.save("user://generated.crt")
+ *
+ * # Encryption
+ * var data = "Some data"
+ * var encrypted = crypto.encrypt(key, data.to_utf8_buffer())
+ *
+ * # Decryption
+ * var decrypted = crypto.decrypt(key, encrypted)
+ *
+ * # Signing
+ * var signature = crypto.sign(HashingContext.HASH_SHA256, data.sha256_buffer(), key)
+ *
+ * # Verifying
+ * var verified = crypto.verify(HashingContext.HASH_SHA256, data.sha256_buffer(), signature, key)
+ *
+ * # Checks
+ * assert(verified)
+ * assert(data.to_utf8_buffer() == decrypted)
+ *
+ * ```
+ */
+export class Crypto extends RefCounted {
+    constructor(name = 231) { super(name); }
+
+    /**
+     * Generates a {@link PackedByteArray} of cryptographically secure random bytes with given `size`.
+     */
+    generateRandomBytes(size: number): PackedByteArray { return _C(this, 3635, size) as PackedByteArray; }
+
+    /**
+     * Generates an RSA {@link CryptoKey} that can be used for creating self-signed certificates and passed to {@link StreamPeerTLS.acceptStream}.
+     */
+    generateRsa(size: number): CryptoKey { return _C(this, 3636, size) as CryptoKey; }
+
+    /**
+     * Generates a self-signed {@link X509Certificate} from the given {@link CryptoKey} and `issuerName`. The certificate validity will be defined by `notBefore` and `notAfter` (first valid date and last valid date). The `issuerName` must contain at least "CN=" (common name, i.e. the domain name), "O=" (organization, i.e. your company name), "C=" (country, i.e. 2 lettered ISO-3166 code of the country the organization is based in).
+     * A small example to generate an RSA key and an X509 self-signed certificate.
+     *
+     *
+     * ```gdscript
+     *
+     * var crypto = Crypto.new()
+     * # Generate 4096 bits RSA key.
+     * var key = crypto.generate_rsa(4096)
+     * # Generate self-signed certificate using the given key.
+     * var cert = crypto.generate_self_signed_certificate(key, "CN=example.com,O=A Game Company,C=IT")
+     *
+     * ```
+     */
+    generateSelfSignedCertificate(key: CryptoKey, issuerName?: string /* = "CN=myserver,O=myorganisation,C=IT" */, notBefore?: string /* = "20140101000000" */, notAfter?: string /* = "20340101000000" */): X509Certificate { return _C(this, 3640, key, issuerName, notBefore, notAfter) as X509Certificate; }
+
+    /**
+     * Sign a given `hash` of type `hashType` with the provided private `key`.
+     */
+    sign(hashType: HashType, hash: PackedByteArray, key: CryptoKey): PackedByteArray { return _C(this, 13597, hashType, hash, key) as PackedByteArray; }
+
+    /**
+     * Verify that a given `signature` for `hash` of type `hashType` against the provided public `key`.
+     */
+    verify(hashType: HashType, hash: PackedByteArray, signature: PackedByteArray, key: CryptoKey): boolean { return _C(this, 14688, hashType, hash, signature, key) as boolean; }
+
+    /**
+     * Encrypt the given `plaintext` with the provided public `key`.
+     * **Note:** The maximum size of accepted plaintext is limited by the key size.
+     */
+    encrypt(key: CryptoKey, plaintext: PackedByteArray): PackedByteArray { return _C(this, 3092, key, plaintext) as PackedByteArray; }
+
+    /**
+     * Decrypt the given `ciphertext` with the provided private `key`.
+     * **Note:** The maximum size of accepted ciphertext is limited by the key size.
+     */
+    decrypt(key: CryptoKey, ciphertext: PackedByteArray): PackedByteArray { return _C(this, 2703, key, ciphertext) as PackedByteArray; }
+
+    /**
+     * Generates an [HMAC](https://en.wikipedia.org/wiki/HMAC) digest of `msg` using `key`. The `hashType` parameter is the hashing algorithm that is used for the inner and outer hashes.
+     * Currently, only {@link HashingContext.HASH_SHA256} and {@link HashingContext.HASH_SHA1} are supported.
+     */
+    hmacDigest(hashType: HashType, key: PackedByteArray, msg: PackedByteArray): PackedByteArray { return _C(this, 7538, hashType, key, msg) as PackedByteArray; }
+
+    /**
+     * Compares two {@link PackedByteArray}s for equality without leaking timing information in order to prevent timing attacks.
+     * See [this blog post](https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy) for more information.
+     */
+    constantTimeCompare(trusted: PackedByteArray, received: PackedByteArray): boolean { return _C(this, 2459, trusted, received) as boolean; }
+
+    static readonly name = _R(231, Crypto);
+}

package/gen/classes/CryptoKey.ts

@@ -0,0 +1,43 @@
+// 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';
+
+/**
+ * The CryptoKey class represents a cryptographic key. Keys can be loaded and saved like any other {@link Resource}.
+ * They can be used to generate a self-signed {@link X509Certificate} via {@link Crypto.generateSelfSignedCertificate} and as private key in {@link StreamPeerTLS.acceptStream} along with the appropriate certificate.
+ */
+export class CryptoKey extends Resource {
+    constructor(name = 232) { super(name); }
+
+    /**
+     * Saves a key to the given `path`. If `publicOnly` is `true`, only the public key will be saved.
+     * **Note:** `path` should be a "*.pub" file if `publicOnly` is `true`, a "*.key" file otherwise.
+     */
+    save(path: string, publicOnly?: boolean /* = false */): Error { return _C(this, 10195, path, publicOnly) as Error; }
+
+    /**
+     * Loads a key from `path`. If `publicOnly` is `true`, only the public key will be loaded.
+     * **Note:** `path` should be a "*.pub" file if `publicOnly` is `true`, a "*.key" file otherwise.
+     */
+    load(path: string, publicOnly?: boolean /* = false */): Error { return _C(this, 8665, path, publicOnly) as Error; }
+
+    /**
+     * Returns `true` if this CryptoKey only has the public part, and not the private one.
+     */
+    isPublicOnly(): boolean { return _C(this, 8221) as boolean; }
+
+    /**
+     * Returns a string containing the key in PEM format. If `publicOnly` is `true`, only the public key will be included.
+     */
+    saveToString(publicOnly?: boolean /* = false */): string { return _C(this, 10208, publicOnly) as string; }
+
+    /**
+     * Loads a key from the given `stringKey`. If `publicOnly` is `true`, only the public key will be loaded.
+     */
+    loadFromString(stringKey: string, publicOnly?: boolean /* = false */): Error { return _C(this, 8679, stringKey, publicOnly) as Error; }
+
+    static readonly name = _R(232, CryptoKey);
+}

package/gen/classes/Cubemap.ts

@@ -0,0 +1,47 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ImageTextureLayered } from './ImageTextureLayered.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * A cubemap is made of 6 textures organized in layers. They are typically used for faking reflections in 3D rendering (see {@link ReflectionProbe}). It can be used to make an object look as if it's reflecting its surroundings. This usually delivers much better performance than other reflection methods.
+ * This resource is typically used as a uniform in custom shaders. Few core Godot methods make use of {@link Cubemap} resources.
+ * To create such a texture file yourself, reimport your image files using the Godot Editor import presets. To create a Cubemap from code, use {@link ImageTextureLayered.createFromImages} on an instance of the Cubemap class.
+ * The expected image order is X+, X-, Y+, Y-, Z+, Z- (in Godot's coordinate system, so Y+ is "up" and Z- is "forward"). You can use one of the following templates as a base:
+ * - [2×3 cubemap template (default layout option)](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_2x3.webp)
+ * - [3×2 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_3x2.webp)
+ * - [1×6 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_1x6.webp)
+ * - [6×1 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_6x1.webp)
+ * **Note:** Godot doesn't support using cubemaps in a {@link PanoramaSkyMaterial}. To use a cubemap as a skybox, convert the default {@link PanoramaSkyMaterial} to a {@link ShaderMaterial} using the **Convert to ShaderMaterial** resource dropdown option, then replace its code with the following:
+ *
+ * ```text
+ *
+ * shader_type sky;
+ *
+ * uniform samplerCube source_panorama : filter_linear, source_color, hint_default_black;
+ * uniform float exposure : hint_range(0, 128) = 1.0;
+ *
+ * void sky() {
+ * 	// If importing a cubemap from another engine, you may need to flip one of the `EYEDIR` components below
+ * 	// by replacing it with `-EYEDIR`.
+ * 	vec3 eyedir = vec3(EYEDIR.x, EYEDIR.y, EYEDIR.z);
+ * 	COLOR = texture(source_panorama, eyedir).rgb * exposure;
+ * }
+ *
+ * ```
+ *
+ * After replacing the shader code and saving, specify the imported Cubemap resource in the Shader Parameters section of the ShaderMaterial in the inspector.
+ * Alternatively, you can use [this tool](https://danilw.github.io/GLSL-howto/cubemap_to_panorama_js/cubemap_to_panorama.html) to convert a cubemap to an equirectangular sky map and use {@link PanoramaSkyMaterial} as usual.
+ */
+export class Cubemap extends ImageTextureLayered {
+    constructor(name = 233) { super(name); }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderCubemap}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    static readonly name = _R(233, Cubemap);
+}

package/gen/classes/CubemapArray.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { ImageTextureLayered } from './ImageTextureLayered.ts';
+import type { Resource } from './Resource.ts';
+
+/**
+ * {@link CubemapArray}s are made of an array of {@link Cubemap}s. Like {@link Cubemap}s, they are made of multiple textures, the amount of which must be divisible by 6 (one for each face of the cube).
+ * The primary benefit of {@link CubemapArray}s is that they can be accessed in shader code using a single texture reference. In other words, you can pass multiple {@link Cubemap}s into a shader using a single {@link CubemapArray}. {@link Cubemap}s are allocated in adjacent cache regions on the GPU, which makes {@link CubemapArray}s the most efficient way to store multiple {@link Cubemap}s.
+ * Godot uses {@link CubemapArray}s internally for many effects, including the {@link Sky} if you set {@link ProjectSettings.rendering/reflections/skyReflections/textureArrayReflections} to `true`.
+ * To create such a texture file yourself, reimport your image files using the Godot Editor import presets. To create a CubemapArray from code, use {@link ImageTextureLayered.createFromImages} on an instance of the CubemapArray class.
+ * The expected image order is X+, X-, Y+, Y-, Z+, Z- (in Godot's coordinate system, so Y+ is "up" and Z- is "forward"). You can use one of the following templates as a base:
+ * - [2×3 cubemap template (default layout option)](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_2x3.webp)
+ * - [3×2 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_3x2.webp)
+ * - [1×6 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_1x6.webp)
+ * - [6×1 cubemap template](https://raw.githubusercontent.com/godotengine/godot-docs/master/tutorials/assets_pipeline/img/cubemap_template_6x1.webp)
+ * Multiple layers are stacked on top of each other when using the default vertical import option (with the first layer at the top). Alternatively, you can choose a horizontal layout in the import options (with the first layer at the left).
+ * **Note:** {@link CubemapArray} is not supported in the Compatibility renderer due to graphics API limitations.
+ */
+export class CubemapArray extends ImageTextureLayered {
+    constructor(name = 234) { super(name); }
+
+    /**
+     * Creates a placeholder version of this resource ({@link PlaceholderCubemapArray}).
+     */
+    createPlaceholder(): Resource { return _C(this, 2563) as Resource; }
+
+    static readonly name = _R(234, CubemapArray);
+}