typescript-to-gdscript 0.1.0

package/typings/classes/Array.d.ts

@@ -0,0 +1,301 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Override: Array<T> — adds generic type parameter to GDScript Array.
+ *
+ * The generator produces `interface Array { ... }` with `unknown` for element types.
+ * This override replaces it with `interface Array<T>` so that typed arrays work:
+ *   var nums: Array<int> = [];
+ *   nums.append(42);       // OK
+ *   nums.append("hello");  // Error: string is not int
+ */
+declare interface Array<T = unknown> {
+  /**
+   * Calls the given {@link Callable} on each element in the array and returns `true` if the {@link Callable} returns `true` for *all* elements in the array. If the {@link Callable} returns `false` for one array element or more, this method returns `false`.
+   * The `method` should take one {@link Variant} parameter (the current array element) and return a [bool].
+   * See also {@link any}, {@link filter}, {@link map} and {@link reduce}.
+   * **Note:** Unlike relying on the size of an array returned by {@link filter}, this method will return as early as possible to improve performance (especially with large arrays).
+   * **Note:** For an empty array, this method always (https://en.wikipedia.org/wiki/Vacuous_truth) returns `true`.
+   */
+  all(method: (value: T) => boolean): boolean;
+  /**
+   * Calls the given {@link Callable} on each element in the array and returns `true` if the {@link Callable} returns `true` for *one or more* elements in the array. If the {@link Callable} returns `false` for all elements in the array, this method returns `false`.
+   * The `method` should take one {@link Variant} parameter (the current array element) and return a [bool].
+   * See also {@link all}, {@link filter}, {@link map} and {@link reduce}.
+   * **Note:** Unlike relying on the size of an array returned by {@link filter}, this method will return as early as possible to improve performance (especially with large arrays).
+   * **Note:** For an empty array, this method always returns `false`.
+   */
+  any(method: (value: T) => boolean): boolean;
+  /** Appends `value` at the end of the array (alias of {@link push_back}). */
+  append(value: T): void;
+  /** Appends another `array` at the end of this array. */
+  append_array(array: Array<T>): void;
+  /**
+   * Assigns elements of another `array` into the array. Resizes the array to match `array`. Performs type conversions if the array is typed.
+   */
+  assign(array: Array<T>): void;
+  /**
+   * Returns the last element of the array. If the array is empty, fails and returns `null`. See also {@link front}.
+   * **Note:** Unlike with the `[]` operator (`array[-1]`), an error is generated without stopping project execution.
+   */
+  back(): T;
+  /**
+   * Returns the index of `value` in the sorted array. If it cannot be found, returns where `value` should be inserted to keep the array sorted. The algorithm used is binary search (https://en.wikipedia.org/wiki/Binary_search_algorithm).
+   * If `before` is `true` (as by default), the returned index comes before all existing elements equal to `value` in the array.
+   * **Note:** Calling {@link bsearch} on an *unsorted* array will result in unexpected behavior. Use {@link sort} before calling this method.
+   */
+  bsearch(value: T, before?: boolean): int;
+  /**
+   * Returns the index of `value` in the sorted array. If it cannot be found, returns where `value` should be inserted to keep the array sorted (using `func` for the comparisons). The algorithm used is binary search (https://en.wikipedia.org/wiki/Binary_search_algorithm).
+   * Similar to {@link sort_custom}, `func` is called as many times as necessary, receiving one array element and `value` as arguments. The function should return `true` if the array element should be *behind* `value`, otherwise it should return `false`.
+   * If `before` is `true` (as by default), the returned index comes before all existing elements equal to `value` in the array.
+   * **Note:** Calling {@link bsearch_custom} on an *unsorted* array will result in unexpected behavior. Use {@link sort_custom} with `func` before calling this method.
+   */
+  bsearch_custom(
+  value: T,
+  func: (a: T, b: T) => boolean,
+  before?: boolean,
+  ): int;
+  /** Removes all elements from the array. This is equivalent to using {@link resize} with a size of `0`. */
+  clear(): void;
+  /**
+   * Returns the number of times an element is in the array.
+   * To count how many elements in an array satisfy a condition, see {@link reduce}.
+   */
+  count(value: T): int;
+  /**
+   * Returns a new copy of the array.
+   * By default, a **shallow** copy is returned: all nested {@link Array}, {@link Dictionary}, and {@link Resource} elements are shared with the original array. Modifying any of those in one array will also affect them in the other.
+   * If `deep` is `true`, a **deep** copy is returned: all nested arrays and dictionaries are also duplicated (recursively). Any {@link Resource} is still shared with the original array, though.
+   */
+  duplicate(deep?: boolean): Array<T>;
+  /**
+   * Duplicates this array, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
+   * `deep_subresources_mode` must be one of the values from {@link Resource.DeepDuplicateMode}. By default, only internal resources will be duplicated (recursively).
+   */
+  duplicate_deep(deep_subresources_mode?: int): Array<T>;
+  /**
+   * Finds and removes the first occurrence of `value` from the array. If `value` does not exist in the array, nothing happens. To remove an element by index, use {@link remove_at} instead.
+   * **Note:** This method shifts every element's index after the removed `value` back, which may have a noticeable performance cost, especially on larger arrays.
+   * **Note:** Erasing elements while iterating over arrays is **not** supported and will result in unpredictable behavior.
+   */
+  erase(value: T): void;
+  /**
+   * Assigns the given `value` to all elements in the array.
+   * This method can often be combined with {@link resize} to create an array with a given size and initialized elements:
+   * **Note:** If `value` is a {@link Variant} passed by reference ({@link Object}-derived, {@link Array}, {@link Dictionary}, etc.), the array will be filled with references to the same `value`, which are not duplicates.
+   */
+  fill(value: T): void;
+  /**
+   * Calls the given {@link Callable} on each element in the array and returns a new, filtered {@link Array}.
+   * The `method` receives one of the array elements as an argument, and should return `true` to add the element to the filtered array, or `false` to exclude it.
+   * See also {@link any}, {@link all}, {@link map} and {@link reduce}.
+   */
+  filter(method: (value: T) => boolean): Array<T>;
+  /**
+   * Returns the index of the **first** occurrence of `what` in this array, or `-1` if there are none. The search's start can be specified with `from`, continuing to the end of the array.
+   * **Note:** If you just want to know whether the array contains `what`, use {@link has} (`Contains` in C#). In GDScript, you may also use the `in` operator.
+   * **Note:** For performance reasons, the search is affected by `what`'s {@link Variant.Type}. For example, `7` ([int]) and `7.0` ([float]) are not considered equal for this method.
+   */
+  find(what: T, from_?: int): int;
+  /**
+   * Returns the index of the **first** element in the array that causes `method` to return `true`, or `-1` if there are none. The search's start can be specified with `from`, continuing to the end of the array.
+   * `method` is a callable that takes an element of the array, and returns a [bool].
+   * **Note:** If you just want to know whether the array contains *anything* that satisfies `method`, use {@link any}.
+   */
+  find_custom(method: (value: T) => boolean, from_?: int): int;
+  /**
+   * Returns the first element of the array. If the array is empty, fails and returns `null`. See also {@link back}.
+   * **Note:** Unlike with the `[]` operator (`array[0]`), an error is generated without stopping project execution.
+   */
+  front(): T;
+  /**
+   * Returns the element at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `null`.
+   * This method is similar (but not identical) to the `[]` operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.
+   */
+  get(index: int): T;
+  /**
+   * Returns the built-in {@link Variant} type of the typed array as a {@link Variant.Type} constant. If the array is not typed, returns {@link TYPE_NIL}. See also {@link is_typed}.
+   */
+  get_typed_builtin(): int;
+  /**
+   * Returns the **built-in** class name of the typed array, if the built-in {@link Variant} type {@link TYPE_OBJECT}. Otherwise, returns an empty {@link StringName}. See also {@link is_typed} and {@link Object.get_class}.
+   */
+  get_typed_class_name(): string;
+  /**
+   * Returns the {@link Script} instance associated with this typed array, or `null` if it does not exist. See also {@link is_typed}.
+   */
+  get_typed_script(): unknown;
+  /**
+   * Returns `true` if the array contains the given `value`.
+   * In GDScript, this is equivalent to the `in` operator:
+   * **Note:** For performance reasons, the search is affected by the `value`'s {@link Variant.Type}. For example, `7` ([int]) and `7.0` ([float]) are not considered equal for this method.
+   */
+  has(value: T): boolean;
+  /**
+   * Returns a hashed 32-bit integer value representing the array and its contents.
+   * **Note:** Arrays with equal hash values are *not* guaranteed to be the same, as a result of hash collisions. On the contrary, arrays with different hash values are guaranteed to be different.
+   */
+  hash(): int;
+  /**
+   * Inserts a new element (`value`) at a given index (`position`) in the array. `position` should be between `0` and the array's {@link size}. If negative, `position` is considered relative to the end of the array.
+   * Returns {@link OK} on success, or one of the other {@link Error} constants if this method fails.
+   * **Note:** Every element's index after `position` needs to be shifted forward, which may have a noticeable performance cost, especially on larger arrays.
+   */
+  insert(position: int, value: T): int;
+  /** Returns `true` if the array is empty (`[]`). See also {@link size}. */
+  is_empty(): boolean;
+  /**
+   * Returns `true` if the array is read-only. See {@link make_read_only}.
+   * In GDScript, arrays are automatically read-only if declared with the `const` keyword.
+   */
+  is_read_only(): boolean;
+  /** Returns `true` if this array is typed the same as the given `array`. See also {@link is_typed}. */
+  is_same_typed(array: Array<T>): boolean;
+  /**
+   * Returns `true` if the array is typed. Typed arrays can only contain elements of a specific type, as defined by the typed array constructor. The methods of a typed array are still expected to return a generic {@link Variant}.
+   * In GDScript, it is possible to define a typed array with static typing:
+   */
+  is_typed(): boolean;
+  /**
+   * Makes the array read-only. The array's elements cannot be overridden with different values, and their order cannot change. Does not apply to nested elements, such as dictionaries.
+   * In GDScript, arrays are automatically read-only if declared with the `const` keyword.
+   */
+  make_read_only(): void;
+  /**
+   * Calls the given {@link Callable} for each element in the array and returns a new array filled with values returned by the `method`.
+   * The `method` should take one {@link Variant} parameter (the current array element) and can return any {@link Variant}.
+   * See also {@link filter}, {@link reduce}, {@link any} and {@link all}.
+   */
+  map<U>(method: (value: T) => U): Array<U>;
+  /**
+   * Returns the maximum value contained in the array, if all elements can be compared. Otherwise, returns `null`. See also {@link min}.
+   * To find the maximum value using a custom comparator, you can use {@link reduce}.
+   */
+  max(): T;
+  /**
+   * Returns the minimum value contained in the array, if all elements can be compared. Otherwise, returns `null`. See also {@link max}.
+   */
+  min(): T;
+  /**
+   * Returns a random element from the array. Generates an error and returns `null` if the array is empty.
+   * **Note:** Like many similar functions in the engine (such as {@link @GlobalScope.randi} or {@link shuffle}), this method uses a common, global random seed. To get a predictable outcome from this method, see {@link @GlobalScope.seed}.
+   */
+  pick_random(): T;
+  /**
+   * Removes and returns the element of the array at index `position`. If negative, `position` is considered relative to the end of the array. Returns `null` if the array is empty. If `position` is out of bounds, an error message is also generated.
+   * **Note:** This method shifts every element's index after `position` back, which may have a noticeable performance cost, especially on larger arrays.
+   */
+  pop_at(position: int): T;
+  /**
+   * Removes and returns the last element of the array. Returns `null` if the array is empty, without generating an error. See also {@link pop_front}.
+   */
+  pop_back(): T;
+  /**
+   * Removes and returns the first element of the array. Returns `null` if the array is empty, without generating an error. See also {@link pop_back}.
+   * **Note:** This method shifts every other element's index back, which may have a noticeable performance cost, especially on larger arrays.
+   */
+  pop_front(): T;
+  /** Appends an element at the end of the array. See also {@link push_front}. */
+  push_back(value: T): void;
+  /**
+   * Adds an element at the beginning of the array. See also {@link push_back}.
+   * **Note:** This method shifts every other element's index forward, which may have a noticeable performance cost, especially on larger arrays.
+   */
+  push_front(value: T): void;
+  /**
+   * Calls the given {@link Callable} for each element in array, accumulates the result in `accum`, then returns it.
+   * The `method` takes two arguments: the current value of `accum` and the current array element. If `accum` is `null` (as by default), the iteration will start from the second element, with the first one used as initial value of `accum`.
+   * If {@link max} is not desirable, this method may also be used to implement a custom comparator:
+   * This method can also be used to count how many elements in an array satisfy a certain condition, similar to {@link count}:
+   * See also {@link map}, {@link filter}, {@link any}, and {@link all}.
+   */
+  reduce<U>(method: (accum: U, value: T) => U, accum: U): U;
+  reduce(method: (accum: T, value: T) => T, accum?: T): T;
+  /**
+   * Removes the element from the array at the given index (`position`). If the index is out of bounds, this method fails. If the index is negative, `position` is considered relative to the end of the array.
+   * If you need to return the removed element, use {@link pop_at}. To remove an element by value, use {@link erase} instead.
+   * **Note:** This method shifts every element's index after `position` back, which may have a noticeable performance cost, especially on larger arrays.
+   */
+  remove_at(position: int): void;
+  /**
+   * Sets the array's number of elements to `size`. If `size` is smaller than the array's current size, the elements at the end are removed. If `size` is greater, new default elements (usually `null`) are added, depending on the array's type.
+   * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@link ERR_LOCKED} if the array is read-only, {@link ERR_INVALID_PARAMETER} if the size is negative, or {@link ERR_OUT_OF_MEMORY} if allocations fail. Use {@link size} to find the actual size of the array after resize.
+   * **Note:** Calling this method once and assigning the new values is faster than calling {@link append} for every new element.
+   */
+  resize(size: int): int;
+  /** Reverses the order of all elements in the array. */
+  reverse(): void;
+  /**
+   * Returns the index of the **last** occurrence of `what` in this array, or `-1` if there are none. The search's start can be specified with `from`, continuing to the beginning of the array. This method is the reverse of {@link find}.
+   */
+  rfind(what: T, from_?: int): int;
+  /**
+   * Returns the index of the **last** element of the array that causes `method` to return `true`, or `-1` if there are none. The search's start can be specified with `from`, continuing to the beginning of the array. This method is the reverse of {@link find_custom}.
+   */
+  rfind_custom(method: (value: T) => boolean, from_?: int): int;
+  /**
+   * Sets the value of the element at the given `index` to the given `value`. This will not change the size of the array, it only changes the value at an index already in the array. This is the same as using the `[]` operator (`array[index] = value`).
+   */
+  set(index: int, value: T): void;
+  /**
+   * Shuffles all elements of the array in a random order.
+   * **Note:** Like many similar functions in the engine (such as {@link @GlobalScope.randi} or {@link pick_random}), this method uses a common, global random seed. To get a predictable outcome from this method, see {@link @GlobalScope.seed}.
+   */
+  shuffle(): void;
+  /**
+   * Returns the number of elements in the array. Empty arrays (`[]`) always return `0`. See also {@link is_empty}.
+   */
+  size(): int;
+  /**
+   * Returns a new {@link Array} containing this array's elements, from index `begin` (inclusive) to `end` (exclusive), every `step` elements.
+   * If either `begin` or `end` are negative, their value is relative to the end of the array.
+   * If `step` is negative, this method iterates through the array in reverse, returning a slice ordered backwards. For this to work, `begin` must be greater than `end`.
+   * If `deep` is `true`, all nested {@link Array} and {@link Dictionary} elements in the slice are duplicated from the original, recursively. See also {@link duplicate}.
+   */
+  slice(begin: int, end?: int, step?: int, deep?: boolean): Array<T>;
+  /**
+   * Sorts the array in ascending order. The final order is dependent on the "less than" (`<`) comparison between elements.
+   * **Note:** The sorting algorithm used is not stable (https://en.wikipedia.org/wiki/Sorting_algorithm#Stability). This means that equivalent elements (such as `2` and `2.0`) may have their order changed when calling {@link sort}.
+   */
+  sort(): void;
+  /**
+   * Sorts the array using a custom {@link Callable}.
+   * `func` is called as many times as necessary, receiving two array elements as arguments. The function should return `true` if the first element should be moved *before* the second one, otherwise it should return `false`.
+   * It may also be necessary to use this method to sort strings by natural order, with {@link String.naturalnocasecmp_to}, as in the following example:
+   * **Note:** In C#, this method is not supported.
+   * **Note:** The sorting algorithm used is not stable (https://en.wikipedia.org/wiki/Sorting_algorithm#Stability). This means that values considered equal may have their order changed when calling this method.
+   * **Note:** You should not randomize the return value of `func`, as the heapsort algorithm expects a consistent result. Randomizing the return value will result in unexpected behavior.
+   */
+  sort_custom(func: (a: T, b: T) => boolean): void;
+
+  // Operator overloads
+  [__ops_ne]: { right: Array<unknown>; ret: boolean };
+  [__ops_add]: { right: Array<unknown>; ret: Array<unknown> };
+  [__ops_lt]: { right: Array<unknown>; ret: boolean };
+  [__ops_lte]: { right: Array<unknown>; ret: boolean };
+  [__ops_eq]: { right: Array<unknown>; ret: boolean };
+  [__ops_gt]: { right: Array<unknown>; ret: boolean };
+  [__ops_gte]: { right: Array<unknown>; ret: boolean };
+
+  [__variant_converts]: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array;
+  [Symbol.iterator](): IterableIterator<T>;
+  [index: number]: T;
+}
+
+declare interface ArrayConstructor {
+  <T>(): Array<T>;
+  <T>(...items: T[]): Array<T>;
+  <T>(from_: PackedByteArray): Array<T>;
+  <T>(from_: PackedColorArray): Array<T>;
+  <T>(from_: PackedFloat32Array): Array<T>;
+  <T>(from_: PackedFloat64Array): Array<T>;
+  <T>(from_: PackedInt32Array): Array<T>;
+  <T>(from_: PackedInt64Array): Array<T>;
+  <T>(from_: PackedStringArray): Array<T>;
+  <T>(from_: PackedVector2Array): Array<T>;
+  <T>(from_: PackedVector3Array): Array<T>;
+  <T>(from_: PackedVector4Array): Array<T>;
+}
+declare var Array: ArrayConstructor;

package/typings/classes/ArrayMesh.d.ts

@@ -0,0 +1,94 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** {@link Mesh} type that provides utility for constructing a surface from arrays. */
+declare class ArrayMesh extends Mesh {
+  /** The blend shape mode. */
+  blend_shape_mode: int;
+  /**
+   * Overrides the {@link AABB} with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices.
+   */
+  custom_aabb: AABB;
+  /**
+   * An optional mesh which can be used for rendering shadows and the depth prepass. Can be used to increase performance by supplying a mesh with fused vertices and only vertex position data (without normals, UVs, colors, etc.).
+   * **Note:** This mesh must have exactly the same vertex positions as the source mesh (including the source mesh's LODs, if present). If vertex positions differ, then the mesh will not draw correctly.
+   */
+  shadow_mesh: ArrayMesh | null;
+  set_blend_shape_mode(value: int): void;
+  get_blend_shape_mode(): int;
+  set_custom_aabb(value: AABB): void;
+  get_custom_aabb(): AABB;
+  set_shadow_mesh(value: ArrayMesh | null): void;
+  get_shadow_mesh(): ArrayMesh | null;
+
+  /**
+   * Adds name for a blend shape that will be added with {@link add_surface_from_arrays}. Must be called before surface is added.
+   */
+  add_blend_shape(name: string): void;
+  /**
+   * Creates a new surface. {@link Mesh.get_surface_count} will become the `surf_idx` for this new surface.
+   * Surfaces are created to be rendered using a `primitive`, which may be any of the values defined in {@link Mesh.PrimitiveType}.
+   * The `arrays` argument is an array of arrays. Each of the {@link Mesh.ARRAY_MAX} elements contains an array with some of the mesh data for this surface as described by the corresponding member of {@link Mesh.ArrayType} or `null` if it is not used by the surface. For example, `arrays[0]` is the array of vertices. That first vertex sub-array is always required; the others are optional. Adding an index array puts this surface into "index mode" where the vertex and other arrays become the sources of data and the index array defines the vertex order. All sub-arrays must have the same length as the vertex array (or be an exact multiple of the vertex array's length, when multiple elements of a sub-array correspond to a single vertex) or be empty, except for {@link Mesh.ARRAY_INDEX} if it is used.
+   * The `blend_shapes` argument is an array of vertex data for each blend shape. Each element is an array of the same structure as `arrays`, but {@link Mesh.ARRAY_VERTEX}, {@link Mesh.ARRAY_NORMAL}, and {@link Mesh.ARRAY_TANGENT} are set if and only if they are set in `arrays` and all other entries are `null`.
+   * The `lods` argument is a dictionary with [float] keys and {@link PackedInt32Array} values. Each entry in the dictionary represents an LOD level of the surface, where the value is the {@link Mesh.ARRAY_INDEX} array to use for the LOD level and the key is roughly proportional to the distance at which the LOD stats being used. I.e., increasing the key of an LOD also increases the distance that the objects has to be from the camera before the LOD is used.
+   * The `flags` argument is the bitwise OR of, as required: One value of {@link Mesh.ArrayCustomFormat} left shifted by `ARRAY_FORMAT_CUSTOMn_SHIFT` for each custom channel in use, {@link Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE}, {@link Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS}, or {@link Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY}.
+   * **Note:** When using indices, it is recommended to only use points, lines, or triangles.
+   */
+  add_surface_from_arrays(primitive: int, arrays: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, blend_shapes?: Array<Array<unknown>>, lods?: Dictionary, flags?: int): void;
+  /** Removes all blend shapes from this {@link ArrayMesh}. */
+  clear_blend_shapes(): void;
+  /** Removes all surfaces from this {@link ArrayMesh}. */
+  clear_surfaces(): void;
+  /** Returns the number of blend shapes that the {@link ArrayMesh} holds. */
+  get_blend_shape_count(): int;
+  /** Returns the name of the blend shape at this index. */
+  get_blend_shape_name(index: int): string;
+  /** Performs a UV unwrap on the {@link ArrayMesh} to prepare the mesh for lightmapping. */
+  lightmap_unwrap(transform: Transform3D | Projection, texel_size: float): int;
+  /** Regenerates tangents for each of the {@link ArrayMesh}'s surfaces. */
+  regen_normal_maps(): void;
+  /** Sets the name of the blend shape at this index. */
+  set_blend_shape_name(index: int, name: string): void;
+  /**
+   * Returns the index of the first surface with this name held within this {@link ArrayMesh}. If none are found, -1 is returned.
+   */
+  surface_find_by_name(name: string | NodePath): int;
+  /**
+   * Returns the length in indices of the index array in the requested surface (see {@link add_surface_from_arrays}).
+   */
+  surface_get_array_index_len(surf_idx: int): int;
+  /**
+   * Returns the length in vertices of the vertex array in the requested surface (see {@link add_surface_from_arrays}).
+   */
+  surface_get_array_len(surf_idx: int): int;
+  /** Returns the format mask of the requested surface (see {@link add_surface_from_arrays}). */
+  surface_get_format(surf_idx: int): int;
+  /** Gets the name assigned to this surface. */
+  surface_get_name(surf_idx: int): string;
+  /** Returns the primitive type of the requested surface (see {@link add_surface_from_arrays}). */
+  surface_get_primitive_type(surf_idx: int): int;
+  /**
+   * Removes the surface at the given index from the Mesh, shifting surfaces with higher index down by one.
+   */
+  surface_remove(surf_idx: int): void;
+  /** Sets a name for a given surface. */
+  surface_set_name(surf_idx: int, name: string | NodePath): void;
+  /**
+   * Updates the attribute buffer of this mesh's surface with the given `data`. The expected data per attribute is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.mesh_surface_get_format_attribute_stride}.
+   * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each attribute.
+   * A {@link PackedVector3Array} of attribute locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.to_byte_array} for use in `data`.
+   */
+  surface_update_attribute_region(surf_idx: int, offset: int, data: PackedByteArray | Array<unknown>): void;
+  /**
+   * Updates the skin buffer of this mesh's surface with the given `data`. The expected data per skin is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.mesh_surface_get_format_skin_stride}.
+   * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each skin.
+   * A {@link PackedVector3Array} of skin locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.to_byte_array} for use in `data`.
+   */
+  surface_update_skin_region(surf_idx: int, offset: int, data: PackedByteArray | Array<unknown>): void;
+  /**
+   * Updates the vertex buffer of this mesh's surface with the given `data`. The expected data per vertex is 12 or 8 bytes (4 bytes per float, 2 floats per {@link Vector2}, and 3 floats per {@link Vector3}) depending on if the mesh is using {@link Vector3} or {@link Vector2} vertices. This value can be determined with {@link RenderingServer.mesh_surface_get_format_vertex_stride}.
+   * The starting point of the updates can be changed with `offset`. The value of `offset` should be a multiple of 12 bytes in most cases to align to each vertex.
+   * A {@link PackedVector3Array} of vertex locations can be converted into a {@link PackedByteArray} using {@link PackedVector3Array.to_byte_array} for use in `data`.
+   */
+  surface_update_vertex_region(surf_idx: int, offset: int, data: PackedByteArray | Array<unknown>): void;
+}

package/typings/classes/ArrayOccluder3D.d.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** 3D polygon shape for use with occlusion culling in {@link OccluderInstance3D}. */
+declare class ArrayOccluder3D extends Occluder3D {
+  /**
+   * The occluder's index position. Indices determine which points from the {@link vertices} array should be drawn, and in which order.
+   * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link set_arrays} instead to avoid updating the occluder twice when it's created.
+   */
+  indices: PackedInt32Array;
+  /**
+   * The occluder's vertex positions in local 3D coordinates.
+   * **Note:** The occluder is always updated after setting this value. If creating occluders procedurally, consider using {@link set_arrays} instead to avoid updating the occluder twice when it's created.
+   */
+  vertices: PackedVector3Array;
+  set_indices(value: PackedInt32Array | Array<unknown>): void;
+  set_vertices(value: PackedVector3Array | Array<unknown>): void;
+
+  /**
+   * Sets {@link indices} and {@link vertices}, while updating the final occluder only once after both values are set.
+   */
+  set_arrays(vertices: PackedVector3Array | Array<unknown>, indices: PackedInt32Array | Array<unknown>): void;
+}

package/typings/classes/AspectRatioContainer.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that preserves the proportions of its child controls. */
+declare class AspectRatioContainer extends Container {
+  /** Specifies the horizontal relative position of child controls. */
+  alignment_horizontal: int;
+  /** Specifies the vertical relative position of child controls. */
+  alignment_vertical: int;
+  /**
+   * The aspect ratio to enforce on child controls. This is the width divided by the height. The ratio depends on the {@link stretch_mode}.
+   */
+  ratio: float;
+  /** The stretch mode used to align child controls. */
+  stretch_mode: int;
+  set_alignment_horizontal(value: int): void;
+  get_alignment_horizontal(): int;
+  set_alignment_vertical(value: int): void;
+  get_alignment_vertical(): int;
+  set_ratio(value: float): void;
+  get_ratio(): float;
+  set_stretch_mode(value: int): void;
+  get_stretch_mode(): int;
+
+  // enum StretchMode
+  /** The height of child controls is automatically adjusted based on the width of the container. */
+  static readonly STRETCH_WIDTH_CONTROLS_HEIGHT: int;
+  /** The width of child controls is automatically adjusted based on the height of the container. */
+  static readonly STRETCH_HEIGHT_CONTROLS_WIDTH: int;
+  /**
+   * The bounding rectangle of child controls is automatically adjusted to fit inside the container while keeping the aspect ratio.
+   */
+  static readonly STRETCH_FIT: int;
+  /**
+   * The width and height of child controls is automatically adjusted to make their bounding rectangle cover the entire area of the container while keeping the aspect ratio.
+   * When the bounding rectangle of child controls exceed the container's size and {@link Control.clip_contents} is enabled, this allows to show only the container's area restricted by its own bounding rectangle.
+   */
+  static readonly STRETCH_COVER: int;
+  // enum AlignmentMode
+  /** Aligns child controls with the beginning (left or top) of the container. */
+  static readonly ALIGNMENT_BEGIN: int;
+  /** Aligns child controls with the center of the container. */
+  static readonly ALIGNMENT_CENTER: int;
+  /** Aligns child controls with the end (right or bottom) of the container. */
+  static readonly ALIGNMENT_END: int;
+}

package/typings/classes/AtlasTexture.d.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A texture that crops out part of another Texture2D. */
+declare class AtlasTexture extends Texture2D {
+  /**
+   * The texture that contains the atlas. Can be any type inheriting from {@link Texture2D}, including another {@link AtlasTexture}.
+   */
+  atlas: Texture2D | null;
+  /**
+   * If `true`, the area outside of the {@link region} is clipped to avoid bleeding of the surrounding texture pixels.
+   */
+  filter_clip: boolean;
+  /**
+   * The margin around the {@link region}. Useful for small adjustments. If the {@link Rect2.size} of this property ("w" and "h" in the editor) is set, the drawn texture is resized to fit within the margin.
+   */
+  margin: Rect2;
+  /**
+   * The region used to draw the {@link atlas}. If either dimension of the region's size is `0`, the value from {@link atlas} size will be used for that axis instead.
+   * **Note:** The image size is always an integer, so the actual region size is rounded down.
+   */
+  region: Rect2;
+  resource_local_to_scene: boolean;
+  set_atlas(value: Texture2D | null): void;
+  get_atlas(): Texture2D | null;
+  set_filter_clip(value: boolean): void;
+  has_filter_clip(): boolean;
+  set_margin(value: Rect2 | Rect2i): void;
+  get_margin(): Rect2;
+  set_region(value: Rect2 | Rect2i): void;
+  get_region(): Rect2;
+}

package/typings/classes/AudioBusLayout.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Stores information about the audio buses. */
+declare class AudioBusLayout extends Resource {
+}

package/typings/classes/AudioEffect.d.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for audio effect resources. */
+declare class AudioEffect extends Resource {
+  /**
+   * Override this method to customize the {@link AudioEffectInstance} created when this effect is applied on a bus in the editor's Audio panel, or through {@link AudioServer.add_bus_effect}.
+   * **Note:** It is recommended to keep a reference to the original {@link AudioEffect} in the new instance. Depending on the implementation this allows the effect instance to listen for changes at run-time and be modified accordingly.
+   */
+  _instantiate(): AudioEffectInstance | null;
+}

package/typings/classes/AudioEffectAmplify.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Adds a volume manipulation audio effect to an audio bus. */
+declare class AudioEffectAmplify extends AudioEffect {
+  /**
+   * Amount of amplification in dB. Positive values make the sound louder, negative values make it quieter. Value can range from -80 to 24.
+   */
+  volume_db: float;
+  /**
+   * Amount of amplification as a linear value.
+   * **Note:** This member modifies {@link volume_db} for convenience. The returned value is equivalent to the result of {@link @GlobalScope.db_to_linear} on {@link volume_db}. Setting this member is equivalent to setting {@link volume_db} to the result of {@link @GlobalScope.linear_to_db} on a value.
+   */
+  volume_linear: float;
+  set_volume_db(value: float): void;
+  get_volume_db(): float;
+  set_volume_linear(value: float): void;
+  get_volume_linear(): float;
+}

package/typings/classes/AudioEffectBandLimitFilter.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Adds a band-limit filter to an audio bus. */
+declare class AudioEffectBandLimitFilter extends AudioEffectFilter {
+}

package/typings/classes/AudioEffectBandPassFilter.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Adds a band-pass filter to an audio bus. */
+declare class AudioEffectBandPassFilter extends AudioEffectFilter {
+}

package/typings/classes/AudioEffectCapture.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Exposes audio samples from an audio bus in real-time, such that it can be accessed as data. */
+declare class AudioEffectCapture extends AudioEffect {
+  /**
+   * Length of the internal ring buffer, in seconds. Higher values keep data around for longer, but require more memory. Value can range from 0.01 to 10.
+   * **Note:** Setting the buffer length will have no effect if already initialized.
+   */
+  buffer_length: float;
+  set_buffer_length(value: float): void;
+  get_buffer_length(): float;
+
+  /** Returns `true` if at least `frames` samples are available to read in the internal ring buffer. */
+  can_get_buffer(frames: int): boolean;
+  /**
+   * Clears the internal ring buffer.
+   * **Note:** Calling this during a capture can cause the loss of samples which causes popping in the playback.
+   */
+  clear_buffer(): void;
+  /**
+   * Gets the next `frames` samples from the internal ring buffer.
+   * Returns a {@link PackedVector2Array} containing exactly `frames` samples if available, or an empty {@link PackedVector2Array} if insufficient data was available.
+   * The samples are signed floating-point PCM between `-1` and `1`. You will have to scale them if you want to use them as 8 or 16-bit integer samples. (`v = 0x7fff * samples[0].x`)
+   */
+  get_buffer(frames: int): PackedVector2Array;
+  /** Returns the total size of the internal ring buffer in number of samples. */
+  get_buffer_length_frames(): int;
+  /** Returns the number of samples discarded from the audio bus due to full buffer. */
+  get_discarded_frames(): int;
+  /** Returns the number of samples available to read using {@link get_buffer}. */
+  get_frames_available(): int;
+  /** Returns the number of samples inserted from the audio bus. */
+  get_pushed_frames(): int;
+}