@bcts/dcbor 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/index.d.cts

@@ -1,5 +1,4 @@
 //#region src/map.d.ts
-
 interface MapEntry {
   readonly key: Cbor;
   readonly value: Cbor;
@@ -11,7 +10,7 @@ interface MapEntry {
  * encoded CBOR representation, ensuring deterministic encoding.
  */
 declare class CborMap {
-  #private;
+  private _dict;
   /**
    * Creates a new, empty CBOR Map.
    * Optionally initializes from a JavaScript Map.
@@ -31,6 +30,7 @@ declare class CborMap {
    * Alias for set() to match Rust's insert() method.
    */
   insert<K extends CborInput, V extends CborInput>(key: K, value: V): void;
+  private _makeKey;
   /**
    * Get a value from the map, given a key.
    * Returns undefined if the key is not present in the map.
@@ -105,6 +105,10 @@ declare class CborMap {
 //#endregion
 //#region src/simple.d.ts
 /**
+ * Copyright © 2023-2026 Blockchain Commons, LLC
+ * Copyright © 2025-2026 Parity Technologies
+ *
+ *
  * CBOR Simple Values (Major Type 7).
  *
  * @module simple
@@ -148,14 +152,28 @@ declare const simpleName: (simple: Simple) => string;
 declare const isNaN: (simple: Simple) => boolean;
 //#endregion
 //#region src/tag.d.ts
+/**
+ * Numeric tag value type alias.
+ *
+ * Mirrors Rust `pub type TagValue = u64`. Where Rust narrows to u64, TS
+ * accepts the broader `CborNumber` (`number | bigint`) since JavaScript
+ * has no native u64 — the runtime guards in `encodeVarInt` enforce the
+ * 0..=2^64-1 range.
+ */
+type TagValue = CborNumber;
 /**
  * A CBOR tag with an optional name.
  *
  * Tags consist of a numeric value and an optional human-readable name.
+ *
+ * Note on equality: Rust derives `PartialEq` on `Tag` keyed on `value`
+ * only — two tags with the same value but different names compare equal.
+ * Use {@link tagsEqual} to mirror that behaviour from TypeScript; raw
+ * `===` on `Tag` objects compares by reference.
  */
 interface Tag {
   /** The numeric tag value */
-  readonly value: CborNumber;
+  readonly value: TagValue;
   /** Optional human-readable name for the tag */
   readonly name?: string;
 }
@@ -172,7 +190,29 @@ interface Tag {
  * const customTag = createTag(12345, 'myCustomTag');
  * ```
  */
-declare const createTag: (value: CborNumber, name?: string) => Tag;
+declare const createTag: (value: TagValue, name?: string) => Tag;
+/**
+ * Create a Tag from just its numeric value, no name attached.
+ *
+ * Mirrors Rust's `Tag::with_value(v: TagValue)`.
+ */
+declare const tagWithValue: (value: TagValue) => Tag;
+/**
+ * Create a Tag with a static (string) name.
+ *
+ * In Rust this distinguishes `Tag::Static(&'static str)` from
+ * `Tag::Dynamic(String)`. TypeScript has no compile-time equivalent — both
+ * variants collapse to the same `{ value, name }` object — but the
+ * function name is preserved for API parity.
+ *
+ * Mirrors Rust's `Tag::with_static_name(v, name)`.
+ */
+declare const tagWithStaticName: (value: TagValue, name: string) => Tag;
+/**
+ * Compare two tags for equality. Mirrors Rust's `PartialEq for Tag`, which
+ * compares by `value` only and ignores the optional `name`.
+ */
+declare const tagsEqual: (a: Tag, b: Tag) => boolean;
 //#endregion
 //#region src/byte-string.d.ts
 /**
@@ -202,7 +242,7 @@ declare const createTag: (value: CborNumber, name?: string) => Tag;
  * ```
  */
 declare class ByteString {
-  #private;
+  private _data;
   /**
    * Creates a new `ByteString` from a Uint8Array or array of bytes.
    *
@@ -494,6 +534,15 @@ interface CborTaggedEncodable extends CborTagged {
  * @returns Tagged CBOR value
  */
 declare const createTaggedCbor: (encodable: CborTaggedEncodable) => Cbor;
+/**
+ * Default `taggedCborData()` implementation — `taggedCbor().toData()`.
+ *
+ * Mirrors Rust's default `tagged_cbor_data()` impl on
+ * `CBORTaggedEncodable`. TypeScript interfaces don't carry method bodies,
+ * so this helper plays the role of the Rust trait default; concrete types
+ * call it from their own `taggedCborData()` if they don't need to override.
+ */
+declare const taggedCborData: (encodable: CborTaggedEncodable) => Uint8Array;
 //#endregion
 //#region src/cbor-tagged-decodable.d.ts
 /**
@@ -634,6 +683,22 @@ declare const validateTag: (cbor: Cbor, expectedTags: Tag[]) => Tag;
  * @throws Error if the value is not tagged
  */
 declare const extractTaggedContent: (cbor: Cbor) => Cbor;
+/**
+ * Default `fromTaggedCborData()` implementation — `decodeCbor(data)` then
+ * delegate to the decodable's `fromTaggedCbor()`.
+ *
+ * Mirrors Rust's default `from_tagged_cbor_data` impl on
+ * `CBORTaggedDecodable`.
+ */
+declare function fromTaggedCborData<T>(decodable: CborTaggedDecodable<T>, data: Uint8Array): T;
+/**
+ * Default `fromUntaggedCborData()` implementation — `decodeCbor(data)`
+ * then delegate to the decodable's `fromUntaggedCbor()`.
+ *
+ * Mirrors Rust's default `from_untagged_cbor_data` impl on
+ * `CBORTaggedDecodable`.
+ */
+declare function fromUntaggedCborData<T>(decodable: CborTaggedDecodable<T>, data: Uint8Array): T;
 //#endregion
 //#region src/cbor-tagged-codable.d.ts
 /**
@@ -809,7 +874,20 @@ interface CborTagged {
  * ```
  */
 declare class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDecodable<CborDate> {
-  #private;
+  /**
+   * Canonical timestamp in seconds since the Unix epoch as a JS `number`
+   * (`f64`). dCBOR encodes Date (tag 1) as a numeric value in seconds, so
+   * keeping `_seconds` as the source of truth avoids the millisecond-only
+   * round-trip precision loss that going through a JS `Date` instance
+   * introduced in earlier versions of this port.
+   *
+   * f64 still bounds the achievable precision (~16 decimal digits, so
+   * roughly microseconds for current epoch values); Rust's
+   * `chrono::DateTime<Utc>` retains nanoseconds in memory but encodes
+   * to the same f64 over the wire, so the *encode/decode round-trip* is
+   * byte-identical.
+   */
+  private _seconds;
   /**
    * Creates a new `CborDate` from the given JavaScript `Date`.
    *
@@ -1136,17 +1214,259 @@ declare class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDec
   private constructor();
 }
 //#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/tags-store.d.ts
+/**
+ * Result type for summarizer functions, matching Rust's Result<String, Error>.
+ */
+type SummarizerResult = {
+  readonly ok: true;
+  readonly value: string;
+} | {
+  readonly ok: false;
+  readonly error: Error;
+};
 /**
  * Function type for custom CBOR value summarizers.
  *
  * Summarizers provide custom string representations for tagged values.
+ * Returns a Result type matching Rust's `Result<String, Error>`.
  *
  * @param cbor - The CBOR value to summarize
  * @param flat - If true, produce single-line output
- * @returns String summary of the value
+ * @returns Result with summary string on success, or error on failure
  */
-type CborSummarizer = (cbor: Cbor, flat: boolean) => string;
+type CborSummarizer = (cbor: Cbor, flat: boolean) => SummarizerResult;
 /**
  * Interface for tag store operations.
  */
@@ -1200,12 +1520,20 @@ interface TagsStoreTrait {
  * Stores tags with their names and optional summarizer functions.
  */
 declare class TagsStore implements TagsStoreTrait {
-  #private;
+  private readonly _tagsByValue;
+  private readonly _tagsByName;
+  private readonly _summarizers;
   constructor();
   /**
    * Insert a tag into the registry.
    *
-   * @param tag - The tag to register
+   * Matches Rust's TagsStore::insert() behavior:
+   * - Throws if the tag name is undefined or empty
+   * - Throws if a tag with the same value exists with a different name
+   * - Allows re-registering the same tag value with the same name
+   *
+   * @param tag - The tag to register (must have a non-empty name)
+   * @throws Error if tag has no name, empty name, or conflicts with existing registration
    *
    * @example
    * ```typescript
@@ -1245,13 +1573,6 @@ declare class TagsStore implements TagsStoreTrait {
    * ```
    */
   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;
@@ -1259,21 +1580,12 @@ declare class TagsStore implements TagsStoreTrait {
   nameForValue(value: CborNumber): string;
   summarizer(tag: CborNumber): CborSummarizer | undefined;
   /**
-   * Get all registered tags.
+   * Create a string key for a numeric tag value.
+   * Handles both number and bigint types.
    *
-   * @returns Array of all registered tags
-   */
-  getAllTags(): Tag[];
-  /**
-   * Clear all registered tags and summarizers.
+   * @private
    */
-  clear(): void;
-  /**
-   * Get the number of registered tags.
-   *
-   * @returns Number of tags in the registry
-   */
-  get size(): number;
+  private _valueKey;
 }
 /**
  * Get the global tags store instance.
@@ -1306,7 +1618,7 @@ declare enum EdgeType {
   /** Value within a map */
   MapValue = "map_value",
   /** Content of a tagged value */
-  TaggedContent = "tagged_content",
+  TaggedContent = "tagged_content"
 }
 /**
  * Discriminated union for edge type information.
@@ -1375,121 +1687,55 @@ 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
+ * @param element - The walk element to extract from
+ * @returns Tuple of [key, value] if keyvalue, undefined otherwise
  *
  * @example
  * ```typescript
- * const doc = cbor({
- *   title: 'Document',
- *   tags: ['urgent', 'draft'],
- *   author: { name: 'Alice' }
- * });
- *
- * const texts = collectAllText(doc);
- * // Returns: ['Document', 'urgent', 'draft', 'Alice']
+ * const element: WalkElement = { type: 'keyvalue', key: keyValue, value: valValue };
+ * const pair = asKeyValue(element); // Returns [keyValue, valValue]
  * ```
  */
-declare const collectAllText: (cbor: Cbor) => string[];
+declare const asKeyValue: (element: WalkElement) => [Cbor, Cbor] | undefined;
+/**
+ * Visitor function type.
+ *
+ * @template State - The type of state passed into each visit
+ * @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 - The state value cloned from the parent visit
+ * @returns Tuple of [newState, stopDescent] where:
+ *   - newState: The state to pass into descendants of this element. Each
+ *     descendant receives an independent clone of `newState`; sibling
+ *     subtrees do *not* see each other's mutations.
+ *   - stopDescent: If true, do not descend into children of this element.
+ */
+type Visitor<State> = (element: WalkElement, level: number, edge: EdgeTypeVariant, state: State) => [State, boolean];
 /**
- * Helper: Get the maximum depth of a CBOR tree.
+ * Walk a CBOR tree, visiting each element with a visitor function.
  *
- * @param cbor - The CBOR value to measure
- * @returns Maximum depth (0 for leaf values, 1+ for containers)
+ * The visitor function is called for each element in the tree, in depth-first order.
+ * State semantics mirror Rust's `walk_internal`:
  *
- * @example
- * ```typescript
- * const flat = cbor([1, 2, 3]);
- * console.log(maxDepth(flat)); // 1
+ * - The visitor's returned `newState` propagates **down** to descendants of
+ *   the just-visited node only.
+ * - Sibling subtrees each receive an independent clone of the parent's
+ *   post-visit state, so accumulating mutations in one subtree never leak
+ *   into a sibling.
+ * - State changes do not propagate **up**: the public `walk` returns `void`.
  *
- * const nested = cbor([[[1]]]);
- * console.log(maxDepth(nested)); // 3
- * ```
+ * For maps, the visitor is called with:
+ * 1. A 'keyvalue' element containing both key and value
+ * 2. The key individually (if descent wasn't stopped)
+ * 3. The value individually (if descent wasn't stopped)
+ *
+ * @template State - The type of state to pass into each visit
+ * @param cbor - The CBOR value to traverse
+ * @param initialState - Initial state value
+ * @param visitor - Function to call for each element
  */
-declare const maxDepth: (cbor: Cbor) => number;
+declare const walk: <State>(cbor: Cbor, initialState: State, visitor: Visitor<State>) => void;
 //#endregion
 //#region src/cbor.d.ts
 declare const MajorType: {
@@ -1671,7 +1917,7 @@ interface CborMethods {
    * @param initialState - Initial state for the visitor
    * @param visitor - Visitor function called for each element
    */
-  walk<State>(initialState: State, visitor: Visitor<State>): State;
+  walk<State>(initialState: State, visitor: Visitor<State>): void;
   /**
    * Validate that value has one of the expected tags.
    * @param expectedTags - Array of expected tag values
@@ -1684,6 +1930,17 @@ interface CborMethods {
   untagged(): Cbor;
 }
 type Cbor = (CborUnsignedType | CborNegativeType | CborByteStringType | CborTextType | CborArrayType | CborMapType | CborTaggedType | CborSimpleType) & CborMethods;
+/**
+ * Structural CBOR value equality.
+ *
+ * Mirrors Rust's `derive(PartialEq) for CBOR`. dCBOR encoding is
+ * deterministic, so two CBOR values are equal iff they encode to the
+ * same byte sequence — this is the simplest correct comparator.
+ *
+ * Use this rather than `===` (which compares JS object references) when
+ * you need value equality across two `Cbor` instances built independently.
+ */
+declare const cborEquals: (a: Cbor, b: Cbor) => boolean;
 /**
  * Convert any value to a CBOR representation.
  * Matches Rust's `From` trait implementations for CBOR.
@@ -1697,6 +1954,10 @@ 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;
+declare const cborFalse: () => Cbor;
+declare const cborTrue: () => Cbor;
+declare const cborNull: () => Cbor;
+declare const cborNaN: () => Cbor;
 /**
  * CBOR constants and helper methods.
  *
@@ -1793,7 +2054,7 @@ declare function decodeCbor(data: Uint8Array): Cbor;
  * ```
  */
 declare class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet> {
-  #private;
+  private readonly _map;
   constructor();
   /**
    * Create CborSet from array.
@@ -1846,6 +2107,20 @@ declare class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSe
    * ```
    */
   insert(value: CborInput): void;
+  /**
+   * Insert an element into the set, requiring it to be strictly greater
+   * (in canonical CBOR-encoded byte order) than every previously-inserted
+   * element. Used by the decoder to reject misordered or duplicate
+   * elements in tag-258 set encodings.
+   *
+   * Mirrors Rust `Set::insert_next` (`pub(crate)`); exposed here because
+   * TypeScript doesn't have a crate-private visibility level.
+   *
+   * @throws CborError of type `MisorderedMap` if `value` would not preserve
+   *   strict ascending CBOR-byte order, or `DuplicateMapKey` for an exact
+   *   repeat.
+   */
+  insertNext(value: CborInput): void;
   /**
    * Check if set contains an element.
    *
@@ -2079,6 +2354,16 @@ declare const TAG_POSITIVE_BIGNUM = 2;
  * Tag 3: Negative bignum (signed arbitrary-precision integer)
  */
 declare const TAG_NEGATIVE_BIGNUM = 3;
+/**
+ * Name for tag 2 (positive bignum).
+ * Matches Rust's `TAG_NAME_POSITIVE_BIGNUM`.
+ */
+declare const TAG_NAME_POSITIVE_BIGNUM = "positive-bignum";
+/**
+ * Name for tag 3 (negative bignum).
+ * Matches Rust's `TAG_NAME_NEGATIVE_BIGNUM`.
+ */
+declare const TAG_NAME_NEGATIVE_BIGNUM = "negative-bignum";
 /**
  * Tag 4: Decimal fraction [exponent, mantissa]
  */
@@ -2218,9 +2503,14 @@ interface DiagFormatOpts {
   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)
+   *
+   * Mirrors Rust's `TagsStoreOpt<'a>` enum (`Custom(&'a dyn TagsStoreTrait)`,
+   * `Global`, `None`). The TS port models the same three-way choice as a
+   * string-literal union — semantically equivalent, just stringly-typed.
+   *
+   * - `TagsStore` instance: use this specific store (Rust `Custom`)
+   * - `'global'`: use global singleton store (Rust `Global`)
+   * - `'none'`: don't resolve names; print bare tag numbers (Rust `None`)
    *
    * @default 'global'
    */
@@ -2255,6 +2545,54 @@ interface DiagFormatOpts {
  * ```
  */
 declare function diagnosticOpt(cbor: Cbor, opts?: DiagFormatOpts): string;
+/**
+ * Format CBOR value as standard diagnostic notation.
+ *
+ * @param cbor - CBOR value to format
+ * @returns Diagnostic string (pretty-printed with multiple lines for complex structures)
+ *
+ * @example
+ * ```typescript
+ * const value = cbor([1, 2, 3]);
+ * console.log(diagnostic(value));
+ * // For simple arrays: "[1, 2, 3]"
+ * // For nested structures: multi-line formatted output
+ * ```
+ */
+declare function diagnostic(cbor: Cbor): string;
+/**
+ * Format CBOR value with tag name annotations.
+ *
+ * Tagged values are displayed with their registered names instead of numeric tags.
+ *
+ * @param cbor - CBOR value to format
+ * @returns Annotated diagnostic string (pretty-printed format)
+ *
+ * @example
+ * ```typescript
+ * const date = CborDate.now().taggedCbor();
+ * console.log(diagnosticAnnotated(date));
+ * // date(1234567890) instead of 1(1234567890)
+ * ```
+ */
+declare function diagnosticAnnotated(cbor: Cbor): string;
+/**
+ * Format CBOR value as flat (single-line) diagnostic notation.
+ *
+ * Arrays and maps are formatted without line breaks.
+ *
+ * @param cbor - CBOR value to format
+ * @returns Flat diagnostic string
+ *
+ * @example
+ * ```typescript
+ * const nested = cbor([[1, 2], [3, 4]]);
+ * console.log(diagnosticFlat(nested));
+ * // "[[1, 2], [3, 4]]"
+ * ```
+ */
+declare function diagnosticFlat(cbor: Cbor): string;
+declare function diagnosticFlat(element: WalkElement): string;
 /**
  * Format CBOR value using custom summarizers for tagged values.
  *
@@ -2290,8 +2628,22 @@ interface HexFormatOpts {
 declare const bytesToHex: (bytes: Uint8Array) => string;
 /**
  * Convert hex string to bytes.
+ *
+ * **Whitespace tolerance.** This implementation strips ASCII whitespace
+ * before decoding so users can paste annotated hex dumps directly. Rust's
+ * `hex::decode` is strict and panics on any whitespace. This is a
+ * deliberate TS-side ergonomic divergence — callers who need strict
+ * Rust-compatible parsing should validate the input first (e.g.
+ * `if (/\s/.test(s)) throw …`).
  */
 declare const hexToBytes: (hexString: string) => Uint8Array;
+/**
+ * Returns the encoded hexadecimal representation of CBOR.
+ *
+ * @param cbor - CBOR value to convert
+ * @returns Hex string
+ */
+declare const hex: (cbor: Cbor) => string;
 /**
  * Returns the encoded hexadecimal representation of CBOR with options.
  *
@@ -2304,6 +2656,14 @@ declare const hexToBytes: (hexString: string) => Uint8Array;
  * @returns Hex string (possibly annotated)
  */
 declare const hexOpt: (cbor: Cbor, opts?: HexFormatOpts) => string;
+/**
+ * Returns the encoded hexadecimal representation of CBOR, with annotations.
+ *
+ * @param cbor - CBOR value to convert
+ * @param tagsStore - Optional tags store for tag name resolution
+ * @returns Annotated hex string
+ */
+declare const hexAnnotated: (cbor: Cbor, tagsStore?: TagsStore) => string;
 //#endregion
 //#region src/cbor-codable.d.ts
 /**
@@ -2453,221 +2813,144 @@ interface CborDecodable<T> {
  */
 interface CborCodable<T> extends CborEncodable, CborDecodable<T> {}
 //#endregion
-//#region src/error.d.ts
+//#region src/bignum.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.
+ * Encode a non-negative bigint as a CBOR tag 2 (positive bignum).
  *
- * 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.
+ * Matches Rust's `From<BigUint> for CBOR`.
+ *
+ * The value is always encoded as a bignum regardless of size.
+ * Zero is encoded as tag 2 with an empty byte string.
+ *
+ * @param value - A non-negative bigint (must be >= 0n)
+ * @returns CBOR tagged value
+ * @throws CborError with type OutOfRange if value is negative
  */
-{
-  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;
-}
+declare function biguintToCbor(value: bigint): Cbor;
 /**
- * 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).
+ * Encode a bigint as a CBOR tag 2 or tag 3 bignum.
  *
- * 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.
+ * Matches Rust's `From<BigInt> for CBOR`.
  *
- * 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.
+ * - Non-negative values use tag 2 (positive bignum).
+ * - Negative values use tag 3 (negative bignum), where the encoded
+ *   magnitude is `|value| - 1` per RFC 8949.
  *
- * All CBOR text strings (major type 3) must be valid UTF-8 per RFC 8949.
- */ | {
-  readonly type: "InvalidString";
-  readonly message: string;
-}
+ * @param value - Any bigint value
+ * @returns CBOR tagged value
+ */
+declare function bigintToCbor(value: bigint): Cbor;
 /**
- * A CBOR text string was not encoded in Unicode Canonical Normalization
- * Form C (NFC).
+ * Decode a BigUint from an untagged CBOR byte string.
  *
- * 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.
+ * Matches Rust's `biguint_from_untagged_cbor()`.
  *
- * 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.
+ * This function is intended for use in tag summarizers where the tag has
+ * already been stripped. It expects a CBOR byte string representing the
+ * big-endian magnitude of a positive bignum (tag 2 content).
  *
- * 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.
+ * Enforces canonical encoding: no leading zero bytes (except empty for zero).
  *
- * 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";
-}
+ * @param cbor - A CBOR value that should be a byte string
+ * @returns Non-negative bigint
+ * @throws CborError with type WrongType if not a byte string
+ * @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
+ */
+declare function biguintFromUntaggedCbor(cbor: Cbor): bigint;
 /**
- * A CBOR numeric value could not be represented in the specified target
- * numeric type.
+ * Decode a BigInt from an untagged CBOR byte string for a negative bignum.
  *
- * 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.
+ * Matches Rust's `bigint_from_negative_untagged_cbor()`.
  *
- * 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.
+ * This function is intended for use in tag summarizers where the tag has
+ * already been stripped. It expects a CBOR byte string representing `n` where
+ * the actual value is `-1 - n` (tag 3 content per RFC 8949).
  *
- * Matches Rust's `Error::msg()` method.
- */
-declare const errorMsg: (message: string) => Error;
-/**
- * Convert an Error to a display string.
+ * Enforces canonical encoding: no leading zero bytes (except single `0x00`
+ * for -1).
  *
- * Matches Rust's `Display` trait / `to_string()` method.
+ * @param cbor - A CBOR value that should be a byte string
+ * @returns Negative bigint
+ * @throws CborError with type WrongType if not a byte string
+ * @throws CborError with type NonCanonicalNumeric if encoding is non-canonical
  */
-declare const errorToString: (error: Error) => string;
+declare function bigintFromNegativeUntaggedCbor(cbor: Cbor): bigint;
 /**
- * Result type matching Rust's `Result<T, Error>`.
+ * Convert CBOR to a non-negative bigint.
  *
- * 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.
+ * Matches Rust's `TryFrom<CBOR> for BigUint`.
+ *
+ * Accepts:
+ * - Major type 0 (unsigned integer)
+ * - Tag 2 (positive bignum) with canonical byte string
+ *
+ * Rejects:
+ * - Major type 1 (negative integer) -> OutOfRange
+ * - Tag 3 (negative bignum) -> OutOfRange
+ * - Floating-point values -> WrongType
+ * - Non-canonical bignum encodings -> NonCanonicalNumeric
+ *
+ * @param cbor - The CBOR value to convert
+ * @returns Non-negative bigint
+ * @throws CborError
  */
-declare const Ok: <T>(value: T) => Result<T>;
+declare function cborToBiguint(cbor: Cbor): bigint;
 /**
- * Create a failed Result.
+ * Convert CBOR to a bigint (any sign).
+ *
+ * Matches Rust's `TryFrom<CBOR> for BigInt`.
+ *
+ * Accepts:
+ * - Major type 0 (unsigned integer)
+ * - Major type 1 (negative integer)
+ * - Tag 2 (positive bignum) with canonical byte string
+ * - Tag 3 (negative bignum) with canonical byte string
+ *
+ * Rejects:
+ * - Floating-point values -> WrongType
+ * - Non-canonical bignum encodings -> NonCanonicalNumeric
+ *
+ * @param cbor - The CBOR value to convert
+ * @returns A bigint value
+ * @throws CborError
  */
-declare const Err: <T>(error: Error) => Result<T>;
+declare function cborToBigint(cbor: Cbor): bigint;
+//#endregion
+//#region src/sortable.d.ts
 /**
- * Typed error class for all CBOR-related errors.
+ * Return a new array sorted by the bytewise lexicographic order of each
+ * element's CBOR encoding.
  *
- * Wraps the discriminated union Error type in a JavaScript Error object
- * for proper error handling with stack traces.
+ * Mirrors Rust `pub fn sort_array_by_cbor_encoding<T>(array)`.
  *
  * @example
  * ```typescript
- * throw new CborError({ type: 'Underrun' });
- * throw new CborError({ type: 'WrongTag', expected: tag1, actual: tag2 });
+ * const sorted = sortArrayByCborEncoding([3, 1, 2]); // [1, 2, 3]
  * ```
  */
-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;
+declare function sortArrayByCborEncoding<T extends CborInput>(array: readonly T[]): T[];
+/**
+ * Sortable-by-CBOR-encoding trait shape.
+ *
+ * Mirrors Rust `pub trait CBORSortable<T> { fn sort_by_cbor_encoding(&self)
+ * -> Vec<T>; }` with blanket implementations for `Vec<T>`, `&[T]`,
+ * `HashSet<T>`. In TypeScript we expose a narrow interface plus
+ * `arraySortable` / `setSortable` helpers that wrap any iterable into a
+ * `CBORSortable` view.
+ */
+interface CBORSortable<T extends CborInput> {
+  sortByCborEncoding(): T[];
 }
+/**
+ * Wrap a readonly array as a {@link CBORSortable}. Equivalent to Rust's
+ * blanket `impl CBORSortable<T> for Vec<T>` / `for &[T]`.
+ */
+declare function arraySortable<T extends CborInput>(array: readonly T[]): CBORSortable<T>;
+/**
+ * Wrap a `Set<T>` as a {@link CBORSortable}. Equivalent to Rust's
+ * `impl CBORSortable<T> for HashSet<T>`.
+ */
+declare function setSortable<T extends CborInput>(set: ReadonlySet<T>): CBORSortable<T>;
 //#endregion
 //#region src/float.d.ts
 /**
@@ -3049,10 +3332,13 @@ declare const getTaggedContent: (cbor: Cbor, tag: number | bigint) => Cbor | und
 /**
  * Extract content if has specific tag, throwing if not.
  *
+ * Mirrors Rust `try_into_expected_tagged_value`. Throws `{ type: "WrongType" }`
+ * if `cbor` is not tagged at all, otherwise `{ type: "WrongTag", expected,
+ * actual }` if the tag doesn't match.
+ *
  * @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;
 /**
@@ -3103,5 +3389,5 @@ declare const asCborMap: (cbor: Cbor) => CborMap | undefined;
  */
 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 };
+export { ByteString, type CBORSortable, 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, type SummarizerResult, 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_NAME_NEGATIVE_BIGNUM, TAG_NAME_POSITIVE_BIGNUM, TAG_NEGATIVE_BIGNUM, TAG_POSITIVE_BIGNUM, TAG_REGEXP, TAG_SELF_DESCRIBE_CBOR, TAG_SET, TAG_STRING_REF_NAMESPACE, TAG_URI, TAG_UUID, type Tag, type TagValue, TagsStore, type TagsStoreTrait, type Visitor, type WalkElement, arrayIsEmpty, arrayItem, arrayLength, arraySortable, asArray, asBoolean, asByteString, asBytes, asCborArray, asCborMap, asFloat, asInteger, asKeyValue, asMap, asNegative, asNumber, asSingle, asTaggedValue, asText, asUnsigned, bigintFromNegativeUntaggedCbor, bigintToCbor, biguintFromUntaggedCbor, biguintToCbor, bytesToHex, cbor, cborData, cborEquals, cborFalse, cborNaN, cborNull, cborToBigint, cborToBiguint, cborTrue, createTag, createTaggedCbor, decodeCbor, decodeVarInt, decodeVarIntData, diagnostic, diagnosticAnnotated, diagnosticFlat, 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, fromTaggedCborData, fromUntaggedCborData, getGlobalTagsStore, getTaggedContent, hasFractionalPart, hasTag, hex, hexAnnotated, hexOpt, hexToBytes, isArray, isBoolean, isBytes, isFloat, isInteger, isMap, isNaN, isNegative, isNull, isNumber, isSimple, isTagged, isText, isUnsigned, mapHas, mapIsEmpty, mapKeys, mapSize, mapValue, mapValues, registerTags, registerTagsIn, setSortable, simpleName, sortArrayByCborEncoding, summary, tagContent, tagValue, tagWithStaticName, tagWithValue, taggedCborData, tagsEqual, tagsForValues, toByteString, toByteStringFromHex, toTaggedValue, validateTag, walk };
 //# sourceMappingURL=index.d.cts.map