typescript-to-gdscript 0.1.0

package/typings/classes/OptionButton.d.ts

@@ -0,0 +1,136 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A button that brings up a dropdown with selectable options when pressed. */
+declare class OptionButton extends Button {
+  /**
+   * <member name="alignment" type="int" setter="set_text_alignment" getter="get_text_alignment" overrides="Button" enum="HorizontalAlignment" default="0" />
+   * <member name="allow_reselect" type="bool" setter="set_allow_reselect" getter="get_allow_reselect" default="false">
+   * If `true`, the currently selected item can be selected again.
+   */
+  action_mode: int;
+  /** Enables the {@link PopupMenu} search bar if the item count is greater than `0`. */
+  enable_search_bar_on_item_count: int;
+  /**
+   * If `true`, minimum size will be determined by the longest item's text, instead of the currently selected one's.
+   * **Note:** For performance reasons, the minimum size doesn't update immediately when adding, removing or modifying items.
+   */
+  fit_to_longest_item: boolean;
+  /** The number of items to select from. */
+  item_count: int;
+  /** The index of the currently selected item, or `-1` if no item is selected. */
+  selected: int;
+  toggle_mode: boolean;
+  set_search_bar_enabled_on_item_count(value: int): void;
+  get_search_bar_enabled_on_item_count(): int;
+  set_fit_to_longest_item(value: boolean): void;
+  is_fit_to_longest_item(): boolean;
+  set_item_count(value: int): void;
+  get_item_count(): int;
+  _select_int(value: int): void;
+  get_selected(): int;
+
+  /**
+   * Adds an item, with a `texture` icon, text `label` and (optionally) `id`. If no `id` is passed, the item index will be used as the item's ID. New items are appended at the end.
+   * **Note:** The item will be selected if there are no other items.
+   */
+  add_icon_item(texture: Texture2D, label: string | NodePath, id?: int): void;
+  /**
+   * Adds an item, with text `label` and (optionally) `id`. If no `id` is passed, the item index will be used as the item's ID. New items are appended at the end.
+   * **Note:** The item will be selected if there are no other items.
+   */
+  add_item(label: string | NodePath, id?: int): void;
+  /**
+   * Adds a separator to the list of items. Separators help to group items, and can optionally be given a `text` header. A separator also gets an index assigned, and is appended at the end of the item list.
+   */
+  add_separator(text?: string | NodePath): void;
+  /** Clears all the items in the {@link OptionButton}. */
+  clear(): void;
+  /** Returns the auto translate mode of the item at index `idx`. */
+  get_item_auto_translate_mode(idx: int): int;
+  /** Returns the icon of the item at index `idx`. */
+  get_item_icon(idx: int): Texture2D | null;
+  /** Returns the ID of the item at index `idx`. */
+  get_item_id(idx: int): int;
+  /** Returns the index of the item with the given `id`. */
+  get_item_index(id: int): int;
+  /**
+   * Retrieves the metadata of an item. Metadata may be any type and can be used to store extra information about an item, such as an external string ID.
+   */
+  get_item_metadata(idx: int): unknown;
+  /** Returns the text of the item at index `idx`. */
+  get_item_text(idx: int): string;
+  /** Returns the tooltip of the item at index `idx`. */
+  get_item_tooltip(idx: int): string;
+  /**
+   * Returns the {@link PopupMenu} contained in this button.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link Window.visible} property.
+   */
+  get_popup(): PopupMenu;
+  /**
+   * Returns the index of the first item which is not disabled, or marked as a separator. If `from_last` is `true`, the items will be searched in reverse order.
+   * Returns `-1` if no item is found.
+   */
+  get_selectable_item(from_last?: boolean): int;
+  /** Returns the ID of the selected item, or `-1` if no item is selected. */
+  get_selected_id(): int;
+  /**
+   * Gets the metadata of the selected item. Metadata for items can be set using {@link set_item_metadata}.
+   */
+  get_selected_metadata(): unknown;
+  /**
+   * Returns `true` if this button contains at least one item which is not disabled, or marked as a separator.
+   */
+  has_selectable_items(): boolean;
+  /** Returns `true` if the item at index `idx` is disabled. */
+  is_item_disabled(idx: int): boolean;
+  /** Returns `true` if the item at index `idx` is marked as a separator. */
+  is_item_separator(idx: int): boolean;
+  /** Returns `true` if the search bar is enabled. */
+  is_search_bar_enabled(): boolean;
+  /** Removes the item at index `idx`. */
+  remove_item(idx: int): void;
+  /**
+   * Selects an item by index and makes it the current item. This will work even if the item is disabled.
+   * Passing `-1` as the index deselects any currently selected item.
+   */
+  select(idx: int): void;
+  /** If `true`, shortcuts are disabled and cannot be used to trigger the button. */
+  set_disable_shortcuts(disabled: boolean): void;
+  /**
+   * Sets the auto translate mode of the item at index `idx`.
+   * Items use {@link Node.AUTO_TRANSLATE_MODE_INHERIT} by default, which uses the same auto translate mode as the {@link OptionButton} itself.
+   */
+  set_item_auto_translate_mode(idx: int, mode: int): void;
+  /**
+   * Sets whether the item at index `idx` is disabled.
+   * Disabled items are drawn differently in the dropdown and are not selectable by the user. If the current selected item is set as disabled, it will remain selected.
+   */
+  set_item_disabled(idx: int, disabled: boolean): void;
+  /** Sets the icon of the item at index `idx`. */
+  set_item_icon(idx: int, texture: Texture2D): void;
+  /** Sets the ID of the item at index `idx`. */
+  set_item_id(idx: int, id: int): void;
+  /**
+   * Sets the metadata of an item. Metadata may be of any type and can be used to store extra information about an item, such as an external string ID.
+   */
+  set_item_metadata(idx: int, metadata: unknown): void;
+  /** Sets the text of the item at index `idx`. */
+  set_item_text(idx: int, text: string | NodePath): void;
+  /** Sets the tooltip of the item at index `idx`. */
+  set_item_tooltip(idx: int, tooltip: string | NodePath): void;
+  /**
+   * Adjusts popup position and sizing for the {@link OptionButton}, then shows the {@link PopupMenu}. Prefer this over using `get_popup().popup()`.
+   */
+  show_popup(): void;
+
+  /**
+   * Emitted when the user navigates to an item using the {@link ProjectSettings.input/ui_up} or {@link ProjectSettings.input/ui_down} input actions. The index of the item selected is passed as argument.
+   */
+  item_focused: Signal<[int]>;
+  /**
+   * Emitted when the current item has been changed by the user. The index of the item selected is passed as argument.
+   * {@link allow_reselect} must be enabled to reselect an item.
+   */
+  item_selected: Signal<[int]>;
+}

package/typings/classes/PCKPacker.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Creates packages that can be loaded into a running project. */
+declare class PCKPacker extends RefCounted {
+  /**
+   * Adds the `source_path` file to the current PCK package at the `target_path` internal path. The `res://` prefix for `target_path` is optional and stripped internally. File content is immediately written to the PCK.
+   */
+  add_file(target_path: string | NodePath, source_path: string | NodePath, encrypt?: boolean): int;
+  /**
+   * Adds the `data` to the current PCK package at the `target_path` internal path. The `res://` prefix for `target_path` is optional and stripped internally. File content is immediately written to the PCK.
+   */
+  add_file_from_buffer(target_path: string | NodePath, data: PackedByteArray | Array<unknown>, encrypt?: boolean): int;
+  /**
+   * Registers a file removal of the `target_path` internal path to the PCK. This is mainly used for patches. If the file at this path has been loaded from a previous PCK, it will be removed. The `res://` prefix for `target_path` is optional and stripped internally.
+   */
+  add_file_removal(target_path: string | NodePath): int;
+  /**
+   * Writes the file directory and closes the PCK. If `verbose` is `true`, a list of files added will be printed to the console for easier debugging.
+   * **Note:** {@link PCKPacker} will automatically flush when it's freed, which happens when it goes out of scope or when it gets assigned with `null`. In C# the reference must be disposed after use, either with the `using` statement or by calling the `Dispose` method directly.
+   */
+  flush(verbose?: boolean): int;
+  /**
+   * Creates a new PCK file at the file path `pck_path`. The `.pck` file extension isn't added automatically, so it should be part of `pck_path` (even though it's not required).
+   */
+  pck_start(pck_path: string | NodePath, alignment?: int, key?: string | NodePath, encrypt_directory?: boolean): int;
+}

package/typings/classes/PackedByteArray.d.ts

@@ -0,0 +1,327 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of bytes. */
+declare interface PackedByteArray {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: int): boolean;
+  /** Appends a {@link PackedByteArray} at the end of this array. */
+  append_array(array: PackedByteArray | 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: int, before?: boolean): int;
+  /**
+   * Swaps the byte order of `count` 16-bit segments of the array starting at `offset`. Swap is done in-place. If `count` is less than zero, all segments to the end of array are processed, if processed data size is not a multiple of 2, the byte after the last processed 16-bit segment is not modified.
+   */
+  bswap16(offset?: int, count?: int): void;
+  /**
+   * Swaps the byte order of `count` 32-bit segments of the array starting at `offset`. Swap is done in-place. If `count` is less than zero, all segments to the end of array are processed, if processed data size is not a multiple of 4, bytes after the last processed 32-bit segment are not modified.
+   */
+  bswap32(offset?: int, count?: int): void;
+  /**
+   * Swaps the byte order of `count` 64-bit segments of the array starting at `offset`. Swap is done in-place. If `count` is less than zero, all segments to the end of array are processed, if processed data size is not a multiple of 8, bytes after the last processed 64-bit segment are not modified.
+   */
+  bswap64(offset?: int, count?: int): void;
+  /** Clears the array. This is equivalent to using {@link resize} with a size of `0`. */
+  clear(): void;
+  /**
+   * Returns a new {@link PackedByteArray} with the data compressed. Set the compression mode using one of {@link FileAccess.CompressionMode}'s constants.
+   */
+  compress(compression_mode?: int): PackedByteArray;
+  /** Returns the number of times an element is in the array. */
+  count(value: int): int;
+  /**
+   * Decodes a 64-bit floating-point number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+   */
+  decode_double(byte_offset: int): float;
+  /**
+   * Decodes a 32-bit floating-point number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+   */
+  decode_float(byte_offset: int): float;
+  /**
+   * Decodes a 16-bit floating-point number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+   */
+  decode_half(byte_offset: int): float;
+  /**
+   * Decodes a 8-bit signed integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_s8(byte_offset: int): int;
+  /**
+   * Decodes a 16-bit signed integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_s16(byte_offset: int): int;
+  /**
+   * Decodes a 32-bit signed integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_s32(byte_offset: int): int;
+  /**
+   * Decodes a 64-bit signed integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_s64(byte_offset: int): int;
+  /**
+   * Decodes a 8-bit unsigned integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_u8(byte_offset: int): int;
+  /**
+   * Decodes a 16-bit unsigned integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_u16(byte_offset: int): int;
+  /**
+   * Decodes a 32-bit unsigned integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_u32(byte_offset: int): int;
+  /**
+   * Decodes a 64-bit unsigned integer number from the bytes starting at `byte_offset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+   */
+  decode_u64(byte_offset: int): int;
+  /**
+   * Decodes a {@link Variant} from the bytes starting at `byte_offset`. Returns `null` if a valid variant can't be decoded or the value is {@link Object}-derived and `allow_objects` is `false`.
+   */
+  decode_var(byte_offset: int, allow_objects?: boolean): unknown;
+  /**
+   * Decodes a size of a {@link Variant} from the bytes starting at `byte_offset`. Requires at least 4 bytes of data starting at the offset, otherwise fails.
+   */
+  decode_var_size(byte_offset: int, allow_objects?: boolean): int;
+  /**
+   * Returns a new {@link PackedByteArray} with the data decompressed. Set `buffer_size` to the size of the uncompressed data. Set the compression mode using one of {@link FileAccess.CompressionMode}'s constants.
+   * **Note:** Decompression is not guaranteed to work with data not compressed by Godot, for example if data compressed with the deflate compression mode lacks a checksum or header.
+   */
+  decompress(buffer_size: int, compression_mode?: int): PackedByteArray;
+  /**
+   * Returns a new {@link PackedByteArray} with the data decompressed. Set the compression mode using one of {@link FileAccess.CompressionMode}'s constants. **This method only accepts brotli, gzip, and deflate compression modes.**
+   * This method is potentially slower than {@link decompress}, as it may have to re-allocate its output buffer multiple times while decompressing, whereas {@link decompress} knows it's output buffer size from the beginning.
+   * GZIP has a maximal compression ratio of 1032:1, meaning it's very possible for a small compressed payload to decompress to a potentially very large output. To guard against this, you may provide a maximum size this function is allowed to allocate in bytes via `max_output_size`. Passing -1 will allow for unbounded output. If any positive value is passed, and the decompression exceeds that amount in bytes, then an error will be returned.
+   * **Note:** Decompression is not guaranteed to work with data not compressed by Godot, for example if data compressed with the deflate compression mode lacks a checksum or header.
+   */
+  decompress_dynamic(max_output_size: int, compression_mode?: int): PackedByteArray;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedByteArray;
+  /**
+   * Encodes a 64-bit floating-point number as bytes at the index of `byte_offset` bytes. The array must have at least 8 bytes of allocated space, starting at the offset.
+   */
+  encode_double(byte_offset: int, value: float): void;
+  /**
+   * Encodes a 32-bit floating-point number as bytes at the index of `byte_offset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+   */
+  encode_float(byte_offset: int, value: float): void;
+  /**
+   * Encodes a 16-bit floating-point number as bytes at the index of `byte_offset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+   */
+  encode_half(byte_offset: int, value: float): void;
+  /**
+   * Encodes a 8-bit signed integer number (signed byte) at the index of `byte_offset` bytes. The array must have at least 1 byte of space, starting at the offset.
+   */
+  encode_s8(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 16-bit signed integer number as bytes at the index of `byte_offset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+   */
+  encode_s16(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 32-bit signed integer number as bytes at the index of `byte_offset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+   */
+  encode_s32(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 64-bit signed integer number as bytes at the index of `byte_offset` bytes. The array must have at least 8 bytes of space, starting at the offset.
+   */
+  encode_s64(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 8-bit unsigned integer number (byte) at the index of `byte_offset` bytes. The array must have at least 1 byte of space, starting at the offset.
+   */
+  encode_u8(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 16-bit unsigned integer number as bytes at the index of `byte_offset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+   */
+  encode_u16(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 32-bit unsigned integer number as bytes at the index of `byte_offset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+   */
+  encode_u32(byte_offset: int, value: int): void;
+  /**
+   * Encodes a 64-bit unsigned integer number as bytes at the index of `byte_offset` bytes. The array must have at least 8 bytes of space, starting at the offset.
+   */
+  encode_u64(byte_offset: int, value: int): void;
+  /**
+   * Encodes a {@link Variant} at the index of `byte_offset` bytes. A sufficient space must be allocated, depending on the encoded variant's size. If `allow_objects` is `false`, {@link Object}-derived values are not permitted and will instead be serialized as ID-only.
+   */
+  encode_var(byte_offset: int, value: unknown, allow_objects?: boolean): int;
+  /**
+   * 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: int): 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: int): 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: int, from_?: int): int;
+  /**
+   * Returns the byte at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `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): int;
+  /**
+   * Converts ASCII/Latin-1 encoded array to {@link String}. Fast alternative to {@link get_string_from_utf8} if the content is ASCII/Latin-1 only. Unlike the UTF-8 function this function maps every byte to a character in the array. Multibyte sequences will not be interpreted correctly. For parsing user input always use {@link get_string_from_utf8}. This is the inverse of {@link String.to_ascii_buffer}.
+   */
+  get_string_from_ascii(): string;
+  /**
+   * Converts system multibyte code page encoded array to {@link String}. If conversion fails, empty string is returned. This is the inverse of {@link String.to_multibyte_char_buffer}.
+   * The values permitted for `encoding` are system dependent. If `encoding` is empty string, system default encoding is used.
+   * - For Windows, see Code Page Identifiers (https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers) .NET names.
+   * - For macOS and Linux/BSD, see `libiconv` library documentation and `iconv --list` for a list of supported encodings.
+   */
+  get_string_from_multibyte_char(encoding?: string | NodePath): string;
+  /**
+   * Converts UTF-8 encoded array to {@link String}. Slower than {@link get_string_from_ascii} but supports UTF-8 encoded data. Use this function if you are unsure about the source of the data. For user input this function should always be preferred. Returns empty string if source array is not valid UTF-8 string. This is the inverse of {@link String.to_utf8_buffer}.
+   */
+  get_string_from_utf8(): string;
+  /**
+   * Converts UTF-16 encoded array to {@link String}. If the BOM is missing, little-endianness is assumed. Returns empty string if source array is not valid UTF-16 string. This is the inverse of {@link String.to_utf16_buffer}.
+   */
+  get_string_from_utf16(): string;
+  /**
+   * Converts UTF-32 encoded array to {@link String}. Returns empty string if source array is not valid UTF-32 string. This is the inverse of {@link String.to_utf32_buffer}.
+   */
+  get_string_from_utf32(): string;
+  /**
+   * Converts wide character (`wchar_t`, UTF-16 on Windows, UTF-32 on other platforms) encoded array to {@link String}. Returns empty string if source array is not valid wide string. This is the inverse of {@link String.to_wchar_buffer}.
+   */
+  get_string_from_wchar(): string;
+  /** Returns `true` if the array contains `value`. */
+  has(value: int): boolean;
+  /**
+   * Returns `true` if a valid {@link Variant} value can be decoded at the `byte_offset`. Returns `false` otherwise or when the value is {@link Object}-derived and `allow_objects` is `false`.
+   */
+  has_encoded_var(byte_offset: int, allow_objects?: boolean): boolean;
+  /** Returns a hexadecimal representation of this array as a {@link String}. */
+  hex_encode(): string;
+  /**
+   * 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: int): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Appends an element at the end of the array. */
+  push_back(value: int): 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: int, from_?: int): int;
+  /** Changes the byte at the given index. */
+  set(index: int, value: int): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedByteArray}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedByteArray}.
+   * 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): PackedByteArray;
+  /** Sorts the elements of the array in ascending order. */
+  sort(): void;
+  /**
+   * Returns a copy of the data converted to a {@link PackedColorArray}, where each block of 16 bytes has been converted to a {@link Color} variant.
+   * **Note:** The size of the input array must be a multiple of 16 (size of four 32-bit float variables). The size of the new array will be `byte_array.size() / 16`. If the original data can't be converted to {@link Color} variants, the resulting data is undefined.
+   */
+  to_color_array(): PackedColorArray;
+  /**
+   * Returns a copy of the data converted to a {@link PackedFloat32Array}, where each block of 4 bytes has been converted to a 32-bit float (C++ [code skip-lint]float[/code]).
+   * The size of the input array must be a multiple of 4 (size of 32-bit float). The size of the new array will be `byte_array.size() / 4`.
+   * If the original data can't be converted to 32-bit floats, the resulting data is undefined.
+   */
+  to_float32_array(): PackedFloat32Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedFloat64Array}, where each block of 8 bytes has been converted to a 64-bit float (C++ `double`, Godot [float]).
+   * The size of the input array must be a multiple of 8 (size of 64-bit double). The size of the new array will be `byte_array.size() / 8`.
+   * If the original data can't be converted to 64-bit floats, the resulting data is undefined.
+   */
+  to_float64_array(): PackedFloat64Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedInt32Array}, where each block of 4 bytes has been converted to a signed 32-bit integer (C++ `int32_t`).
+   * The size of the input array must be a multiple of 4 (size of 32-bit integer). The size of the new array will be `byte_array.size() / 4`.
+   * If the original data can't be converted to signed 32-bit integers, the resulting data is undefined.
+   */
+  to_int32_array(): PackedInt32Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedInt64Array}, where each block of 8 bytes has been converted to a signed 64-bit integer (C++ `int64_t`, Godot [int]).
+   * The size of the input array must be a multiple of 8 (size of 64-bit integer). The size of the new array will be `byte_array.size() / 8`.
+   * If the original data can't be converted to signed 64-bit integers, the resulting data is undefined.
+   */
+  to_int64_array(): PackedInt64Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedVector2Array}, where each block of 8 bytes or 16 bytes (32-bit or 64-bit) has been converted to a {@link Vector2} variant.
+   * **Note:** The size of the input array must be a multiple of 8 or 16 (depending on the build settings, see {@link Vector2} for more details). The size of the new array will be `byte_array.size() / (8 or 16)`. If the original data can't be converted to {@link Vector2} variants, the resulting data is undefined.
+   */
+  to_vector2_array(): PackedVector2Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedVector3Array}, where each block of 12 or 24 bytes (32-bit or 64-bit) has been converted to a {@link Vector3} variant.
+   * **Note:** The size of the input array must be a multiple of 12 or 24 (depending on the build settings, see {@link Vector3} for more details). The size of the new array will be `byte_array.size() / (12 or 24)`. If the original data can't be converted to {@link Vector3} variants, the resulting data is undefined.
+   */
+  to_vector3_array(): PackedVector3Array;
+  /**
+   * Returns a copy of the data converted to a {@link PackedVector4Array}, where each block of 16 or 32 bytes (32-bit or 64-bit) has been converted to a {@link Vector4} variant.
+   * **Note:** The size of the input array must be a multiple of 16 or 32 (depending on the build settings, see {@link Vector4} for more details). The size of the new array will be `byte_array.size() / (16 or 32)`. If the original data can't be converted to {@link Vector4} variants, the resulting data is undefined.
+   */
+  to_vector4_array(): PackedVector4Array;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedByteArray; ret: boolean };
+  [__ops_add]: { right: PackedByteArray; ret: PackedByteArray };
+  [__ops_eq]: { right: PackedByteArray; ret: boolean };
+
+  [__variant_converts]: PackedByteArray | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<int>;
+
+  // 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 PackedByteArrayConstructor {
+  readonly prototype: PackedByteArray;
+  /** Constructs an empty {@link PackedByteArray}. */
+  (): PackedByteArray;
+  /** Constructs a {@link PackedByteArray} as a copy of the given {@link PackedByteArray}. */
+  (from_: PackedByteArray): PackedByteArray;
+  /**
+   * Constructs a new {@link PackedByteArray}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   */
+  (from_: Array<unknown>): PackedByteArray;
+}
+declare const PackedByteArray: PackedByteArrayConstructor;

package/typings/classes/PackedColorArray.d.ts

@@ -0,0 +1,125 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A packed array of {@link Color}s. */
+declare interface PackedColorArray {
+  /** Appends an element at the end of the array (alias of {@link push_back}). */
+  append(value: Color): boolean;
+  /** Appends a {@link PackedColorArray} at the end of this array. */
+  append_array(array: PackedColorArray | 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: Color, 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: Color): int;
+  /** Creates a copy of the array, and returns it. */
+  duplicate(): PackedColorArray;
+  /**
+   * 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: Color): 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: Color): 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: Color, from_?: int): int;
+  /**
+   * Returns the {@link Color} at the given `index` in the array. If `index` is out-of-bounds or negative, this method fails and returns `Color(0, 0, 0, 1)`.
+   * 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): Color;
+  /** Returns `true` if the array contains `value`. */
+  has(value: Color): 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: Color): int;
+  /** Returns `true` if the array is empty. */
+  is_empty(): boolean;
+  /** Appends a value to the array. */
+  push_back(value: Color): 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: Color, from_?: int): int;
+  /** Changes the {@link Color} at the given index. */
+  set(index: int, value: Color): void;
+  /** Returns the number of elements in the array. */
+  size(): int;
+  /**
+   * Returns the slice of the {@link PackedColorArray}, from `begin` (inclusive) to `end` (exclusive), as a new {@link PackedColorArray}.
+   * 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): PackedColorArray;
+  /** Sorts the elements of the array in ascending order. */
+  sort(): void;
+  /** Returns a {@link PackedByteArray} with each color encoded as bytes. */
+  to_byte_array(): PackedByteArray;
+
+  // Operator overloads
+  [__ops_ne]: { right: PackedColorArray; ret: boolean };
+  [__ops_add]: { right: PackedColorArray; ret: PackedColorArray };
+  [__ops_eq]: { right: PackedColorArray; ret: boolean };
+
+  [__variant_converts]: PackedColorArray | Array<unknown>;
+
+  [Symbol.iterator](): IterableIterator<Color>;
+
+  // 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 PackedColorArrayConstructor {
+  readonly prototype: PackedColorArray;
+  /** Constructs an empty {@link PackedColorArray}. */
+  (): PackedColorArray;
+  /** Constructs a {@link PackedColorArray} as a copy of the given {@link PackedColorArray}. */
+  (from_: PackedColorArray): PackedColorArray;
+  /**
+   * Constructs a new {@link PackedColorArray}. Optionally, you can pass in a generic {@link Array} that will be converted.
+   * **Note:** When initializing a {@link PackedColorArray} with elements, it must be initialized with an {@link Array} of {@link Color} values:
+   */
+  (from_: Array<unknown>): PackedColorArray;
+}
+declare const PackedColorArray: PackedColorArrayConstructor;

package/typings/classes/PackedDataContainer.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Efficiently packs and serializes {@link Array} or {@link Dictionary}. */
+declare class PackedDataContainer extends Resource {
+  /**
+   * Packs the given container into a binary representation. The `value` must be either {@link Array} or {@link Dictionary}, any other type will result in invalid data error.
+   * **Note:** Subsequent calls to this method will overwrite the existing data.
+   */
+  pack(value: unknown): int;
+  /** Returns the size of the packed container (see {@link Array.size} and {@link Dictionary.size}). */
+  size(): int;
+}

package/typings/classes/PackedDataContainerRef.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An internal class used by {@link PackedDataContainer} to pack nested arrays and dictionaries. */
+declare class PackedDataContainerRef extends RefCounted {
+  /** Returns the size of the packed container (see {@link Array.size} and {@link Dictionary.size}). */
+  size(): int;
+}