ox 0.0.1 → 0.1.0

package/_types/Bytes.d.ts

@@ -0,0 +1,674 @@
+import * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import * as internal from './internal/bytes.js';
+import * as internal_hex from './internal/hex.js';
+/** Root type for a Bytes array. */
+export type Bytes = Uint8Array;
+/**
+ * Asserts if the given value is {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.assert('abc')
+ * // @error: Bytes.InvalidBytesTypeError:
+ * // @error: Value `"abc"` of type `string` is an invalid Bytes value.
+ * // @error: Bytes values must be of type `Uint8Array`.
+ * ```
+ *
+ * @param value - Value to assert.
+ */
+export declare function assert(value: unknown): asserts value is Bytes;
+export declare namespace assert {
+    var parseError: (error: unknown) => assert.ErrorType;
+}
+export declare namespace assert {
+    type ErrorType = InvalidBytesTypeError | Errors.GlobalErrorType;
+}
+/**
+ * Concatenates two or more {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const bytes = Bytes.concat(
+ *   Bytes.from([1]),
+ *   Bytes.from([69]),
+ *   Bytes.from([420, 69]),
+ * )
+ * // @log: Uint8Array [ 1, 69, 420, 69 ]
+ * ```
+ *
+ * @param values - Values to concatenate.
+ * @returns Concatenated {@link ox#Bytes.Bytes}.
+ */
+export declare function concat(...values: readonly Bytes[]): Bytes;
+export declare namespace concat {
+    var parseError: (error: unknown) => concat.ErrorType;
+}
+export declare namespace concat {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Instantiates a {@link ox#Bytes.Bytes} value from a `Uint8Array`, a hex string, or an array of unsigned 8-bit integers.
+ *
+ * :::tip
+ *
+ * To instantiate from a **Boolean**, **String**, or **Number**, use one of the following:
+ *
+ * - `Bytes.fromBoolean`
+ *
+ * - `Bytes.fromString`
+ *
+ * - `Bytes.fromNumber`
+ *
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.from([255, 124, 5, 4])
+ * // @log: Uint8Array([255, 124, 5, 4])
+ *
+ * const data = Bytes.from('0xdeadbeef')
+ * // @log: Uint8Array([222, 173, 190, 239])
+ * ```
+ *
+ * @param value - Value to convert.
+ * @returns A {@link ox#Bytes.Bytes} instance.
+ */
+export declare function from(value: Hex.Hex | Bytes | readonly number[]): Bytes;
+export declare namespace from {
+    var parseError: (error: unknown) => from.ErrorType;
+}
+export declare namespace from {
+    type ErrorType = fromHex.ErrorType | fromArray.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Converts an array of unsigned 8-bit integers into {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromArray([255, 124, 5, 4])
+ * // @log: Uint8Array([255, 124, 5, 4])
+ * ```
+ *
+ * @param value - Value to convert.
+ * @returns A {@link ox#Bytes.Bytes} instance.
+ */
+export declare function fromArray(value: readonly number[] | Uint8Array): Bytes;
+export declare namespace fromArray {
+    var parseError: (error: unknown) => fromArray.ErrorType;
+}
+export declare namespace fromArray {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Encodes a boolean value into {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromBoolean(true)
+ * // @log: Uint8Array([1])
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromBoolean(true, { size: 32 })
+ * // @log: Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+ * ```
+ *
+ * @param value - Boolean value to encode.
+ * @param options - Encoding options.
+ * @returns Encoded {@link ox#Bytes.Bytes}.
+ */
+export declare function fromBoolean(value: boolean, options?: fromBoolean.Options): Uint8Array;
+export declare namespace fromBoolean {
+    var parseError: (error: unknown) => fromBoolean.ErrorType;
+}
+export declare namespace fromBoolean {
+    type Options = {
+        /** Size of the output bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = internal.assertSize.ErrorType | padLeft.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Hex.Hex} value into {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromHex('0x48656c6c6f20776f726c6421')
+ * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromHex('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ * ```
+ *
+ * @param value - {@link ox#Hex.Hex} value to encode.
+ * @param options - Encoding options.
+ * @returns Encoded {@link ox#Bytes.Bytes}.
+ */
+export declare function fromHex(value: Hex.Hex, options?: fromHex.Options): Bytes;
+export declare namespace fromHex {
+    var parseError: (error: unknown) => fromHex.ErrorType;
+}
+export declare namespace fromHex {
+    type Options = {
+        /** Size of the output bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = internal_hex.assertSize.ErrorType | Hex.padRight.ErrorType | Hex.InvalidLengthError | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a number value into {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromNumber(420)
+ * // @log: Uint8Array([1, 164])
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromNumber(420, { size: 4 })
+ * // @log: Uint8Array([0, 0, 1, 164])
+ * ```
+ *
+ * @param value - Number value to encode.
+ * @param options - Encoding options.
+ * @returns Encoded {@link ox#Bytes.Bytes}.
+ */
+export declare function fromNumber(value: bigint | number, options?: fromNumber.Options | undefined): Uint8Array;
+export declare namespace fromNumber {
+    var parseError: (error: unknown) => fromNumber.ErrorType;
+}
+export declare namespace fromNumber {
+    type Options = Hex.fromNumber.Options;
+    type ErrorType = Hex.fromNumber.ErrorType | fromHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a string into {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromString('Hello world!')
+ * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ * ```
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.fromString('Hello world!', { size: 32 })
+ * // @log: Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ * ```
+ *
+ * @param value - String to encode.
+ * @param options - Encoding options.
+ * @returns Encoded {@link ox#Bytes.Bytes}.
+ */
+export declare function fromString(value: string, options?: fromString.Options): Bytes;
+export declare namespace fromString {
+    var parseError: (error: unknown) => fromString.ErrorType;
+}
+export declare namespace fromString {
+    type Options = {
+        /** Size of the output bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = internal.assertSize.ErrorType | padRight.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Checks if two {@link ox#Bytes.Bytes} values are equal.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.isEqual(Bytes.from([1]), Bytes.from([1]))
+ * // @log: true
+ *
+ * Bytes.isEqual(Bytes.from([1]), Bytes.from([2]))
+ * // @log: false
+ * ```
+ *
+ * @param bytesA - First {@link ox#Bytes.Bytes} value.
+ * @param bytesB - Second {@link ox#Bytes.Bytes} value.
+ * @returns `true` if the two values are equal, otherwise `false`.
+ */
+export declare function isEqual(bytesA: Bytes, bytesB: Bytes): boolean;
+export declare namespace isEqual {
+    var parseError: (error: unknown) => isEqual.ErrorType;
+}
+export declare namespace isEqual {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Pads a {@link ox#Bytes.Bytes} value to the left with zero bytes until it reaches the given `size` (default: 32 bytes).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.padLeft(Bytes.from([1]), 4)
+ * // @log: Uint8Array([0, 0, 0, 1])
+ * ```
+ *
+ * @param value - {@link ox#Bytes.Bytes} value to pad.
+ * @param size - Size to pad the {@link ox#Bytes.Bytes} value to.
+ * @returns Padded {@link ox#Bytes.Bytes} value.
+ */
+export declare function padLeft(value: Bytes, size?: number | undefined): padLeft.ReturnType;
+export declare namespace padLeft {
+    var parseError: (error: unknown) => padLeft.ErrorType;
+}
+export declare namespace padLeft {
+    type ReturnType = internal.pad.ReturnType;
+    type ErrorType = internal.pad.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Pads a {@link ox#Bytes.Bytes} value to the right with zero bytes until it reaches the given `size` (default: 32 bytes).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.padRight(Bytes.from([1]), 4)
+ * // @log: Uint8Array([1, 0, 0, 0])
+ * ```
+ *
+ * @param value - {@link ox#Bytes.Bytes} value to pad.
+ * @param size - Size to pad the {@link ox#Bytes.Bytes} value to.
+ * @returns Padded {@link ox#Bytes.Bytes} value.
+ */
+export declare function padRight(value: Bytes, size?: number | undefined): padRight.ReturnType;
+export declare namespace padRight {
+    var parseError: (error: unknown) => padRight.ErrorType;
+}
+export declare namespace padRight {
+    type ReturnType = internal.pad.ReturnType;
+    type ErrorType = internal.pad.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Generates random {@link ox#Bytes.Bytes} of the specified length.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const bytes = Bytes.random(32)
+ * // @log: Uint8Array([... x32])
+ * ```
+ *
+ * @param length - Length of the random {@link ox#Bytes.Bytes} to generate.
+ * @returns Random {@link ox#Bytes.Bytes} of the specified length.
+ */
+export declare function random(length: number): Bytes;
+export declare namespace random {
+    var parseError: (error: unknown) => random.ErrorType;
+}
+export declare namespace random {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Retrieves the size of a {@link ox#Bytes.Bytes} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.size(Bytes.from([1, 2, 3, 4]))
+ * // @log: 4
+ * ```
+ *
+ * @param value - {@link ox#Bytes.Bytes} value.
+ * @returns Size of the {@link ox#Bytes.Bytes} value.
+ */
+export declare function size(value: Bytes): number;
+export declare namespace size {
+    var parseError: (error: unknown) => size.ErrorType;
+}
+export declare namespace size {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Returns a section of a {@link ox#Bytes.Bytes} value given a start/end bytes offset.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.slice(
+ *   Bytes.from([1, 2, 3, 4, 5, 6, 7, 8, 9]),
+ *   1,
+ *   4,
+ * )
+ * // @log: Uint8Array([2, 3, 4])
+ * ```
+ *
+ * @param value - The {@link ox#Bytes.Bytes} value.
+ * @param start - Start offset.
+ * @param end - End offset.
+ * @param options - Slice options.
+ * @returns Sliced {@link ox#Bytes.Bytes} value.
+ */
+export declare function slice(value: Bytes, start?: number | undefined, end?: number | undefined, options?: slice.Options): Bytes;
+export declare namespace slice {
+    var parseError: (error: unknown) => slice.ErrorType;
+}
+export declare namespace slice {
+    type Options = {
+        /** Asserts that the sliced value is the same size as the given start/end offsets. */
+        strict?: boolean | undefined;
+    };
+    type ErrorType = internal.assertStartOffset.ErrorType | internal.assertEndOffset.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a {@link ox#Bytes.Bytes} into a bigint.
+ *
+ * @example
+ * ```ts
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.toBigInt(Bytes.from([1, 164]))
+ * // @log: 420n
+ * ```
+ *
+ * @param bytes - The {@link ox#Bytes.Bytes} to decode.
+ * @param options - Decoding options.
+ * @returns Decoded bigint.
+ */
+export declare function toBigInt(bytes: Bytes, options?: toBigInt.Options): bigint;
+export declare namespace toBigInt {
+    var parseError: (error: unknown) => toBigInt.ErrorType;
+}
+export declare namespace toBigInt {
+    type Options = {
+        /** Whether or not the number of a signed representation. */
+        signed?: boolean | undefined;
+        /** Size of the bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = Hex.fromBytes.ErrorType | Hex.toBigInt.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a {@link ox#Bytes.Bytes} into a boolean.
+ *
+ * @example
+ * ```ts
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.toBoolean(Bytes.from([1]))
+ * // @log: true
+ * ```
+ *
+ * @param bytes - The {@link ox#Bytes.Bytes} to decode.
+ * @param options - Decoding options.
+ * @returns Decoded boolean.
+ */
+export declare function toBoolean(bytes: Bytes, options?: toBoolean.Options): boolean;
+export declare namespace toBoolean {
+    var parseError: (error: unknown) => toBoolean.ErrorType;
+}
+export declare namespace toBoolean {
+    type Options = {
+        /** Size of the bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = internal.assertSize.ErrorType | trimLeft.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Bytes.Bytes} value into a {@link ox#Hex.Hex} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.toHex(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+ * // '0x48656c6c6f20576f726c6421'
+ * ```
+ *
+ * @param value - The {@link ox#Bytes.Bytes} to decode.
+ * @param options - Options.
+ * @returns Decoded {@link ox#Hex.Hex} value.
+ */
+export declare function toHex(value: Bytes, options?: toHex.Options): Hex.Hex;
+export declare namespace toHex {
+    var parseError: (error: unknown) => toHex.ErrorType;
+}
+export declare namespace toHex {
+    type Options = {
+        /** Size of the bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = Hex.fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a {@link ox#Bytes.Bytes} into a number.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.toNumber(Bytes.from([1, 164]))
+ * // @log: 420
+ * ```
+ */
+export declare function toNumber(bytes: Bytes, options?: toNumber.Options): number;
+export declare namespace toNumber {
+    var parseError: (error: unknown) => toNumber.ErrorType;
+}
+export declare namespace toNumber {
+    type Options = {
+        /** Whether or not the number of a signed representation. */
+        signed?: boolean | undefined;
+        /** Size of the bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = Hex.fromBytes.ErrorType | Hex.toNumber.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Decodes a {@link ox#Bytes.Bytes} into a string.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const data = Bytes.toString(Bytes.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+ * // @log: 'Hello world'
+ * ```
+ *
+ * @param bytes - The {@link ox#Bytes.Bytes} to decode.
+ * @param options - Options.
+ * @returns Decoded string.
+ */
+export declare function toString(bytes: Bytes, options?: toString.Options): string;
+export declare namespace toString {
+    var parseError: (error: unknown) => toString.ErrorType;
+}
+export declare namespace toString {
+    type Options = {
+        /** Size of the bytes. */
+        size?: number | undefined;
+    };
+    type ErrorType = internal.assertSize.ErrorType | trimRight.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Trims leading zeros from a {@link ox#Bytes.Bytes} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.trimLeft(Bytes.from([0, 0, 0, 0, 1, 2, 3]))
+ * // @log: Uint8Array([1, 2, 3])
+ * ```
+ *
+ * @param value - {@link ox#Bytes.Bytes} value.
+ * @returns Trimmed {@link ox#Bytes.Bytes} value.
+ */
+export declare function trimLeft(value: Bytes): Bytes;
+export declare namespace trimLeft {
+    var parseError: (error: unknown) => trimLeft.ErrorType;
+}
+export declare namespace trimLeft {
+    type ErrorType = internal.trim.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Trims trailing zeros from a {@link ox#Bytes.Bytes} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.trimRight(Bytes.from([1, 2, 3, 0, 0, 0, 0]))
+ * // @log: Uint8Array([1, 2, 3])
+ * ```
+ *
+ * @param value - {@link ox#Bytes.Bytes} value.
+ * @returns Trimmed {@link ox#Bytes.Bytes} value.
+ */
+export declare function trimRight(value: Bytes): Bytes;
+export declare namespace trimRight {
+    var parseError: (error: unknown) => trimRight.ErrorType;
+}
+export declare namespace trimRight {
+    type ErrorType = internal.trim.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Checks if the given value is {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.validate('0x')
+ * // @log: false
+ *
+ * Bytes.validate(Bytes.from([1, 2, 3]))
+ * // @log: true
+ * ```
+ *
+ * @param value - Value to check.
+ * @returns `true` if the value is {@link ox#Bytes.Bytes}, otherwise `false`.
+ */
+export declare function validate(value: unknown): value is Bytes;
+export declare namespace validate {
+    var parseError: (error: unknown) => validate.ErrorType;
+}
+export declare namespace validate {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Thrown when the bytes value cannot be represented as a boolean.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.toBoolean(Bytes.from([5]))
+ * // @error: Bytes.InvalidBytesBooleanError: Bytes value `[5]` is not a valid boolean.
+ * // @error: The bytes array must contain a single byte of either a `0` or `1` value.
+ * ```
+ */
+export declare class InvalidBytesBooleanError extends Errors.BaseError {
+    readonly name = "Bytes.InvalidBytesBooleanError";
+    constructor(bytes: Bytes);
+}
+/**
+ * Thrown when a value cannot be converted to bytes.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.from('foo')
+ * // @error: Bytes.InvalidBytesTypeError: Value `foo` of type `string` is an invalid Bytes value.
+ * ```
+ */
+export declare class InvalidBytesTypeError extends Errors.BaseError {
+    readonly name = "Bytes.InvalidBytesTypeError";
+    constructor(value: unknown);
+}
+/**
+ * Thrown when a size exceeds the maximum allowed size.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.fromString('Hello World!', { size: 8 })
+ * // @error: Bytes.SizeOverflowError: Size cannot exceed `8` bytes. Given size: `12` bytes.
+ * ```
+ */
+export declare class SizeOverflowError extends Errors.BaseError {
+    readonly name = "Bytes.SizeOverflowError";
+    constructor({ givenSize, maxSize }: {
+        givenSize: number;
+        maxSize: number;
+    });
+}
+/**
+ * Thrown when a slice offset is out-of-bounds.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.slice(Bytes.from([1, 2, 3]), 4)
+ * // @error: Bytes.SliceOffsetOutOfBoundsError: Slice starting at offset `4` is out-of-bounds (size: `3`).
+ * ```
+ */
+export declare class SliceOffsetOutOfBoundsError extends Errors.BaseError {
+    readonly name = "Bytes.SliceOffsetOutOfBoundsError";
+    constructor({ offset, position, size, }: {
+        offset: number;
+        position: 'start' | 'end';
+        size: number;
+    });
+}
+/**
+ * Thrown when a the padding size exceeds the maximum allowed size.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * Bytes.padLeft(Bytes.fromString('Hello World!'), 8)
+ * // @error: [Bytes.SizeExceedsPaddingSizeError: Bytes size (`12`) exceeds padding size (`8`).
+ * ```
+ */
+export declare class SizeExceedsPaddingSizeError extends Errors.BaseError {
+    readonly name = "Bytes.SizeExceedsPaddingSizeError";
+    constructor({ size, targetSize, type, }: {
+        size: number;
+        targetSize: number;
+        type: 'Hex' | 'Bytes';
+    });
+}
+//# sourceMappingURL=Bytes.d.ts.map

package/_types/Bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bytes.d.ts","sourceRoot":"","sources":["../Bytes.ts"],"names":[],"mappings":"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"}

package/_types/Caches.d.ts

@@ -0,0 +1,13 @@
+import { LruMap } from './internal/lru.js';
+export declare const checksum: LruMap<`0x${string}`>;
+/**
+ * Clears all global caches.
+ *
+ * @example
+ * ```ts
+ * import { Caches } from 'ox'
+ * Caches.clear()
+ * ```
+ */
+export declare function clear(): void;
+//# sourceMappingURL=Caches.d.ts.map

package/_types/Caches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Caches.d.ts","sourceRoot":"","sources":["../Caches.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAM1C,eAAO,MAAM,QAAQ,uBAAkB,CAAA;AAEvC;;;;;;;;GAQG;AACH,wBAAgB,KAAK,SAEpB"}