@catstral/levy-utils 1.0.0 → 2.0.0

package/dist/misc/utils/readOnly/index.d.ts

@@ -0,0 +1,47 @@
+import type { Key } from "~/types";
+export type ReadOnlyTarget = Record<Key, unknown> | readonly unknown[] | unknown[] | Map<unknown, unknown> | Set<unknown>;
+export type ReadOnly<T> = T extends Record<Key, unknown> ? Readonly<T> : T extends readonly (infer U)[] ? readonly U[] : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<K, V> : T extends ReadonlySet<infer U> ? ReadonlySet<U> : T;
+export type DeepReadOnly<T> = T extends Record<Key, unknown> ? {
+    readonly [K in keyof T]: DeepReadOnly<T[K]>;
+} : T extends readonly (infer U)[] ? readonly DeepReadOnly<U>[] : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadOnly<K>, DeepReadOnly<V>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadOnly<U>> : T;
+/**
+ * Checks if the given value is read-only.
+ *
+ * Whether an object's existing property attributes and values cannot be modified, and new properties cannot be added.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {Record<Key, unknown> | unknown[] | readonly unknown[]} T
+ * @param {T} value The value to check if it is read-only
+ * @returns {value is Readonly<T>} A boolean that signals if the given value is read-only
+ */
+export declare function isReadOnly<const T extends Record<Key, unknown> | unknown[] | readonly unknown[]>(value: T): value is Readonly<T>;
+/**
+ * Returns a shallow read-only copy of an object, array, map, or set.
+ *
+ * Only `value` itself is copied and frozen — nested objects/arrays/maps/sets keep the exact same
+ * references as `value` and remain mutable.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of top-level entries in `value`.
+ *
+ * @template {ReadOnlyTarget} T
+ * @param {T} value The object, array, map, or set to return a frozen shallow copy of
+ * @param {false} [deepFreeze] Whether nested objects, arrays, maps, and sets should also be cloned and frozen
+ * @returns {Readonly<T>} A frozen shallow copy of `value`
+ */
+export declare function readOnly<const T extends ReadOnlyTarget>(value: T, deepFreeze?: false): Readonly<T>;
+/**
+ * Returns a deep read-only copy of an object, array, map, or set.
+ *
+ * Every nested object, array, map, and set is recursively cloned and frozen, so nothing in the
+ * result is shared with `value`.
+ *
+ * The time complexity for this is `O(n)` where `n` is the total amount of nested entries in `value`.
+ *
+ * @template {ReadOnlyTarget} T
+ * @param {T} value The object, array, map, or set to return a frozen deep copy of
+ * @param {true} deepFreeze Whether nested objects, arrays, maps, and sets should also be cloned and frozen
+ * @returns {DeepReadOnly<T>} A deeply frozen copy of `value`
+ */
+export declare function readOnly<const T extends ReadOnlyTarget>(value: T, deepFreeze: true): DeepReadOnly<T>;
+export declare function readOnly<const T extends ReadOnlyTarget>(value: T, deepFreeze: boolean): Readonly<T> | DeepReadOnly<T>;

package/dist/misc/utils/sleep/index.d.ts

@@ -3,7 +3,7 @@
  *
  * The time complexity for this is `O(1)`.
  *
- * @param {number} delay The delay to wait to resolve the returned promise
+ * @param {number} delayMs The delay to wait to resolve the returned promise
  * @returns {Promise<void>} A Promise that resolved after the specified delay has elapsed
  */
-export declare function sleep(delay: number): Promise<void>;
+export declare function sleep(delayMs: number): Promise<void>;

package/dist/misc/utils/timeout/index.d.ts

@@ -0,0 +1,40 @@
+import { UtilError } from "~/error";
+import type { Computable } from "../compute";
+export declare class TimeoutUtilError extends UtilError {
+    readonly util = "timeout";
+}
+export declare class TimeoutError extends Error {
+    constructor(delayMs: number);
+}
+export interface TimeoutOptions {
+    /**
+     * A callback that runs when the delay has elapsed.
+     *
+     * Throwing a value inside this callback rejects the promise with that value instead of a {@link TimeoutError}.
+     *
+     * @param {number} delayMs
+     * @returns {void}
+     */
+    onTimeout?: (delayMs: number) => void;
+}
+/**
+ * Wraps the given promise into one that rejects after a given delay has elapsed.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @param {Computable<Promise<T>, [signal: AbortSignal]>} value The promise or callback that returns a promise to handle
+ * @param {number} delayMs The delay in milliseconds to wait before rejecting the promise
+ * @param {TimeoutOptions<T>} [options] The options given to the timeout
+ * @returns {Promise<T>} A promise that resolves with the given promise's result and rejects after the specified delay has elapsed
+ * @throws {TimeoutUtilError} If the given delay is smaller than 0
+ * @throws {TimeoutError} If the given delay has elapsed
+ */
+export declare function timeout<const T>(value: Computable<Promise<T>, [signal: AbortSignal]>, delayMs: number, options?: TimeoutOptions): Promise<T>;
+/**
+ * Checks if the given value is a timeout error.
+ *
+ * @param {?} value The value to check if it is a timeout error.
+ * @returns {boolean} A boolean that signals if the given value is an instance of {@link TimeoutError}
+ */
+export declare function isTimeoutError(value: unknown): value is TimeoutError;

package/dist/misc/utils/values/index.d.ts

@@ -0,0 +1,13 @@
+import type { Key } from "~/types";
+export type ValuesTarget = ArrayLike<unknown> | Record<Key, unknown> | Map<unknown, unknown> | Set<unknown> | Iterable<unknown>;
+export type Values<T extends ValuesTarget> = T extends ArrayLike<infer V> ? V[] : T extends Record<Key, infer V> ? V[] : T extends Map<unknown, infer V> ? V[] : T extends Set<infer V> ? V[] : T extends Iterable<infer V> ? V[] : never;
+/**
+ * Returns an array of values based on the given target.
+ *
+ * The time complexity for this is `O(n)` where `n` is the amount of values in the given `target`.
+ *
+ * @template {ValuesTarget} T
+ * @param target The given value to extract values from
+ * @returns {Values<T>} An array of values associated with `target`
+ */
+export declare function values<const T extends ValuesTarget>(target: T): Values<T>;

package/dist/number/index.d.ts

@@ -1,2 +1,13 @@
-export * from './utils/toFloat';
-export * from './utils/toInt';
+export * from "./math";
+export * from "./types";
+export * from "./utils/clamp";
+export * from "./utils/isDecimal";
+export * from "./utils/isEven";
+export * from "./utils/isInteger";
+export * from "./utils/isOdd";
+export * from "./utils/negative";
+export * from "./utils/positive";
+export * from "./utils/sign";
+export * from "./utils/toFloat";
+export * from "./utils/toInt";
+export * from "./utils/trunc";

package/dist/number/math/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils/isPrime";
+export * from "./utils/mod";

package/dist/number/math/utils/isPrime/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is a prime number.
+ *
+ * The time complexity for this is `O(√n)` where `n` is the given number.
+ *
+ * @param {number} value The value to check if it is a prime number
+ * @returns {boolean} A boolean that signals if the given number is a prime number
+ */
+export declare function isPrime(value: number): boolean;

package/dist/number/math/utils/mod/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the modulo of a dividend and a divisor.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} dividend The number to be divided
+ * @param {number} divisor The number to divide by
+ * @returns {number} The modulo of the division
+ */
+export declare function mod(dividend: number, divisor: number): number;

package/dist/number/types.d.ts

@@ -0,0 +1,11 @@
+export type Zero = 0 | -0;
+export type Integer<T extends number> = `${T}` extends `${infer V extends number}.${number}` ? V : T;
+export type IsInteger<T extends number> = number extends T ? boolean : T extends Integer<T> ? true : false;
+export type Positive<T extends number> = T extends Zero ? 0 : `${T}` extends `-${infer V extends number}` ? V : T;
+export type IsPositive<T extends number> = number extends T ? boolean : T extends Positive<T> ? true : false;
+export type Negative<T extends number> = T extends Zero ? -0 : `-${T}` extends `${infer N extends number}` ? N : T;
+export type IsNegative<T extends number> = number extends T ? boolean : T extends Negative<T> ? true : false;
+export type PositiveInteger<T extends number> = Integer<Positive<T>>;
+export type NegativeInteger<T extends number> = Integer<Negative<T>>;
+export type NonZero<T extends number> = Exclude<T, Zero>;
+export type IsNonZero<T extends number> = number extends T ? boolean : T extends NonZero<T> ? true : false;

package/dist/number/utils/clamp/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Clamps a number between a minimum and maximum value.
+ *
+ * Returns `NaN` if the minimum and maximum contradict each other.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} min The minimum value
+ * @param {number} value The value to be clamped between `min` and `max`
+ * @param {number} max The maximum value
+ * @returns {number} The clamped number
+ */
+export declare function clamp(min: number, value: number, max: number): number;

package/dist/number/utils/isDecimal/index.d.ts

@@ -0,0 +1,11 @@
+export type IsDecimal<T extends number> = number extends T ? boolean : `${T}` extends `${number}.${number}` ? true : false;
+/**
+ * Checks if the given value is a number with decimals.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to check if it has decimals
+ * @returns {IsDecimal<T>} A boolean that signals if the given number has decimals
+ */
+export declare function isDecimal<const T extends number>(value: T): IsDecimal<T>;

package/dist/number/utils/isEven/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is an even number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} value The value to check if it is an even number
+ * @returns {boolean} A boolean that signals if the given number is even
+ */
+export declare function isEven(value: number): boolean;

package/dist/number/utils/isInteger/index.d.ts

@@ -0,0 +1,11 @@
+import type { IsInteger } from "~/number";
+/**
+ * Checks if the given value is an integer.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to check if it is an integer
+ * @returns {IsInteger<T>} A boolean that signals if the given number is an integer
+ */
+export declare function isInteger<const T extends number>(value: T): IsInteger<T>;

package/dist/number/utils/isOdd/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is an odd number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} value The value to check if it is an odd number
+ * @returns {boolean} A boolean that signals if the given number is odd
+ */
+export declare function isOdd(value: number): boolean;

package/dist/number/utils/negative/index.d.ts

@@ -0,0 +1,21 @@
+import type { IsNegative, Negative } from "~/number";
+/**
+ * Converts a number into a negative number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {Negative<T>} value The value to convert into a negative number
+ * @returns {Negative<T>} A negative number
+ */
+export declare function negative<const T extends number>(value: T): Negative<T>;
+/**
+ * Checks if the given value is a negative number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The value to check if it is a negative number
+ * @returns {IsNegative<T>} A boolean that signals if the given number is negative
+ */
+export declare function isNegative<const T extends number>(value: T): IsNegative<T>;

package/dist/number/utils/positive/index.d.ts

@@ -0,0 +1,21 @@
+import type { IsPositive, Positive } from "~/number";
+/**
+ * Converts a number into a positive number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {Positive<T>} value The value to convert into a positive number
+ * @returns {Positive<T>} A positive number
+ */
+export declare function positive<const T extends number>(value: T): Positive<T>;
+/**
+ * Checks if the given value is a positive number.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The value to check if it is a positive number
+ * @returns {IsPositive<T>} A boolean that signals if the given number is positive
+ */
+export declare function isPositive<const T extends number>(value: T): IsPositive<T>;

package/dist/number/utils/sign/index.d.ts

@@ -0,0 +1,14 @@
+import type { IsNegative, Zero } from "~/number";
+export type Sign<T extends number> = number extends T ? -1 | 0 | 1 : T extends Zero ? 0 : IsNegative<T> extends true ? -1 : 1;
+/**
+ * Returns the sign of the given number.
+ *
+ * `NaN` is converted into zero.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {T} value The number to return the sign of
+ * @returns {Sign<T>} A number indicating whether the given number is positive, negative or zero
+ */
+export declare function sign<const T extends number>(value: T): Sign<T>;

package/dist/number/utils/toInt/index.d.ts

@@ -1,4 +1,4 @@
-export type Integer<T extends number> = `${T}` extends `${string}.${string}` ? never : T;
+import type { Integer } from "~/number";
 /**
  * Turns a value into an integer where invalid values, `NaN` or `Infinity` will return a fallback.
  *

package/dist/number/utils/trunc/index.d.ts

@@ -0,0 +1,16 @@
+import type { PositiveInteger } from "~/number/types";
+/**
+ * Truncates a number to the specified number of fraction digits.
+ *
+ * If no fraction digits are specified, the value is truncated to an integer.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template {number} T
+ * @param {number} value The number to truncate
+ * @param {PositiveInteger<T>} [fractionDigits=0]  The number of digits to preserve after the decimal point
+ * @returns {number} The truncated number
+ * @throws {RangeError} If `fractionDigits` is less than `0` or greater than `100`
+ */
+export declare function trunc(value: number): number;
+export declare function trunc<const T extends number>(value: number, fractionDigits: PositiveInteger<T>): number;

package/dist/object/index.d.ts

@@ -1,5 +1,6 @@
-export * from './utils/entries';
-export * from './utils/isObject';
-export * from './utils/keys';
-export * from './utils/omit';
-export * from './utils/pick';
+export * from "./utils/entries";
+export * from "./utils/extend";
+export * from "./utils/isObject";
+export * from "./utils/keys";
+export * from "./utils/omit";
+export * from "./utils/pick";

package/dist/object/utils/extend/index.d.ts

@@ -0,0 +1,21 @@
+import type { Key } from "~/types";
+/**
+ * @private
+ */
+type Mask<T extends Record<Key, unknown>> = (Partial<T> & Record<Key, unknown>) | Record<Key, unknown>;
+export type Extend<T extends Record<Key, unknown>, U extends Mask<T>> = Omit<T, keyof U> & U;
+/**
+ * Extends an object with another object.
+ *
+ * The time complexity for this is `O(n + m)` where:
+ * - `n` is the amount of keys in `value`.
+ * - `m` is the amount of keys in `other`.
+ *
+ * @template {Record<Key, unknown>} T
+ * @template {Partial<T> & Record<Key, unknown>} U
+ * @param {T} value The object to extend
+ * @param {U} other The object to override or extend properties of `value` with
+ * @returns {Extend<T, U>} An object where `value` is extended by `other`
+ */
+export declare function extend<const T extends Record<Key, unknown>, const U extends Mask<T>>(value: T, other: U): Extend<T, U>;
+export {};

package/dist/random/helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a random value less then max.
+ *
+ * NOTE: This is meant for getting an array index as the max number here is equal to the max array length.
+ */
+export declare function getCryptoSecureRandomNumber(max: number): number;

package/dist/random/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./utils/draw";
+export * from "./utils/maybe";
+export * from "./utils/random";
+export * from "./utils/shuffle";
+export * from "./utils/uid";
+export * from "./uuid";

package/dist/random/utils/chance/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a boolean based on the given chance percentage.
+ *
+ * The percentage specified should be on a scale of 0 - 1, meaning if you want a 50% chance
+ * the percentage should be specified to be 0.5.
+ *
+ * If the percentage is more than or equal to 1, the returned value will always be true.
+ * If the percentage is less than or equal to 0, the returned value will always be false.
+ *
+ * @param {number} percentage The percentage chance it has of being true (scale: 0 - 1)
+ * @returns {boolean} The random boolean based on the specified chance
+ */
+export declare function chance(percentage: number): boolean;

package/dist/random/utils/draw/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a random item from a given array or `undefined` if the array length is 0.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @template T
+ * @param {T[]} list The array to pick a random item from
+ * @returns {T | undefined} The random item
+ */
+export declare function draw<T>(list: [T, ...T[]]): T;
+export declare function draw<T>(list: T[]): T | undefined;
+export declare function draw<T>(list: readonly [T, ...T[]]): T;
+export declare function draw<T>(list: readonly T[]): T | undefined;

package/dist/random/utils/maybe/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a random boolean.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {boolean} A random boolean
+ */
+export declare function maybe(): boolean;

package/dist/random/utils/random/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a random number between a given minimum and maximum value.
+ *
+ * Returns `NaN` if the minimum and maximum contradict each other.
+ *
+ * NOTE: this utility is **NOT** cryptographically secure.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {number} [min=0] The minimum random value (default = `0`)
+ * @param {number} [max=1] The maximum random value (default = `1`)
+ * @returns {number} A random number between the min and max value
+ */
+export declare function random(min?: number, max?: number): number;

package/dist/random/utils/scatter/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @typedef {Object} ScatterOptions
+ * @prop {"FLOOR" | "ROUND" | "CEIL"} [bias="ROUND"] The bias of the split
+ */
+export interface ScatterOptions {
+    /**
+     * The bias of the split.
+     *
+     * @default `"ROUND"`
+     */
+    bias?: "FLOOR" | "ROUND" | "CEILING";
+}
+/**
+ * Returns an array split into a specified percentage of the original length with the original values
+ * assigned to either side at random.
+ *
+ * *NOTE: The first array of the returned tuple will be in a random order, while the second array will have the order preserved.*
+ *
+ * The time complexity of this is `O(n + n**2)` where `n` is the amount of items in the list.
+ *
+ * *NOTE: The time complexity of this is `O(n)` if the split is outside the specified range.*
+ *
+ * @template T
+ * @param {T[]} list The list to scatter
+ * @param {number} [split=0.5] The percentage to split the array into (scale: 0 - 1) (default = `0.5`)
+ * @param {ScatterOptions} [options] The options given to scatter the array
+ * @returns {[T[], T[]]} A split of the original array
+ */
+export declare function scatter<const T>(list: T[], split?: number, options?: ScatterOptions): [T[], T[]];
+export declare function scatter<const T>(list: readonly T[], split?: number, options?: ScatterOptions): [T[], T[]];

package/dist/random/utils/shuffle/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a new Array from a given array, with every item moved to a random position.
+ *
+ * The time complexity for this is `O(2n)` where `n` is the amount of values in the list.
+ *
+ * @template T
+ * @param {T[]} list The array to shuffle
+ * @returns {T[]} The shuffled array
+ */
+export declare function shuffle<const T>(list: T[]): T[];
+export declare function shuffle<const T>(list: readonly T[]): T[];

package/dist/random/utils/uid/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a cryptographically secure random string of characters, based on a given charset, grown to a specified length.
+ *
+ * The time complexity for this is `O(n log8(m))` where:
+ * - `n` is the length of the uid.
+ * - `m` is the length of the charset.
+ *
+ * @param {number} [length=8] The length of de uid (default = `8`)
+ * @param {string} [charset="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"] The characters used for generation (default = `"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"`)
+ * @returns {string} A random string of characters from the charset, with the specified length
+ */
+export declare function uid(length?: number, charset?: string): string;

package/dist/random/uuid/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { UuidRNGOptions } from "./types";
+export declare function rng(): Uint8Array;
+export declare function getRNG(options?: UuidRNGOptions): Uint8Array | null;
+export declare function stringifyBytes(bytes: Uint8Array): string;

package/dist/random/uuid/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./utils/max";
+export * from "./utils/nil";
+export * from "./utils/v1";
+export * from "./utils/v4";
+export * from "./utils/v7";

package/dist/random/uuid/types.d.ts

@@ -0,0 +1,16 @@
+export type UuidRNG = () => Uint8Array;
+/**
+ * @typedef {Object} UuidRNGOptions
+ * @prop {UuidRNG} [rng] A function that returns a list of randomly generated bytes
+ * @prop {Uint8Array} [random] A list of randomly generated bytes
+ */
+export interface UuidRNGOptions {
+    /**
+     * A function that returns a list of randomly generated bytes.
+     */
+    rng?: UuidRNG;
+    /**
+     * A list of randomly generated bytes.
+     */
+    random?: Uint8Array;
+}

package/dist/random/uuid/utils/max/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a max UUID string that is all 'f' (or ones in bit form).
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {string} The max UUID string
+ */
+export declare function uuidMax(): string;

package/dist/random/uuid/utils/nil/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a nil UUID string that is all zero's.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @returns {string} The nil UUID string
+ */
+export declare function uuidNil(): string;

package/dist/random/uuid/utils/v1/index.d.ts

@@ -0,0 +1,46 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV1UtilError extends UtilError {
+    readonly util = "uuidV1";
+}
+/**
+ * @typedef {Object} UuidV1Options
+ * @extends UuidRNGOptions
+ * @prop {number} [milliseconds=Date.now()] The amount of milliseconds that have past since the EPOCH (01-01-1970)
+ * @prop {number} [nanoseconds=0] The amount of nanoseconds that have elapsed in the current millisecond
+ * @prop {number} [clockSequence] The clock sequence used for generation
+ * @prop {Uint8Array} [node] A list of random bytes used to complete the UUID
+ */
+export interface UuidV1Options extends UuidRNGOptions {
+    /**
+     * The amount of milliseconds that have past since the EPOCH (01-01-1970).
+     *
+     * @default `Date.now()`
+     */
+    milliseconds?: number;
+    /**
+     * The amount of nanoseconds that have elapsed in the current millisecond.
+     *
+     * @default `0`
+     */
+    nanoseconds?: number;
+    /**
+     * The clock sequence used for generation.
+     */
+    clockSequence?: number;
+    /**
+     * A list of random bytes used to complete the UUID.
+     */
+    node?: Uint8Array;
+}
+/**
+ * Returns a Cryptographically secure random V1 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV1Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V1 UUID string
+ * @throws {UuidV1UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV1(options?: UuidV1Options): string;
+export { uuidV1 as v1 };

package/dist/random/uuid/utils/v4/index.d.ts

@@ -0,0 +1,22 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV4UtilError extends UtilError {
+    readonly util = "uuidV4";
+}
+/**
+ * @typedef {Object} UuidV4Options
+ * @extends UuidRNGOptions
+ */
+export interface UuidV4Options extends UuidRNGOptions {
+}
+/**
+ * Returns a Cryptographically secure random V4 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV1Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V4 UUID string
+ * @throws {UuidV4UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV4(options?: UuidV4Options): string;
+export { uuidV4 as v4, uuidV4 as uuid };

package/dist/random/uuid/utils/v7/index.d.ts

@@ -0,0 +1,34 @@
+import { UtilError } from "~/error";
+import type { UuidRNGOptions } from "../../types";
+export declare class UuidV7UtilError extends UtilError {
+    readonly util = "uuidV7";
+}
+/**
+ * @typedef {Object} UuidV7Options
+ * @extends UuidRNGOptions
+ * @prop {number} [milliseconds=Date.now()] The amount of milliseconds that have past since the EPOCH (01-01-1970)
+ * @prop {number} [clockSequence] The clock sequence used for generation
+ */
+export interface UuidV7Options extends UuidRNGOptions {
+    /**
+     * The amount of milliseconds that have past since the EPOCH (01-01-1970).
+     *
+     * @default `Date.now()`
+     */
+    milliseconds?: number;
+    /**
+     * The clock sequence used for generation.
+     */
+    sequence?: number;
+}
+/**
+ * Returns a Cryptographically secure random V7 UUID string.
+ *
+ * The time complexity for this is `O(1)`.
+ *
+ * @param {UuidV7Options} [options] The options to decide how to generate the UUID
+ * @returns {string} A V7 UUID string
+ * @throws {UuidV7UtilError} If the length of the specified random bytes is less then 16
+ */
+export declare function uuidV7(options?: UuidV7Options): string;
+export { uuidV7 as v7 };