typescript-to-gdscript 0.1.0

package/typings/classes/PackedStringArray.d.ts

@@ -0,0 +1,124 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of {@link String}s. */
+declare interface PackedStringArray {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: string | NodePath): boolean;
+  /** Appends a {@link PackedStringArray} at the end of this array. */
+  append_array(array: PackedStringArray | Array<unknown>): void;
+  /**
+   * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a `before` specifier can be passed. If `false`, the returned index comes after all existing entries of the value in the array.
+   * **Note:** Calling {@link bsearch} on an unsorted array results in unexpected behavior.
+   */
+  bsearch(value: string | NodePath, before?: boolean): int;
+  /** Clears 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. */
+  count(value: string | NodePath): int;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedStringArray;
+  /**
+   * Removes the first occurrence of a value from the array and returns `true`. If the value does not exist in the array, nothing happens and `false` is returned. To remove an element by index, use {@link remove_at} instead.
+   */
+  erase(value: string | NodePath): boolean;
+  /**
+   * Assigns the given value to all elements in the array. This can typically be used together with {@link resize} to create an array with a given size and initialized elements.
+   */
+  fill(value: string | NodePath): void;
+  /**
+   * Searches the array for a value and returns its index or `-1` if not found. Optionally, the initial search index can be passed.
+   */
+  find(value: string | NodePath, from_?: int): int;
+  /**
+   * Returns the {@link String} at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns an empty string.
+   * 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): string;
+  /** Returns `true` if the array contains `value`. */
+  has(value: string | NodePath): boolean;
+  /**
+   * Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (`idx == size()`).
+   */
+  insert(at_index: int, value: string | NodePath): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Appends a string element at end of the array. */
+  push_back(value: string | NodePath): boolean;
+  /** Removes an element from the array by index. */
+  remove_at(index: int): void;
+  /**
+   * Sets the size of the array. If the array is grown, reserves elements at the end of the array. If the array is shrunk, truncates the array to the new size. Calling {@link resize} once and assigning the new values is faster than adding new elements one by one.
+   * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@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.
+   */
+  resize(new_size: int): int;
+  /** Reverses the order of the elements in the array. */
+  reverse(): void;
+  /**
+   * Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
+   */
+  rfind(value: string | NodePath, from_?: int): int;
+  /** Changes the {@link String} at the given index. */
+  set(index: int, value: string | NodePath): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedStringArray}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedStringArray}.
+   * The absolute value of `begin` and `end` will be clamped to the array size, so the default value for `end` makes it slice to the size of the array by default (i.e. `arr.slice(1)` is a shorthand for `arr.slice(1, arr.size())`).
+   * If either `begin` or `end` are negative, they will be relative to the end of the array (i.e. `arr.slice(0, -2)` is a shorthand for `arr.slice(0, arr.size() - 2)`).
+   */
+  slice(begin: int, end?: int): PackedStringArray;
+  /** Sorts the elements of the array in ascending order. */
+  sort(): void;
+  /** Returns a {@link PackedByteArray} with each string encoded as UTF-8. Strings are `null` terminated. */
+  to_byte_array(): PackedByteArray;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedStringArray; ret: boolean };
+  [__ops_add]: { right: PackedStringArray; ret: PackedStringArray };
+  [__ops_eq]: { right: PackedStringArray; ret: boolean };
+
+  [__variant_converts]: PackedStringArray | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<string>;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  duplicate_deep: never;
+  find_key: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has_all: never;
+  hash: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  values: never;
+}
+
+declare interface PackedStringArrayConstructor {
+  readonly prototype: PackedStringArray;
+  /** Constructs an empty {@link PackedStringArray}. */
+  (): PackedStringArray;
+  /** Constructs a {@link PackedStringArray} as a copy of the given {@link PackedStringArray}. */
+  (from_: PackedStringArray): PackedStringArray;
+  /**
+   * Constructs a new {@link PackedStringArray}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   */
+  (from_: Array<unknown>): PackedStringArray;
+}
+declare const PackedStringArray: PackedStringArrayConstructor;

package/typings/classes/PackedVector2Array.d.ts

@@ -0,0 +1,139 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of {@link Vector2}s. */
+declare interface PackedVector2Array {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: Vector2 | Vector2i): boolean;
+  /** Appends a {@link PackedVector2Array} at the end of this array. */
+  append_array(array: PackedVector2Array | Array<unknown>): void;
+  /**
+   * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a `before` specifier can be passed. If `false`, the returned index comes after all existing entries of the value in the array.
+   * **Note:** Calling {@link bsearch} on an unsorted array results in unexpected behavior.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  bsearch(value: Vector2 | Vector2i, before?: boolean): int;
+  /** Clears 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.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  count(value: Vector2 | Vector2i): int;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedVector2Array;
+  /**
+   * Removes the first occurrence of a value from the array and returns `true`. If the value does not exist in the array, nothing happens and `false` is returned. To remove an element by index, use {@link remove_at} instead.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  erase(value: Vector2 | Vector2i): boolean;
+  /**
+   * Assigns the given value to all elements in the array. This can typically be used together with {@link resize} to create an array with a given size and initialized elements.
+   */
+  fill(value: Vector2 | Vector2i): void;
+  /**
+   * Searches the array for a value and returns its index or `-1` if not found. Optionally, the initial search index can be passed.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  find(value: Vector2 | Vector2i, from_?: int): int;
+  /**
+   * Returns the {@link Vector2} at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `Vector2(0, 0)`.
+   * 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): Vector2;
+  /**
+   * Returns `true` if the array contains `value`.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  has(value: Vector2 | Vector2i): boolean;
+  /**
+   * Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (`idx == size()`).
+   */
+  insert(at_index: int, value: Vector2 | Vector2i): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Inserts a {@link Vector2} at the end. */
+  push_back(value: Vector2 | Vector2i): boolean;
+  /** Removes an element from the array by index. */
+  remove_at(index: int): void;
+  /**
+   * Sets the size of the array. If the array is grown, reserves elements at the end of the array. If the array is shrunk, truncates the array to the new size. Calling {@link resize} once and assigning the new values is faster than adding new elements one by one.
+   * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@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.
+   */
+  resize(new_size: int): int;
+  /** Reverses the order of the elements in the array. */
+  reverse(): void;
+  /**
+   * Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  rfind(value: Vector2 | Vector2i, from_?: int): int;
+  /** Changes the {@link Vector2} at the given index. */
+  set(index: int, value: Vector2 | Vector2i): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedVector2Array}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedVector2Array}.
+   * The absolute value of `begin` and `end` will be clamped to the array size, so the default value for `end` makes it slice to the size of the array by default (i.e. `arr.slice(1)` is a shorthand for `arr.slice(1, arr.size())`).
+   * If either `begin` or `end` are negative, they will be relative to the end of the array (i.e. `arr.slice(0, -2)` is a shorthand for `arr.slice(0, arr.size() - 2)`).
+   */
+  slice(begin: int, end?: int): PackedVector2Array;
+  /**
+   * Sorts the elements of the array in ascending order.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  sort(): void;
+  /** Returns a {@link PackedByteArray} with each vector encoded as bytes. */
+  to_byte_array(): PackedByteArray;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedVector2Array; ret: boolean };
+  [__ops_mul]: { right: Transform2D; ret: PackedVector2Array };
+  [__ops_add]: { right: PackedVector2Array; ret: PackedVector2Array };
+  [__ops_eq]: { right: PackedVector2Array; ret: boolean };
+
+  [__variant_converts]: PackedVector2Array | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<Vector2>;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  duplicate_deep: never;
+  find_key: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has_all: never;
+  hash: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  values: never;
+}
+
+declare interface PackedVector2ArrayConstructor {
+  readonly prototype: PackedVector2Array;
+  /** Constructs an empty {@link PackedVector2Array}. */
+  (): PackedVector2Array;
+  /** Constructs a {@link PackedVector2Array} as a copy of the given {@link PackedVector2Array}. */
+  (from_: PackedVector2Array): PackedVector2Array;
+  /**
+   * Constructs a new {@link PackedVector2Array}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   * **Note:** When initializing a {@link PackedVector2Array} with elements, it must be initialized with an {@link Array} of {@link Vector2} values:
+   */
+  (from_: Array<unknown>): PackedVector2Array;
+}
+declare const PackedVector2Array: PackedVector2ArrayConstructor;

package/typings/classes/PackedVector3Array.d.ts

@@ -0,0 +1,139 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of {@link Vector3}s. */
+declare interface PackedVector3Array {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: Vector3 | Vector3i): boolean;
+  /** Appends a {@link PackedVector3Array} at the end of this array. */
+  append_array(array: PackedVector3Array | Array<unknown>): void;
+  /**
+   * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a `before` specifier can be passed. If `false`, the returned index comes after all existing entries of the value in the array.
+   * **Note:** Calling {@link bsearch} on an unsorted array results in unexpected behavior.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  bsearch(value: Vector3 | Vector3i, before?: boolean): int;
+  /** Clears 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.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  count(value: Vector3 | Vector3i): int;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedVector3Array;
+  /**
+   * Removes the first occurrence of a value from the array and returns `true`. If the value does not exist in the array, nothing happens and `false` is returned. To remove an element by index, use {@link remove_at} instead.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  erase(value: Vector3 | Vector3i): boolean;
+  /**
+   * Assigns the given value to all elements in the array. This can typically be used together with {@link resize} to create an array with a given size and initialized elements.
+   */
+  fill(value: Vector3 | Vector3i): void;
+  /**
+   * Searches the array for a value and returns its index or `-1` if not found. Optionally, the initial search index can be passed.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  find(value: Vector3 | Vector3i, from_?: int): int;
+  /**
+   * Returns the {@link Vector3} at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `Vector3(0, 0, 0)`.
+   * 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): Vector3;
+  /**
+   * Returns `true` if the array contains `value`.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  has(value: Vector3 | Vector3i): boolean;
+  /**
+   * Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (`idx == size()`).
+   */
+  insert(at_index: int, value: Vector3 | Vector3i): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Inserts a {@link Vector3} at the end. */
+  push_back(value: Vector3 | Vector3i): boolean;
+  /** Removes an element from the array by index. */
+  remove_at(index: int): void;
+  /**
+   * Sets the size of the array. If the array is grown, reserves elements at the end of the array. If the array is shrunk, truncates the array to the new size. Calling {@link resize} once and assigning the new values is faster than adding new elements one by one.
+   * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@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.
+   */
+  resize(new_size: int): int;
+  /** Reverses the order of the elements in the array. */
+  reverse(): void;
+  /**
+   * Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  rfind(value: Vector3 | Vector3i, from_?: int): int;
+  /** Changes the {@link Vector3} at the given index. */
+  set(index: int, value: Vector3 | Vector3i): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedVector3Array}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedVector3Array}.
+   * The absolute value of `begin` and `end` will be clamped to the array size, so the default value for `end` makes it slice to the size of the array by default (i.e. `arr.slice(1)` is a shorthand for `arr.slice(1, arr.size())`).
+   * If either `begin` or `end` are negative, they will be relative to the end of the array (i.e. `arr.slice(0, -2)` is a shorthand for `arr.slice(0, arr.size() - 2)`).
+   */
+  slice(begin: int, end?: int): PackedVector3Array;
+  /**
+   * Sorts the elements of the array in ascending order.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  sort(): void;
+  /** Returns a {@link PackedByteArray} with each vector encoded as bytes. */
+  to_byte_array(): PackedByteArray;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedVector3Array; ret: boolean };
+  [__ops_mul]: { right: Transform3D; ret: PackedVector3Array };
+  [__ops_add]: { right: PackedVector3Array; ret: PackedVector3Array };
+  [__ops_eq]: { right: PackedVector3Array; ret: boolean };
+
+  [__variant_converts]: PackedVector3Array | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<Vector3>;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  duplicate_deep: never;
+  find_key: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has_all: never;
+  hash: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  values: never;
+}
+
+declare interface PackedVector3ArrayConstructor {
+  readonly prototype: PackedVector3Array;
+  /** Constructs an empty {@link PackedVector3Array}. */
+  (): PackedVector3Array;
+  /** Constructs a {@link PackedVector3Array} as a copy of the given {@link PackedVector3Array}. */
+  (from_: PackedVector3Array): PackedVector3Array;
+  /**
+   * Constructs a new {@link PackedVector3Array}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   * **Note:** When initializing a {@link PackedVector3Array} with elements, it must be initialized with an {@link Array} of {@link Vector3} values:
+   */
+  (from_: Array<unknown>): PackedVector3Array;
+}
+declare const PackedVector3Array: PackedVector3ArrayConstructor;

package/typings/classes/PackedVector4Array.d.ts

@@ -0,0 +1,138 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of {@link Vector4}s. */
+declare interface PackedVector4Array {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: Vector4 | Vector4i): boolean;
+  /** Appends a {@link PackedVector4Array} at the end of this array. */
+  append_array(array: PackedVector4Array | Array<unknown>): void;
+  /**
+   * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. Optionally, a `before` specifier can be passed. If `false`, the returned index comes after all existing entries of the value in the array.
+   * **Note:** Calling {@link bsearch} on an unsorted array results in unexpected behavior.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  bsearch(value: Vector4 | Vector4i, before?: boolean): int;
+  /** Clears 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.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  count(value: Vector4 | Vector4i): int;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedVector4Array;
+  /**
+   * Removes the first occurrence of a value from the array and returns `true`. If the value does not exist in the array, nothing happens and `false` is returned. To remove an element by index, use {@link remove_at} instead.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  erase(value: Vector4 | Vector4i): boolean;
+  /**
+   * Assigns the given value to all elements in the array. This can typically be used together with {@link resize} to create an array with a given size and initialized elements.
+   */
+  fill(value: Vector4 | Vector4i): void;
+  /**
+   * Searches the array for a value and returns its index or `-1` if not found. Optionally, the initial search index can be passed.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  find(value: Vector4 | Vector4i, from_?: int): int;
+  /**
+   * Returns the {@link Vector4} at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `Vector4(0, 0, 0, 0)`.
+   * 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): Vector4;
+  /**
+   * Returns `true` if the array contains `value`.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  has(value: Vector4 | Vector4i): boolean;
+  /**
+   * Inserts a new element at a given position in the array. The position must be valid, or at the end of the array (`idx == size()`).
+   */
+  insert(at_index: int, value: Vector4 | Vector4i): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Inserts a {@link Vector4} at the end. */
+  push_back(value: Vector4 | Vector4i): boolean;
+  /** Removes an element from the array by index. */
+  remove_at(index: int): void;
+  /**
+   * Sets the size of the array. If the array is grown, reserves elements at the end of the array. If the array is shrunk, truncates the array to the new size. Calling {@link resize} once and assigning the new values is faster than adding new elements one by one.
+   * Returns {@link OK} on success, or one of the following {@link Error} constants if this method fails: {@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.
+   */
+  resize(new_size: int): int;
+  /** Reverses the order of the elements in the array. */
+  reverse(): void;
+  /**
+   * Searches the array in reverse order. Optionally, a start search index can be passed. If negative, the start index is considered relative to the end of the array.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  rfind(value: Vector4 | Vector4i, from_?: int): int;
+  /** Changes the {@link Vector4} at the given index. */
+  set(index: int, value: Vector4 | Vector4i): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedVector4Array}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedVector4Array}.
+   * The absolute value of `begin` and `end` will be clamped to the array size, so the default value for `end` makes it slice to the size of the array by default (i.e. `arr.slice(1)` is a shorthand for `arr.slice(1, arr.size())`).
+   * If either `begin` or `end` are negative, they will be relative to the end of the array (i.e. `arr.slice(0, -2)` is a shorthand for `arr.slice(0, arr.size() - 2)`).
+   */
+  slice(begin: int, end?: int): PackedVector4Array;
+  /**
+   * Sorts the elements of the array in ascending order.
+   * **Note:** Vectors with {@link @GDScript.NAN} elements don't behave the same as other vectors. Therefore, the results from this method may not be accurate if NaNs are included.
+   */
+  sort(): void;
+  /** Returns a {@link PackedByteArray} with each vector encoded as bytes. */
+  to_byte_array(): PackedByteArray;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedVector4Array; ret: boolean };
+  [__ops_add]: { right: PackedVector4Array; ret: PackedVector4Array };
+  [__ops_eq]: { right: PackedVector4Array; ret: boolean };
+
+  [__variant_converts]: PackedVector4Array | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<Vector4>;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  duplicate_deep: never;
+  find_key: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has_all: never;
+  hash: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  values: never;
+}
+
+declare interface PackedVector4ArrayConstructor {
+  readonly prototype: PackedVector4Array;
+  /** Constructs an empty {@link PackedVector4Array}. */
+  (): PackedVector4Array;
+  /** Constructs a {@link PackedVector4Array} as a copy of the given {@link PackedVector4Array}. */
+  (from_: PackedVector4Array): PackedVector4Array;
+  /**
+   * Constructs a new {@link PackedVector4Array}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   * **Note:** When initializing a {@link PackedVector4Array} with elements, it must be initialized with an {@link Array} of {@link Vector4} values:
+   */
+  (from_: Array<unknown>): PackedVector4Array;
+}
+declare const PackedVector4Array: PackedVector4ArrayConstructor;

package/typings/classes/PacketPeer.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstraction and base class for packet-based protocols. */
+declare class PacketPeer extends RefCounted {
+  /**
+   * Maximum buffer size allowed when encoding {@link Variant}s. Raise this value to support heavier memory allocations.
+   * The {@link put_var} method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the {@link Variant}. If the {@link Variant} is bigger than {@link encode_buffer_max_size}, the method will error out with {@link ERR_OUT_OF_MEMORY}.
+   */
+  encode_buffer_max_size: int;
+  set_encode_buffer_max_size(value: int): void;
+  get_encode_buffer_max_size(): int;
+
+  /** Returns the number of packets currently available in the ring-buffer. */
+  get_available_packet_count(): int;
+  /** Gets a raw packet. */
+  get_packet(): PackedByteArray;
+  /** Returns the error state of the last packet received (via {@link get_packet} and {@link get_var}). */
+  get_packet_error(): int;
+  /**
+   * Gets a Variant. If `allow_objects` is `true`, decoding objects is allowed.
+   * Internally, this uses the same decoding mechanism as the {@link @GlobalScope.bytes_to_var} method.
+   * **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
+   */
+  get_var(allow_objects?: boolean): unknown;
+  /** Sends a raw packet. */
+  put_packet(buffer: PackedByteArray | Array<unknown>): int;
+  /**
+   * Sends a {@link Variant} as a packet. If `full_objects` is `true`, encoding objects is allowed (and can potentially include code).
+   * Internally, this uses the same encoding mechanism as the {@link @GlobalScope.var_to_bytes} method.
+   */
+  put_var(var_: unknown, full_objects?: boolean): int;
+}

package/typings/classes/PacketPeerDTLS.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** DTLS packet peer. */
+declare class PacketPeerDTLS extends PacketPeer {
+  /**
+   * Connects a `packet_peer` beginning the DTLS handshake using the underlying {@link PacketPeerUDP} which must be connected (see {@link PacketPeerUDP.connect_to_host}). You can optionally specify the `client_options` to be used while verifying the TLS connections. See {@link TLSOptions.client} and {@link TLSOptions.client_unsafe}.
+   */
+  connect_to_peer(packet_peer: PacketPeerUDP, hostname: string | NodePath, client_options?: TLSOptions): int;
+  /** Disconnects this peer, terminating the DTLS session. */
+  disconnect_from_peer(): void;
+  /** Returns the status of the connection. */
+  get_status(): int;
+  /**
+   * Poll the connection to check for incoming packets. Call this frequently to update the status and keep the connection working.
+   */
+  poll(): void;
+
+  // enum Status
+  /** A status representing a {@link PacketPeerDTLS} that is disconnected. */
+  static readonly STATUS_DISCONNECTED: int;
+  /**
+   * A status representing a {@link PacketPeerDTLS} that is currently performing the handshake with a remote peer.
+   */
+  static readonly STATUS_HANDSHAKING: int;
+  /** A status representing a {@link PacketPeerDTLS} that is connected to a remote peer. */
+  static readonly STATUS_CONNECTED: int;
+  /** A status representing a {@link PacketPeerDTLS} in a generic error state. */
+  static readonly STATUS_ERROR: int;
+  /**
+   * An error status that shows a mismatch in the DTLS certificate domain presented by the host and the domain requested for validation.
+   */
+  static readonly STATUS_ERROR_HOSTNAME_MISMATCH: int;
+}

package/typings/classes/PacketPeerExtension.d.ts

@@ -0,0 +1,9 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class PacketPeerExtension extends PacketPeer {
+  _get_available_packet_count(): int;
+  _get_max_packet_size(): int;
+  _get_packet(r_buffer: int, r_buffer_size: int): int;
+  _put_packet(p_buffer: int, p_buffer_size: int): int;
+}

package/typings/classes/PacketPeerStream.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Wrapper to use a PacketPeer over a StreamPeer. */
+declare class PacketPeerStream extends PacketPeer {
+  input_buffer_max_size: int;
+  output_buffer_max_size: int;
+  /** The wrapped {@link StreamPeer} object. */
+  stream_peer: StreamPeer | null;
+  set_input_buffer_max_size(value: int): void;
+  get_input_buffer_max_size(): int;
+  set_output_buffer_max_size(value: int): void;
+  get_output_buffer_max_size(): int;
+  set_stream_peer(value: StreamPeer | null): void;
+  get_stream_peer(): StreamPeer | null;
+}