@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/byte-array.d.ts

@@ -4,28 +4,156 @@ export interface ByteArrayInit {
     data?: number;
     len?: number;
 }
+/** Contains the public fields of a `GByteArray`. */
 export declare class ByteArray {
     ptr: unknown;
     constructor(init?: ByteArrayInit);
     protected createPtr(init: ByteArrayInit): unknown;
+    /**
+     * Adds the given bytes to the end of the `GByteArray`.
+     * The array will grow in size automatically if necessary.
+     * @param array - a byte array
+     * @param data - the byte data to be added
+     * @param len - the number of bytes to add
+     */
     static append(array: ByteArray, data: number[], len: number): ByteArray;
+    /**
+     * Frees the memory allocated by the `GByteArray`. If `free_segment` is
+     * true it frees the actual byte data. If the reference count of
+     * `array` is greater than one, the `GByteArray` wrapper is preserved but
+     * the size of `array` will be set to zero.
+     * @param array - a byte array
+     * @param freeSegment - if true, the actual byte data is freed as well
+     */
     static free(array: ByteArray, freeSegment: boolean): number[];
+    /**
+     * Transfers the data from the `GByteArray` into a new immutable
+     * [struct@GLib.Bytes].
+     *
+     * The `GByteArray` is freed unless the reference count of `array` is greater
+     * than one, in which the `GByteArray` wrapper is preserved but the size of
+     * `array` will be set to zero.
+     *
+     * This is identical to using [ctor@GLib.Bytes.new_take] and
+     * [func@GLib.ByteArray.free] together.
+     * @param array - a byte array
+     */
     static freeToBytes(array: ByteArray): Bytes;
+    /**
+     * Creates a new `GByteArray` with a reference count of 1.
+     */
     static _new(): ByteArray;
+    /**
+     * Creates a byte array containing the @data.
+     * After this call, `data` belongs to the `GByteArray` and may no longer be
+     * modified by the caller. The memory of `data` has to be dynamically
+     * allocated and will eventually be freed with [func@GLib.free].
+     *
+     * Do not use it if `len` is greater than `G_MAXUINT`.
+     * `GByteArray` stores the length of its data in `guint`, which may be shorter
+     * than `gsize`.
+     * @param data - the byte data for the array
+     * @param len - the length of @data
+     */
     static newTake(data: number[], len: number): ByteArray;
+    /**
+     * Adds the given data to the start of the `GByteArray`.
+     * The array will grow in size automatically if necessary.
+     * @param array - a byte array
+     * @param data - the byte data to be added
+     * @param len - the number of bytes to add
+     */
     static prepend(array: ByteArray, data: number[], len: number): ByteArray;
+    /**
+     * Atomically increments the reference count of `array` by one.
+     * This function is thread-safe and may be called from any thread.
+     * @param array - a byte array
+     */
     static ref(array: ByteArray): ByteArray;
+    /**
+     * Removes the byte at the given index from a `GByteArray`.
+     * The following bytes are moved down one place.
+     * @param array - a byte array
+     * @param index_ - the index of the byte to remove
+     */
     static removeIndex(array: ByteArray, index_: number): ByteArray;
+    /**
+     * Removes the byte at the given index from a `GByteArray`. The last
+     * element in the array is used to fill in the space, so this function
+     * does not preserve the order of the `GByteArray`. But it is faster
+     * than [func@GLib.ByteArray.remove_index].
+     * @param array - a byte array
+     * @param index_ - the index of the byte to remove
+     */
     static removeIndexFast(array: ByteArray, index_: number): ByteArray;
+    /**
+     * Removes the given number of bytes starting at the given index from a
+     * `GByteArray`. The following elements are moved to close the gap.
+     * @param array - a byte array
+     * @param index_ - the index of the first byte to remove
+     * @param length - the number of bytes to remove
+     */
     static removeRange(array: ByteArray, index_: number, length: number): ByteArray;
+    /**
+     * Sets the size of the `GByteArray`, expanding it if necessary.
+     * @param array - a byte array
+     * @param length - the new size of the `GByteArray`
+     */
     static setSize(array: ByteArray, length: number): ByteArray;
+    /**
+     * Creates a new `GByteArray` with `reserved_size` bytes preallocated.
+     * This avoids frequent reallocation, if you are going to add many
+     * bytes to the array. Note however that the size of the array is still
+     * 0.
+     * @param reservedSize - the number of bytes preallocated
+     */
     static sizedNew(reservedSize: number): ByteArray;
+    /**
+     * Sorts a byte array, using `compare_func` which should be a
+     * `qsort()`-style comparison function (returns less than zero for first
+     * arg is less than second arg, zero for equal, greater than zero if
+     * first arg is greater than second arg).
+     *
+     * If two array elements compare equal, their order in the sorted array
+     * is undefined. If you want equal elements to keep their order (i.e.
+     * you want a stable sort) you can write a comparison function that,
+     * if two elements would otherwise compare equal, compares them by
+     * their addresses.
+     * @param array - a byte array
+     * @param compareFunc - the comparison function
+     */
     static sort(array: ByteArray, compareFunc: (...args: unknown[]) => unknown): void;
+    /**
+     * Like [func@GLib.ByteArray.sort], but the comparison function takes an extra
+     * user data argument.
+     * @param array - a byte array
+     * @param compareFunc - the comparison function
+     * @param userData - the data to pass to @compare_func
+     */
     static sortWithData(array: ByteArray, compareFunc: (...args: unknown[]) => unknown, userData?: number | null): void;
+    /**
+     * Frees the data in the array and resets the size to zero, while
+     * the underlying array is preserved for use elsewhere and returned
+     * to the caller.
+     * @param array - a byte array
+     * @param len - the pointer to retrieve the number of
+     */
     static steal(array: ByteArray, len?: Ref<number> | null): number[];
+    /**
+     * Atomically decrements the reference count of `array` by one. If the
+     * reference count drops to 0, all memory allocated by the array is
+     * released. This function is thread-safe and may be called from any
+     * thread.
+     * @param array - a byte array
+     */
     static unref(array: ByteArray): void;
+    /**
+     * a pointer to the element data. The data may be moved as
+     * elements are added to the `GByteArray`
+     */
     get data(): number;
     set data(value: number);
+    /** the number of elements in the `GByteArray` */
     get len(): number;
     set len(value: number);
 }

package/dist/generated/glib/byte-array.js

@@ -1,5 +1,6 @@
 import { alloc, call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/** Contains the public fields of a `GByteArray`. */
 export class ByteArray {
     ptr;
     constructor(init = {}) {
@@ -13,6 +14,13 @@ export class ByteArray {
             write(ptr, { type: "int", size: 32, unsigned: true }, 4, init.len);
         return ptr;
     }
+    /**
+     * Adds the given bytes to the end of the `GByteArray`.
+     * The array will grow in size automatically if necessary.
+     * @param array - a byte array
+     * @param data - the byte data to be added
+     * @param len - the number of bytes to add
+     */
     static append(array, data, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_append", [
             {
@@ -43,6 +51,14 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Frees the memory allocated by the `GByteArray`. If `free_segment` is
+     * true it frees the actual byte data. If the reference count of
+     * `array` is greater than one, the `GByteArray` wrapper is preserved but
+     * the size of `array` will be set to zero.
+     * @param array - a byte array
+     * @param freeSegment - if true, the actual byte data is freed as well
+     */
     static free(array, freeSegment) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_free", [
             {
@@ -59,6 +75,18 @@ export class ByteArray {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Transfers the data from the `GByteArray` into a new immutable
+     * [struct@GLib.Bytes].
+     *
+     * The `GByteArray` is freed unless the reference count of `array` is greater
+     * than one, in which the `GByteArray` wrapper is preserved but the size of
+     * `array` will be set to zero.
+     *
+     * This is identical to using [ctor@GLib.Bytes.new_take] and
+     * [func@GLib.ByteArray.free] together.
+     * @param array - a byte array
+     */
     static freeToBytes(array) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_free_to_bytes", [
             {
@@ -76,6 +104,9 @@ export class ByteArray {
             lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
         });
     }
+    /**
+     * Creates a new `GByteArray` with a reference count of 1.
+     */
     static _new() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_new", [], {
             type: "boxed",
@@ -85,6 +116,18 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Creates a byte array containing the @data.
+     * After this call, `data` belongs to the `GByteArray` and may no longer be
+     * modified by the caller. The memory of `data` has to be dynamically
+     * allocated and will eventually be freed with [func@GLib.free].
+     *
+     * Do not use it if `len` is greater than `G_MAXUINT`.
+     * `GByteArray` stores the length of its data in `guint`, which may be shorter
+     * than `gsize`.
+     * @param data - the byte data for the array
+     * @param len - the length of @data
+     */
     static newTake(data, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_new_take", [
             {
@@ -106,6 +149,13 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Adds the given data to the start of the `GByteArray`.
+     * The array will grow in size automatically if necessary.
+     * @param array - a byte array
+     * @param data - the byte data to be added
+     * @param len - the number of bytes to add
+     */
     static prepend(array, data, len) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_prepend", [
             {
@@ -136,6 +186,11 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Atomically increments the reference count of `array` by one.
+     * This function is thread-safe and may be called from any thread.
+     * @param array - a byte array
+     */
     static ref(array) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_ref", [
             {
@@ -155,6 +210,12 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Removes the byte at the given index from a `GByteArray`.
+     * The following bytes are moved down one place.
+     * @param array - a byte array
+     * @param index_ - the index of the byte to remove
+     */
     static removeIndex(array, index_) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_remove_index", [
             {
@@ -178,6 +239,14 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Removes the byte at the given index from a `GByteArray`. The last
+     * element in the array is used to fill in the space, so this function
+     * does not preserve the order of the `GByteArray`. But it is faster
+     * than [func@GLib.ByteArray.remove_index].
+     * @param array - a byte array
+     * @param index_ - the index of the byte to remove
+     */
     static removeIndexFast(array, index_) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_remove_index_fast", [
             {
@@ -201,6 +270,13 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Removes the given number of bytes starting at the given index from a
+     * `GByteArray`. The following elements are moved to close the gap.
+     * @param array - a byte array
+     * @param index_ - the index of the first byte to remove
+     * @param length - the number of bytes to remove
+     */
     static removeRange(array, index_, length) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_remove_range", [
             {
@@ -228,6 +304,11 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Sets the size of the `GByteArray`, expanding it if necessary.
+     * @param array - a byte array
+     * @param length - the new size of the `GByteArray`
+     */
     static setSize(array, length) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_set_size", [
             {
@@ -251,6 +332,13 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Creates a new `GByteArray` with `reserved_size` bytes preallocated.
+     * This avoids frequent reallocation, if you are going to add many
+     * bytes to the array. Note however that the size of the array is still
+     * 0.
+     * @param reservedSize - the number of bytes preallocated
+     */
     static sizedNew(reservedSize) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sized_new", [
             {
@@ -265,6 +353,20 @@ export class ByteArray {
         });
         return getObject(ptr, ByteArray);
     }
+    /**
+     * Sorts a byte array, using `compare_func` which should be a
+     * `qsort()`-style comparison function (returns less than zero for first
+     * arg is less than second arg, zero for equal, greater than zero if
+     * first arg is greater than second arg).
+     *
+     * If two array elements compare equal, their order in the sorted array
+     * is undefined. If you want equal elements to keep their order (i.e.
+     * you want a stable sort) you can write a comparison function that,
+     * if two elements would otherwise compare equal, compares them by
+     * their addresses.
+     * @param array - a byte array
+     * @param compareFunc - the comparison function
+     */
     static sort(array, compareFunc) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sort", [
             {
@@ -282,6 +384,13 @@ export class ByteArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Like [func@GLib.ByteArray.sort], but the comparison function takes an extra
+     * user data argument.
+     * @param array - a byte array
+     * @param compareFunc - the comparison function
+     * @param userData - the data to pass to @compare_func
+     */
     static sortWithData(array, compareFunc, userData) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_sort_with_data", [
             {
@@ -304,6 +413,13 @@ export class ByteArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Frees the data in the array and resets the size to zero, while
+     * the underlying array is preserved for use elsewhere and returned
+     * to the caller.
+     * @param array - a byte array
+     * @param len - the pointer to retrieve the number of
+     */
     static steal(array, len) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_steal", [
             {
@@ -325,6 +441,13 @@ export class ByteArray {
             },
         ], { type: "array", itemType: { type: "int", size: 8, unsigned: true } });
     }
+    /**
+     * Atomically decrements the reference count of `array` by one. If the
+     * reference count drops to 0, all memory allocated by the array is
+     * released. This function is thread-safe and may be called from any
+     * thread.
+     * @param array - a byte array
+     */
     static unref(array) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_byte_array_unref", [
             {
@@ -337,12 +460,17 @@ export class ByteArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * a pointer to the element data. The data may be moved as
+     * elements are added to the `GByteArray`
+     */
     get data() {
         return read(this.ptr, { type: "int", size: 8, unsigned: true }, 0);
     }
     set data(value) {
         write(this.ptr, { type: "int", size: 8, unsigned: true }, 0, value);
     }
+    /** the number of elements in the `GByteArray` */
     get len() {
         return read(this.ptr, { type: "int", size: 32, unsigned: true }, 4);
     }

package/dist/generated/glib/bytes.d.ts

@@ -1,19 +1,195 @@
 import { Ref } from "@gtkx/native";
 import { ByteArray } from "./byte-array.js";
+/**
+ * A simple reference counted data type representing an immutable sequence of
+ * zero or more bytes from an unspecified origin.
+ *
+ * The purpose of a `GBytes` is to keep the memory region that it holds
+ * alive for as long as anyone holds a reference to the bytes.  When
+ * the last reference count is dropped, the memory is released. Multiple
+ * unrelated callers can use byte data in the `GBytes` without coordinating
+ * their activities, resting assured that the byte data will not change or
+ * move while they hold a reference.
+ *
+ * A `GBytes` can come from many different origins that may have
+ * different procedures for freeing the memory region.  Examples are
+ * memory from [func@GLib.malloc], from memory slices, from a
+ * [struct@GLib.MappedFile] or memory from other allocators.
+ *
+ * `GBytes` work well as keys in [struct@GLib.HashTable]. Use
+ * [method@GLib.Bytes.equal] and [method@GLib.Bytes.hash] as parameters to
+ * [func@GLib.HashTable.new] or [func@GLib.HashTable.new_full].
+ * `GBytes` can also be used as keys in a [struct@GLib.Tree] by passing the
+ * [method@GLib.Bytes.compare] function to [ctor@GLib.Tree.new].
+ *
+ * The data pointed to by this bytes must not be modified. For a mutable
+ * array of bytes see [struct@GLib.ByteArray]. Use
+ * [method@GLib.Bytes.unref_to_array] to create a mutable array for a `GBytes`
+ * sequence. To create an immutable `GBytes` from a mutable
+ * [struct@GLib.ByteArray], use the [func@GLib.ByteArray.free_to_bytes]
+ * function.
+ */
 export declare class Bytes {
     ptr: unknown;
+    /**
+     * Creates a new [struct@GLib.Bytes] from @data.
+     *
+     * `data` is copied. If `size` is 0, `data` may be `NULL`.
+     *
+     * As an optimization, [ctor@GLib.Bytes.new] may avoid an extra allocation by
+     * copying the data within the resulting bytes structure if sufficiently small
+     * (since GLib 2.84).
+     * @param data - the data to be used for the bytes
+     * @param size - the size of @data
+     */
     constructor(size: number, data?: number[] | null);
+    /**
+     * Creates a new [struct@GLib.Bytes] from @data.
+     *
+     * After this call, `data` belongs to the `GBytes` and may no longer be
+     * modified by the caller. The memory of `data` has to be dynamically
+     * allocated and will eventually be freed with [func@GLib.free].
+     *
+     * For creating `GBytes` with memory from other allocators, see
+     * [ctor@GLib.Bytes.new_with_free_func].
+     *
+     * `data` may be `NULL` if `size` is 0.
+     * @param data - the data to be used for the bytes
+     * @param size - the size of @data
+     */
     static newTake(size: number, data?: number[] | null): Bytes;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Compares the two [struct@GLib.Bytes] values.
+     *
+     * This function can be used to sort `GBytes` instances in lexicographical
+     * order.
+     *
+     * If `bytes1` and `bytes2` have different length but the shorter one is a
+     * prefix of the longer one then the shorter one is considered to be less than
+     * the longer one. Otherwise the first byte where both differ is used for
+     * comparison. If `bytes1` has a smaller value at that position it is
+     * considered less, otherwise greater than @bytes2.
+     * @param bytes2 - a pointer to a [struct@GLib.Bytes] to compare with @bytes1
+     */
     compare(bytes2: Bytes): number;
+    /**
+     * Compares the two [struct@GLib.Bytes] values being pointed to and returns
+     * `TRUE` if they are equal.
+     *
+     * This function can be passed to [func@GLib.HashTable.new] as the
+     * `key_equal_func` parameter, when using non-`NULL` `GBytes` pointers as keys in
+     * a [struct@GLib.HashTable].
+     * @param bytes2 - a pointer to a [struct@GLib.Bytes] to compare with @bytes1
+     */
     equal(bytes2: Bytes): boolean;
+    /**
+     * Get the byte data in the [struct@GLib.Bytes].
+     *
+     * This data should not be modified.
+     *
+     * This function will always return the same pointer for a given `GBytes`.
+     *
+     * `NULL` may be returned if `size` is 0. This is not guaranteed, as the `GBytes`
+     * may represent an empty string with `data` non-`NULL` and `size` as 0. `NULL`
+     * will not be returned if `size` is non-zero.
+     * @param size - location to return size of byte data
+     */
     getData(size?: Ref<number> | null): number[] | null;
+    /**
+     * Gets a pointer to a region in @bytes.
+     *
+     * The region starts at `offset` many bytes from the start of the data
+     * and contains `n_elements` many elements of `element_size` size.
+     *
+     * `n_elements` may be zero, but `element_size` must always be non-zero.
+     * Ideally, `element_size` is a static constant (eg: `sizeof` a struct).
+     *
+     * This function does careful bounds checking (including checking for
+     * arithmetic overflows) and returns a non-`NULL` pointer if the
+     * specified region lies entirely within the @bytes. If the region is
+     * in some way out of range, or if an overflow has occurred, then `NULL`
+     * is returned.
+     *
+     * Note: it is possible to have a valid zero-size region. In this case,
+     * the returned pointer will be equal to the base pointer of the data of
+     * @bytes, plus @offset.  This will be non-`NULL` except for the case
+     * where `bytes` itself was a zero-sized region.  Since it is unlikely
+     * that you will be using this function to check for a zero-sized region
+     * in a zero-sized @bytes, `NULL` effectively always means ‘error’.
+     * @param elementSize - a non-zero element size
+     * @param offset - an offset to the start of the region within the @bytes
+     * @param nElements - the number of elements in the region
+     */
     getRegion(elementSize: number, offset: number, nElements: number): number | null;
+    /**
+     * Get the size of the byte data in the [struct@GLib.Bytes].
+     *
+     * This function will always return the same value for a given `GBytes`.
+     */
     getSize(): number;
+    /**
+     * Creates an integer hash code for the byte data in the [struct@GLib.Bytes].
+     *
+     * This function can be passed to [func@GLib.HashTable.new] as the
+     * `key_hash_func` parameter, when using non-`NULL` `GBytes` pointers as keys in
+     * a [struct@GLib.HashTable].
+     */
     hash(): number;
+    /**
+     * Creates a [struct@GLib.Bytes] which is a subsection of another `GBytes`.
+     *
+     * The `offset` + `length` may not be longer than the size of @bytes.
+     *
+     * A reference to `bytes` will be held by the newly created `GBytes` until
+     * the byte data is no longer needed.
+     *
+     * Since 2.56, if `offset` is 0 and `length` matches the size of @bytes, then
+     * `bytes` will be returned with the reference count incremented by 1. If `bytes` is a slice of another `GBytes`, then the resulting `GBytes` will reference
+     * the same `GBytes` instead of @bytes. This allows consumers to simplify the
+     * usage of `GBytes` when asynchronously writing to streams.
+     * @param offset - offset which subsection starts at
+     * @param length - length of subsection
+     */
     newFromBytes(offset: number, length: number): Bytes;
+    /**
+     * Increase the reference count on @bytes.
+     */
     ref(): Bytes;
+    /**
+     * Releases a reference on @bytes.
+     *
+     * This may result in the bytes being freed. If `bytes` is `NULL`, it will
+     * return immediately.
+     */
     unref(): void;
+    /**
+     * Unreferences the bytes, and returns a new mutable [struct@GLib.ByteArray]
+     * containing the same byte data.
+     *
+     * As an optimization, the byte data is transferred to the array without copying
+     * if this was the last reference to `bytes` and `bytes` was created with
+     * [ctor@GLib.Bytes.new], [ctor@GLib.Bytes.new_take] or
+     * [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size
+     * [struct@GLib.Bytes] may internalize within its allocation. In all other cases
+     * the data is copied.
+     *
+     * Do not use it if `bytes` contains more than %G_MAXUINT
+     * bytes. [struct@GLib.ByteArray] stores the length of its data in `guint`,
+     * which may be shorter than `gsize`, that `bytes` is using.
+     */
     unrefToArray(): ByteArray;
+    /**
+     * Unreferences the bytes, and returns a pointer the same byte data
+     * contents.
+     *
+     * As an optimization, the byte data is returned without copying if this was
+     * the last reference to `bytes` and `bytes` was created with
+     * [ctor@GLib.Bytes.new], [ctor@GLib.Bytes.new_take] or
+     * [func@GLib.ByteArray.free_to_bytes] and the buffer was larger than the size
+     * [struct@GLib.Bytes] may internalize within its allocation. In all other cases
+     * the data is copied.
+     * @param size - location to place the length of the returned data
+     */
     unrefToData(size: Ref<number>): number[];
 }