@ringozz/godot 0.1.0

package/gen/heap-types/PackedByteArray.ts

@@ -0,0 +1,400 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R } from '../../src/runtime.ts';
+import type { PackedColorArray, PackedFloat32Array, PackedFloat64Array, PackedInt32Array, PackedInt64Array, PackedVector2Array, PackedVector3Array, PackedVector4Array, Variant } from './index.ts';
+
+/**
+ * An array specifically designed to hold bytes. Packs data tightly, so it saves memory for large array sizes.
+ * {@link PackedByteArray} also provides methods to encode/decode various types to/from bytes. The way values are encoded is an implementation detail and shouldn't be relied upon when interacting with external apps.
+ * **Note:** Packed arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use {@link duplicate}. This is *not* the case for built-in properties and methods. In these cases the returned packed array is a copy, and changing it will *not* affect the original value. To update a built-in property of this type, modify the returned array and then assign it to the property again.
+ * **Note:** In a boolean context, a packed array will evaluate to `false` if it's empty. Otherwise, a packed array will always evaluate to `true`.
+ */
+export class PackedByteArray<T = any> extends GodotVar implements Iterable<T> {
+    constructor(...args: any[]) { super(29, ...args); }
+
+    get length(): number { return _C(this, 13608) as number; }
+
+    *[Symbol.iterator](): Iterator<T> {
+        const n = _C(this, 13608) as number;
+        for (let i = 0; i < n; i++) yield _C(this, 3652, i) as T;
+    }
+    /**
+     * 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: number): number { return _C(this, 3652, index) as number; }
+
+    /**
+     * Changes the byte at the given index.
+     */
+    set(index: number, value: T): void { _C(this, 10392, index, value); }
+
+    /**
+     * Returns the number of elements in the array.
+     */
+    size(): number { return _C(this, 13608) as number; }
+
+    /**
+     * Returns `true` if the array is empty.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    /**
+     * Appends an element at the end of the array.
+     */
+    pushBack(value: T): boolean { return _C(this, 9630, value) as boolean; }
+
+    /**
+     * Appends an element at the end of the array (alias of {@link pushBack}).
+     */
+    append(value: T): boolean { return _C(this, 1512, value) as boolean; }
+
+    /**
+     * Appends a {@link PackedByteArray} at the end of this array.
+     */
+    appendArray(array: PackedByteArray): void { _C(this, 1513, array); }
+
+    /**
+     * Removes an element from the array by index.
+     */
+    removeAt(index: number): void { _C(this, 9886, index); }
+
+    /**
+     * 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(atIndex: number, value: T): number { return _C(this, 7631, atIndex, value) as number; }
+
+    /**
+     * 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: T): void { _C(this, 3260, value); }
+
+    /**
+     * 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(newSize: number): number { return _C(this, 10077, newSize) as number; }
+
+    /**
+     * Clears the array. This is equivalent to using {@link resize} with a size of `0`.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns `true` if the array contains `value`.
+     */
+    has(value: T): boolean { return _C(this, 7349, value) as boolean; }
+
+    /**
+     * Reverses the order of the elements in the array.
+     */
+    reverse(): void { _C(this, 10104); }
+
+    /**
+     * 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: number, end?: number /* = 2147483647 */): PackedByteArray { return _C(this, 13658, begin, end) as PackedByteArray; }
+
+    /**
+     * Sorts the elements of the array in ascending order.
+     */
+    sort(): void { _C(this, 13723); }
+
+    /**
+     * 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: T, before?: boolean /* = true */): number { return _C(this, 1915, value, before) as number; }
+
+    /**
+     * Creates a copy of the array, and returns it.
+     */
+    duplicate(): PackedByteArray { return _C(this, 2980) as PackedByteArray; }
+
+    /**
+     * 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: T, from?: number /* = 0 */): number { return _C(this, 3276, value, from) as number; }
+
+    /**
+     * 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: T, from?: number /* = -1 */): number { return _C(this, 10108, value, from) as number; }
+
+    /**
+     * Returns the number of times an element is in the array.
+     */
+    count(value: T): number { return _C(this, 2502, value) as number; }
+
+    /**
+     * 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 removeAt} instead.
+     */
+    erase(value: T): boolean { return _C(this, 3154, value) as boolean; }
+
+    /**
+     * Converts ASCII/Latin-1 encoded array to {@link String}. Fast alternative to {@link getStringFromUtf8} 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 getStringFromUtf8}. This is the inverse of {@link String.toAsciiBuffer}.
+     */
+    getStringFromAscii(): string { return _C(this, 6576) as string; }
+
+    /**
+     * Converts UTF-8 encoded array to {@link String}. Slower than {@link getStringFromAscii} 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.toUtf8Buffer}.
+     */
+    getStringFromUtf8(): string { return _C(this, 6580) as 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.toUtf16Buffer}.
+     */
+    getStringFromUtf16(): string { return _C(this, 6578) as 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.toUtf32Buffer}.
+     */
+    getStringFromUtf32(): string { return _C(this, 6579) as 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.toWcharBuffer}.
+     */
+    getStringFromWchar(): string { return _C(this, 6581) as 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.toMultibyteCharBuffer}.
+     * 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.
+     */
+    getStringFromMultibyteChar(encoding?: string /* = "" */): string { return _C(this, 6577, encoding) as string; }
+
+    /**
+     * Returns a hexadecimal representation of this array as a {@link String}.
+     *
+     *
+     * ```gdscript
+     *
+     * var array = PackedByteArray([11, 46, 255])
+     * print(array.hex_encode()) # Prints "0b2eff"
+     *
+     * ```
+     */
+    hexEncode(): string { return _C(this, 7507) as string; }
+
+    /**
+     * Returns a new {@link PackedByteArray} with the data compressed. Set the compression mode using one of {@link FileAccess.CompressionMode}'s constants.
+     */
+    compress(compressionMode?: number /* = 0 */): PackedByteArray { return _C(this, 2410, compressionMode) as PackedByteArray; }
+
+    /**
+     * Returns a new {@link PackedByteArray} with the data decompressed. Set `bufferSize` 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(bufferSize: number, compressionMode?: number /* = 0 */): PackedByteArray { return _C(this, 2701, bufferSize, compressionMode) as 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 `maxOutputSize`. 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.
+     */
+    decompressDynamic(maxOutputSize: number, compressionMode?: number /* = 0 */): PackedByteArray { return _C(this, 2702, maxOutputSize, compressionMode) as PackedByteArray; }
+
+    /**
+     * Decodes a 8-bit unsigned integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeU8(byteOffset: number): number { return _C(this, 2697, byteOffset) as number; }
+
+    /**
+     * Decodes a 8-bit signed integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeS8(byteOffset: number): number { return _C(this, 2693, byteOffset) as number; }
+
+    /**
+     * Decodes a 16-bit unsigned integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeU16(byteOffset: number): number { return _C(this, 2694, byteOffset) as number; }
+
+    /**
+     * Decodes a 16-bit signed integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeS16(byteOffset: number): number { return _C(this, 2690, byteOffset) as number; }
+
+    /**
+     * Decodes a 32-bit unsigned integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeU32(byteOffset: number): number { return _C(this, 2695, byteOffset) as number; }
+
+    /**
+     * Decodes a 32-bit signed integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeS32(byteOffset: number): number { return _C(this, 2691, byteOffset) as number; }
+
+    /**
+     * Decodes a 64-bit unsigned integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeU64(byteOffset: number): number { return _C(this, 2696, byteOffset) as number; }
+
+    /**
+     * Decodes a 64-bit signed integer number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0` if a valid number can't be decoded.
+     */
+    decodeS64(byteOffset: number): number { return _C(this, 2692, byteOffset) as number; }
+
+    /**
+     * Decodes a 16-bit floating-point number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+     */
+    decodeHalf(byteOffset: number): number { return _C(this, 2689, byteOffset) as number; }
+
+    /**
+     * Decodes a 32-bit floating-point number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+     */
+    decodeFloat(byteOffset: number): number { return _C(this, 2688, byteOffset) as number; }
+
+    /**
+     * Decodes a 64-bit floating-point number from the bytes starting at `byteOffset`. Fails if the byte count is insufficient. Returns `0.0` if a valid number can't be decoded.
+     */
+    decodeDouble(byteOffset: number): number { return _C(this, 2687, byteOffset) as number; }
+
+    /**
+     * Returns `true` if a valid {@link Variant} value can be decoded at the `byteOffset`. Returns `false` otherwise or when the value is {@link Object}-derived and `allowObjects` is `false`.
+     */
+    hasEncodedVar(byteOffset: number, allowObjects?: boolean /* = false */): boolean { return _C(this, 7391, byteOffset, allowObjects) as boolean; }
+
+    /**
+     * Decodes a {@link Variant} from the bytes starting at `byteOffset`. Returns `null` if a valid variant can't be decoded or the value is {@link Object}-derived and `allowObjects` is `false`.
+     */
+    decodeVar(byteOffset: number, allowObjects?: boolean /* = false */): T { return _C(this, 2698, byteOffset, allowObjects) as T; }
+
+    /**
+     * Decodes a size of a {@link Variant} from the bytes starting at `byteOffset`. Requires at least 4 bytes of data starting at the offset, otherwise fails.
+     */
+    decodeVarSize(byteOffset: number, allowObjects?: boolean /* = false */): number { return _C(this, 2699, byteOffset, allowObjects) as number; }
+
+    /**
+     * 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.
+     */
+    toInt32Array(): PackedInt32Array { return _C(this, 14299) as 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 {@link 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.
+     */
+    toInt64Array(): PackedInt64Array { return _C(this, 14300) as PackedInt64Array; }
+
+    /**
+     * 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++ {@link 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.
+     */
+    toFloat32Array(): PackedFloat32Array { return _C(this, 14294) as 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 {@link 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.
+     */
+    toFloat64Array(): PackedFloat64Array { return _C(this, 14295) as PackedFloat64Array; }
+
+    /**
+     * 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.
+     */
+    toVector2Array(): PackedVector2Array { return _C(this, 14317) as 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.
+     */
+    toVector3Array(): PackedVector3Array { return _C(this, 14318) as 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.
+     */
+    toVector4Array(): PackedVector4Array { return _C(this, 14319) as PackedVector4Array; }
+
+    /**
+     * 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.
+     */
+    toColorArray(): PackedColorArray { return _C(this, 14291) as PackedColorArray; }
+
+    /**
+     * 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?: number /* = 0 */, count?: number /* = -1 */): void { _C(this, 1917, offset, count); }
+
+    /**
+     * 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?: number /* = 0 */, count?: number /* = -1 */): void { _C(this, 1918, offset, count); }
+
+    /**
+     * 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?: number /* = 0 */, count?: number /* = -1 */): void { _C(this, 1919, offset, count); }
+
+    /**
+     * Encodes a 8-bit unsigned integer number (byte) at the index of `byteOffset` bytes. The array must have at least 1 byte of space, starting at the offset.
+     */
+    encodeU8(byteOffset: number, value: T): void { _C(this, 3090, byteOffset, value); }
+
+    /**
+     * Encodes a 8-bit signed integer number (signed byte) at the index of `byteOffset` bytes. The array must have at least 1 byte of space, starting at the offset.
+     */
+    encodeS8(byteOffset: number, value: T): void { _C(this, 3085, byteOffset, value); }
+
+    /**
+     * Encodes a 16-bit unsigned integer number as bytes at the index of `byteOffset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+     */
+    encodeU16(byteOffset: number, value: T): void { _C(this, 3087, byteOffset, value); }
+
+    /**
+     * Encodes a 16-bit signed integer number as bytes at the index of `byteOffset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+     */
+    encodeS16(byteOffset: number, value: T): void { _C(this, 3082, byteOffset, value); }
+
+    /**
+     * Encodes a 32-bit unsigned integer number as bytes at the index of `byteOffset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+     */
+    encodeU32(byteOffset: number, value: T): void { _C(this, 3088, byteOffset, value); }
+
+    /**
+     * Encodes a 32-bit signed integer number as bytes at the index of `byteOffset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+     */
+    encodeS32(byteOffset: number, value: T): void { _C(this, 3083, byteOffset, value); }
+
+    /**
+     * Encodes a 64-bit unsigned integer number as bytes at the index of `byteOffset` bytes. The array must have at least 8 bytes of space, starting at the offset.
+     */
+    encodeU64(byteOffset: number, value: T): void { _C(this, 3089, byteOffset, value); }
+
+    /**
+     * Encodes a 64-bit signed integer number as bytes at the index of `byteOffset` bytes. The array must have at least 8 bytes of space, starting at the offset.
+     */
+    encodeS64(byteOffset: number, value: T): void { _C(this, 3084, byteOffset, value); }
+
+    /**
+     * Encodes a 16-bit floating-point number as bytes at the index of `byteOffset` bytes. The array must have at least 2 bytes of space, starting at the offset.
+     */
+    encodeHalf(byteOffset: number, value: T): void { _C(this, 3081, byteOffset, value); }
+
+    /**
+     * Encodes a 32-bit floating-point number as bytes at the index of `byteOffset` bytes. The array must have at least 4 bytes of space, starting at the offset.
+     */
+    encodeFloat(byteOffset: number, value: T): void { _C(this, 3080, byteOffset, value); }
+
+    /**
+     * Encodes a 64-bit floating-point number as bytes at the index of `byteOffset` bytes. The array must have at least 8 bytes of allocated space, starting at the offset.
+     */
+    encodeDouble(byteOffset: number, value: T): void { _C(this, 3079, byteOffset, value); }
+
+    /**
+     * Encodes a {@link Variant} at the index of `byteOffset` bytes. A sufficient space must be allocated, depending on the encoded variant's size. If `allowObjects` is `false`, {@link Object}-derived values are not permitted and will instead be serialized as ID-only.
+     */
+    encodeVar(byteOffset: number, value: T, allowObjects?: boolean /* = false */): number { return _C(this, 3091, byteOffset, value, allowObjects) as number; }
+
+    static readonly name = _R(29, PackedByteArray);
+}

package/gen/heap-types/PackedColorArray.ts

@@ -0,0 +1,144 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R } from '../../src/runtime.ts';
+import type { Color } from '../value-types/index.ts';
+import type { PackedByteArray } from './index.ts';
+
+/**
+ * An array specifically designed to hold {@link Color}. Packs data tightly, so it saves memory for large array sizes.
+ * **Differences between packed arrays, typed arrays, and untyped arrays:** Packed arrays are generally faster to iterate on and modify compared to a typed array of the same type (e.g. {@link PackedColorArray} versus `Array[Color]`). Also, packed arrays consume less memory. As a downside, packed arrays are less flexible as they don't offer as many convenience methods such as {@link Array.map}. Typed arrays are in turn faster to iterate on and modify than untyped arrays.
+ * **Note:** Packed arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use {@link duplicate}. This is *not* the case for built-in properties and methods. In these cases the returned packed array is a copy, and changing it will *not* affect the original value. To update a built-in property of this type, modify the returned array and then assign it to the property again.
+ * **Note:** In a boolean context, a packed array will evaluate to `false` if it's empty. Otherwise, a packed array will always evaluate to `true`.
+ */
+export class PackedColorArray<T = any> extends GodotVar implements Iterable<T> {
+    constructor(...args: any[]) { super(37, ...args); }
+
+    get length(): number { return _C(this, 13608) as number; }
+
+    *[Symbol.iterator](): Iterator<T> {
+        const n = _C(this, 13608) as number;
+        for (let i = 0; i < n; i++) yield _C(this, 3652, i) as T;
+    }
+    /**
+     * 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: number): Color { return _C(this, 3652, index) as Color; }
+
+    /**
+     * Changes the {@link Color} at the given index.
+     */
+    set(index: number, value: T): void { _C(this, 10392, index, value); }
+
+    /**
+     * Returns the number of elements in the array.
+     */
+    size(): number { return _C(this, 13608) as number; }
+
+    /**
+     * Returns `true` if the array is empty.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    /**
+     * Appends a value to the array.
+     */
+    pushBack(value: T): boolean { return _C(this, 9630, value) as boolean; }
+
+    /**
+     * Appends an element at the end of the array (alias of {@link pushBack}).
+     */
+    append(value: T): boolean { return _C(this, 1512, value) as boolean; }
+
+    /**
+     * Appends a {@link PackedColorArray} at the end of this array.
+     */
+    appendArray(array: PackedColorArray): void { _C(this, 1513, array); }
+
+    /**
+     * Removes an element from the array by index.
+     */
+    removeAt(index: number): void { _C(this, 9886, index); }
+
+    /**
+     * 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(atIndex: number, value: T): number { return _C(this, 7631, atIndex, value) as number; }
+
+    /**
+     * 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: T): void { _C(this, 3260, value); }
+
+    /**
+     * 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(newSize: number): number { return _C(this, 10077, newSize) as number; }
+
+    /**
+     * Clears the array. This is equivalent to using {@link resize} with a size of `0`.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns `true` if the array contains `value`.
+     */
+    has(value: T): boolean { return _C(this, 7349, value) as boolean; }
+
+    /**
+     * Reverses the order of the elements in the array.
+     */
+    reverse(): void { _C(this, 10104); }
+
+    /**
+     * 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: number, end?: number /* = 2147483647 */): PackedColorArray { return _C(this, 13658, begin, end) as PackedColorArray; }
+
+    /**
+     * Returns a {@link PackedByteArray} with each color encoded as bytes.
+     */
+    toByteArray(): PackedByteArray { return _C(this, 14289) as PackedByteArray; }
+
+    /**
+     * Sorts the elements of the array in ascending order.
+     */
+    sort(): void { _C(this, 13723); }
+
+    /**
+     * 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: T, before?: boolean /* = true */): number { return _C(this, 1915, value, before) as number; }
+
+    /**
+     * Creates a copy of the array, and returns it.
+     */
+    duplicate(): PackedColorArray { return _C(this, 2980) as PackedColorArray; }
+
+    /**
+     * 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: T, from?: number /* = 0 */): number { return _C(this, 3276, value, from) as number; }
+
+    /**
+     * 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: T, from?: number /* = -1 */): number { return _C(this, 10108, value, from) as number; }
+
+    /**
+     * Returns the number of times an element is in the array.
+     */
+    count(value: T): number { return _C(this, 2502, value) as number; }
+
+    /**
+     * 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 removeAt} instead.
+     */
+    erase(value: T): boolean { return _C(this, 3154, value) as boolean; }
+
+    static readonly name = _R(37, PackedColorArray);
+}