@cybearl/cypack 1.1.0

package/backend.d.ts

@@ -0,0 +1,1193 @@
+import pino from 'pino';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { Session } from 'next-auth';
+
+/**
+ * The type of the benchmark function result.
+ */
+type BenchmarkResult = {
+    operationsPerSecond: number;
+    avgExecutionTime: number;
+    operations: number;
+};
+/**
+ * An object containing multiple benchmark results, ordered by functions.
+ */
+type BenchmarkResults = {
+    [fn: string]: BenchmarkResult;
+};
+/**
+ * A class that provides a simple way to benchmark functions.
+ */
+declare class Bench {
+    /**
+     * The duration of the benchmark in milliseconds.
+     */
+    benchmarkDuration: number;
+    /**
+     * Stores the results of the benchmark.
+     */
+    results: BenchmarkResults;
+    /**
+     * Creates a new benchmarking instance.
+     * @param benchmarkDuration The duration of the benchmark in milliseconds (optional, defaults to 256ms).
+     */
+    constructor(benchmarkDuration?: number);
+    /**
+     * The main headless benchmarking function.
+     *
+     * Does not print anything to the console but returns the number of iterations per second
+     * and the logs themselves for further formatting, such as console coloring depending on the results.
+     * @param fn The function to run.
+     * @param name The name of the function to run.
+     * @returns The benchmark result (operations per second, average execution time, and total operations).
+     */
+    benchmark: (fn: () => unknown, name: string) => void;
+    /**
+     * Formats and prints multiple benchmark results.
+     * @param category The category of the benchmark results (optional, defaults to `RESULTS`).
+     * @param clear Whether to clear the results object for the next benchmark (optional, defaults to `true`).
+     */
+    print: (category?: string, clear?: boolean) => void;
+}
+
+/**
+ * The type for the CGAS status string, it can either be:
+ * - `enabled`: The application is enabled and available to the public.
+ * - `disabled`: The application is disabled and not available to the public.
+ * - `in-maintenance`: The application is in maintenance mode and not available to the public.
+ * - `in-development`: The application is in development mode and not available to the public.
+ */
+type CGASStatusString = "enabled" | "disabled" | "in-maintenance" | "in-development"
+
+/**
+ * The Cybearl General API System (CGAS) status response.
+ *
+ * About the status of the application (allows to enable/disable the application),
+ * it can either be:
+ * - `enabled`: The application is enabled and available to the public.
+ * - `disabled`: The application is disabled and not available to the public.
+ * - `in-maintenance`: The application is in maintenance mode and not available to the public.
+ * - `in-development`: The application is in development mode and not available to the public.
+ */
+type CGASStatus = {
+	status: CGASStatusString
+	marker: string
+	timestamp: string
+	version: {
+		raw: string
+		formatted: `v${string}` | "unavailable"
+	}
+	message: string
+}
+
+/**
+ * Returns the formatted status of the application based on the different parameters.
+ * This function should be executed within the CGAS API endpoint to return the status.
+ * @param status The status of the application.
+ * @param marker The marker of the application.
+ * @param version The version of the application (optional).
+ * @param message The message to display (optional).
+ * @param markerOnly Whether to only return the marker (optional, defaults to false).
+ * @returns The formatted status of the application.
+ */
+declare function generateCGASStatus(status: CGASStatusString, marker: string, version: string | undefined, message?: string, markerOnly?: boolean): CGASStatus | string;
+
+/**
+ * A type for a single bit (`0` or `1`).
+ */
+type Bit = 0 | 1;
+/**
+ * A type for the endianness of a buffer.
+ */
+type Endianness = "LE" | "BE";
+/**
+ * A type for the encoding of a string.
+ */
+type StringEncoding = "utf8" | "hex";
+/**
+ * `CyBuffer` is a helper class that indirectly extends the Uint8Array class with additional methods
+ * similar to the Buffer class in Node.js, while also providing multiple utility methods
+ * linked to advanced cryptography and binary data manipulation.
+ */
+declare class CyBuffer {
+    /**
+     * The platform's endianness which all related methods will use by default,
+     * in order to normalize the endianness parameter.
+     */
+    readonly platformEndianness: Endianness;
+    /**
+     * The ArrayBuffer instance referenced by the buffer.
+     */
+    readonly arrayBuffer: ArrayBuffer;
+    /**
+     * The Uint8Array instance that acts as a bridge between the buffer and the array buffer.
+     */
+    readonly array: Uint8Array;
+    /**
+     * The offset in bytes of the buffer.
+     */
+    readonly offset: number;
+    /**
+     * The length in bytes of the buffer.
+     */
+    readonly length: number;
+    /**
+     * Creates a new `CyBuffer` instance based on a length or an input.
+     * @param length The length of the buffer to create.
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @param options The options to use (optional).
+     * - `arrayBuffer`: The array buffer to use.
+     * - `offset`: The offset in bytes to start reading from (optional, defaults to 0).
+     * - `length`: The length in bytes to read (optional, defaults to the input length).
+     */
+    constructor(length: number, options?: {
+        arrayBuffer: ArrayBuffer;
+        offset?: number;
+        length?: number;
+    });
+    /**
+     * ============
+     *  SIGNATURES
+     * ============
+     */
+    /**
+     * Signature for the `[]` operator.
+     */
+    [index: number]: number;
+    /**
+     * ==================
+     *  INTERNAL METHODS
+     * ==================
+     */
+    /**
+     * Get the platform endianness.
+     * @returns The platform endianness.
+     */
+    getPlatformEndianness: () => Endianness;
+    /**
+     * Normalizes the endianness parameter.
+     *
+     * By default, the extended Uint8Array is written for Little Endian, to keep it consistent,
+     * if the platform is big endian the endianness parameter is reversed.
+     *
+     * - Little endian platform:
+     *   - `LE` read from left to right.
+     *   - `BE` read from right to left.
+     * - Big endian platform:
+     *   - `LE` read from right to left.
+     *   - `BE` read from left to right.
+     */
+    normalizeEndianness: (endianness: Endianness) => Endianness;
+    /**
+     * Checks the offset and length for validity.
+     *
+     * **Note:** This method is used internally by the read/write methods.
+     * @param offset The offset to check.
+     * @param length The length to check.
+     * @throws If the offset or length are invalid.
+     * @returns The current buffer instance.
+     */
+    check: (offset: number, length: number) => this;
+    /**
+     * ================
+     *  STATIC METHODS
+     * ================
+     */
+    /**
+     * Creates a new `CyBuffer` instance of the specified length, initially filled with zeros.
+     * @param length The length of the buffer.
+     * @param fillWith The value to initially fill the buffer with (optional).
+     * @returns A new `CyBuffer` instance.
+     */
+    static alloc: (length: number, fillWith?: number) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from an hexadecimal string (supports `0x` prefix).
+     *
+     * **Note:** There is no `endianness` parameter here as there is no concept of word size,
+     * the order will simply follow the string.
+     * @param value The hexadecimal string to create the buffer from.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromHexString: (value: string) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from an UTF-8 string.
+     * @param value The UTF-8 string to create the buffer from.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromUtf8String: (value: string) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a string using a specific encoding.
+     * @param value The string to create the buffer from.
+     * @param encoding The encoding to use (optional, defaults to "utf8").
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromString: (value: string, encoding?: StringEncoding) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from an array of bits.
+     * @param array The array of bits to create the buffer from.
+     * @param msbFirst Whether to write the bits from the most significant bit (optional, defaults to `true`).
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromBits: (array: Bit[], msbFirst?: boolean) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a Uint8Array.
+     * @param array The Uint8Array to create the buffer from.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromUint8Array: (array: Uint8Array) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a Uint16Array.
+     * @param array The Uint16Array to create the buffer from.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromUint16Array: (array: Uint16Array) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a Uint32Array.
+     * @param array The Uint32Array to create the buffer from.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromUint32Array: (array: Uint32Array) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a big integer.
+     * @param value The big integer to create the buffer from.
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromBigInt: (value: bigint, endianness?: Endianness) => CyBuffer;
+    /**
+     * Creates a new `CyBuffer` instance from a range of numbers between 0 and 255.
+     * @param start The start of the range, inclusive.
+     * @param end The end of the range, exclusive.
+     * @returns A new `CyBuffer` instance.
+     */
+    static fromRange: (start: number, end: number) => CyBuffer;
+    /**
+     * ===========
+     *  ACCESSORS
+     * ===========
+     */
+    /**
+     * The proxy that allows to access/assign values via the [] operator.
+     * Note that both the getter and setter are safe and never throw.
+     * @returns The proxy returned by the constructor.
+     */
+    private get _proxy();
+    /**
+     * The symbol iterator of the buffer, allowing to iterate over the buffer
+     * using `for..of` loops and returning bytes.
+     * @returns A new generator yielding the bytes of the buffer.
+     */
+    [Symbol.iterator](): Generator<number>;
+    /**
+     * Iterates over the buffer and yields the index and value of each byte as an array.
+     * @returns The generator yielding the index and value of each byte.
+     */
+    entries(): Generator<[number, number]>;
+    /**
+     * ===============
+     *  WRITE METHODS
+     * ===============
+     */
+    /**
+     * Writes an hexadecimal string to the buffer (supports `0x` prefix).
+     *
+     * **Note:** There is no `endianness` parameter here as there is no concept of word size,
+     * the order will simply follow the string.
+     * @param value The hexadecimal string to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the value length).
+     * @returns The current buffer instance.
+     */
+    writeHexString: (value: string, offset?: number, length?: number) => this;
+    /**
+     * Writes an UTF-8 string to the buffer.
+     * @param value The UTF-8 string to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the value length).
+     * @returns The current buffer instance.
+     */
+    writeUtf8String: (value: string, offset?: number, length?: number) => this;
+    /**
+     * Writes a string to the buffer using a specific encoding.
+     *
+     * **Notes:**
+     * - The `hex` encoding supports `0x` prefix but there's no `endianness` parameter here,
+     *   it follows the order of the string.
+     * @param value The string to write to the buffer.
+     * @param encoding The encoding to use (optional, defaults to "utf8").
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the value length).
+     * @returns The current buffer instance.
+     */
+    writeString: (value: string, encoding?: StringEncoding, offset?: number, length?: number) => this;
+    /**
+     * Writes a single bit to the buffer.
+     * @param value The value to write (`0` or `1`).
+     * @param bitOffset The offset to read from **as a number of bits** (optional, defaults to 0).
+     * @param msbFirst Whether to write the bit to the most significant bit (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeBit: (value: Bit, bitOffset?: number, msbFirst?: boolean, check?: boolean) => this;
+    /**
+     * Writes a single byte to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint8: (value: number, offset?: number, check?: boolean) => this;
+    /**
+     * **[LITTLE ENDIAN]** Writes a single 16-bit value to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint16LE: (value: number, offset?: number, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * **[BIG ENDIAN]** Writes a single 16-bit value to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint16BE: (value: number, offset?: number, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * Writes a single 16-bit value to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint16: (value: number, offset?: number, endianness?: Endianness, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * **[LITTLE ENDIAN]** Writes a single 32-bit word to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint32LE: (value: number, offset?: number, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * **[BIG ENDIAN]** Writes a single 32-bit word to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint32BE: (value: number, offset?: number, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * Writes a single 32-bit word to the buffer.
+     * @param value The value to write.
+     * @param offset The offset to write to (optional, defaults to 0).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint32: (value: number, offset?: number, endianness?: Endianness, verifyAlignment?: boolean, check?: boolean) => this;
+    /**
+     * Writes an array of bits to the buffer.
+     * @param array The array of bits to write to the buffer.
+     * @param bitOffset The offset to start writing at **as a number of bits** (optional, defaults to 0).
+     * @param bitLength The length to write **as a number of bits** (optional, defaults to the array length).
+     * @param msbFirst Whether to write the bits from the most significant bit (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeBits: (array: Bit[], bitOffset?: number, bitLength?: number, msbFirst?: boolean) => this;
+    /**
+     * Writes a Uint8Array to the buffer.
+     * @param array The Uint8Array to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @param arrayOffset The offset to start reading from in the array (optional, defaults to 0).
+     * @returns The current buffer instance.
+     */
+    writeUint8Array: (array: Uint8Array, offset?: number, length?: number, arrayOffset?: number) => this;
+    /**
+     * Writes a Uint16Array to the buffer.
+     * @param array The Uint16Array to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @param arrayOffset The offset to start reading from in the array (optional, defaults to 0).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint16Array: (array: Uint16Array, offset?: number, length?: number, arrayOffset?: number, endianness?: Endianness, verifyAlignment?: boolean) => this;
+    /**
+     * Writes a Uint32Array to the buffer.
+     * @param array The Uint16Array to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @param arrayOffset The offset to start reading from in the array (optional, defaults to 0).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @returns The current buffer instance.
+     */
+    writeUint32Array: (array: Uint32Array, offset?: number, length?: number, arrayOffset?: number, endianness?: Endianness, verifyAlignment?: boolean) => this;
+    /**
+     * **[LITTLE ENDIAN]** Writes a big integer of any size to the buffer.
+     *
+     * **No alignment is required, the length is automatically calculated.**
+     * @param value The big integer to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @returns The current buffer instance.
+     */
+    writeBigIntLE: (value: bigint, offset?: number, length?: number) => this;
+    /**
+     * **[BIG ENDIAN]** Writes a big integer of any size to the buffer.
+     *
+     * **No alignment is required, the length is automatically calculated.**
+     * @param value The big integer to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @returns The current buffer instance.
+     */
+    writeBigIntBE: (value: bigint, offset?: number, length?: number) => this;
+    /**
+     * Writes a big integer of any size to the buffer.
+     *
+     * **No alignment is required, the length is automatically calculated.**
+     * @param value The big integer to write to the buffer.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @param length The length to write (optional, defaults to the array length).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @returns The current buffer instance.
+     */
+    writeBigInt: (value: bigint, offset?: number, length?: number, endianness?: Endianness) => this;
+    /**
+     * Writes a range of numbers between 0 and 255 to the buffer.
+     * @param start The start of the range, inclusive.
+     * @param end The end of the range, exclusive.
+     * @param offset The offset to start writing at (optional, defaults to 0).
+     * @returns The current buffer instance.
+     */
+    writeRange: (start: number, end: number, offset?: number) => this;
+    /**
+     * ==============
+     *  READ METHODS
+     * ==============
+     *
+     * Notes:
+     * - All read methods have the capability to disable the overall check.
+     * - All of the "endianness sensitive" methods are wrapped within a single
+     *   method with an optional endianness parameter.
+     */
+    /**
+     * **[LITTLE ENDIAN]** Reads a part of the buffer and returns it as an hexadecimal string (always uppercase).
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The hexadecimal string.
+     */
+    readHexStringLE: (offset?: number, length?: number, check?: boolean) => string;
+    /**
+     * **[BIG ENDIAN]** Reads a part of the buffer and returns it as an hexadecimal string (always uppercase).
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The hexadecimal string.
+     */
+    readHexStringBE: (offset?: number, length?: number, check?: boolean) => string;
+    /**
+     * Reads a part of the buffer and returns it as an hexadecimal string (always uppercase).
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).'
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The hexadecimal string.
+     */
+    readHexString: (offset?: number, length?: number, endianness?: Endianness, check?: boolean) => string;
+    /**
+     * Reads a part of the buffer and returns it as an UTF-8 string.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The UTF-8 string.
+     */
+    readUtf8String: (offset?: number, length?: number, check?: boolean) => string;
+    /**
+     * Read a single bit from the buffer.
+     *
+     * **Note:** The offset is in bits, not bytes in contrast to the other methods.
+     * @param bitOffset The offset to read from **as a number of bits** (optional, defaults to 0).
+     * @param msbFirst Whether to read the bit from the most significant bit (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The bit as 0 or 1.
+     */
+    readBit: (bitOffset?: number, msbFirst?: boolean, check?: boolean) => Bit;
+    /**
+     * Reads a single byte from the buffer.
+     *
+     * Equivalent to using the index signature (square bracket notation).
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The byte as number.
+     */
+    readUint8: (offset?: number, check?: boolean) => number;
+    /**
+     * **[LITTLE ENDIAN]** Reads a single 16-bit value from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The 16-bit value.
+     */
+    readUint16LE: (offset?: number, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * **[BIG ENDIAN]** Reads a single 16-bit value from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The 16-bit value.
+     */
+    readUint16BE: (offset?: number, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * Reads a single 16-bit value from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param endianness Whether to read the value in Little Endian (optional, defaults to `false`).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 2 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The 16-bit value.
+     */
+    readUint16: (offset?: number, endianness?: Endianness, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * **[LITTLE ENDIAN]** Reads a single 32-bit word from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     */
+    readUint32LE: (offset?: number, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * **[BIG ENDIAN]** Reads a single 32-bit word from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     */
+    readUint32BE: (offset?: number, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * Reads a single 32-bit word from the buffer.
+     * @param offset The offset to read from (optional, defaults to 0).
+     * @param endianness Whether to read the value in Little Endian (optional, defaults to `false`).
+     * @param verifyAlignment Whether to verify that the offset is aligned to 4 bytes (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     */
+    readUint32: (offset?: number, endianness?: Endianness, verifyAlignment?: boolean, check?: boolean) => number;
+    /**
+     * Reads a part of the buffer and return it as a bit array.
+     *
+     * **Note:** The offset is in bits, not bytes in contrast to the other methods.
+     * @param bitOffset The offset to read from **as a number of bits** (optional, defaults to 0).
+     * @param bitLength The length to read **as a number of bits** (optional, defaults to the buffer length - offset).
+     * @param msbFirst Whether to read the bits from the most significant bit (optional, defaults to `true`).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The bit array.
+     */
+    readBits: (offset?: number, length?: number, msbFirst?: boolean, check?: boolean) => Bit[];
+    /**
+     * Reads a part of the buffer and return it as a Uint8Array.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param check Whether to enable the overall check (optional, defaults to `true`).
+     * @returns The Uint8Array.
+     */
+    readUint8Array: (offset?: number, length?: number, check?: boolean) => Uint8Array;
+    /**
+     * Reads a part of the buffer and return it as a Uint16Array.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @returns The Uint16Array.
+     */
+    readUint16Array: (offset?: number, length?: number, check?: boolean) => Uint16Array;
+    /**
+     * Reads a part of the buffer and return it as a Uint32Array.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @returns The Uint32Array.
+     */
+    readUint32Array: (offset?: number, length?: number, check?: boolean) => Uint32Array;
+    /**
+     * **[LITTLE ENDIAN]** Reads a certain amount of bytes from the buffer and converts it into a big integer.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @returns The big integer.
+     */
+    readBigIntLE: (offset?: number, length?: number, check?: boolean) => bigint;
+    /**
+     * **[BIG ENDIAN]** Reads a certain amount of bytes from the buffer and converts it into a big integer.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @returns The big integer.
+     */
+    readBigIntBE: (offset?: number, length?: number, check?: boolean) => bigint;
+    /**
+     * Reads a certain amount of bytes from the buffer and converts it into a big integer.
+     * @param offset The offset to start reading from (optional, defaults to 0).
+     * @param length The length to read (optional, defaults to the buffer length - offset).
+     * @param endianness Whether to read the value in Little Endian (optional, defaults to `false`).
+     * @returns The big integer.
+     */
+    readBigInt: (offset?: number, length?: number, endianness?: Endianness, check?: boolean) => bigint;
+    /**
+     * ====================
+     *  CONVERSION METHODS
+     * ====================
+     */
+    /**
+     * Converts the buffer into an hexadecimal string (always uppercase).
+     * @param prefix Whether to prefix the hexadecimal string with `0x` (optional, defaults to `false`).
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @returns The hexadecimal string.
+     */
+    toHexString: (prefix?: boolean, endianness?: Endianness) => string;
+    /**
+     * Converts the buffer into an UTF-8 string.
+     * @returns The UTF-8 string.
+     */
+    toUtf8String: () => string;
+    /**
+     * Converts the buffer into a string representation (hex string is always uppercase).
+     * @param encoding The encoding to use (optional, defaults to "hex").
+     * @param hexPrefix Whether to prefix the hexadecimal string with `0x` (optional, defaults to `false`).
+     * @returns The string representation of the buffer.
+     */
+    toString: (encoding?: "utf8" | "hex", hexPrefix?: boolean) => string;
+    /**
+     * Converts the buffer into a bit array.
+     * @param msbFirst Whether to read the bits from the most significant bit (optional, defaults to `true`).
+     * @returns The bit array.
+     */
+    toBits: (msbFirst?: boolean) => Bit[];
+    /**
+     * Converts the buffer into a Uint8Array.
+     * @returns The Uint8Array.
+     */
+    toUint8Array: () => Uint8Array;
+    /**
+     * Converts the buffer into a Uint16Array.
+     * @returns The Uint16Array.
+     */
+    toUint16Array: () => Uint16Array;
+    /**
+     * Converts the buffer into a Uint32Array.
+     * @returns The Uint32Array.
+     */
+    toUint32Array: () => Uint32Array;
+    /**
+     * Converts the buffer into a big integer.
+     * @param endianness The endianness to use (optional, defaults to the platform's endianness).
+     * @returns The big integer.
+     */
+    toBigInt: (endianness?: Endianness) => bigint;
+    /**
+     * ===============
+     *  CHECK METHODS
+     * ===============
+     */
+    /**
+     * Checks if the current buffer is equal to the specified buffer.
+     * @param buffer The buffer to compare to.
+     * @returns Whether the buffers are equal.
+     */
+    equals: (buffer: CyBuffer) => boolean;
+    /**
+     * Check if the buffer is empty.
+     * @returns Whether the buffer is empty.
+     */
+    isEmpty: () => boolean;
+    /**
+     * Check if the buffer is full.
+     * @returns Whether the buffer is full.
+     */
+    isFull: () => boolean;
+    /**
+     * ====================
+     *  RANDOMNESS METHODS
+     * ====================
+     */
+    /**
+     * Randomly fills the buffer with bytes.
+     *
+     * **WARNING:** This method is not safe for cryptographic contexts, use the `safeRandomFill` method
+     * when security is a concern.
+     * @param offset The offset to start filling at (optional, defaults to 0).
+     * @param length The length to fill (optional, defaults to the buffer length - offset).
+     */
+    randomFill: (offset?: number, length?: number) => void;
+    /**
+     * Randomly fills the buffer with bytes.
+     *
+     * **WARNING:** This method is safe for cryptographic contexts, but is far slower than the `randomFill` method,
+     * use this method when security is a concern. Uses the Node.js `crypto.randomFillSync` method.
+     * @param offset The offset to start filling at (optional, defaults to 0).
+     * @param length The length to fill (optional, defaults to the buffer length - offset).
+     */
+    safeRandomFill: (offset?: number, length?: number) => Uint8Array<ArrayBufferLike>;
+    /**
+     * =================
+     *  UTILITY METHODS
+     * =================
+     */
+    /**
+     * Copies the buffer into a new buffer.
+     * @param offset The offset to start copying at (optional, defaults to 0).
+     * @param length The length to copy (optional, defaults to the buffer length).
+     * @returns A new buffer containing the copied data.
+     */
+    copy: (offset?: number, length?: number) => CyBuffer;
+    /**
+     * Returns a new buffer that references the same memory as the original buffer,
+     * A lot more efficient than copying it (~ 4 times faster than the `copy` method).
+     * @param offset The start offset (optional, defaults to 0).
+     * @param end The end offset (optional, defaults to the buffer length).
+     * @returns The subarray pointing to the same memory.
+     */
+    subarray: (offset?: number, length?: number) => CyBuffer;
+    /**
+     * Swaps the order of the buffer.
+     * @param offset The offset to start swapping at (optional, defaults to 0).
+     * @param length The length to swap (optional, defaults to the buffer length).
+     * @param wordLength The length per word (optional, defaults to 4).
+     * @returns The current buffer instance.
+     */
+    swap: (offset?: number, length?: number, wordLength?: number) => this;
+    /**
+     * Reverses a part of the buffer.
+     * @param offset The offset to start reversing at (optional, defaults to 0).
+     * @param length The length to reverse (optional, defaults to the buffer length).
+     * @returns The current buffer instance.
+     */
+    partialReverse: (offset?: number, length?: number) => this;
+    /**
+     * Reverses the entire buffer.
+     * @returns The current buffer instance.
+     */
+    reverse: () => this;
+    /**
+     * Rotates the buffer to the left.
+     * @returns The current buffer instance.
+     */
+    rotateLeft: () => this;
+    /**
+     * Rotates the buffer to the right.
+     * @returns The current buffer instance.
+     */
+    rotateRight: () => this;
+    /**
+     * Shifts the buffer to the left, filling the empty space with zeros.
+     * @param offset The offset to start shifting at (optional, defaults to 0).
+     * @param length The length to shift (optional, defaults to the buffer length).
+     * @param shift The number of bytes to shift (optional, defaults to 1).
+     * @returns The current buffer instance.
+     */
+    shiftLeft: (offset?: number, length?: number, shift?: number) => this;
+    /**
+     * Shifts the buffer to the right, filling the empty spaces with zeros.
+     * @param offset The offset to start shifting at (optional, defaults to 0).
+     * @param length The length to shift (optional, defaults to the buffer length).
+     * @param shift The number of bytes to shift (optional, defaults to 1).
+     * @returns The current buffer instance.
+     */
+    shiftRight: (offset?: number, length?: number, shift?: number) => this;
+    /**
+     * Fills the buffer with a specified value.
+     * @param value The value to fill the buffer with.
+     * @param offset The offset to start filling at (optional, defaults to 0).
+     * @param length The length to fill (optional, defaults to the buffer length).
+     * @returns The current buffer instance.
+     */
+    fill: (value: number, offset?: number, length?: number) => this;
+    /**
+     * Clears the buffer by filling it with zeros.
+     * @param offset The offset to start clearing at (optional, defaults to 0).
+     * @param length The length to clear (optional, defaults to the buffer length).
+     * @returns The current buffer instance.
+     */
+    clear: (offset?: number, length?: number) => this;
+}
+
+/**
+ * The type definition for an error object.
+ */
+type ErrorObj = {
+	status: number
+	name: string
+	message: string
+	data: unknown
+}
+
+/**
+ * Formats an `ErrorObj` into a standard error sent back by an API endpoint.
+ */
+declare function formatErrorResponse(error: ErrorObj, customMessage?: string, additionalData?: unknown): {
+    success: boolean;
+    message: string;
+    error: ErrorObj;
+};
+/**
+ * Formats an `ErrorObj` and stringifies it for it to be supported by the `Error` class.
+ * @param error The `ErrorObj` object to format.
+ * @param message Replaces the standard error message with a custom one (optional).
+ * @param additionalData Additional data to include in the error (optional).
+ * @returns The formatted error string.
+ */
+declare function stringifyError(error: ErrorObj, message?: string, additionalData?: unknown): string;
+/**
+ * Contains all the standard available errors for the application, it serves as a base
+ * to extend with your custom errors.
+ *
+ * The recommended way is to create an `AppErrors` object that extends this one, preferably
+ * at a place similar to `lib/utils/errors.ts`:
+ * ```typescript
+ * import { BaseErrors } from "@cybearl/cypack"
+ *
+ * export const AppErrors = {
+ *     ...BaseErrors,
+ *     // Add your custom errors here
+ * }
+ * ```
+ */
+declare const BaseErrors: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly name: "BadRequest";
+        readonly message: "Bad request.";
+        readonly data: null;
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly name: "Unauthorized";
+        readonly message: "Unauthorized.";
+        readonly data: null;
+    };
+    readonly PAYMENT_REQUIRED: {
+        readonly status: 402;
+        readonly name: "PaymentRequired";
+        readonly message: "Payment required.";
+        readonly data: null;
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly name: "Forbidden";
+        readonly message: "Forbidden.";
+        readonly data: null;
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly name: "NotFound";
+        readonly message: "Not found.";
+        readonly data: null;
+    };
+    readonly METHOD_NOT_ALLOWED: {
+        readonly status: 405;
+        readonly name: "MethodNotAllowed";
+        readonly message: "Method not allowed.";
+        readonly data: null;
+    };
+    readonly REQUEST_TIMEOUT: {
+        readonly status: 408;
+        readonly name: "RequestTimeout";
+        readonly message: "Request timed out.";
+        readonly data: null;
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly name: "Conflict";
+        readonly message: "Conflict.";
+        readonly data: null;
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly name: "InternalServerError";
+        readonly message: "Internal server error.";
+        readonly data: null;
+    };
+    readonly BACKEND_FUNCTION_RUNNING_ON_CLIENT: {
+        readonly status: 500;
+        readonly name: "BackendFunctionRunningOnClient";
+        readonly message: "A function reserved for the backend is running on the client.";
+        readonly data: null;
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly name: "NotImplemented";
+        readonly message: "Not implemented.";
+        readonly data: null;
+    };
+    readonly BANDWIDTH_LIMIT_EXCEEDED: {
+        readonly status: 509;
+        readonly name: "BandwidthLimitExceeded";
+        readonly message: "Bandwidth limit exceeded.";
+        readonly data: null;
+    };
+};
+
+/**
+ * Get the name of the host on which the application is running.
+ * @returns The name of the host.
+ */
+declare function getHostname(): string | undefined;
+
+/**
+ * The type of the parameters object.
+ */
+type Parameters = {
+    level: pino.LevelWithSilentOrString;
+    showLevel: boolean;
+    showTimestamp: boolean;
+    foreignObjectStartAtNewLine: boolean;
+    foreignObjectPadding: number | "after-timestamp" | "after-level";
+    foreignObjectIndent: number;
+};
+/**
+ * A custom logger instance compatible with both front and back-end, allowing to log messages
+ * with different levels and colors.
+ *
+ * The available levels are:
+ * - `fatal`
+ * - `error`
+ * - `warn`
+ * - `info`
+ * - `debug`
+ * - `trace`
+ *
+ * The available parameters are:
+ * - `setLevel`: Set the logger level (defaults to `"trace"`).
+ * - `setShowLevel`: Set the logger level display (defaults to `true`).
+ * - `setShowTimestamp`: Set the logger timestamp display (defaults to `true`).
+ * - `setForeignObjectStartAtNewLine`: Set the logger foreign object new line display (defaults to `false`).
+ * - `setForeignObjectPadding`: Set the padding for foreign objects (defaults to `0`).
+ * - `setForeignObjectIndent`: Set the indent for foreign objects (defaults to `4`).
+ * - `setParameters`: Set all the parameters at once.
+ * - `resetParameters`: Reset all the parameters to their default values.
+ */
+declare const logger: pino.Logger & {
+    /**
+     * Set the logger level, available levels are:
+     * - `fatal`
+     * - `error`
+     * - `warn`
+     * - `info`
+     * - `debug`
+     * - `trace`
+     *
+     * The logging level is a **minimum** level. For instance if `logger.level` is `"info"` then all
+     * `"fatal"`, `"error"`, `"warn"` and `"info"` logs will be enabled.
+     * @param level The new logger level.
+     */
+    setLevel: (level: Parameters["level"]) => void;
+    /**
+     * Set the logger level display.
+     * @param showLevel Whether to show the level or not.
+     */
+    setShowLevel: (showLevel: Parameters["showLevel"]) => void;
+    /**
+     * Set the logger timestamp display.
+     * @param showTimestamp Whether to show the timestamp or not.
+     */
+    setShowTimestamp: (showTimestamp: Parameters["showTimestamp"]) => void;
+    /**
+     * Set the logger foreign object new line display (wether to start the foreign object on a new line or not).
+     * @param foreignObjectStartAtNewLine Whether to start the foreign object on a new line or not.
+     */
+    setForeignObjectStartAtNewLine: (foreignObjectStartAtNewLine: Parameters["foreignObjectStartAtNewLine"]) => void;
+    /**
+     * Set the padding for foreign objects, it also accepts `"after-timestamp"` and
+     * `"after-level"` to automatically calculate the padding to match the beginning of the
+     * specified element.
+     * @param padding The padding for foreign objects.
+     */
+    setForeignObjectPadding: (padding: Parameters["foreignObjectPadding"]) => void;
+    /**
+     * Set the indent for foreign objects.
+     * @param indent The indent for foreign objects.
+     */
+    setForeignObjectIndent: (indent: Parameters["foreignObjectIndent"]) => void;
+    /**
+     * Set all the parameters at once.
+     * @param parameters The new parameters.
+     */
+    setParameters: (parameters: Parameters) => void;
+    /**
+     * Reset all the parameters to their default values.
+     */
+    resetParameters: () => void;
+};
+
+/**
+ * A session with a user extended with optional roles.
+ */
+type ExtendedSession = Session & {
+    user: Session["user"] & {
+        roles: string[] | undefined;
+    };
+};
+/**
+ * The type for the authentication options.
+ */
+type AuthOptions = {
+    requireAuth?: boolean;
+    hasRole?: string;
+    hasSomeRoles?: string[];
+    hasAllRoles?: string[];
+};
+/**
+ * The type for the overall wrapper options.
+ */
+type WrapperOptions = {
+    authFunction?: (req: NextApiRequest, res: NextApiResponse) => Promise<ExtendedSession | null>;
+    roles?: string[];
+} & AuthOptions;
+/**
+ * The type for a Next API wrapped method.
+ */
+type NextApiMethodInput = {
+    req: NextApiRequest;
+    res: NextApiResponse;
+    session: ExtendedSession | null;
+    wrapper: NextApiWrapper;
+};
+/**
+ * The type for a Next API wrapped method.
+ */
+type NextApiMethod = ({ req, res, session, wrapper }: NextApiMethodInput) => Promise<void> | void;
+/**
+ * The type for a Next API wrapped method, extended with specific auth options.
+ */
+type NextApiMethodWithAuthOptions = {
+    method: NextApiMethod;
+    authOptions?: AuthOptions;
+};
+/**
+ * An object containing all methods for the API route.
+ */
+type NextApiMethods = {
+    read?: NextApiMethod | NextApiMethodWithAuthOptions;
+    write?: NextApiMethod | NextApiMethodWithAuthOptions;
+    update?: NextApiMethod | NextApiMethodWithAuthOptions;
+    remove?: NextApiMethod | NextApiMethodWithAuthOptions;
+};
+/**
+ * A class that wraps the Next.js API routes.
+ */
+declare class NextApiWrapper {
+    private _req;
+    private _res;
+    private _read;
+    private _write;
+    private _update;
+    private _remove;
+    private _options;
+    /**
+     * The constructor for the NextApiWrapper class.
+     * @param req The `NextApiRequest` object.
+     * @param res The `NextApiResponse` object.
+     * @param methods The methods to be used for the API route:
+     * - `read`: The *GET* method.
+     * - `write`: The *POST* method.
+     * - `update`: The *PATCH* method.
+     * - `remove`: The *DELETE* method.
+     * @param options The options for the wrapper:
+     * - `authFunction`: The function to be used for authentication.
+     * - `roles`: The roles to be used for the wrapper.
+     * - `requireAuth`: Whether to require authentication (defaults to `false`).
+     * - `hasRole`: The user needs to have the role.
+     * - `hasSomeRoles`: The user needs to have at least one of the roles.
+     * - `hasAllRoles`: The user needs to have all of the roles.
+     */
+    constructor(req: NextApiRequest, res: NextApiResponse, methods?: NextApiMethods, options?: WrapperOptions);
+    /**
+     * Set request and response objects.
+     * @param req The new `NextApiRequest` object.
+     * @param res The new `NextApiResponse` object.
+     */
+    setRequestResponse(req: NextApiRequest, res: NextApiResponse): void;
+    /**
+     * Set methods for the API route.
+     * @param methods The new methods to be used for the API route:
+     * - `read`: The *GET* method.
+     * - `write`: The *POST* method.
+     * - `update`: The *PATCH* method.
+     * - `remove`: The *DELETE* method.
+     */
+    setMethods(methods: NextApiMethods): void;
+    /**
+     * Set options for the API route.
+     * @param options The new options for the wrapper:
+     * - `requireAuth`: Whether to require authentication (defaults to `false`).
+     * - `hasRole`: The user needs to have the role.
+     * - `hasSomeRoles`: The user needs to have at least one of the roles.
+     * - `hasAllRoles`: The user needs to have all of the roles.
+     */
+    setOptions(options: Partial<AuthOptions>): void;
+    /**
+     * A private method to check data validity.
+     * @param data The data to be checked.
+     * @returns Whether the data is valid.
+     */
+    private _checkDataValidity;
+    /**
+     * Returns a properly formatted success response.
+     * @param status Status code to be sent in the response.
+     * @param data Data to be sent in the response (optional, defaults to `null`).
+     */
+    successResponse(status: number, data?: unknown): void;
+    /**
+     * Returns a properly formatted error response, based on error constants.
+     * @param error Error code constant to be sent in the response.
+     * @param data Additional data to be sent in the response (optional).
+     * @param message Error message to be sent in the response (optional, defaults to the internal error message).
+     */
+    errorResponse(error: ErrorObj, data?: unknown, message?: string): void;
+    /**
+     * Verify if the user has a specific role.
+     * @param user The user object.
+     * @param role The role to be checked.
+     * @returns Whether the user has the role.
+     */
+    hasRole(user: ExtendedSession["user"], role: string): boolean | undefined;
+    /**
+     * Verify if the user has at least one of the roles.
+     * @param user The user object.
+     * @param roles The roles to be checked.
+     * @returns Whether the user has at least one of the roles.
+     */
+    hasSomeRoles(user: ExtendedSession["user"], roles: string[]): boolean;
+    /**
+     * Verify if the user has all of the roles.
+     * @param user The user object.
+     * @param roles The roles to be checked.
+     * @returns Whether the user has all of the roles.
+     */
+    hasAllRoles(user: ExtendedSession["user"], roles: string[]): boolean;
+    /**
+     * Check the authentication and roles of the user based on the auth options.
+     * @param session The session object.
+     * @param authOptions The authentication options.
+     * @returns Whether the user has the required authentication and roles.
+     */
+    checkAuthOptions(session: ExtendedSession | null, authOptions: AuthOptions): boolean;
+    /**
+     * Check if a method is a direct method or a method with auth options and execute it.
+     * @param method The method to be checked.
+     * @param methodInput The method input object.
+     * @returns Whether the method was executed successfully.
+     */
+    private _executeMethod;
+    /**
+     * Run and route the request to the appropriate method.
+     * @returns The response from the method.
+     */
+    run(): Promise<boolean | void>;
+}
+
+export { BaseErrors, Bench, type BenchmarkResult, type BenchmarkResults, type Bit, CyBuffer, type Endianness, NextApiWrapper, type StringEncoding, formatErrorResponse, generateCGASStatus, getHostname, logger, stringifyError };