@bcts/dcbor 1.0.0-alpha.10

package/dist/index.d.cts

@@ -0,0 +1,3107 @@
+//#region src/map.d.ts
+
+interface MapEntry {
+  readonly key: Cbor;
+  readonly value: Cbor;
+}
+/**
+ * A deterministic CBOR map implementation.
+ *
+ * Maps are always encoded with keys sorted lexicographically by their
+ * encoded CBOR representation, ensuring deterministic encoding.
+ */
+declare class CborMap {
+  #private;
+  /**
+   * Creates a new, empty CBOR Map.
+   * Optionally initializes from a JavaScript Map.
+   */
+  constructor(map?: Map<unknown, unknown>);
+  /**
+   * Creates a new, empty CBOR Map.
+   * Matches Rust's Map::new().
+   */
+  static new(): CborMap;
+  /**
+   * Inserts a key-value pair into the map.
+   * Matches Rust's Map::insert().
+   */
+  set<K extends CborInput, V extends CborInput>(key: K, value: V): void;
+  /**
+   * Alias for set() to match Rust's insert() method.
+   */
+  insert<K extends CborInput, V extends CborInput>(key: K, value: V): void;
+  /**
+   * Get a value from the map, given a key.
+   * Returns undefined if the key is not present in the map.
+   * Matches Rust's Map::get().
+   */
+  get<K extends CborInput, V>(key: K): V | undefined;
+  /**
+   * Get a value from the map, given a key.
+   * Throws an error if the key is not present.
+   * Matches Rust's Map::extract().
+   */
+  extract<K extends CborInput, V>(key: K): V;
+  /**
+   * Tests if the map contains a key.
+   * Matches Rust's Map::contains_key().
+   */
+  containsKey<K extends CborInput>(key: K): boolean;
+  delete<K extends CborInput>(key: K): boolean;
+  has<K extends CborInput>(key: K): boolean;
+  clear(): void;
+  /**
+   * Returns the number of entries in the map.
+   * Matches Rust's Map::len().
+   */
+  get length(): number;
+  /**
+   * Alias for length to match JavaScript Map API.
+   * Also matches Rust's Map::len().
+   */
+  get size(): number;
+  /**
+   * Returns the number of entries in the map.
+   * Matches Rust's Map::len().
+   */
+  len(): number;
+  /**
+   * Checks if the map is empty.
+   * Matches Rust's Map::is_empty().
+   */
+  isEmpty(): boolean;
+  /**
+   * Get the entries of the map as an array.
+   * Keys are sorted in lexicographic order of their encoded CBOR bytes.
+   */
+  get entriesArray(): MapEntry[];
+  /**
+   * Gets an iterator over the entries of the CBOR map, sorted by key.
+   * Key sorting order is lexicographic by the key's binary-encoded CBOR.
+   * Matches Rust's Map::iter().
+   */
+  iter(): MapEntry[];
+  /**
+   * Returns an iterator of [key, value] tuples for JavaScript Map API compatibility.
+   * This matches the standard JavaScript Map.entries() method behavior.
+   */
+  entries(): IterableIterator<[Cbor, Cbor]>;
+  /**
+   * Inserts the next key-value pair into the map during decoding.
+   * This is used for efficient map building during CBOR decoding.
+   * Throws if the key is not in ascending order or is a duplicate.
+   * Matches Rust's Map::insert_next().
+   */
+  setNext<K extends CborInput, V extends CborInput>(key: K, value: V): void;
+  get debug(): string;
+  get diagnostic(): string;
+  private static entryDebug;
+  private static formatDebug;
+  private static entryDiagnostic;
+  [Symbol.iterator](): Iterator<[Cbor, Cbor]>;
+  toMap<K, V>(): Map<K, V>;
+}
+//#endregion
+//#region src/simple.d.ts
+/**
+ * CBOR Simple Values (Major Type 7).
+ *
+ * @module simple
+ */
+/**
+ * Represents CBOR simple values (major type 7).
+ *
+ * In CBOR, simple values are a special category that includes booleans (`true`
+ * and `false`), `null`, and floating point numbers.
+ *
+ * Per Section 2.4 of the dCBOR specification, only these specific simple
+ * values are valid in dCBOR. All other major type 7 values (such as undefined
+ * or other simple values) are invalid and will be rejected by dCBOR decoders.
+ *
+ * When encoding floating point values, dCBOR follows specific numeric
+ * reduction rules detailed in Section 2.3 of the dCBOR specification,
+ * including
+ * - Integral floating point values must be reduced to integers when possible
+ * - NaN values must be normalized to the canonical form `f97e00`
+ */
+type Simple = {
+  readonly type: "False";
+} | {
+  readonly type: "True";
+} | {
+  readonly type: "Null";
+} | {
+  readonly type: "Float";
+  readonly value: number;
+};
+/**
+ * Returns the standard name of the simple value as a string.
+ *
+ * For `False`, `True`, and `Null`, this returns their lowercase string
+ * representation. For `Float` values, it returns their numeric representation.
+ */
+declare const simpleName: (simple: Simple) => string;
+/**
+ * Checks if the simple value is the NaN (Not a Number) representation.
+ */
+declare const isNaN: (simple: Simple) => boolean;
+//#endregion
+//#region src/tag.d.ts
+/**
+ * A CBOR tag with an optional name.
+ *
+ * Tags consist of a numeric value and an optional human-readable name.
+ */
+interface Tag {
+  /** The numeric tag value */
+  readonly value: CborNumber;
+  /** Optional human-readable name for the tag */
+  readonly name?: string;
+}
+/**
+ * Create a new Tag.
+ *
+ * @param value - The numeric tag value
+ * @param name - Optional human-readable name
+ * @returns A new Tag object
+ *
+ * @example
+ * ```typescript
+ * const dateTag = createTag(1, 'date');
+ * const customTag = createTag(12345, 'myCustomTag');
+ * ```
+ */
+declare const createTag: (value: CborNumber, name?: string) => Tag;
+//#endregion
+//#region src/byte-string.d.ts
+/**
+ * Represents a CBOR byte string (major type 2).
+ *
+ * Use Cases:
+ * - Binary data such as images, audio, or other non-text content
+ * - Cryptographic values like hashes, signatures, and public keys
+ * - Embedded CBOR (wrapped with tag 24)
+ * - Other serialized data formats embedded in CBOR
+ *
+ * @example
+ * ```typescript
+ * // Creating a byte string from various sources
+ * const bytes1 = new ByteString(new Uint8Array([1, 2, 3, 4]));
+ * const bytes2 = ByteString.from([5, 6, 7, 8]);
+ * const bytes3 = ByteString.from(new Uint8Array([9, 10, 11, 12]));
+ *
+ * // Converting to and from CBOR
+ * const cborValue = bytes1.toCbor();
+ *
+ * // ByteString provides Uint8Array-like operations
+ * const bytes = new ByteString(new Uint8Array([1, 2]));
+ * bytes.extend(new Uint8Array([3, 4]));
+ * assert(bytes.len() === 4);
+ * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4]));
+ * ```
+ */
+declare class ByteString {
+  #private;
+  /**
+   * Creates a new `ByteString` from a Uint8Array or array of bytes.
+   *
+   * @param data - The byte data
+   *
+   * @example
+   * ```typescript
+   * // From a Uint8Array
+   * const bytes1 = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   *
+   * // From a number array
+   * const bytes2 = new ByteString(new Uint8Array([5, 6, 7, 8]));
+   * ```
+   */
+  constructor(data: Uint8Array | number[]);
+  /**
+   * Creates a new `ByteString` from various input types.
+   *
+   * @param data - Uint8Array, number array, or string
+   * @returns New ByteString instance
+   *
+   * @example
+   * ```typescript
+   * const bytes1 = ByteString.from([1, 2, 3, 4]);
+   * const bytes2 = ByteString.from(new Uint8Array([5, 6, 7, 8]));
+   * const bytes3 = ByteString.from("hello");
+   * ```
+   */
+  static from(data: Uint8Array | number[] | string): ByteString;
+  /**
+   * Returns a reference to the underlying byte data.
+   *
+   * @returns The raw bytes
+   *
+   * @example
+   * ```typescript
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4]));
+   *
+   * // You can use standard slice operations on the result
+   * assert.deepEqual(bytes.data().slice(1, 3), new Uint8Array([2, 3]));
+   * ```
+   */
+  data(): Uint8Array;
+  /**
+   * Returns the length of the byte string in bytes.
+   *
+   * @returns Number of bytes
+   *
+   * @example
+   * ```typescript
+   * const empty = new ByteString(new Uint8Array([]));
+   * assert(empty.len() === 0);
+   *
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   * assert(bytes.len() === 4);
+   * ```
+   */
+  len(): number;
+  /**
+   * Returns `true` if the byte string contains no bytes.
+   *
+   * @returns true if empty
+   *
+   * @example
+   * ```typescript
+   * const empty = new ByteString(new Uint8Array([]));
+   * assert(empty.isEmpty());
+   *
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   * assert(!bytes.isEmpty());
+   * ```
+   */
+  isEmpty(): boolean;
+  /**
+   * Extends the byte string with additional bytes.
+   *
+   * @param other - Bytes to append
+   *
+   * @example
+   * ```typescript
+   * const bytes = new ByteString(new Uint8Array([1, 2]));
+   * bytes.extend(new Uint8Array([3, 4]));
+   * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4]));
+   *
+   * // You can extend with different types
+   * bytes.extend([5, 6]);
+   * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4, 5, 6]));
+   * ```
+   */
+  extend(other: Uint8Array | number[]): void;
+  /**
+   * Creates a new Uint8Array containing a copy of the byte string's data.
+   *
+   * @returns Copy of the data
+   *
+   * @example
+   * ```typescript
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   * const arr = bytes.toUint8Array();
+   * assert.deepEqual(arr, new Uint8Array([1, 2, 3, 4]));
+   *
+   * // The returned array is a clone, so you can modify it independently
+   * const arr2 = bytes.toUint8Array();
+   * arr2[0] = 99;
+   * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4])); // original unchanged
+   * ```
+   */
+  toUint8Array(): Uint8Array;
+  /**
+   * Returns an iterator over the bytes in the byte string.
+   *
+   * @returns Iterator yielding each byte
+   *
+   * @example
+   * ```typescript
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3]));
+   * const iter = bytes.iter();
+   *
+   * assert(iter.next().value === 1);
+   * assert(iter.next().value === 2);
+   * assert(iter.next().value === 3);
+   * assert(iter.next().done);
+   *
+   * // You can also use for loops
+   * let sum = 0;
+   * for (const byte of bytes) {
+   *   sum += byte;
+   * }
+   * assert(sum === 6);
+   * ```
+   */
+  iter(): Iterator<number>;
+  /**
+   * Makes ByteString iterable.
+   */
+  [Symbol.iterator](): Iterator<number>;
+  /**
+   * Converts the ByteString to a CBOR value.
+   *
+   * @returns CBOR byte string
+   *
+   * @example
+   * ```typescript
+   * const bytes = new ByteString(new Uint8Array([1, 2, 3, 4]));
+   * const cborValue = bytes.toCbor();
+   * ```
+   */
+  toCbor(): Cbor;
+  /**
+   * Attempts to convert a CBOR value into a ByteString.
+   *
+   * @param cbor - CBOR value
+   * @returns ByteString if successful
+   * @throws Error if the CBOR value is not a byte string
+   *
+   * @example
+   * ```typescript
+   * const cborValue = toCbor(new Uint8Array([1, 2, 3, 4]));
+   * const bytes = ByteString.fromCbor(cborValue);
+   * assert.deepEqual(bytes.data(), new Uint8Array([1, 2, 3, 4]));
+   *
+   * // Converting from a different CBOR type throws
+   * const cborInt = toCbor(42);
+   * try {
+   *   ByteString.fromCbor(cborInt); // throws
+   * } catch(e) {
+   *   // Error: Wrong type
+   * }
+   * ```
+   */
+  static fromCbor(cbor: Cbor): ByteString;
+  /**
+   * Get element at index.
+   *
+   * @param index - Index to access
+   * @returns Byte at index or undefined
+   */
+  at(index: number): number | undefined;
+  /**
+   * Equality comparison.
+   *
+   * @param other - ByteString to compare with
+   * @returns true if equal
+   */
+  equals(other: ByteString): boolean;
+  /**
+   * Clone this ByteString.
+   *
+   * @returns New ByteString with copied data
+   */
+  clone(): ByteString;
+}
+//#endregion
+//#region src/cbor-tagged-encodable.d.ts
+/**
+ * Interface for types that can be encoded to CBOR with a specific tag.
+ *
+ * This interface extends `CborTagged` to provide methods for encoding a value
+ * with its associated tag. Types that implement this interface define how they
+ * should be represented in CBOR format, both with and without their tag.
+ *
+ * @example
+ * ```typescript
+ * // Define a Date type
+ * class Date implements CborTaggedEncodable {
+ *   constructor(private timestamp: number) {}
+ *
+ *   cborTags(): Tag[] {
+ *     return [createTag(1, 'date')]; // Standard date tag
+ *   }
+ *
+ *   untaggedCbor(): Cbor {
+ *     // Date content is represented as a number
+ *     return cbor(this.timestamp);
+ *   }
+ *
+ *   taggedCbor(): Cbor {
+ *     const tags = this.cborTags();
+ *     return {
+ *       isCbor: true,
+ *       type: MajorType.Tagged,
+ *       tag: tags[0].value,
+ *       value: this.untaggedCbor()
+ *     };
+ *   }
+ *
+ *   taggedCborData(): Uint8Array {
+ *     return cborData(this.taggedCbor());
+ *   }
+ * }
+ *
+ * // Create a date and encode it
+ * const date = new Date(1609459200);
+ *
+ * // Get the untagged CBOR (just the timestamp)
+ * const untagged = date.untaggedCbor();
+ *
+ * // Get the tagged CBOR (with tag 1)
+ * const tagged = date.taggedCbor();
+ *
+ * // Get binary representation
+ * const data = date.taggedCborData();
+ * ```
+ */
+interface CborTaggedEncodable extends CborTagged {
+  /**
+   * Returns the untagged CBOR encoding of this instance.
+   *
+   * This method defines how the value itself (without its tag) should
+   * be represented in CBOR format.
+   *
+   * @returns Untagged CBOR representation
+   */
+  untaggedCbor(): Cbor;
+  /**
+   * Returns the tagged CBOR encoding of this instance.
+   *
+   * This method wraps the result of `untaggedCbor()` with the first tag
+   * from `cborTags()`, which is considered the "preferred" tag for the
+   * type.
+   *
+   * Even if a type supports multiple tags for backward-compatible decoding
+   * via `cborTags()`, only the first (preferred) tag is used for encoding.
+   * This ensures consistency in newly created data while maintaining the
+   * ability to read older formats.
+   *
+   * In most cases, you don't need to override this method.
+   *
+   * @returns Tagged CBOR representation
+   */
+  taggedCbor(): Cbor;
+  /**
+   * Returns the tagged value in CBOR binary representation.
+   *
+   * This is a convenience method that converts the result of `taggedCbor()`
+   * to binary format.
+   *
+   * @returns Binary CBOR representation
+   */
+  taggedCborData?(): Uint8Array;
+}
+/**
+ * Helper function to create tagged CBOR from an encodable object.
+ *
+ * Uses the first tag from cborTags().
+ *
+ * @param encodable - Object implementing CborTaggedEncodable
+ * @returns Tagged CBOR value
+ */
+declare const createTaggedCbor: (encodable: CborTaggedEncodable) => Cbor;
+//#endregion
+//#region src/cbor-tagged-decodable.d.ts
+/**
+ * Interface for types that can be decoded from CBOR with a specific tag.
+ *
+ * This interface extends `CborTagged` to provide methods for
+ * decoding tagged CBOR data into TypeScript types. It handles verification that
+ * the CBOR data has the expected tag(s) and provides utilities for both
+ * tagged and untagged decoding.
+ *
+ * @example
+ * ```typescript
+ * // Define a Date type
+ * class Date implements CborTaggedDecodable<Date> {
+ *   constructor(public timestamp: number) {}
+ *
+ *   cborTags(): Tag[] {
+ *     return [createTag(1, 'date')]; // Standard date tag
+ *   }
+ *
+ *   fromUntaggedCbor(cbor: Cbor): Date {
+ *     // Convert the untagged CBOR to a number
+ *     if (cbor.type !== MajorType.Unsigned) {
+ *       throw new Error('Wrong type');
+ *     }
+ *     const timestamp = typeof cbor.value === 'bigint' ? Number(cbor.value) : cbor.value;
+ *     return new Date(timestamp);
+ *   }
+ *
+ *   fromTaggedCbor(cbor: Cbor): Date {
+ *     if (cbor.type !== MajorType.Tagged) {
+ *       throw new Error('Wrong type');
+ *     }
+ *
+ *     const tags = this.cborTags();
+ *     const tagValues = tags.map(t => t.value);
+ *     if (!tagValues.includes(cbor.tag as number)) {
+ *       throw new Error(`Wrong tag: expected ${tagValues[0]}, got ${cbor.tag}`);
+ *     }
+ *
+ *     return this.fromUntaggedCbor(cbor.value);
+ *   }
+ *
+ *   static fromTaggedCborData(data: Uint8Array): Date {
+ *     const cbor = decodeCbor(data);
+ *     return new Date(0).fromTaggedCbor(cbor);
+ *   }
+ *
+ *   static fromUntaggedCborData(data: Uint8Array): Date {
+ *     const cbor = decodeCbor(data);
+ *     return new Date(0).fromUntaggedCbor(cbor);
+ *   }
+ * }
+ *
+ * // Create tagged CBOR data
+ * const taggedCbor = {
+ *   isCbor: true,
+ *   type: MajorType.Tagged,
+ *   tag: 1,
+ *   value: cbor(1609459200)
+ * };
+ *
+ * // Decode using the interface
+ * const date = new Date(0).fromTaggedCbor(taggedCbor);
+ * assert(date.timestamp === 1609459200);
+ * ```
+ */
+interface CborTaggedDecodable<T> extends CborTagged {
+  /**
+   * Creates an instance of this type by decoding it from untagged CBOR.
+   *
+   * This method defines how to interpret the CBOR content (without
+   * considering the tag) and convert it to the implementing type.
+   *
+   * @param cbor - Untagged CBOR value
+   * @returns Decoded instance
+   * @throws Error if the CBOR value cannot be decoded
+   */
+  fromUntaggedCbor(cbor: Cbor): T;
+  /**
+   * Creates an instance of this type by decoding it from tagged CBOR.
+   *
+   * This method first verifies that the CBOR value has one of the expected
+   * tags (as defined by `cborTags()`), then delegates to
+   * `fromUntaggedCbor()` to decode the content.
+   *
+   * For backward compatibility, this method accepts any tag from the
+   * `cborTags()` array, not just the first one. This allows new
+   * versions of types to still accept data tagged with older/alternative
+   * tag values.
+   *
+   * In most cases, you don't need to override this method.
+   *
+   * @param cbor - Tagged CBOR value
+   * @returns Decoded instance
+   * @throws Error if the CBOR value has the wrong tag or cannot be decoded
+   */
+  fromTaggedCbor(cbor: Cbor): T;
+  /**
+   * Creates an instance of this type by decoding it from binary encoded
+   * tagged CBOR.
+   *
+   * This is a convenience method that first parses the binary data into a
+   * CBOR value, then uses `fromTaggedCbor()` to decode it.
+   *
+   * @param data - Binary CBOR data
+   * @returns Decoded instance
+   * @throws Error if the data cannot be parsed or decoded
+   */
+  fromTaggedCborData?(data: Uint8Array): T;
+  /**
+   * Creates an instance of this type by decoding it from binary encoded
+   * untagged CBOR.
+   *
+   * This is a convenience method that first parses the binary data into a
+   * CBOR value, then uses `fromUntaggedCbor()` to decode it.
+   *
+   * @param data - Binary CBOR data
+   * @returns Decoded instance
+   * @throws Error if the data cannot be parsed or decoded
+   */
+  fromUntaggedCborData?(data: Uint8Array): T;
+}
+/**
+ * Helper function to validate that a CBOR value has one of the expected tags.
+ *
+ * @param cbor - CBOR value to validate
+ * @param expectedTags - Array of valid tags
+ * @returns The matching tag
+ * @throws Error if the value is not tagged or has an unexpected tag
+ */
+declare const validateTag: (cbor: Cbor, expectedTags: Tag[]) => Tag;
+/**
+ * Helper function to extract the content from a tagged CBOR value.
+ *
+ * @param cbor - Tagged CBOR value
+ * @returns The untagged content
+ * @throws Error if the value is not tagged
+ */
+declare const extractTaggedContent: (cbor: Cbor) => Cbor;
+//#endregion
+//#region src/cbor-tagged-codable.d.ts
+/**
+ * Interface for types that can be both encoded to and decoded from CBOR with a
+ * specific tag.
+ *
+ * This interface is automatically implemented for any type that implements both
+ * `CborTaggedEncodable` and `CborTaggedDecodable`. It serves as a convenience
+ * marker to indicate full-tagged CBOR serialization support.
+ *
+ * @example
+ * ```typescript
+ * // Define a Date type
+ * class Date implements CborTaggedCodable<Date> {
+ *   constructor(public timestamp: number) {}
+ *
+ *   cborTags(): Tag[] {
+ *     return [createTag(1, 'date')]; // Standard date tag
+ *   }
+ *
+ *   // Implement encoding to tagged CBOR
+ *   untaggedCbor(): Cbor {
+ *     return cbor(this.timestamp);
+ *   }
+ *
+ *   taggedCbor(): Cbor {
+ *     const tags = this.cborTags();
+ *     return {
+ *       isCbor: true,
+ *       type: MajorType.Tagged,
+ *       tag: tags[0].value,
+ *       value: this.untaggedCbor()
+ *     };
+ *   }
+ *
+ *   // Implement decoding from tagged CBOR
+ *   fromUntaggedCbor(cbor: Cbor): Date {
+ *     const timestamp = cbor.value as number;
+ *     return new Date(timestamp);
+ *   }
+ *
+ *   fromTaggedCbor(cbor: Cbor): Date {
+ *     if (cbor.type !== MajorType.Tagged) {
+ *       throw new Error('Wrong type');
+ *     }
+ *     return this.fromUntaggedCbor(cbor.value);
+ *   }
+ * }
+ *
+ * // The CborTaggedCodable interface is automatically implemented
+ * // Create a date and demonstrate round-trip conversion
+ * const original = new Date(1609459200);
+ * const cborValue = original.taggedCbor();
+ * const roundtrip = new Date(0).fromTaggedCbor(cborValue);
+ * assert(original.timestamp === roundtrip.timestamp);
+ * ```
+ */
+interface CborTaggedCodable<T> extends CborTaggedEncodable, CborTaggedDecodable<T> {}
+//#endregion
+//#region src/cbor-tagged.d.ts
+/**
+ * Interface for types that have associated CBOR tags.
+ *
+ * In CBOR, tags provide semantic information about how to interpret data
+ * items. This interface defines which CBOR tag(s) are associated with a particular
+ * TypeScript type.
+ *
+ * Implementing this interface is a prerequisite for implementing
+ * `CborTaggedEncodable` and `CborTaggedDecodable`.
+ *
+ * ## Multiple Tags for Backward Compatibility
+ *
+ * The `cborTags()` method returns an array of tags, enabling support for
+ * backward compatibility with older tag versions:
+ *
+ * - **When encoding**: Only the first tag in the array is used for
+ *   serialization
+ * - **When decoding**: Any of the tags in the array will be accepted
+ *
+ * This design solves several real-world problems:
+ *
+ * 1. **IANA Registration Simplification**: If you initially choose a tag in
+ *    the Specification Required range (24-32767) and later want to move to the
+ *    simpler First Come, First Served range (32768+), you can migrate while
+ *    maintaining compatibility with existing data.
+ *
+ * 2. **Protocol Evolution**: As your protocol evolves, you can introduce new
+ *    preferred tags while still supporting data encoded with older tags.
+ *
+ * 3. **Versioning**: Different tags can represent different versions of your
+ *    data format while sharing the same TypeScript type for handling.
+ *
+ * @example
+ * ```typescript
+ * // Single tag
+ * class Date implements CborTagged {
+ *   cborTags(): Tag[] {
+ *     return [createTag(1, 'date')];
+ *   }
+ * }
+ *
+ * // Multiple tags for backward compatibility
+ * class Seed implements CborTagged {
+ *   cborTags(): Tag[] {
+ *     return [
+ *       createTag(40300, 'seed'),  // Primary tag (used for encoding)
+ *       createTag(300, 'seed-legacy'), // Legacy tag (accepted for decoding)
+ *     ];
+ *   }
+ * }
+ * ```
+ */
+interface CborTagged {
+  /**
+   * Returns the CBOR tags associated with this type.
+   *
+   * This method should return an array of tags in order of preference:
+   *
+   * - The first tag in the array is the "preferred" tag and will be used
+   *   when encoding values of this type via
+   *   `CborTaggedEncodable.taggedCbor()`.
+   *
+   * - All tags in the array are considered equivalent for decoding. When
+   *   `CborTaggedDecodable.fromTaggedCbor()` is called, any tag in this
+   *   array will be accepted as valid for this type.
+   *
+   * This design enables backward compatibility: you can introduce a new tag
+   * (placed first in the array) while still supporting older tags for
+   * decoding.
+   *
+   * For standard CBOR tags, you can use predefined tag constants from the
+   * `tags` module, or create custom tags with `createTag()`.
+   */
+  cborTags(): Tag[];
+}
+//#endregion
+//#region src/date.d.ts
+/**
+ * A CBOR-friendly representation of a date and time.
+ *
+ * The `CborDate` type provides a wrapper around JavaScript's native `Date` that
+ * supports encoding and decoding to/from CBOR with tag 1, following the CBOR
+ * date/time standard specified in RFC 8949.
+ *
+ * When encoded to CBOR, dates are represented as tag 1 followed by a numeric
+ * value representing the number of seconds since (or before) the Unix epoch
+ * (1970-01-01T00:00:00Z). The numeric value can be a positive or negative
+ * integer, or a floating-point value for dates with fractional seconds.
+ *
+ * # Features
+ *
+ * - Supports UTC dates with optional fractional seconds
+ * - Provides convenient constructors for common date creation patterns
+ * - Implements the `CborTagged`, `CborTaggedEncodable`, and
+ *   `CborTaggedDecodable` interfaces
+ * - Supports arithmetic operations with durations and between dates
+ *
+ * @example
+ * ```typescript
+ * import { CborDate } from './date';
+ *
+ * // Create a date from a timestamp (seconds since Unix epoch)
+ * const date = CborDate.fromTimestamp(1675854714.0);
+ *
+ * // Create a date from year, month, day
+ * const date2 = CborDate.fromYmd(2023, 2, 8);
+ *
+ * // Convert to CBOR
+ * const cborValue = date.taggedCbor();
+ *
+ * // Decode from CBOR
+ * const decoded = CborDate.fromTaggedCbor(cborValue);
+ * ```
+ */
+declare class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDecodable<CborDate> {
+  #private;
+  /**
+   * Creates a new `CborDate` from the given JavaScript `Date`.
+   *
+   * This method creates a new `CborDate` instance by wrapping a
+   * JavaScript `Date`.
+   *
+   * @param dateTime - A `Date` instance to wrap
+   *
+   * @returns A new `CborDate` instance
+   *
+   * @example
+   * ```typescript
+   * const datetime = new Date();
+   * const date = CborDate.fromDatetime(datetime);
+   * ```
+   */
+  static fromDatetime(dateTime: Date): CborDate;
+  /**
+   * Creates a new `CborDate` from year, month, and day components.
+   *
+   * This method creates a new `CborDate` with the time set to 00:00:00 UTC.
+   *
+   * @param year - The year component (e.g., 2023)
+   * @param month - The month component (1-12)
+   * @param day - The day component (1-31)
+   *
+   * @returns A new `CborDate` instance
+   *
+   * @example
+   * ```typescript
+   * // Create February 8, 2023
+   * const date = CborDate.fromYmd(2023, 2, 8);
+   * ```
+   *
+   * @throws Error if the provided components do not form a valid date.
+   */
+  static fromYmd(year: number, month: number, day: number): CborDate;
+  /**
+   * Creates a new `CborDate` from year, month, day, hour, minute, and second
+   * components.
+   *
+   * @param year - The year component (e.g., 2023)
+   * @param month - The month component (1-12)
+   * @param day - The day component (1-31)
+   * @param hour - The hour component (0-23)
+   * @param minute - The minute component (0-59)
+   * @param second - The second component (0-59)
+   *
+   * @returns A new `CborDate` instance
+   *
+   * @example
+   * ```typescript
+   * // Create February 8, 2023, 15:30:45 UTC
+   * const date = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
+   * ```
+   *
+   * @throws Error if the provided components do not form a valid date and time.
+   */
+  static fromYmdHms(year: number, month: number, day: number, hour: number, minute: number, second: number): CborDate;
+  /**
+   * Creates a new `CborDate` from seconds since (or before) the Unix epoch.
+   *
+   * This method creates a new `CborDate` representing the specified number of
+   * seconds since the Unix epoch (1970-01-01T00:00:00Z). Negative values
+   * represent times before the epoch.
+   *
+   * @param secondsSinceUnixEpoch - Seconds from the Unix epoch (positive or
+   *   negative), which can include a fractional part for sub-second
+   *   precision
+   *
+   * @returns A new `CborDate` instance
+   *
+   * @example
+   * ```typescript
+   * // Create a date from a timestamp
+   * const date = CborDate.fromTimestamp(1675854714.0);
+   *
+   * // Create a date one second before the Unix epoch
+   * const beforeEpoch = CborDate.fromTimestamp(-1.0);
+   *
+   * // Create a date with fractional seconds
+   * const withFraction = CborDate.fromTimestamp(1675854714.5);
+   * ```
+   */
+  static fromTimestamp(secondsSinceUnixEpoch: number): CborDate;
+  /**
+   * Creates a new `CborDate` from a string containing an ISO-8601 (RFC-3339)
+   * date (with or without time).
+   *
+   * This method parses a string representation of a date or date-time in
+   * ISO-8601/RFC-3339 format and creates a new `CborDate` instance. It
+   * supports both full date-time strings (e.g., "2023-02-08T15:30:45Z")
+   * and date-only strings (e.g., "2023-02-08").
+   *
+   * @param value - A string containing a date or date-time in ISO-8601/RFC-3339
+   *   format
+   *
+   * @returns A new `CborDate` instance if parsing succeeds
+   *
+   * @throws Error if the string cannot be parsed as a valid date or date-time
+   *
+   * @example
+   * ```typescript
+   * // Parse a date-time string
+   * const date = CborDate.fromString("2023-02-08T15:30:45Z");
+   *
+   * // Parse a date-only string (time will be set to 00:00:00)
+   * const date2 = CborDate.fromString("2023-02-08");
+   * ```
+   */
+  static fromString(value: string): CborDate;
+  /**
+   * Creates a new `CborDate` containing the current date and time.
+   *
+   * @returns A new `CborDate` instance representing the current UTC date and time
+   *
+   * @example
+   * ```typescript
+   * const now = CborDate.now();
+   * ```
+   */
+  static now(): CborDate;
+  /**
+   * Creates a new `CborDate` containing the current date and time plus the given
+   * duration.
+   *
+   * @param durationMs - The duration in milliseconds to add to the current time
+   *
+   * @returns A new `CborDate` instance representing the current UTC date and time plus
+   * the duration
+   *
+   * @example
+   * ```typescript
+   * // Get a date 1 hour from now
+   * const oneHourLater = CborDate.withDurationFromNow(3600 * 1000);
+   * ```
+   */
+  static withDurationFromNow(durationMs: number): CborDate;
+  /**
+   * Returns the underlying JavaScript `Date` object.
+   *
+   * This method provides access to the wrapped JavaScript `Date`
+   * instance.
+   *
+   * @returns The wrapped `Date` instance
+   *
+   * @example
+   * ```typescript
+   * const date = CborDate.now();
+   * const datetime = date.datetime();
+   * const year = datetime.getFullYear();
+   * ```
+   */
+  datetime(): Date;
+  /**
+   * Returns the `CborDate` as the number of seconds since the Unix epoch.
+   *
+   * This method converts the date to a floating-point number representing
+   * the number of seconds since the Unix epoch (1970-01-01T00:00:00Z).
+   * Negative values represent times before the epoch. The fractional
+   * part represents sub-second precision.
+   *
+   * @returns Seconds since the Unix epoch as a `number`
+   *
+   * @example
+   * ```typescript
+   * const date = CborDate.fromYmd(2023, 2, 8);
+   * const timestamp = date.timestamp();
+   * ```
+   */
+  timestamp(): number;
+  /**
+   * Add seconds to this date.
+   *
+   * @param seconds - Seconds to add (can be fractional)
+   * @returns New CborDate instance
+   *
+   * @example
+   * ```typescript
+   * const date = CborDate.fromYmd(2022, 3, 21);
+   * const tomorrow = date.add(24 * 60 * 60);
+   * ```
+   */
+  add(seconds: number): CborDate;
+  /**
+   * Subtract seconds from this date.
+   *
+   * @param seconds - Seconds to subtract (can be fractional)
+   * @returns New CborDate instance
+   *
+   * @example
+   * ```typescript
+   * const date = CborDate.fromYmd(2022, 3, 21);
+   * const yesterday = date.subtract(24 * 60 * 60);
+   * ```
+   */
+  subtract(seconds: number): CborDate;
+  /**
+   * Get the difference in seconds between this date and another.
+   *
+   * @param other - Other CborDate to compare with
+   * @returns Difference in seconds (this - other)
+   *
+   * @example
+   * ```typescript
+   * const date1 = CborDate.fromYmd(2022, 3, 22);
+   * const date2 = CborDate.fromYmd(2022, 3, 21);
+   * const diff = date1.difference(date2);
+   * // Returns 86400 (one day in seconds)
+   * ```
+   */
+  difference(other: CborDate): number;
+  /**
+   * Implementation of the `CborTagged` interface for `CborDate`.
+   *
+   * This implementation specifies that `CborDate` values are tagged with CBOR tag 1,
+   * which is the standard CBOR tag for date/time values represented as seconds
+   * since the Unix epoch per RFC 8949.
+   *
+   * @returns A vector containing tag 1
+   */
+  cborTags(): Tag[];
+  /**
+   * Implementation of the `CborTaggedEncodable` interface for `CborDate`.
+   *
+   * Converts this `CborDate` to an untagged CBOR value.
+   *
+   * The date is converted to a numeric value representing the number of
+   * seconds since the Unix epoch. This value may be an integer or a
+   * floating-point number, depending on whether the date has fractional
+   * seconds.
+   *
+   * @returns A CBOR value representing the timestamp
+   */
+  untaggedCbor(): Cbor;
+  /**
+   * Converts this `CborDate` to a tagged CBOR value with tag 1.
+   *
+   * @returns Tagged CBOR value
+   */
+  taggedCbor(): Cbor;
+  /**
+   * Implementation of the `CborTaggedDecodable` interface for `CborDate`.
+   *
+   * Creates a `CborDate` from an untagged CBOR value.
+   *
+   * The CBOR value must be a numeric value (integer or floating-point)
+   * representing the number of seconds since the Unix epoch.
+   *
+   * @param cbor - The untagged CBOR value
+   *
+   * @returns This CborDate instance (mutated)
+   *
+   * @throws Error if the CBOR value is not a valid timestamp
+   */
+  fromUntaggedCbor(cbor: Cbor): CborDate;
+  /**
+   * Creates a `CborDate` from a tagged CBOR value with tag 1.
+   *
+   * @param cbor - Tagged CBOR value
+   *
+   * @returns This CborDate instance (mutated)
+   *
+   * @throws Error if the CBOR value has the wrong tag or cannot be decoded
+   */
+  fromTaggedCbor(cbor: Cbor): CborDate;
+  /**
+   * Static method to create a CborDate from tagged CBOR.
+   *
+   * @param cbor - Tagged CBOR value
+   * @returns New CborDate instance
+   */
+  static fromTaggedCbor(cbor: Cbor): CborDate;
+  /**
+   * Static method to create a CborDate from untagged CBOR.
+   *
+   * @param cbor - Untagged CBOR value
+   * @returns New CborDate instance
+   */
+  static fromUntaggedCbor(cbor: Cbor): CborDate;
+  /**
+   * Implementation of the `toString` method for `CborDate`.
+   *
+   * This implementation provides a string representation of a `CborDate` in ISO-8601
+   * format. For dates with time exactly at midnight (00:00:00), only the date
+   * part is shown. For other times, a full date-time string is shown.
+   *
+   * @returns String representation in ISO-8601 format
+   *
+   * @example
+   * ```typescript
+   * // A date at midnight will display as just the date
+   * const date = CborDate.fromYmd(2023, 2, 8);
+   * // Returns "2023-02-08"
+   * console.log(date.toString());
+   *
+   * // A date with time will display as date and time
+   * const date2 = CborDate.fromYmdHms(2023, 2, 8, 15, 30, 45);
+   * // Returns "2023-02-08T15:30:45.000Z"
+   * console.log(date2.toString());
+   * ```
+   */
+  toString(): string;
+  /**
+   * Compare two dates for equality.
+   *
+   * @param other - Other CborDate to compare
+   * @returns true if dates represent the same moment in time
+   */
+  equals(other: CborDate): boolean;
+  /**
+   * Compare two dates.
+   *
+   * @param other - Other CborDate to compare
+   * @returns -1 if this < other, 0 if equal, 1 if this > other
+   */
+  compare(other: CborDate): number;
+  /**
+   * Convert to JSON (returns ISO 8601 string).
+   *
+   * @returns ISO 8601 string
+   */
+  toJSON(): string;
+  private constructor();
+}
+//#endregion
+//#region src/tags-store.d.ts
+/**
+ * Function type for custom CBOR value summarizers.
+ *
+ * Summarizers provide custom string representations for tagged values.
+ *
+ * @param cbor - The CBOR value to summarize
+ * @param flat - If true, produce single-line output
+ * @returns String summary of the value
+ */
+type CborSummarizer = (cbor: Cbor, flat: boolean) => string;
+/**
+ * Interface for tag store operations.
+ */
+interface TagsStoreTrait {
+  /**
+   * Get the assigned name for a tag, if any.
+   *
+   * @param tag - The tag to look up
+   * @returns The assigned name, or undefined if no name is registered
+   */
+  assignedNameForTag(tag: Tag): string | undefined;
+  /**
+   * Get a display name for a tag.
+   *
+   * @param tag - The tag to get a name for
+   * @returns The assigned name if available, otherwise the tag value as a string
+   */
+  nameForTag(tag: Tag): string;
+  /**
+   * Look up a tag by its numeric value.
+   *
+   * @param value - The numeric tag value
+   * @returns The Tag object if found, undefined otherwise
+   */
+  tagForValue(value: CborNumber): Tag | undefined;
+  /**
+   * Look up a tag by its name.
+   *
+   * @param name - The tag name
+   * @returns The Tag object if found, undefined otherwise
+   */
+  tagForName(name: string): Tag | undefined;
+  /**
+   * Get a display name for a tag value.
+   *
+   * @param value - The numeric tag value
+   * @returns The tag name if registered, otherwise the value as a string
+   */
+  nameForValue(value: CborNumber): string;
+  /**
+   * Get a custom summarizer function for a tag, if registered.
+   *
+   * @param tag - The numeric tag value
+   * @returns The summarizer function if registered, undefined otherwise
+   */
+  summarizer(tag: CborNumber): CborSummarizer | undefined;
+}
+/**
+ * Tag registry implementation.
+ *
+ * Stores tags with their names and optional summarizer functions.
+ */
+declare class TagsStore implements TagsStoreTrait {
+  #private;
+  constructor();
+  /**
+   * Insert a tag into the registry.
+   *
+   * @param tag - The tag to register
+   *
+   * @example
+   * ```typescript
+   * const store = new TagsStore();
+   * store.insert(createTag(12345, 'myCustomTag'));
+   * ```
+   */
+  insert(tag: Tag): void;
+  /**
+   * Insert multiple tags into the registry.
+   * Matches Rust's insert_all() method.
+   *
+   * @param tags - Array of tags to register
+   *
+   * @example
+   * ```typescript
+   * const store = new TagsStore();
+   * store.insertAll([
+   *   createTag(1, 'date'),
+   *   createTag(100, 'custom')
+   * ]);
+   * ```
+   */
+  insertAll(tags: Tag[]): void;
+  /**
+   * Register a custom summarizer function for a tag.
+   *
+   * @param tagValue - The numeric tag value
+   * @param summarizer - The summarizer function
+   *
+   * @example
+   * ```typescript
+   * store.setSummarizer(1, (cbor, flat) => {
+   *   // Custom date formatting
+   *   return `Date(${extractCbor(cbor)})`;
+   * });
+   * ```
+   */
+  setSummarizer(tagValue: CborNumber, summarizer: CborSummarizer): void;
+  /**
+   * Remove a tag from the registry.
+   *
+   * @param tagValue - The numeric tag value to remove
+   * @returns true if a tag was removed, false otherwise
+   */
+  remove(tagValue: CborNumber): boolean;
+  assignedNameForTag(tag: Tag): string | undefined;
+  nameForTag(tag: Tag): string;
+  tagForValue(value: CborNumber): Tag | undefined;
+  tagForName(name: string): Tag | undefined;
+  nameForValue(value: CborNumber): string;
+  summarizer(tag: CborNumber): CborSummarizer | undefined;
+  /**
+   * Get all registered tags.
+   *
+   * @returns Array of all registered tags
+   */
+  getAllTags(): Tag[];
+  /**
+   * Clear all registered tags and summarizers.
+   */
+  clear(): void;
+  /**
+   * Get the number of registered tags.
+   *
+   * @returns Number of tags in the registry
+   */
+  get size(): number;
+}
+/**
+ * Get the global tags store instance.
+ *
+ * Creates the instance on first access.
+ *
+ * @returns The global TagsStore instance
+ *
+ * @example
+ * ```typescript
+ * const store = getGlobalTagsStore();
+ * store.insert(createTag(999, 'myTag'));
+ * ```
+ */
+declare const getGlobalTagsStore: () => TagsStore;
+//#endregion
+//#region src/walk.d.ts
+/**
+ * Types of edges in the CBOR tree traversal.
+ */
+declare enum EdgeType {
+  /** No specific edge type (root element) */
+  None = "none",
+  /** Element within an array */
+  ArrayElement = "array_element",
+  /** Key-value pair in a map (semantic unit) */
+  MapKeyValue = "map_key_value",
+  /** Key within a map */
+  MapKey = "map_key",
+  /** Value within a map */
+  MapValue = "map_value",
+  /** Content of a tagged value */
+  TaggedContent = "tagged_content",
+}
+/**
+ * Discriminated union for edge type information.
+ */
+type EdgeTypeVariant = {
+  type: EdgeType.None;
+} | {
+  type: EdgeType.ArrayElement;
+  index: number;
+} | {
+  type: EdgeType.MapKeyValue;
+} | {
+  type: EdgeType.MapKey;
+} | {
+  type: EdgeType.MapValue;
+} | {
+  type: EdgeType.TaggedContent;
+};
+/**
+ * Returns a short text label for the edge type, or undefined if no label is needed.
+ *
+ * This is primarily used for tree formatting to identify relationships between elements.
+ *
+ * @param edge - The edge type variant to get a label for
+ * @returns Short label string, or undefined for None edge type
+ *
+ * @example
+ * ```typescript
+ * edgeLabel({ type: EdgeType.ArrayElement, index: 0 }); // Returns "arr[0]"
+ * edgeLabel({ type: EdgeType.MapKeyValue }); // Returns "kv"
+ * edgeLabel({ type: EdgeType.MapKey }); // Returns "key"
+ * edgeLabel({ type: EdgeType.MapValue }); // Returns "val"
+ * edgeLabel({ type: EdgeType.TaggedContent }); // Returns "content"
+ * edgeLabel({ type: EdgeType.None }); // Returns undefined
+ * ```
+ */
+declare const edgeLabel: (edge: EdgeTypeVariant) => string | undefined;
+/**
+ * Element visited during tree traversal.
+ * Can be either a single CBOR value or a key-value pair from a map.
+ */
+type WalkElement = {
+  type: "single";
+  cbor: Cbor;
+} | {
+  type: "keyvalue";
+  key: Cbor;
+  value: Cbor;
+};
+/**
+ * Helper functions for WalkElement
+ */
+/**
+ * Returns the single CBOR element if this is a 'single' variant.
+ *
+ * @param element - The walk element to extract from
+ * @returns The CBOR value if single, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const element: WalkElement = { type: 'single', cbor: someCbor };
+ * const cbor = asSingle(element); // Returns someCbor
+ * ```
+ */
+declare const asSingle: (element: WalkElement) => Cbor | undefined;
+/**
+ * Returns the key-value pair if this is a 'keyvalue' variant.
+ *
+ * @param element - The walk element to extract from
+ * @returns Tuple of [key, value] if keyvalue, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const element: WalkElement = { type: 'keyvalue', key: keyValue, value: valValue };
+ * const pair = asKeyValue(element); // Returns [keyValue, valValue]
+ * ```
+ */
+declare const asKeyValue: (element: WalkElement) => [Cbor, Cbor] | undefined;
+/**
+ * Visitor function type with state threading.
+ *
+ * @template State - The type of state passed through the traversal
+ * @param element - The element being visited
+ * @param level - The depth level in the tree (0 = root)
+ * @param edge - Information about the edge leading to this element
+ * @param state - Current state value
+ * @returns Tuple of [newState, stopDescent] where:
+ *   - newState: The updated state to pass to subsequent visits
+ *   - stopDescent: If true, don't descend into children of this element
+ */
+type Visitor<State> = (element: WalkElement, level: number, edge: EdgeTypeVariant, state: State) => [State, boolean];
+/**
+ * Helper: Count all elements in a CBOR tree.
+ *
+ * @param cbor - The CBOR value to count
+ * @returns Total number of elements visited
+ *
+ * @example
+ * ```typescript
+ * const structure = cbor([1, 2, [3, 4]]);
+ * const count = countElements(structure);
+ * console.log(count); // 6 (array, 1, 2, inner array, 3, 4)
+ * ```
+ */
+declare const countElements: (cbor: Cbor) => number;
+/**
+ * Helper: Collect all elements at a specific depth level.
+ *
+ * @param cbor - The CBOR value to traverse
+ * @param targetLevel - The depth level to collect (0 = root)
+ * @returns Array of CBOR values at the target level
+ *
+ * @example
+ * ```typescript
+ * const structure = cbor([[1, 2], [3, 4]]);
+ * const level1 = collectAtLevel(structure, 1);
+ * // Returns: [[1, 2], [3, 4]]
+ * const level2 = collectAtLevel(structure, 2);
+ * // Returns: [1, 2, 3, 4]
+ * ```
+ */
+declare const collectAtLevel: (cbor: Cbor, targetLevel: number) => Cbor[];
+/**
+ * Helper: Find first element matching a predicate.
+ *
+ * @template T - Type of extracted value
+ * @param cbor - The CBOR value to search
+ * @param predicate - Function to test each element
+ * @returns First matching element, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * const structure = cbor({ users: [
+ *   { name: 'Alice', age: 30 },
+ *   { name: 'Bob', age: 25 }
+ * ]});
+ *
+ * const bob = findFirst(structure, (element) => {
+ *   if (element.type === 'single' &&
+ *       element.cbor.type === MajorType.Text &&
+ *       element.cbor.value === 'Bob') {
+ *     return true;
+ *   }
+ *   return false;
+ * });
+ * ```
+ */
+declare const findFirst: (cbor: Cbor, predicate: (element: WalkElement) => boolean) => Cbor | undefined;
+/**
+ * Helper: Collect all text strings in a CBOR tree.
+ *
+ * @param cbor - The CBOR value to traverse
+ * @returns Array of all text string values found
+ *
+ * @example
+ * ```typescript
+ * const doc = cbor({
+ *   title: 'Document',
+ *   tags: ['urgent', 'draft'],
+ *   author: { name: 'Alice' }
+ * });
+ *
+ * const texts = collectAllText(doc);
+ * // Returns: ['Document', 'urgent', 'draft', 'Alice']
+ * ```
+ */
+declare const collectAllText: (cbor: Cbor) => string[];
+/**
+ * Helper: Get the maximum depth of a CBOR tree.
+ *
+ * @param cbor - The CBOR value to measure
+ * @returns Maximum depth (0 for leaf values, 1+ for containers)
+ *
+ * @example
+ * ```typescript
+ * const flat = cbor([1, 2, 3]);
+ * console.log(maxDepth(flat)); // 1
+ *
+ * const nested = cbor([[[1]]]);
+ * console.log(maxDepth(nested)); // 3
+ * ```
+ */
+declare const maxDepth: (cbor: Cbor) => number;
+//#endregion
+//#region src/cbor.d.ts
+declare const MajorType: {
+  readonly Unsigned: 0;
+  readonly Negative: 1;
+  readonly ByteString: 2;
+  readonly Text: 3;
+  readonly Array: 4;
+  readonly Map: 5;
+  readonly Tagged: 6;
+  readonly Simple: 7;
+};
+type MajorType = (typeof MajorType)[keyof typeof MajorType];
+/**
+ * Numeric type that can be encoded in CBOR.
+ *
+ * Supports both standard JavaScript numbers and BigInt for large integers.
+ * Numbers are automatically encoded as either unsigned or negative integers
+ * depending on their value, following dCBOR canonical encoding rules.
+ *
+ * @example
+ * ```typescript
+ * const smallNum: CborNumber = 42;
+ * const largeNum: CborNumber = 9007199254740992n;
+ * ```
+ */
+type CborNumber = number | bigint;
+/**
+ * Type for values that can be converted to CBOR.
+ *
+ * This is a comprehensive union type representing all values that can be encoded
+ * as CBOR using the `cbor()` function. It includes:
+ * - Already-encoded CBOR values (`Cbor`)
+ * - Primitive types: numbers, bigints, strings, booleans, null, undefined
+ * - Binary data: `Uint8Array`, `ByteString`
+ * - Dates: `CborDate`
+ * - Collections: `CborMap`, arrays, JavaScript `Map`, JavaScript `Set`
+ * - Objects: Plain objects are converted to CBOR maps
+ *
+ * Matches Rust's `From<T>` trait implementations for CBOR.
+ *
+ * @example
+ * ```typescript
+ * cbor(42);                              // number
+ * cbor("hello");                         // string
+ * cbor([1, 2, 3]);                       // array
+ * cbor(new Map([["key", "value"]]));     // Map
+ * cbor({ name: "Alice", age: 30 });      // plain object -> CborMap
+ * ```
+ */
+type CborInput = Cbor | CborNumber | string | boolean | null | undefined | Uint8Array | ByteString | CborDate | CborMap | CborInput[] | Map<unknown, unknown> | Set<unknown> | Record<string, unknown>;
+interface CborUnsignedType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Unsigned;
+  readonly value: CborNumber;
+}
+interface CborNegativeType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Negative;
+  readonly value: CborNumber;
+}
+interface CborByteStringType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.ByteString;
+  readonly value: Uint8Array;
+}
+interface CborTextType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Text;
+  readonly value: string;
+}
+interface CborArrayType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Array;
+  readonly value: readonly Cbor[];
+}
+interface CborMapType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Map;
+  readonly value: CborMap;
+}
+interface CborTaggedType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Tagged;
+  readonly tag: CborNumber;
+  readonly value: Cbor;
+}
+interface CborSimpleType {
+  readonly isCbor: true;
+  readonly type: typeof MajorType.Simple;
+  readonly value: Simple;
+}
+interface CborMethods {
+  toData(): Uint8Array;
+  toHex(): string;
+  toHexAnnotated(tagsStore?: TagsStore): string;
+  toString(): string;
+  toDebugString(): string;
+  toDiagnostic(): string;
+  toDiagnosticAnnotated(): string;
+  isByteString(): boolean;
+  isText(): boolean;
+  isArray(): boolean;
+  isMap(): boolean;
+  isTagged(): boolean;
+  isSimple(): boolean;
+  isBool(): boolean;
+  isTrue(): boolean;
+  isFalse(): boolean;
+  isNull(): boolean;
+  isNumber(): boolean;
+  isInteger(): boolean;
+  isUnsigned(): boolean;
+  isNegative(): boolean;
+  isNaN(): boolean;
+  isFloat(): boolean;
+  asByteString(): Uint8Array | undefined;
+  asText(): string | undefined;
+  asArray(): readonly Cbor[] | undefined;
+  asMap(): CborMap | undefined;
+  asTagged(): [Tag, Cbor] | undefined;
+  asBool(): boolean | undefined;
+  asInteger(): (number | bigint) | undefined;
+  asNumber(): (number | bigint) | undefined;
+  asSimpleValue(): Simple | undefined;
+  /**
+   * Convert to byte string, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a byte string type
+   */
+  toByteString(): Uint8Array;
+  /**
+   * Convert to text string, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a text string type
+   */
+  toText(): string;
+  /**
+   * Convert to array, throwing if type doesn't match.
+   * @throws {TypeError} If value is not an array type
+   */
+  toArray(): readonly Cbor[];
+  /**
+   * Convert to map, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a map type
+   */
+  toMap(): CborMap;
+  /**
+   * Convert to tagged value, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a tagged type
+   */
+  toTagged(): [Tag, Cbor];
+  /**
+   * Convert to boolean, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a boolean (True/False) type
+   */
+  toBool(): boolean;
+  /**
+   * Convert to integer, throwing if type doesn't match.
+   * @throws {TypeError} If value is not an integer (Unsigned or Negative) type
+   */
+  toInteger(): number | bigint;
+  /**
+   * Convert to number, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a numeric (Unsigned, Negative, or Float) type
+   */
+  toNumber(): number | bigint;
+  /**
+   * Convert to simple value, throwing if type doesn't match.
+   * @throws {TypeError} If value is not a simple type
+   */
+  toSimpleValue(): Simple;
+  /**
+   * Expect specific tag and return content, throwing if tag doesn't match.
+   * @param tag - Expected tag value
+   * @throws {CborError} With type 'WrongType' if value is not tagged, or 'Custom' if tag doesn't match
+   */
+  expectTag(tag: CborNumber | Tag): Cbor;
+  /**
+   * Walk the CBOR structure with a visitor function.
+   * @param initialState - Initial state for the visitor
+   * @param visitor - Visitor function called for each element
+   */
+  walk<State>(initialState: State, visitor: Visitor<State>): State;
+  /**
+   * Validate that value has one of the expected tags.
+   * @param expectedTags - Array of expected tag values
+   * @throws {CborError} With type 'WrongType' if value is not tagged, or 'Custom' if tag doesn't match any expected value
+   */
+  validateTag(expectedTags: Tag[]): Tag;
+  /**
+   * Remove one level of tagging, returning the inner content.
+   */
+  untagged(): Cbor;
+}
+type Cbor = (CborUnsignedType | CborNegativeType | CborByteStringType | CborTextType | CborArrayType | CborMapType | CborTaggedType | CborSimpleType) & CborMethods;
+/**
+ * Convert any value to a CBOR representation.
+ * Matches Rust's `From` trait implementations for CBOR.
+ */
+declare const cbor: (value: CborInput) => Cbor;
+/**
+ * Encode a CBOR value to binary data.
+ * Matches Rust's `CBOR::to_cbor_data()` method.
+ */
+declare const cborData: (value: CborInput) => Uint8Array;
+declare const toByteString: (data: Uint8Array) => Cbor;
+declare const toByteStringFromHex: (hex: string) => Cbor;
+declare const toTaggedValue: (tag: CborNumber | Tag, item: CborInput) => Cbor;
+/**
+ * CBOR constants and helper methods.
+ *
+ * Provides constants for common simple values (False, True, Null) and static methods
+ * matching the Rust CBOR API for encoding/decoding.
+ */
+declare const Cbor: {
+  False: {
+    isCbor: true;
+    type: 7;
+    value: {
+      type: "False";
+    };
+  } & CborMethods;
+  True: {
+    isCbor: true;
+    type: 7;
+    value: {
+      type: "True";
+    };
+  } & CborMethods;
+  Null: {
+    isCbor: true;
+    type: 7;
+    value: {
+      type: "Null";
+    };
+  } & CborMethods;
+  NaN: {
+    isCbor: true;
+    type: 7;
+    value: {
+      type: "Float";
+      value: number;
+    };
+  } & CborMethods;
+  /**
+   * Creates a CBOR value from any JavaScript value.
+   *
+   * Matches Rust's `CBOR::from()` behavior for various types.
+   *
+   * @param value - Any JavaScript value (number, string, boolean, null, array, object, etc.)
+   * @returns A CBOR symbolic representation with instance methods
+   */
+  from(value: CborInput): Cbor;
+  /**
+   * Decodes binary data into CBOR symbolic representation.
+   *
+   * Matches Rust's `CBOR::try_from_data()` method.
+   *
+   * @param data - The binary data to decode
+   * @returns A CBOR value with instance methods
+   * @throws Error if the data is not valid CBOR or violates dCBOR encoding rules
+   */
+  tryFromData(data: Uint8Array): Cbor;
+  /**
+   * Decodes a hexadecimal string into CBOR symbolic representation.
+   *
+   * Matches Rust's `CBOR::try_from_hex()` method.
+   *
+   * @param hex - A string containing hexadecimal characters
+   * @returns A CBOR value with instance methods
+   * @throws Error if the hex string is invalid or the resulting data is not valid dCBOR
+   */
+  tryFromHex(hex: string): Cbor;
+};
+//#endregion
+//#region src/decode.d.ts
+declare function decodeCbor(data: Uint8Array): Cbor;
+//#endregion
+//#region src/set.d.ts
+/**
+ * CBOR Set type with tag(258) encoding.
+ *
+ * Internally uses a CborMap to ensure unique elements with deterministic ordering.
+ * Elements are ordered by their CBOR encoding (lexicographic byte order).
+ *
+ * @example
+ * ```typescript
+ * // Create set
+ * const set = CborSet.fromArray([1, 2, 3]);
+ * const set2 = CborSet.fromSet(new Set([1, 2, 3]));
+ *
+ * // Add elements
+ * set.insert(4);
+ * set.insert(2); // Duplicate, no effect
+ *
+ * // Check membership
+ * console.log(set.contains(2)); // true
+ * console.log(set.contains(99)); // false
+ *
+ * // Encode to CBOR
+ * const tagged = set.taggedCbor();
+ * ```
+ */
+declare class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet> {
+  #private;
+  constructor();
+  /**
+   * Create CborSet from array.
+   *
+   * Duplicates are automatically removed.
+   *
+   * @param items - Array of items to add to the set
+   * @returns New CborSet instance
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([1, 2, 3, 2, 1]);
+   * console.log(set.size); // 3
+   * ```
+   */
+  static fromArray<T extends CborInput>(items: T[]): CborSet;
+  /**
+   * Create CborSet from JavaScript Set.
+   *
+   * @param items - JavaScript Set of items
+   * @returns New CborSet instance
+   *
+   * @example
+   * ```typescript
+   * const jsSet = new Set([1, 2, 3]);
+   * const cborSet = CborSet.fromSet(jsSet);
+   * ```
+   */
+  static fromSet<T extends CborInput>(items: Set<T>): CborSet;
+  /**
+   * Create CborSet from iterable.
+   *
+   * @param items - Iterable of items
+   * @returns New CborSet instance
+   */
+  static fromIterable<T extends CborInput>(items: Iterable<T>): CborSet;
+  /**
+   * Insert an element into the set.
+   *
+   * If the element already exists, has no effect.
+   *
+   * @param value - Value to insert
+   *
+   * @example
+   * ```typescript
+   * const set = new CborSet();
+   * set.insert(1);
+   * set.insert(2);
+   * set.insert(1); // No effect, already exists
+   * ```
+   */
+  insert(value: CborInput): void;
+  /**
+   * Check if set contains an element.
+   *
+   * @param value - Value to check
+   * @returns true if element is in the set
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([1, 2, 3]);
+   * console.log(set.contains(2)); // true
+   * console.log(set.contains(99)); // false
+   * ```
+   */
+  contains(value: CborInput): boolean;
+  /**
+   * Remove an element from the set.
+   *
+   * @param value - Value to remove
+   * @returns true if element was removed, false if not found
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([1, 2, 3]);
+   * set.delete(2); // Returns true
+   * set.delete(99); // Returns false
+   * ```
+   */
+  delete(value: CborInput): boolean;
+  /**
+   * Remove all elements from the set.
+   */
+  clear(): void;
+  /**
+   * Get the number of elements in the set.
+   *
+   * @returns Number of elements
+   */
+  get size(): number;
+  /**
+   * Check if the set is empty.
+   *
+   * @returns true if set has no elements
+   */
+  isEmpty(): boolean;
+  /**
+   * Create a new set containing elements in this set or the other set.
+   *
+   * @param other - Other set
+   * @returns New set with union of elements
+   *
+   * @example
+   * ```typescript
+   * const set1 = CborSet.fromArray([1, 2, 3]);
+   * const set2 = CborSet.fromArray([3, 4, 5]);
+   * const union = set1.union(set2);
+   * // union contains [1, 2, 3, 4, 5]
+   * ```
+   */
+  union(other: CborSet): CborSet;
+  /**
+   * Create a new set containing elements in both this set and the other set.
+   *
+   * @param other - Other set
+   * @returns New set with intersection of elements
+   *
+   * @example
+   * ```typescript
+   * const set1 = CborSet.fromArray([1, 2, 3]);
+   * const set2 = CborSet.fromArray([2, 3, 4]);
+   * const intersection = set1.intersection(set2);
+   * // intersection contains [2, 3]
+   * ```
+   */
+  intersection(other: CborSet): CborSet;
+  /**
+   * Create a new set containing elements in this set but not in the other set.
+   *
+   * @param other - Other set
+   * @returns New set with difference of elements
+   *
+   * @example
+   * ```typescript
+   * const set1 = CborSet.fromArray([1, 2, 3]);
+   * const set2 = CborSet.fromArray([2, 3, 4]);
+   * const diff = set1.difference(set2);
+   * // diff contains [1]
+   * ```
+   */
+  difference(other: CborSet): CborSet;
+  /**
+   * Check if this set is a subset of another set.
+   *
+   * @param other - Other set
+   * @returns true if all elements of this set are in the other set
+   */
+  isSubsetOf(other: CborSet): boolean;
+  /**
+   * Check if this set is a superset of another set.
+   *
+   * @param other - Other set
+   * @returns true if all elements of the other set are in this set
+   */
+  isSupersetOf(other: CborSet): boolean;
+  /**
+   * Iterate over elements in the set.
+   *
+   * Elements are returned in deterministic order (by CBOR encoding).
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([3, 1, 2]);
+   * for (const value of set) {
+   *   console.log(extractCbor(value));
+   * }
+   * ```
+   */
+  [Symbol.iterator](): Iterator<Cbor>;
+  /**
+   * Get all values as an array.
+   *
+   * @returns Array of CBOR values in deterministic order
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([3, 1, 2]);
+   * const values = set.values();
+   * // Values in deterministic order
+   * ```
+   */
+  values(): Cbor[];
+  /**
+   * Execute a function for each element.
+   *
+   * @param callback - Function to call for each element
+   *
+   * @example
+   * ```typescript
+   * set.forEach(value => {
+   *   console.log(extractCbor(value));
+   * });
+   * ```
+   */
+  forEach(callback: (value: Cbor) => void): void;
+  cborTags(): Tag[];
+  untaggedCbor(): Cbor;
+  taggedCbor(): Cbor;
+  fromUntaggedCbor(c: Cbor): CborSet;
+  fromTaggedCbor(c: Cbor): CborSet;
+  /**
+   * Decode a CborSet from tagged CBOR (static method).
+   *
+   * @param cbor - Tagged CBOR value with tag(258)
+   * @returns Decoded CborSet instance
+   */
+  static fromTaggedCborStatic(cbor: Cbor): CborSet;
+  /**
+   * Convert to CBOR array (untagged).
+   *
+   * @returns CBOR array
+   */
+  toCbor(): Cbor;
+  /**
+   * Convert to CBOR bytes (tagged).
+   *
+   * @returns Encoded CBOR bytes
+   */
+  toBytes(): Uint8Array;
+  /**
+   * Convert to JavaScript Set.
+   *
+   * @returns JavaScript Set with extracted values
+   *
+   * @example
+   * ```typescript
+   * const cborSet = CborSet.fromArray([1, 2, 3]);
+   * const jsSet = cborSet.toSet();
+   * console.log(jsSet.has(1)); // true
+   * ```
+   */
+  toSet(): Set<unknown>;
+  /**
+   * Convert to JavaScript Array.
+   *
+   * @returns Array with extracted values
+   */
+  toArray(): unknown[];
+  /**
+   * Get diagnostic notation for the set.
+   *
+   * @returns String representation
+   *
+   * @example
+   * ```typescript
+   * const set = CborSet.fromArray([1, 2, 3]);
+   * console.log(set.diagnostic); // "[1, 2, 3]"
+   * ```
+   */
+  get diagnostic(): string;
+  /**
+   * Convert to string (same as diagnostic).
+   *
+   * @returns String representation
+   */
+  toString(): string;
+  /**
+   * Convert to JSON (returns array of values).
+   *
+   * @returns Array for JSON serialization
+   */
+  toJSON(): unknown[];
+}
+//#endregion
+//#region src/tags.d.ts
+/**
+ * Tag 0: Standard date/time string (RFC 3339)
+ */
+declare const TAG_DATE_TIME_STRING = 0;
+/**
+ * Tag 1: Epoch-based date/time (seconds since 1970-01-01T00:00:00Z)
+ */
+declare const TAG_EPOCH_DATE_TIME = 1;
+/**
+ * Tag 100: Epoch-based date (days since 1970-01-01)
+ */
+declare const TAG_EPOCH_DATE = 100;
+/**
+ * Tag 2: Positive bignum (unsigned arbitrary-precision integer)
+ */
+declare const TAG_POSITIVE_BIGNUM = 2;
+/**
+ * Tag 3: Negative bignum (signed arbitrary-precision integer)
+ */
+declare const TAG_NEGATIVE_BIGNUM = 3;
+/**
+ * Tag 4: Decimal fraction [exponent, mantissa]
+ */
+declare const TAG_DECIMAL_FRACTION = 4;
+/**
+ * Tag 5: Bigfloat [exponent, mantissa]
+ */
+declare const TAG_BIGFLOAT = 5;
+/**
+ * Tag 21: Expected conversion to base64url encoding
+ */
+declare const TAG_BASE64URL = 21;
+/**
+ * Tag 22: Expected conversion to base64 encoding
+ */
+declare const TAG_BASE64 = 22;
+/**
+ * Tag 23: Expected conversion to base16 encoding
+ */
+declare const TAG_BASE16 = 23;
+/**
+ * Tag 24: Encoded CBOR data item
+ */
+declare const TAG_ENCODED_CBOR = 24;
+/**
+ * Tag 32: URI (text string)
+ */
+declare const TAG_URI = 32;
+/**
+ * Tag 33: base64url-encoded text
+ */
+declare const TAG_BASE64URL_TEXT = 33;
+/**
+ * Tag 34: base64-encoded text
+ */
+declare const TAG_BASE64_TEXT = 34;
+/**
+ * Tag 35: Regular expression (PCRE/ECMA262)
+ */
+declare const TAG_REGEXP = 35;
+/**
+ * Tag 36: MIME message
+ */
+declare const TAG_MIME_MESSAGE = 36;
+/**
+ * Tag 37: Binary UUID
+ */
+declare const TAG_UUID = 37;
+/**
+ * Tag 256: string reference (namespace)
+ */
+declare const TAG_STRING_REF_NAMESPACE = 256;
+/**
+ * Tag 257: binary UUID reference
+ */
+declare const TAG_BINARY_UUID = 257;
+/**
+ * Tag 258: Set of values (array with no duplicates)
+ */
+declare const TAG_SET = 258;
+/**
+ * Tag 55799: Self-describe CBOR (magic number 0xd9d9f7)
+ */
+declare const TAG_SELF_DESCRIBE_CBOR = 55799;
+declare const TAG_DATE = 1;
+declare const TAG_NAME_DATE = "date";
+/**
+ * Register standard tags in a specific tags store.
+ * Matches Rust's register_tags_in() function.
+ *
+ * @param tagsStore - The tags store to register tags into
+ */
+declare const registerTagsIn: (tagsStore: TagsStore) => void;
+/**
+ * Register standard tags in the global tags store.
+ * Matches Rust's register_tags() function.
+ *
+ * This function is idempotent - calling it multiple times is safe.
+ */
+declare const registerTags: () => void;
+/**
+ * Converts an array of tag values to their corresponding Tag objects.
+ * Matches Rust's tags_for_values() function.
+ *
+ * This function looks up each tag value in the global tag registry and returns
+ * an array of complete Tag objects. For any tag values that aren't
+ * registered in the global registry, it creates a basic Tag with just the
+ * value (no name).
+ *
+ * @param values - Array of numeric tag values to convert
+ * @returns Array of Tag objects corresponding to the input values
+ *
+ * @example
+ * ```typescript
+ * // Register some tags first
+ * registerTags();
+ *
+ * // Convert tag values to Tag objects
+ * const tags = tagsForValues([1, 42, 999]);
+ *
+ * // The first tag (value 1) should be registered as "date"
+ * console.log(tags[0].value); // 1
+ * console.log(tags[0].name); // "date"
+ *
+ * // Unregistered tags will have a value but no name
+ * console.log(tags[1].value); // 42
+ * console.log(tags[2].value); // 999
+ * ```
+ */
+declare const tagsForValues: (values: (number | bigint)[]) => Tag[];
+//#endregion
+//#region src/diag.d.ts
+/**
+ * Options for diagnostic formatting.
+ */
+interface DiagFormatOpts {
+  /**
+   * Add tag names as annotations.
+   * When true, tagged values are displayed as "tagName(content)" instead of "tagValue(content)".
+   *
+   * @default false
+   */
+  annotate?: boolean;
+  /**
+   * Use custom summarizers for tagged values.
+   * When true, calls registered summarizers for tagged values.
+   *
+   * @default false
+   */
+  summarize?: boolean;
+  /**
+   * Single-line (flat) output.
+   * When true, arrays and maps are formatted without line breaks.
+   *
+   * @default false
+   */
+  flat?: boolean;
+  /**
+   * Tag store to use for tag name resolution.
+   * - TagsStore instance: Use specific store
+   * - 'global': Use global singleton store
+   * - 'none': Don't use any store (show tag numbers)
+   *
+   * @default 'global'
+   */
+  tags?: TagsStore | "global" | "none";
+  /**
+   * Current indentation level (internal use for recursion).
+   * @internal
+   */
+  indent?: number;
+  /**
+   * Indentation string (spaces per level).
+   * @internal
+   */
+  indentString?: string;
+}
+/**
+ * Format CBOR value as diagnostic notation with options.
+ *
+ * @param cbor - CBOR value to format
+ * @param opts - Formatting options
+ * @returns Diagnostic string
+ *
+ * @example
+ * ```typescript
+ * const value = cbor({ name: 'Alice', age: 30 });
+ * console.log(diagnosticOpt(value, { flat: true }));
+ * // {\"name\": \"Alice\", \"age\": 30}
+ *
+ * const tagged = createTaggedCbor({ ... });
+ * console.log(diagnosticOpt(tagged, { annotate: true }));
+ * // date(1234567890)
+ * ```
+ */
+declare function diagnosticOpt(cbor: Cbor, opts?: DiagFormatOpts): string;
+/**
+ * Format CBOR value using custom summarizers for tagged values.
+ *
+ * If a summarizer is registered for a tagged value, uses that instead of
+ * showing the full content.
+ *
+ * @param cbor - CBOR value to format
+ * @returns Summarized diagnostic string
+ *
+ * @example
+ * ```typescript
+ * // If a summarizer is registered for tag 123:
+ * const tagged = cbor({ type: MajorType.Tagged, tag: 123, value: ... });
+ * console.log(summary(tagged));
+ * // "custom-summary" (instead of full content)
+ * ```
+ */
+declare function summary(cbor: Cbor): string;
+//#endregion
+//#region src/dump.d.ts
+/**
+ * Options for hex formatting.
+ */
+interface HexFormatOpts {
+  /** Whether to annotate the hex dump with semantic information */
+  annotate?: boolean;
+  /** Optional tags store for resolving tag names */
+  tagsStore?: TagsStore;
+}
+/**
+ * Convert bytes to hex string.
+ */
+declare const bytesToHex: (bytes: Uint8Array) => string;
+/**
+ * Convert hex string to bytes.
+ */
+declare const hexToBytes: (hexString: string) => Uint8Array;
+/**
+ * Returns the encoded hexadecimal representation of CBOR with options.
+ *
+ * Optionally annotates the output, e.g., breaking the output up into
+ * semantically meaningful lines, formatting dates, and adding names of
+ * known tags.
+ *
+ * @param cbor - CBOR value to convert
+ * @param opts - Formatting options
+ * @returns Hex string (possibly annotated)
+ */
+declare const hexOpt: (cbor: Cbor, opts?: HexFormatOpts) => string;
+//#endregion
+//#region src/cbor-codable.d.ts
+/**
+ * Interface for types that can be encoded to CBOR.
+ *
+ * This interface provides convenient methods for converting
+ * instances into CBOR objects and binary data.
+ *
+ * @example
+ * ```typescript
+ * // Custom type that can convert to CBOR
+ * class Person implements CborEncodable {
+ *   constructor (public name: string, public age: number) {}
+ *
+ *   toCbor(): Cbor {
+ *     const map = new CborMap();
+ *     map.set(cbor('name'), cbor(this.name));
+ *     map.set(cbor('age'), cbor(this.age));
+ *     return cbor(map);
+ *   }
+ *
+ *   toCborData(): Uint8Array {
+ *     return cborData(this.toCbor());
+ *   }
+ * }
+ *
+ * // Use the interface
+ * const person = new Person('Alice', 30);
+ *
+ * // Convert to CBOR
+ * const cborValue = person.toCbor();
+ *
+ * // Convert directly to binary CBOR data
+ * const data = person.toCborData();
+ * ```
+ */
+interface CborEncodable {
+  /**
+   * Converts this value to a CBOR object.
+   *
+   * @returns CBOR representation
+   */
+  toCbor(): Cbor;
+  /**
+   * Converts this value directly to binary CBOR data.
+   *
+   * This is a shorthand for `cborData(this.toCbor())`.
+   *
+   * @returns Binary CBOR data
+   */
+  toCborData(): Uint8Array;
+}
+/**
+ * Interface for types that can be decoded from CBOR.
+ *
+ * This interface serves as a marker to indicate that a type
+ * supports being created from CBOR data.
+ *
+ * @typeParam T - The type being decoded
+ *
+ * @example
+ * ```typescript
+ * // Custom type that can be decoded from CBOR
+ * class Person implements CborDecodable<Person> {
+ *   constructor(public name: string = '', public age: number = 0) {}
+ *
+ *   static fromCbor(cbor: Cbor): Person {
+ *     if (cbor.type !== MajorType.Map) {
+ *       throw new Error('Expected a CBOR map');
+ *     }
+ *     const map = cbor.value as CborMap;
+ *     const name = extractCbor(map.get(cbor('name'))!) as string;
+ *     const age = extractCbor(map.get(cbor('age'))!) as number;
+ *     return new Person(name, age);
+ *   }
+ *
+ *   tryFromCbor(cbor: Cbor): Person {
+ *     return Person.fromCbor(cbor);
+ *   }
+ * }
+ *
+ * // Parse from CBOR
+ * const cborMap = ...; // some CBOR map
+ * const person = Person.fromCbor(cborMap);
+ * ```
+ */
+interface CborDecodable<T> {
+  /**
+   * Try to create an instance from a CBOR value.
+   *
+   * @param cbor - CBOR value to decode
+   * @returns Decoded instance
+   * @throws Error if decoding fails
+   */
+  tryFromCbor(cbor: Cbor): T;
+}
+/**
+ * Interface for types that can be both encoded to and decoded from CBOR.
+ *
+ * This interface is a convenience marker for types that implement both
+ * `CborEncodable` and `CborDecodable`. It serves to indicate full CBOR
+ * serialization support.
+ *
+ * @typeParam T - The type being encoded/decoded
+ *
+ * @example
+ * ```typescript
+ * // Custom type that implements both conversion directions
+ * class Person implements CborCodable<Person> {
+ *   constructor(public name: string = '', public age: number = 0) {}
+ *
+ *   // Implement encoding to CBOR
+ *   toCbor(): Cbor {
+ *     const map = new CborMap();
+ *     map.set(cbor('name'), cbor(this.name));
+ *     map.set(cbor('age'), cbor(this.age));
+ *     return cbor(map);
+ *   }
+ *
+ *   toCborData(): Uint8Array {
+ *     return cborData(this.toCbor());
+ *   }
+ *
+ *   // Implement decoding from CBOR
+ *   static fromCbor(cbor: Cbor): Person {
+ *     if (cbor.type !== MajorType.Map) {
+ *       throw new Error('Expected a CBOR map');
+ *     }
+ *     const map = cbor.value as CborMap;
+ *     const name = extractCbor(map.get(cbor('name'))!) as string;
+ *     const age = extractCbor(map.get(cbor('age'))!) as number;
+ *     return new Person(name, age);
+ *   }
+ *
+ *   tryFromCbor(cbor: Cbor): Person {
+ *     return Person.fromCbor(cbor);
+ *   }
+ * }
+ *
+ * // Person now implements CborCodable
+ * const person = new Person('Alice', 30);
+ * const cborValue = person.toCbor(); // Using CborEncodable
+ *
+ * // Create a round-trip copy
+ * const personCopy = Person.fromCbor(cborValue); // Using CborDecodable
+ * ```
+ */
+interface CborCodable<T> extends CborEncodable, CborDecodable<T> {}
+//#endregion
+//#region src/error.d.ts
+/**
+ * A comprehensive set of errors that can occur during CBOR encoding and
+ * decoding operations with special focus on enforcing the deterministic
+ * encoding rules specified in the dCBOR specification.
+ *
+ * The dCBOR implementation validates all encoded CBOR against the
+ * deterministic encoding requirements of RFC 8949 §4.2.1, plus additional
+ * constraints defined in the dCBOR application profile. These errors represent
+ * all the possible validation failures and decoding issues that can arise.
+ */
+type Error =
+/**
+ * The CBOR data ended prematurely during decoding, before a complete CBOR
+ * item could be decoded. This typically happens when a CBOR item's
+ * structure indicates more data than is actually present.
+ */
+{
+  readonly type: "Underrun";
+}
+/**
+ * An unsupported or invalid value was encountered in a CBOR header byte.
+ * The parameter contains the unsupported header byte value.
+ * This can occur when decoding CBOR that uses unsupported features or is
+ * malformed.
+ */ | {
+  readonly type: "UnsupportedHeaderValue";
+  readonly value: number;
+}
+/**
+ * A CBOR numeric value was encoded in a non-canonical form, violating the
+ * deterministic encoding requirement of dCBOR (per Section 2.3 of the
+ * dCBOR specification).
+ *
+ * This error is triggered when:
+ * - An integer is not encoded in its shortest possible form
+ * - A floating point value that could be represented as an integer was not
+ *   reduced
+ * - A NaN value was not encoded in its canonical form (`f97e00`)
+ */ | {
+  readonly type: "NonCanonicalNumeric";
+}
+/**
+ * An invalid CBOR simple value was encountered during decoding.
+ *
+ * Per Section 2.4 of the dCBOR specification, only `false`, `true`,
+ * `null`, and floating point values are valid simple values in dCBOR.
+ * All other major type 7 values are invalid.
+ */ | {
+  readonly type: "InvalidSimpleValue";
+}
+/**
+ * A CBOR text string was not valid UTF-8. The parameter contains the
+ * specific error message.
+ *
+ * All CBOR text strings (major type 3) must be valid UTF-8 per RFC 8949.
+ */ | {
+  readonly type: "InvalidString";
+  readonly message: string;
+}
+/**
+ * A CBOR text string was not encoded in Unicode Canonical Normalization
+ * Form C (NFC).
+ *
+ * Per Section 2.5 of the dCBOR specification, all text strings must be in
+ * NFC form, and decoders must reject any encoded text strings that are
+ * not in NFC.
+ */ | {
+  readonly type: "NonCanonicalString";
+}
+/**
+ * The decoded CBOR item didn't consume all input data.
+ * The parameter contains the number of unused bytes.
+ *
+ * This error occurs when decoding functions expect exactly one CBOR item
+ * but the input contains additional data after a valid CBOR item.
+ */ | {
+  readonly type: "UnusedData";
+  readonly count: number;
+}
+/**
+ * The keys in a decoded CBOR map were not in the canonical lexicographic order
+ * of their encoding.
+ *
+ * Per the CDE specification and Section 2.1 of dCBOR, map keys must be in
+ * ascending lexicographic order of their encoded representation for
+ * deterministic encoding.
+ */ | {
+  readonly type: "MisorderedMapKey";
+}
+/**
+ * A decoded CBOR map contains duplicate keys, which is invalid.
+ *
+ * Per Section 2.2 of the dCBOR specification, CBOR maps must not contain
+ * duplicate keys, and decoders must reject encoded maps with duplicate
+ * keys.
+ */ | {
+  readonly type: "DuplicateMapKey";
+}
+/**
+ * A requested key was not found in a CBOR map during data extraction.
+ */ | {
+  readonly type: "MissingMapKey";
+}
+/**
+ * A CBOR numeric value could not be represented in the specified target
+ * numeric type.
+ *
+ * This occurs when attempting to convert a CBOR number to a numeric
+ * type that is too small to represent the value without loss of
+ * precision.
+ */ | {
+  readonly type: "OutOfRange";
+}
+/**
+ * The CBOR value is not of the expected type for a conversion or
+ * operation.
+ *
+ * This occurs when attempting to convert a CBOR value to a type that
+ * doesn't match the actual CBOR item's type (e.g., trying to convert a
+ * string to an integer).
+ */ | {
+  readonly type: "WrongType";
+}
+/**
+ * The CBOR tagged value had a different tag than expected.
+ * Contains the expected tag and the actual tag found.
+ */ | {
+  readonly type: "WrongTag";
+  readonly expected: Tag;
+  readonly actual: Tag;
+}
+/**
+ * Invalid UTF‑8 in a text string.
+ */ | {
+  readonly type: "InvalidUtf8";
+  readonly message: string;
+}
+/**
+ * Invalid ISO 8601 date format.
+ */ | {
+  readonly type: "InvalidDate";
+  readonly message: string;
+}
+/**
+ * Custom error message.
+ */ | {
+  readonly type: "Custom";
+  readonly message: string;
+};
+/**
+ * Create a custom error with a message.
+ *
+ * Matches Rust's `Error::msg()` method.
+ */
+declare const errorMsg: (message: string) => Error;
+/**
+ * Convert an Error to a display string.
+ *
+ * Matches Rust's `Display` trait / `to_string()` method.
+ */
+declare const errorToString: (error: Error) => string;
+/**
+ * Result type matching Rust's `Result<T, Error>`.
+ *
+ * In TypeScript, we use a discriminated union for Result instead of
+ * try/catch for better type safety and Rust compatibility.
+ */
+type Result<T> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  error: Error;
+};
+/**
+ * Create a successful Result.
+ */
+declare const Ok: <T>(value: T) => Result<T>;
+/**
+ * Create a failed Result.
+ */
+declare const Err: <T>(error: Error) => Result<T>;
+/**
+ * Typed error class for all CBOR-related errors.
+ *
+ * Wraps the discriminated union Error type in a JavaScript Error object
+ * for proper error handling with stack traces.
+ *
+ * @example
+ * ```typescript
+ * throw new CborError({ type: 'Underrun' });
+ * throw new CborError({ type: 'WrongTag', expected: tag1, actual: tag2 });
+ * ```
+ */
+declare class CborError extends Error {
+  /**
+   * The structured error information.
+   */
+  readonly errorType: Error;
+  /**
+   * Create a new CborError.
+   *
+   * @param errorType - The discriminated union error type
+   * @param message - Optional custom message (defaults to errorToString(errorType))
+   */
+  constructor(errorType: Error, message?: string);
+  /**
+   * Check if an error is a CborError.
+   *
+   * @param error - Error to check
+   * @returns True if error is a CborError
+   */
+  static isCborError(error: unknown): error is CborError;
+}
+//#endregion
+//#region src/float.d.ts
+/**
+ * Check if a number has a fractional part.
+ */
+declare const hasFractionalPart: (n: number) => boolean;
+//#endregion
+//#region src/varint.d.ts
+declare const encodeVarInt: (value: CborNumber, majorType: MajorType) => Uint8Array;
+declare const decodeVarIntData: (dataView: DataView, offset: number) => {
+  majorType: MajorType;
+  value: CborNumber;
+  offset: number;
+};
+declare const decodeVarInt: (data: Uint8Array) => {
+  majorType: MajorType;
+  value: CborNumber;
+  offset: number;
+};
+//#endregion
+//#region src/conveniences.d.ts
+/**
+ * Extract native JavaScript value from CBOR.
+ * Converts CBOR types to their JavaScript equivalents.
+ */
+declare const extractCbor: (cbor: Cbor | Uint8Array) => unknown;
+/**
+ * Check if CBOR value is an unsigned integer.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is unsigned integer
+ *
+ * @example
+ * ```typescript
+ * if (isUnsigned(value)) {
+ *   console.log('Unsigned:', value.value);
+ * }
+ * ```
+ */
+declare const isUnsigned: (cbor: Cbor) => cbor is CborUnsignedType & CborMethods;
+/**
+ * Check if CBOR value is a negative integer.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is negative integer
+ */
+declare const isNegative: (cbor: Cbor) => cbor is CborNegativeType & CborMethods;
+/**
+ * Check if CBOR value is any integer (unsigned or negative).
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is an integer
+ */
+declare const isInteger: (cbor: Cbor) => cbor is (CborUnsignedType | CborNegativeType) & CborMethods;
+/**
+ * Check if CBOR value is a byte string.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is byte string
+ */
+declare const isBytes: (cbor: Cbor) => cbor is CborByteStringType & CborMethods;
+/**
+ * Check if CBOR value is a text string.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is text string
+ */
+declare const isText: (cbor: Cbor) => cbor is CborTextType & CborMethods;
+/**
+ * Check if CBOR value is an array.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is array
+ */
+declare const isArray: (cbor: Cbor) => cbor is CborArrayType & CborMethods;
+/**
+ * Check if CBOR value is a map.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is map
+ */
+declare const isMap: (cbor: Cbor) => cbor is CborMapType & CborMethods;
+/**
+ * Check if CBOR value is tagged.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is tagged
+ */
+declare const isTagged: (cbor: Cbor) => cbor is CborTaggedType & CborMethods;
+/**
+ * Check if CBOR value is a simple value.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is simple
+ */
+declare const isSimple: (cbor: Cbor) => cbor is CborSimpleType & CborMethods;
+/**
+ * Check if CBOR value is a boolean (true or false).
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is boolean
+ */
+declare const isBoolean: (cbor: Cbor) => cbor is CborSimpleType & CborMethods & {
+  readonly value: {
+    readonly type: "False";
+  } | {
+    readonly type: "True";
+  };
+};
+/**
+ * Check if CBOR value is null.
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is null
+ */
+declare const isNull: (cbor: Cbor) => cbor is CborSimpleType & CborMethods & {
+  readonly value: {
+    readonly type: "Null";
+  };
+};
+/**
+ * Check if CBOR value is a float (f16, f32, or f64).
+ *
+ * @param cbor - CBOR value to check
+ * @returns True if value is float
+ */
+declare const isFloat: (cbor: Cbor) => cbor is CborSimpleType & CborMethods & {
+  readonly value: {
+    readonly type: "Float";
+    readonly value: number;
+  };
+};
+/**
+ * Extract unsigned integer value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Unsigned integer or undefined
+ */
+declare const asUnsigned: (cbor: Cbor) => number | bigint | undefined;
+/**
+ * Extract negative integer value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Negative integer or undefined
+ */
+declare const asNegative: (cbor: Cbor) => number | bigint | undefined;
+/**
+ * Extract any integer value (unsigned or negative) if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Integer or undefined
+ */
+declare const asInteger: (cbor: Cbor) => number | bigint | undefined;
+/**
+ * Extract byte string value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Byte string or undefined
+ */
+declare const asBytes: (cbor: Cbor) => Uint8Array | undefined;
+/**
+ * Extract text string value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Text string or undefined
+ */
+declare const asText: (cbor: Cbor) => string | undefined;
+/**
+ * Extract array value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Array or undefined
+ */
+declare const asArray: (cbor: Cbor) => readonly Cbor[] | undefined;
+/**
+ * Extract map value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Map or undefined
+ */
+declare const asMap: (cbor: Cbor) => CborMap | undefined;
+/**
+ * Extract boolean value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Boolean or undefined
+ */
+declare const asBoolean: (cbor: Cbor) => boolean | undefined;
+/**
+ * Extract float value if type matches.
+ *
+ * @param cbor - CBOR value
+ * @returns Float or undefined
+ */
+declare const asFloat: (cbor: Cbor) => number | undefined;
+/**
+ * Extract any numeric value (integer or float).
+ *
+ * @param cbor - CBOR value
+ * @returns Number or undefined
+ */
+declare const asNumber: (cbor: Cbor) => CborNumber | undefined;
+/**
+ * Extract unsigned integer value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Unsigned integer
+ * @throws {CborError} With type 'WrongType' if cbor is not an unsigned integer
+ */
+declare const expectUnsigned: (cbor: Cbor) => number | bigint;
+/**
+ * Extract negative integer value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Negative integer
+ * @throws {CborError} With type 'WrongType' if cbor is not a negative integer
+ */
+declare const expectNegative: (cbor: Cbor) => number | bigint;
+/**
+ * Extract any integer value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Integer
+ * @throws {CborError} With type 'WrongType' if cbor is not an integer
+ */
+declare const expectInteger: (cbor: Cbor) => number | bigint;
+/**
+ * Extract byte string value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Byte string
+ * @throws {CborError} With type 'WrongType' if cbor is not a byte string
+ */
+declare const expectBytes: (cbor: Cbor) => Uint8Array;
+/**
+ * Extract text string value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Text string
+ * @throws {CborError} With type 'WrongType' if cbor is not a text string
+ */
+declare const expectText: (cbor: Cbor) => string;
+/**
+ * Extract array value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Array
+ * @throws {CborError} With type 'WrongType' if cbor is not an array
+ */
+declare const expectArray: (cbor: Cbor) => readonly Cbor[];
+/**
+ * Extract map value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Map
+ * @throws {CborError} With type 'WrongType' if cbor is not a map
+ */
+declare const expectMap: (cbor: Cbor) => CborMap;
+/**
+ * Extract boolean value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Boolean
+ * @throws {CborError} With type 'WrongType' if cbor is not a boolean
+ */
+declare const expectBoolean: (cbor: Cbor) => boolean;
+/**
+ * Extract float value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Float
+ * @throws {CborError} With type 'WrongType' if cbor is not a float
+ */
+declare const expectFloat: (cbor: Cbor) => number;
+/**
+ * Extract any numeric value, throwing if type doesn't match.
+ *
+ * @param cbor - CBOR value
+ * @returns Number
+ * @throws {CborError} With type 'WrongType' if cbor is not a number
+ */
+declare const expectNumber: (cbor: Cbor) => CborNumber;
+/**
+ * Get array item at index.
+ *
+ * @param cbor - CBOR value (must be array)
+ * @param index - Array index
+ * @returns Item at index or undefined
+ */
+declare const arrayItem: (cbor: Cbor, index: number) => Cbor | undefined;
+/**
+ * Get array length.
+ *
+ * @param cbor - CBOR value (must be array)
+ * @returns Array length or undefined
+ */
+declare const arrayLength: (cbor: Cbor) => number | undefined;
+/**
+ * Check if array is empty.
+ *
+ * @param cbor - CBOR value (must be array)
+ * @returns True if empty, false if not empty, undefined if not array
+ */
+declare const arrayIsEmpty: (cbor: Cbor) => boolean | undefined;
+/**
+ * Get map value by key.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @param key - Map key
+ * @returns Value for key or undefined
+ */
+declare function mapValue<K extends CborInput, V>(cbor: Cbor, key: K): V | undefined;
+/**
+ * Check if map has key.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @param key - Map key
+ * @returns True if key exists, false otherwise, undefined if not map
+ */
+declare function mapHas<K extends CborInput>(cbor: Cbor, key: K): boolean | undefined;
+/**
+ * Get all map keys.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @returns Array of keys or undefined
+ */
+declare const mapKeys: (cbor: Cbor) => Cbor[] | undefined;
+/**
+ * Get all map values.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @returns Array of values or undefined
+ */
+declare const mapValues: (cbor: Cbor) => Cbor[] | undefined;
+/**
+ * Get map size.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @returns Map size or undefined
+ */
+declare const mapSize: (cbor: Cbor) => number | undefined;
+/**
+ * Check if map is empty.
+ *
+ * @param cbor - CBOR value (must be map)
+ * @returns True if empty, false if not empty, undefined if not map
+ */
+declare const mapIsEmpty: (cbor: Cbor) => boolean | undefined;
+/**
+ * Get tag value from tagged CBOR.
+ *
+ * @param cbor - CBOR value (must be tagged)
+ * @returns Tag value or undefined
+ */
+declare const tagValue: (cbor: Cbor) => number | bigint | undefined;
+/**
+ * Get content from tagged CBOR.
+ *
+ * @param cbor - CBOR value (must be tagged)
+ * @returns Tagged content or undefined
+ */
+declare const tagContent: (cbor: Cbor) => Cbor | undefined;
+/**
+ * Check if CBOR has a specific tag.
+ *
+ * @param cbor - CBOR value
+ * @param tag - Tag value to check
+ * @returns True if has tag, false otherwise
+ */
+declare const hasTag: (cbor: Cbor, tag: number | bigint) => boolean;
+/**
+ * Extract content if has specific tag.
+ *
+ * @param cbor - CBOR value
+ * @param tag - Expected tag value
+ * @returns Tagged content or undefined
+ */
+declare const getTaggedContent: (cbor: Cbor, tag: number | bigint) => Cbor | undefined;
+/**
+ * Extract content if has specific tag, throwing if not.
+ *
+ * @param cbor - CBOR value
+ * @param tag - Expected tag value
+ * @returns Tagged content
+ * @throws {CborError} With type 'WrongType' if cbor is not tagged with the expected tag
+ */
+declare const expectTaggedContent: (cbor: Cbor, tag: number | bigint) => Cbor;
+/**
+ * Extract tagged value as tuple [Tag, Cbor] if CBOR is tagged.
+ * This is used by envelope for decoding.
+ *
+ * @param cbor - CBOR value
+ * @returns [Tag, Cbor] tuple or undefined
+ */
+declare const asTaggedValue: (cbor: Cbor) => [Tag, Cbor] | undefined;
+/**
+ * Alias for asBytes - extract byte string value if type matches.
+ * Named asByteString for envelope compatibility.
+ *
+ * @param cbor - CBOR value
+ * @returns Byte string or undefined
+ */
+declare const asByteString: (cbor: Cbor) => Uint8Array | undefined;
+/**
+ * A wrapper around CBOR arrays that provides a get(index) method
+ * for envelope compatibility.
+ */
+interface CborArrayWrapper {
+  readonly length: number;
+  get(index: number): Cbor | undefined;
+  [Symbol.iterator](): Iterator<Cbor>;
+}
+/**
+ * Extract array value with get() method for envelope compatibility.
+ *
+ * @param cbor - CBOR value
+ * @returns Array wrapper with get() method or undefined
+ */
+declare const asCborArray: (cbor: Cbor) => CborArrayWrapper | undefined;
+/**
+ * Alias for asMap - extract map value if type matches.
+ * Named asCborMap for envelope compatibility.
+ *
+ * @param cbor - CBOR value
+ * @returns Map or undefined
+ */
+declare const asCborMap: (cbor: Cbor) => CborMap | undefined;
+/**
+ * Check if CBOR value is any numeric type (unsigned, negative, or float).
+ *
+ * @param cbor - CBOR value
+ * @returns True if value is numeric
+ */
+declare const isNumber: (cbor: Cbor) => boolean;
+//#endregion
+export { ByteString, Cbor, type CborArrayType, type CborArrayWrapper, type CborByteStringType, type CborCodable, CborDate, type CborDecodable, type CborEncodable, CborError, type CborInput, CborMap, type CborMapType, type CborMethods, type CborNegativeType, type CborNumber, CborSet, type CborSimpleType, type CborSummarizer, type CborTagged, type CborTaggedCodable, type CborTaggedDecodable, type CborTaggedEncodable, type CborTaggedType, type CborTextType, type CborUnsignedType, type DiagFormatOpts, type EdgeType, type EdgeTypeVariant, Err, type Error, type HexFormatOpts, MajorType, type MapEntry, Ok, type Result, type Simple, TAG_BASE16, TAG_BASE64, TAG_BASE64URL, TAG_BASE64URL_TEXT, TAG_BASE64_TEXT, TAG_BIGFLOAT, TAG_BINARY_UUID, TAG_DATE, TAG_DATE_TIME_STRING, TAG_DECIMAL_FRACTION, TAG_ENCODED_CBOR, TAG_EPOCH_DATE, TAG_EPOCH_DATE_TIME, TAG_MIME_MESSAGE, TAG_NAME_DATE, TAG_NEGATIVE_BIGNUM, TAG_POSITIVE_BIGNUM, TAG_REGEXP, TAG_SELF_DESCRIBE_CBOR, TAG_SET, TAG_STRING_REF_NAMESPACE, TAG_URI, TAG_UUID, type Tag, TagsStore, type TagsStoreTrait, type Visitor, type WalkElement, arrayIsEmpty, arrayItem, arrayLength, asArray, asBoolean, asByteString, asBytes, asCborArray, asCborMap, asFloat, asInteger, asKeyValue, asMap, asNegative, asNumber, asSingle, asTaggedValue, asText, asUnsigned, bytesToHex, cbor, cborData, collectAllText, collectAtLevel, countElements, createTag, createTaggedCbor, decodeCbor, decodeVarInt, decodeVarIntData, diagnosticOpt, edgeLabel, encodeVarInt, errorMsg, errorToString, expectArray, expectBoolean, expectBoolean as tryIntoBool, expectBytes, expectBytes as tryIntoByteString, expectFloat, expectInteger, expectMap, expectNegative, expectNumber, expectTaggedContent, expectTaggedContent as tryExpectedTaggedValue, expectText, expectText as tryIntoText, expectUnsigned, extractCbor, extractTaggedContent, findFirst, getGlobalTagsStore, getTaggedContent, hasFractionalPart, hasTag, hexOpt, hexToBytes, isArray, isBoolean, isBytes, isFloat, isInteger, isMap, isNaN, isNegative, isNull, isNumber, isSimple, isTagged, isText, isUnsigned, mapHas, mapIsEmpty, mapKeys, mapSize, mapValue, mapValues, maxDepth, registerTags, registerTagsIn, simpleName, summary, tagContent, tagValue, tagsForValues, toByteString, toByteStringFromHex, toTaggedValue, validateTag };
+//# sourceMappingURL=index.d.cts.map