zeed 1.2.4 → 1.3.0

package/dist/time-DxE-vjjw.d.mts

@@ -0,0 +1,140 @@
+//#region src/common/time.d.ts
+/**
+ * Set a fixed timestamp (ms since epoch) used by `getTimestamp` for tests.
+ *
+ * Pass a millisecond timestamp (for example created with Date.UTC) to force
+ * time-based helpers to return deterministic values during tests.
+ *
+ * @param ts - timestamp in milliseconds (defaults to 2000-01-01T00:00:00.000Z)
+ */
+declare function setTimestampTest(ts?: number): void;
+/**
+ * Return the current timestamp in milliseconds.
+ *
+ * In test mode (when `setTimestampTest` was called) the forced value is
+ * returned instead of the real current time.
+ *
+ * @returns timestamp in milliseconds
+ */
+declare function getTimestamp(): number;
+/**
+ * Return the current timestamp in seconds.
+ *
+ * Uses `getTimestamp()` which can be overridden for tests with
+ * `setTimestampTest`.
+ *
+ * @returns timestamp in whole seconds (integer)
+ */
+declare function getTimestampInSeconds(): number;
+/**
+ * Convert a UNIX timestamp in seconds to a JavaScript Date.
+ *
+ * @param ts - seconds since epoch
+ * @returns Date instance corresponding to the provided seconds
+ */
+declare function dateFromSeconds(ts: number): Date;
+/**
+ * Format a millisecond duration into a human readable string.
+ *
+ * - Values >= 1000ms are shown in seconds with one decimal (e.g. "1.2 s").
+ * - Smaller values are shown in milliseconds with two decimals (e.g. "123.45 ms").
+ *
+ * @param ms - duration in milliseconds
+ * @returns formatted duration string
+ */
+declare function formatMilliseconds(ms: number): string;
+/**
+ * Parses the given date candidates and returns the first valid Date object found.
+ *
+ * @param dateCandidates - The date candidates to parse, which can be either strings or Date objects.
+ * @returns The parsed Date object, or undefined if no valid date is found.
+ */
+declare function parseDate(...dateCandidates: (string | Date)[]): Date | undefined;
+/**
+ * Return a high-resolution timestamp in milliseconds.
+ *
+ * Uses the `performance.now()` clock when available (monotonic, high
+ * resolution), otherwise falls back to `Date.now()`.
+ *
+ * @returns timestamp in milliseconds (relative for performance.now, epoch for Date.now)
+ */
+declare function getPerformanceTimestamp(): number;
+/**
+ * Create a simple duration reporter.
+ *
+ * Returns a function that, when called, reports the elapsed time since
+ * `duration()` was called. The returned string is formatted via
+ * `formatMilliseconds`.
+ *
+ * Example: const t = duration(); // do work...; console.log(t());
+ *
+ * @returns a zero-argument function that returns the elapsed time string
+ */
+declare function duration(): () => string;
+/**
+ * If you parsed a date string that didn't include a time zone, adjust the
+ * naive UTC components into a local Date with the same Y/M/D/H/M/S values.
+ *
+ * This effectively treats the input as if it already represented local time
+ * and builds a corresponding Date using the local timezone.
+ */
+declare function datetimeToLocal(fromDate: Date): Date;
+/**
+ * If you parsed a date string that didn't include a time zone, adjust the
+ * local date components into a UTC Date with the same Y/M/D/H/M/S values.
+ */
+declare function datetimeToUTC(fromDate: Date): Date;
+/**
+ * Convert a timestamp in milliseconds to seconds.
+ *
+ * When `smart` is true the function will try to detect already-second
+ * timestamps and return them unchanged (heuristic threshold). For example,
+ * small numbers (< 1e12) are likely seconds and are returned as-is.
+ *
+ * @param ts - timestamp in milliseconds or seconds
+ * @param smart - enable heuristic detection (default: true)
+ * @returns timestamp in seconds
+ */
+declare function timestampMillisecondsToSeconds(ts: number, smart?: boolean): number;
+/**
+ * Convert a timestamp in seconds to milliseconds.
+ *
+ * When `smart` is true the function tries to detect already-millisecond
+ * values and returns them unchanged (heuristic threshold). Very large
+ * numbers (> 1e12) are assumed to already be milliseconds.
+ *
+ * @param ts - timestamp in seconds or milliseconds
+ * @param smart - enable heuristic detection (default: true)
+ * @returns timestamp in milliseconds
+ */
+declare function timestampSecondsToMilliseconds(ts: number, smart?: boolean): number;
+/** Number of milliseconds in (approx.) one year (365 days). */
+declare const TIME_YEAR_MS = 31536000000;
+/** Number of seconds in (approx.) one year (365 days). */
+declare const TIME_YEAR_S = 31536000;
+/** Number of milliseconds in (approx.) one month (30 days). */
+declare const TIME_MONTH_MS = 2592000000;
+/** Number of seconds in (approx.) one month (30 days). */
+declare const TIME_MONTH_S = 2592000;
+/** Number of milliseconds in one week (7 days). */
+declare const TIME_WEEK_MS = 604800000;
+/** Number of seconds in one week (7 days). */
+declare const TIME_WEEK_S = 604800;
+/** Number of milliseconds in one day (24 hours). */
+declare const TIME_DAY_MS = 86400000;
+/** Number of seconds in one day (24 hours). */
+declare const TIME_DAY_S = 86400;
+/** Number of milliseconds in one hour (60 minutes). */
+declare const TIME_HOUR_MS = 3600000;
+/** Number of seconds in one hour (60 minutes). */
+declare const TIME_HOUR_S = 3600;
+/** Number of milliseconds in one minute (60 seconds). */
+declare const TIME_MINUTE_MS = 60000;
+/** Number of seconds in one minute (60 seconds). */
+declare const TIME_MINUTE_S = 60;
+/** Build number is minutes since 2025-01-01 in base32 "agnoster" encoded format */
+declare function getBuildNumber(): string;
+declare function getSecondsFromBuildNumber(buildNumber: string): number;
+//#endregion
+export { parseDate as C, timestampSecondsToMilliseconds as E, getTimestampInSeconds as S, timestampMillisecondsToSeconds as T, formatMilliseconds as _, TIME_MINUTE_MS as a, getSecondsFromBuildNumber as b, TIME_MONTH_S as c, TIME_YEAR_MS as d, TIME_YEAR_S as f, duration as g, datetimeToUTC as h, TIME_HOUR_S as i, TIME_WEEK_MS as l, datetimeToLocal as m, TIME_DAY_S as n, TIME_MINUTE_S as o, dateFromSeconds as p, TIME_HOUR_MS as r, TIME_MONTH_MS as s, TIME_DAY_MS as t, TIME_WEEK_S as u, getBuildNumber as v, setTimestampTest as w, getTimestamp as x, getPerformanceTimestamp as y };
+//# sourceMappingURL=time-DxE-vjjw.d.mts.map

package/dist/timeout-CnUk6Ruj.d.mts

@@ -0,0 +1,13 @@
+//#region src/common/timeout.d.ts
+/**
+ * Slightliy enhanced setTimeout to avoid garbage collection issues.
+ * Returns a dispose function.
+ *
+ * Discussion see
+ * https://jakearchibald.com/2024/garbage-collection-and-closures/
+ * https://news.ycombinator.com/item?id=41111062
+ */
+declare function safeTimeout(fn: () => void, delay?: number, unref?: boolean): () => void;
+//#endregion
+export { safeTimeout as t };
+//# sourceMappingURL=timeout-CnUk6Ruj.d.mts.map

package/dist/timeout-CpFcK8MD.d.cts

@@ -0,0 +1,13 @@
+//#region src/common/timeout.d.ts
+/**
+ * Slightliy enhanced setTimeout to avoid garbage collection issues.
+ * Returns a dispose function.
+ *
+ * Discussion see
+ * https://jakearchibald.com/2024/garbage-collection-and-closures/
+ * https://news.ycombinator.com/item?id=41111062
+ */
+declare function safeTimeout(fn: () => void, delay?: number, unref?: boolean): () => void;
+//#endregion
+export { safeTimeout as t };
+//# sourceMappingURL=timeout-CpFcK8MD.d.cts.map

package/dist/type-test-BiKyEZkc.d.mts

@@ -0,0 +1,6 @@
+//#region src/common/schema/type-test.d.ts
+type Expect<T extends true> = T;
+type IsEqual<X, Y> = (<T>() => T extends X ? true : false) extends (<T>() => T extends Y ? true : false) ? true : false;
+//#endregion
+export { IsEqual as n, Expect as t };
+//# sourceMappingURL=type-test-BiKyEZkc.d.mts.map

package/dist/type-test-sM7QpfQU.d.cts

@@ -0,0 +1,6 @@
+//#region src/common/schema/type-test.d.ts
+type Expect<T extends true> = T;
+type IsEqual<X, Y> = (<T>() => T extends X ? true : false) extends (<T>() => T extends Y ? true : false) ? true : false;
+//#endregion
+export { IsEqual as n, Expect as t };
+//# sourceMappingURL=type-test-sM7QpfQU.d.cts.map

package/dist/types-BCtWYsuv.d.cts

@@ -0,0 +1,15 @@
+//#region src/common/types.d.ts
+type Json = string | number | boolean | null | {
+  [property: string]: Json;
+} | Json[];
+interface ObjectStorage<T = any> {
+  setItem: (key: string, value: T) => void;
+  getItem: (key: string) => T | undefined;
+  removeItem: (key: string) => void;
+  clear: () => void;
+  allKeys: () => string[];
+}
+type NestedArray<T> = T | Array<NestedArray<T>>;
+//#endregion
+export { NestedArray as n, ObjectStorage as r, Json as t };
+//# sourceMappingURL=types-BCtWYsuv.d.cts.map

package/dist/types-ejoFe34F.d.mts

@@ -0,0 +1,15 @@
+//#region src/common/types.d.ts
+type Json = string | number | boolean | null | {
+  [property: string]: Json;
+} | Json[];
+interface ObjectStorage<T = any> {
+  setItem: (key: string, value: T) => void;
+  getItem: (key: string) => T | undefined;
+  removeItem: (key: string) => void;
+  clear: () => void;
+  allKeys: () => string[];
+}
+type NestedArray<T> = T | Array<NestedArray<T>>;
+//#endregion
+export { NestedArray as n, ObjectStorage as r, Json as t };
+//# sourceMappingURL=types-ejoFe34F.d.mts.map

package/dist/url-4ihUPRLi.d.cts

@@ -0,0 +1,13 @@
+//#region src/common/data/url.d.ts
+declare function toHumanReadableUrl(url: string): string;
+declare const RX_URL: RegExp;
+/** @deprecated use linkifyPlainText */
+declare function linkifyPlainTextSimple(text: string): string;
+interface LinkifyOptions {}
+declare function linkifyPlainText(text: string, options?: LinkifyOptions): string;
+declare function linkifyPlainTextWithLineBreaks(text: string, options?: LinkifyOptions): string;
+declare function encodeQuery(data: Record<string, any>, filterValue?: (value: any) => boolean): string;
+declare function parseQuery(queryString: string): any;
+//#endregion
+export { linkifyPlainTextSimple as a, toHumanReadableUrl as c, linkifyPlainText as i, RX_URL as n, linkifyPlainTextWithLineBreaks as o, encodeQuery as r, parseQuery as s, LinkifyOptions as t };
+//# sourceMappingURL=url-4ihUPRLi.d.cts.map

package/dist/url-Bz-wgbtY.d.mts

@@ -0,0 +1,13 @@
+//#region src/common/data/url.d.ts
+declare function toHumanReadableUrl(url: string): string;
+declare const RX_URL: RegExp;
+/** @deprecated use linkifyPlainText */
+declare function linkifyPlainTextSimple(text: string): string;
+interface LinkifyOptions {}
+declare function linkifyPlainText(text: string, options?: LinkifyOptions): string;
+declare function linkifyPlainTextWithLineBreaks(text: string, options?: LinkifyOptions): string;
+declare function encodeQuery(data: Record<string, any>, filterValue?: (value: any) => boolean): string;
+declare function parseQuery(queryString: string): any;
+//#endregion
+export { linkifyPlainTextSimple as a, toHumanReadableUrl as c, linkifyPlainText as i, RX_URL as n, linkifyPlainTextWithLineBreaks as o, encodeQuery as r, parseQuery as s, LinkifyOptions as t };
+//# sourceMappingURL=url-Bz-wgbtY.d.mts.map

package/dist/utils-B8DsVgFr.d.mts

@@ -0,0 +1,11 @@
+import { n as Type } from "./schema-eMFkYY24.mjs";
+
+//#region src/common/schema/utils.d.ts
+declare function isSchemaObject(schema: Type<any>): boolean;
+declare function isSchemaOptional(schema: Type<any>): boolean;
+declare function isSchemaDefault(schema: Type<any>): boolean;
+declare function isSchemaPrimitive(schema: Type<any>): boolean;
+declare function isSchemaObjectFlat(schema: Type<any>): boolean;
+//#endregion
+export { isSchemaPrimitive as a, isSchemaOptional as i, isSchemaObject as n, isSchemaObjectFlat as r, isSchemaDefault as t };
+//# sourceMappingURL=utils-B8DsVgFr.d.mts.map

package/dist/utils-Bctk_WhH.d.cts

@@ -0,0 +1,11 @@
+import { n as Type } from "./schema-BNke0iHR.cjs";
+
+//#region src/common/schema/utils.d.ts
+declare function isSchemaObject(schema: Type<any>): boolean;
+declare function isSchemaOptional(schema: Type<any>): boolean;
+declare function isSchemaDefault(schema: Type<any>): boolean;
+declare function isSchemaPrimitive(schema: Type<any>): boolean;
+declare function isSchemaObjectFlat(schema: Type<any>): boolean;
+//#endregion
+export { isSchemaPrimitive as a, isSchemaOptional as i, isSchemaObject as n, isSchemaObjectFlat as r, isSchemaDefault as t };
+//# sourceMappingURL=utils-Bctk_WhH.d.cts.map

package/dist/utils-BfZkD2Pt.d.mts

@@ -0,0 +1,5 @@
+//#region src/common/utils.d.ts
+declare function noop(): void;
+//#endregion
+export { noop as t };
+//# sourceMappingURL=utils-BfZkD2Pt.d.mts.map

package/dist/utils-DHQBNh-Z.d.cts

@@ -0,0 +1,5 @@
+//#region src/common/utils.d.ts
+declare function noop(): void;
+//#endregion
+export { noop as t };
+//# sourceMappingURL=utils-DHQBNh-Z.d.cts.map

package/dist/utils-DX0sASsJ.d.mts

@@ -0,0 +1,45 @@
+import { t as Json } from "./types-ejoFe34F.mjs";
+
+//#region src/common/data/utils.d.ts
+/**
+ * Call a create function if key does not yet exist on an object. Returns the found or created object. Example:
+ *
+ * ```js
+ * function createRoom(room, rooms) { return new Room() }
+ * ensureKey(rooms, room, createRoom).enter()
+ * ```
+ */
+declare function ensureKey<T>(obj: Record<string, T>, key: string, createFn: (key?: string, obj?: Record<string, T>) => T): T;
+/**
+ * Call a create function if key does not yet exist on an object. Returns the found or created object. Example:
+ *
+ * ```js
+ * async function fetchItem(id, cache) { ... }
+ * let data = await ensureKey(cache, id, fetchItem)
+ * ```
+ */
+declare function ensureKeyAsync<T>(obj: Record<string, T>, key: string, createFn: (key?: string, obj?: Record<string, T>) => Promise<T>): Promise<T>;
+/**
+ * Returns the size of an object, array, string or similar. For example:
+ */
+declare function size(obj: any): any;
+declare function first<T>(array?: T[]): T | undefined;
+declare function last<T>(array?: T[]): T | undefined;
+declare function empty(value: any): boolean;
+declare function cloneObject<T>(obj: T): T;
+declare function cloneJsonObject<T = Json>(obj: T): T;
+/**
+ * Cache result of a function. Same arguments have to always return the same result in order to get expected optimization!
+ *
+ * ```
+ * const square = memoize((value) => value * value)`
+ * square(2) // == 2
+ * ```
+ */
+declare function memoize<In, Out>(fn: (arg: In) => Out): (arg: In) => Out;
+declare function memoizeAsync<In extends any[], Out extends Promise<any>>(fn: (...arg: In) => Out): (...arg: In) => Promise<Out>;
+/** Repeat `count` times. Starts with `0` */
+declare function forTimes<T = undefined>(count: number, fn: (i: number, count: number) => T): T[];
+//#endregion
+export { ensureKeyAsync as a, last as c, size as d, ensureKey as i, memoize as l, cloneObject as n, first as o, empty as r, forTimes as s, cloneJsonObject as t, memoizeAsync as u };
+//# sourceMappingURL=utils-DX0sASsJ.d.mts.map

package/dist/utils-DxFqV18u.d.cts

@@ -0,0 +1,45 @@
+import { t as Json } from "./types-BCtWYsuv.cjs";
+
+//#region src/common/data/utils.d.ts
+/**
+ * Call a create function if key does not yet exist on an object. Returns the found or created object. Example:
+ *
+ * ```js
+ * function createRoom(room, rooms) { return new Room() }
+ * ensureKey(rooms, room, createRoom).enter()
+ * ```
+ */
+declare function ensureKey<T>(obj: Record<string, T>, key: string, createFn: (key?: string, obj?: Record<string, T>) => T): T;
+/**
+ * Call a create function if key does not yet exist on an object. Returns the found or created object. Example:
+ *
+ * ```js
+ * async function fetchItem(id, cache) { ... }
+ * let data = await ensureKey(cache, id, fetchItem)
+ * ```
+ */
+declare function ensureKeyAsync<T>(obj: Record<string, T>, key: string, createFn: (key?: string, obj?: Record<string, T>) => Promise<T>): Promise<T>;
+/**
+ * Returns the size of an object, array, string or similar. For example:
+ */
+declare function size(obj: any): any;
+declare function first<T>(array?: T[]): T | undefined;
+declare function last<T>(array?: T[]): T | undefined;
+declare function empty(value: any): boolean;
+declare function cloneObject<T>(obj: T): T;
+declare function cloneJsonObject<T = Json>(obj: T): T;
+/**
+ * Cache result of a function. Same arguments have to always return the same result in order to get expected optimization!
+ *
+ * ```
+ * const square = memoize((value) => value * value)`
+ * square(2) // == 2
+ * ```
+ */
+declare function memoize<In, Out>(fn: (arg: In) => Out): (arg: In) => Out;
+declare function memoizeAsync<In extends any[], Out extends Promise<any>>(fn: (...arg: In) => Out): (...arg: In) => Promise<Out>;
+/** Repeat `count` times. Starts with `0` */
+declare function forTimes<T = undefined>(count: number, fn: (i: number, count: number) => T): T[];
+//#endregion
+export { ensureKeyAsync as a, last as c, size as d, ensureKey as i, memoize as l, cloneObject as n, first as o, empty as r, forTimes as s, cloneJsonObject as t, memoizeAsync as u };
+//# sourceMappingURL=utils-DxFqV18u.d.cts.map

package/dist/uuid-Cusm2nIK.d.cts

@@ -0,0 +1,196 @@
+//#region src/common/uuid.d.ts
+/**
+ * Generate raw UUID bytes (128 bits / 16 bytes).
+ *
+ * Uses a cryptographically secure random source provided by
+ * `randomUint8Array`.
+ *
+ * @returns Uint8Array of length 16 with random bytes
+ */
+declare function uuidBytes(): Uint8Array;
+/**
+ * Create a Base62-encoded UUID string from the provided bytes or a newly
+ * generated random UUID. The result is a compact, URL-safe identifier.
+ *
+ * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+ * @returns Base62 string representation (22 characters)
+ */
+declare function uuidB62(bytes?: Uint8Array): string;
+/**
+ * Encode raw UUID bytes to a Base62 string.
+ *
+ * @param bytes - 16-byte UUID as Uint8Array
+ * @returns Base62-encoded string
+ */
+declare function uuidEncodeB62(bytes: Uint8Array): string;
+/**
+ * Decode a Base62-encoded UUID string into raw bytes.
+ *
+ * @param uuid - Base62 string
+ * @returns 16-byte Uint8Array
+ */
+declare function uuidDecodeB62(uuid: string): Uint8Array;
+/**
+ * Create a Base32-encoded UUID string from bytes or a new random UUID.
+ *
+ * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated
+ * @returns Base32 string representation (26 characters)
+ */
+declare function uuidB32(bytes?: Uint8Array): string;
+/**
+ * Encode raw UUID bytes to a Base32 string.
+ *
+ * @param bytes - 16-byte UUID as Uint8Array
+ * @returns Base32-encoded string
+ */
+declare function uuidEncodeB32(bytes: Uint8Array): string;
+/**
+ * Decode a Base32-encoded UUID string into raw bytes.
+ *
+ * @param uuid - Base32 string
+ * @returns 16-byte Uint8Array
+ */
+declare function uuidDecodeB32(uuid: string): Uint8Array;
+/**
+ * Generate a UUID v4 string.
+ *
+ * Uses the native `crypto.randomUUID()` if available; otherwise falls back to
+ * a random-based implementation using `randomUint8Array`.
+ *
+ * @returns UUID v4 string in standard 8-4-4-4-12 hex format
+ */
+declare function uuidv4(): string;
+/**
+ * Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).
+ *
+ * @param bytes - 16-byte Uint8Array
+ * @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+ */
+declare function uuidEncodeV4(bytes: Uint8Array): string;
+/**
+ * Decode a UUID v4 string (hex with dashes) into raw bytes.
+ *
+ * @param uuid - UUID string
+ * @returns 16-byte Uint8Array
+ */
+declare function uuidDecodeV4(uuid: string): Uint8Array;
+/**
+ * Create a sortable unique identifier (SUID) as raw bytes.
+ *
+ * The first 6 bytes encode a millisecond timestamp offset from an internal
+ * reference date to allow lexicographic sorting by creation time. The
+ * remaining 10 bytes are random.
+ *
+ * @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random
+ */
+declare function suidBytes(): Uint8Array;
+/**
+ * Create a sortable unique identifier (SUID) and return it encoded using the
+ * currently configured UUID encoding.
+ *
+ * @returns encoded SUID string
+ */
+declare function suid(): string;
+/**
+ * Extract the creation Date from an encoded SUID string.
+ *
+ * @param id - encoded SUID
+ * @returns Date corresponding to the timestamp component of the SUID
+ */
+declare function suidDate(id: string): Date;
+/**
+ * Extract the creation Date from raw SUID bytes.
+ *
+ * @param id - 16-byte SUID as Uint8Array
+ * @returns Date corresponding to the timestamp encoded in bytes 0-5
+ */
+declare function suidBytesDate(id: Uint8Array): Date;
+/**
+ * Generate a 32-bit unsigned integer from 4 random bytes.
+ *
+ * @returns a random 32-bit unsigned integer
+ */
+declare function uuid32bit(): number;
+declare const mapModes: {
+  base62: {
+    uuid: typeof uuidB62;
+    uuidDecode: typeof uuidDecodeB62;
+    uuidEncode: typeof uuidEncodeB62;
+  };
+  base32: {
+    uuid: typeof uuidB32;
+    uuidDecode: typeof uuidDecodeB32;
+    uuidEncode: typeof uuidEncodeB32;
+  };
+  uuidv4: {
+    uuid: typeof uuidv4;
+    uuidDecode: typeof uuidDecodeV4;
+    uuidEncode: typeof uuidEncodeV4;
+  };
+  test: {
+    uuid: () => string;
+    uuidDecode: (id: string) => Uint8Array;
+    uuidEncode: (bin: Uint8Array) => string;
+  };
+};
+/**
+ * Configure the default encoding and whether generated IDs should be
+ * lexicographically sortable.
+ *
+ * @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')
+ * @param sorted - when true, `uuid()` will prefer sortable SUIDs
+ */
+declare function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted?: boolean): void;
+/**
+ * Generate an identifier using the current encoding mode.
+ *
+ * If the default encoding is configured with `sorted=true`, this returns a
+ * sortable SUID; otherwise a random UUID is returned.
+ *
+ * @returns encoded identifier string
+ */
+declare function uuid(): string;
+/**
+ * Decode an encoded identifier according to the current encoding mode into
+ * raw bytes.
+ *
+ * @param uuid - encoded identifier string
+ * @returns raw 16-byte Uint8Array
+ */
+declare function uuidDecode(uuid: string): Uint8Array;
+/**
+ * Encode raw UUID bytes using the current encoding mode.
+ *
+ * @param bytes - 16-byte Uint8Array
+ * @returns encoded identifier string
+ */
+declare function uuidEncode(bytes: Uint8Array): string;
+/**
+ * Validate an encoded identifier by attempting to decode it and checking
+ * for the expected byte length.
+ *
+ * @param uuid - encoded identifier string
+ * @returns true when valid and decodes to 16 bytes
+ */
+declare function uuidIsValid(uuid: string): boolean;
+/**
+ * Simple counter-based unique name generator.
+ *
+ * Returns strings like 'name-0', 'name-1', ... and increments an internal
+ * counter per `name`.
+ *
+ * @param name - base name for the counter (default: 'id')
+ * @returns generated unique name
+ */
+declare function uname(name?: string): string;
+/** Reset the counter used by `uname` for the given name. */
+declare function unameReset(name?: string): void;
+/**
+ * Quick global incremental id generator.
+ *
+ * Returns strings like 'id-0', 'id-1', ... using a single global counter.
+ */
+declare function qid(): string;
+//#endregion
+export { uuidv4 as C, uuidIsValid as S, uuidDecodeV4 as _, suidBytesDate as a, uuidEncodeB62 as b, unameReset as c, uuidB32 as d, uuidB62 as f, uuidDecodeB62 as g, uuidDecodeB32 as h, suidBytes as i, uuid as l, uuidDecode as m, setUuidDefaultEncoding as n, suidDate as o, uuidBytes as p, suid as r, uname as s, qid as t, uuid32bit as u, uuidEncode as v, uuidEncodeV4 as x, uuidEncodeB32 as y };
+//# sourceMappingURL=uuid-Cusm2nIK.d.cts.map