@bcts/known-values 1.0.0-alpha.10

package/dist/index.d.mts

@@ -0,0 +1,664 @@
+import * as _bcts_dcbor0 from "@bcts/dcbor";
+import { Cbor, CborTaggedDecodable, CborTaggedEncodable, Tag } from "@bcts/dcbor";
+
+//#region src/known-value.d.ts
+
+/**
+ * The numeric value for the CBOR tag used for Known Values.
+ * This is Tag 40000 as defined in the Blockchain Commons registry.
+ */
+declare const TAG_KNOWN_VALUE: _bcts_dcbor0.CborNumber;
+/**
+ * The CBOR tag used for Known Values.
+ * This is Tag 40000 as defined in the Blockchain Commons registry.
+ */
+declare const KNOWN_VALUE_TAG: Tag;
+/**
+ * Type for values that can be used to create a KnownValue.
+ * Supports both number (for values up to 2^53-1) and bigint (for full 64-bit range).
+ */
+type KnownValueInput = number | bigint;
+declare class KnownValue implements CborTaggedEncodable, CborTaggedDecodable<KnownValue> {
+  private readonly _value;
+  private readonly _assignedName;
+  /**
+   * Creates a new KnownValue with the given numeric value and optional name.
+   *
+   * @param value - The numeric value (number or bigint). Numbers are converted to bigint internally.
+   * @param assignedName - Optional human-readable name for the value
+   *
+   * @example
+   * ```typescript
+   * const knownValue = new KnownValue(42);
+   * console.log(knownValue.value()); // 42
+   *
+   * const namedValue = new KnownValue(1, 'isA');
+   * console.log(namedValue.name()); // "isA"
+   *
+   * // Using bigint for large values
+   * const largeValue = new KnownValue(9007199254740993n);
+   * ```
+   */
+  constructor(value: KnownValueInput, assignedName?: string);
+  /**
+   * Returns the numeric value of the KnownValue.
+   *
+   * This is the raw unsigned integer that identifies the concept.
+   * Returns a number for backward compatibility. For values > MAX_SAFE_INTEGER,
+   * use `valueBigInt()`.
+   *
+   * @example
+   * ```typescript
+   * import { IS_A, NOTE } from '@bcts/known-values';
+   * console.log(IS_A.value()); // 1
+   * console.log(NOTE.value()); // 4
+   * ```
+   */
+  value(): number;
+  /**
+   * Returns the numeric value of the KnownValue as a bigint.
+   *
+   * Use this for values that may exceed Number.MAX_SAFE_INTEGER (2^53-1).
+   *
+   * @example
+   * ```typescript
+   * const largeValue = new KnownValue(9007199254740993n);
+   * console.log(largeValue.valueBigInt()); // 9007199254740993n
+   * ```
+   */
+  valueBigInt(): bigint;
+  /**
+   * Returns the assigned name of the KnownValue, if one exists.
+   *
+   * @example
+   * ```typescript
+   * const namedValue = new KnownValue(1, 'isA');
+   * console.log(namedValue.assignedName()); // "isA"
+   *
+   * const unnamedValue = new KnownValue(42);
+   * console.log(unnamedValue.assignedName()); // undefined
+   * ```
+   */
+  assignedName(): string | undefined;
+  /**
+   * Returns a human-readable name for the KnownValue.
+   *
+   * If the KnownValue has an assigned name, that name is returned.
+   * Otherwise, the string representation of the numeric value is returned.
+   *
+   * @example
+   * ```typescript
+   * const namedValue = new KnownValue(1, 'isA');
+   * console.log(namedValue.name()); // "isA"
+   *
+   * const unnamedValue = new KnownValue(42);
+   * console.log(unnamedValue.name()); // "42"
+   * ```
+   */
+  name(): string;
+  /**
+   * Compares this KnownValue with another for equality.
+   * Equality is based solely on the numeric value, ignoring the name.
+   *
+   * @param other - The KnownValue to compare with
+   * @returns true if the values are equal
+   *
+   * @example
+   * ```typescript
+   * const kv1 = new KnownValue(1, 'isA');
+   * const kv2 = new KnownValue(1, 'different');
+   * console.log(kv1.equals(kv2)); // true (same value, different name)
+   * ```
+   */
+  equals(other: KnownValue): boolean;
+  /**
+   * Hash code based on the numeric value.
+   * Useful for using KnownValue in hash-based collections.
+   */
+  hashCode(): number;
+  /**
+   * String representation of the KnownValue.
+   *
+   * If a name is assigned, the name is displayed. Otherwise, the numeric value
+   * is displayed.
+   */
+  toString(): string;
+  /**
+   * Returns the CBOR tags associated with KnownValue.
+   *
+   * The primary tag is TAG_KNOWN_VALUE (201).
+   *
+   * @returns Array containing the KnownValue tag
+   */
+  cborTags(): Tag[];
+  /**
+   * Returns the untagged CBOR encoding of this KnownValue.
+   *
+   * The untagged representation is simply the unsigned integer value.
+   *
+   * @returns CBOR representation of the value (unsigned integer)
+   */
+  untaggedCbor(): Cbor;
+  /**
+   * Returns the tagged CBOR encoding of this KnownValue.
+   *
+   * This wraps the unsigned integer value with tag 201.
+   *
+   * @returns Tagged CBOR representation
+   *
+   * @example
+   * ```typescript
+   * const kv = new KnownValue(1, 'isA');
+   * const tagged = kv.taggedCbor();
+   * console.log(tagged.toHex()); // "d8c901" (tag 201, value 1)
+   * ```
+   */
+  taggedCbor(): Cbor;
+  /**
+   * Returns the tagged CBOR encoding as binary data.
+   *
+   * @returns Binary CBOR representation
+   *
+   * @example
+   * ```typescript
+   * const kv = new KnownValue(1, 'isA');
+   * const bytes = kv.toCborData();
+   * // bytes is Uint8Array containing the CBOR encoding
+   * ```
+   */
+  toCborData(): Uint8Array;
+  /**
+   * Alias for `toCborData()` to match the dcbor interface.
+   */
+  taggedCborData(): Uint8Array;
+  /**
+   * Creates a KnownValue from untagged CBOR (an unsigned integer).
+   * Instance method for interface compliance.
+   *
+   * @param cborValue - The CBOR value (must be an unsigned integer)
+   * @returns A new KnownValue
+   * @throws {Error} If the CBOR is not an unsigned integer
+   */
+  fromUntaggedCbor(cborValue: Cbor): KnownValue;
+  /**
+   * Creates a KnownValue from tagged CBOR (tag 201).
+   * Instance method for interface compliance.
+   *
+   * @param cborValue - The tagged CBOR value
+   * @returns A new KnownValue
+   * @throws {Error} If the CBOR is not properly tagged or contains invalid data
+   */
+  fromTaggedCbor(cborValue: Cbor): KnownValue;
+  /**
+   * Creates a KnownValue from untagged CBOR (an unsigned integer).
+   *
+   * @param cborValue - The CBOR value (must be an unsigned integer)
+   * @returns A new KnownValue
+   * @throws {Error} If the CBOR is not an unsigned integer
+   *
+   * @example
+   * ```typescript
+   * const cborValue = cbor(42);
+   * const kv = KnownValue.fromUntaggedCbor(cborValue);
+   * console.log(kv.value()); // 42
+   * ```
+   */
+  static fromUntaggedCbor(cborValue: Cbor): KnownValue;
+  /**
+   * Creates a KnownValue from tagged CBOR (tag 201).
+   *
+   * @param cborValue - The tagged CBOR value
+   * @returns A new KnownValue
+   * @throws {Error} If the CBOR is not properly tagged or contains invalid data
+   *
+   * @example
+   * ```typescript
+   * const kv = KnownValue.fromTaggedCbor(taggedCborValue);
+   * ```
+   */
+  static fromTaggedCbor(cborValue: Cbor): KnownValue;
+  /**
+   * Creates a KnownValue from binary CBOR data.
+   *
+   * @param data - Binary CBOR data (must be a tagged KnownValue)
+   * @returns A new KnownValue
+   * @throws {Error} If the data cannot be decoded or is not a valid KnownValue
+   *
+   * @example
+   * ```typescript
+   * const bytes = new Uint8Array([0xd8, 0xc9, 0x01]); // tag 201, value 1
+   * const kv = KnownValue.fromCborData(bytes);
+   * console.log(kv.value()); // 1
+   * ```
+   */
+  static fromCborData(data: Uint8Array): KnownValue;
+  /**
+   * Creates a KnownValue from a CBOR value, automatically detecting
+   * whether it's tagged or untagged.
+   *
+   * @param cborValue - The CBOR value (tagged or untagged)
+   * @returns A new KnownValue
+   * @throws {Error} If the CBOR cannot be converted to a KnownValue
+   *
+   * @example
+   * ```typescript
+   * // Works with both tagged and untagged
+   * const kv1 = KnownValue.fromCbor(cbor(42));
+   * const kv2 = KnownValue.fromCbor(taggedCborValue);
+   * ```
+   */
+  static fromCbor(cborValue: Cbor): KnownValue;
+}
+//#endregion
+//#region src/known-values-store.d.ts
+/**
+ * A store that maps between Known Values and their assigned names.
+ *
+ * The `KnownValuesStore` provides a bidirectional mapping between:
+ * - Numeric values (bigint) and their corresponding KnownValue instances
+ * - String names and their corresponding KnownValue instances
+ *
+ * This enables efficient lookup in both directions, making it possible to:
+ * - Find the name for a given numeric value
+ * - Find the numeric value for a given name
+ * - Retrieve complete KnownValue instances by either name or value
+ *
+ * The store is typically populated with predefined Known Values from the
+ * registry, but can also be extended with custom values.
+ *
+ * @example
+ * ```typescript
+ * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+ *
+ * // Create a store with predefined Known Values
+ * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+ *
+ * // Look up a Known Value by name
+ * const isA = store.knownValueNamed('isA');
+ * console.log(isA?.value()); // 1
+ *
+ * // Look up a name for a raw value
+ * const name = store.name(new KnownValue(3));
+ * console.log(name); // "signed"
+ *
+ * // Insert a custom Known Value
+ * const customStore = store.clone();
+ * customStore.insert(new KnownValue(100, 'customValue'));
+ * console.log(customStore.knownValueNamed('customValue')?.value()); // 100
+ * ```
+ */
+declare class KnownValuesStore {
+  private knownValuesByRawValue;
+  private knownValuesByAssignedName;
+  /**
+   * Creates a new KnownValuesStore with the provided Known Values.
+   *
+   * This constructor takes an iterable of KnownValue instances and
+   * populates the store with them, creating mappings from both raw
+   * values and names to the corresponding KnownValue instances.
+   *
+   * @param knownValues - Iterable of KnownValue instances to populate the store
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';
+   *
+   * // Create a store with predefined Known Values
+   * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);
+   *
+   * // Look up Known Values
+   * console.log(store.knownValueNamed('isA')?.value()); // 1
+   * console.log(store.knownValueNamed('note')?.value()); // 4
+   * ```
+   */
+  constructor(knownValues?: Iterable<KnownValue>);
+  /**
+   * Inserts a KnownValue into the store.
+   *
+   * If the KnownValue has an assigned name, it will be indexed by both its
+   * raw value and its name. If a KnownValue with the same raw value or name
+   * already exists in the store, it will be replaced.
+   *
+   * @param knownValue - The KnownValue to insert
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, KnownValue } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore();
+   * store.insert(new KnownValue(100, 'customValue'));
+   * console.log(store.knownValueNamed('customValue')?.value()); // 100
+   * ```
+   */
+  insert(knownValue: KnownValue): void;
+  /**
+   * Returns the assigned name for a KnownValue, if present in the store.
+   *
+   * @param knownValue - The KnownValue to look up
+   * @returns The assigned name, or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   * console.log(store.assignedName(IS_A)); // "isA"
+   * console.log(store.assignedName(new KnownValue(999))); // undefined
+   * ```
+   */
+  assignedName(knownValue: KnownValue): string | undefined;
+  /**
+   * Returns a human-readable name for a KnownValue.
+   *
+   * If the KnownValue has an assigned name in the store, that name is
+   * returned. Otherwise, the KnownValue's default name (which may be its
+   * numeric value as a string) is returned.
+   *
+   * @param knownValue - The KnownValue to get the name for
+   * @returns The name (assigned or numeric)
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   * console.log(store.name(IS_A)); // "isA"
+   * console.log(store.name(new KnownValue(999))); // "999"
+   * ```
+   */
+  name(knownValue: KnownValue): string;
+  /**
+   * Looks up a KnownValue by its assigned name.
+   *
+   * Returns the KnownValue if found, or undefined if no KnownValue
+   * with the given name exists in the store.
+   *
+   * @param assignedName - The name to look up
+   * @returns The KnownValue, or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   *
+   * const isA = store.knownValueNamed('isA');
+   * console.log(isA?.value()); // 1
+   *
+   * console.log(store.knownValueNamed('nonexistent')); // undefined
+   * ```
+   */
+  knownValueNamed(assignedName: string): KnownValue | undefined;
+  /**
+   * Looks up a KnownValue by its raw numeric value.
+   *
+   * @param rawValue - The numeric value to look up (number or bigint)
+   * @returns The KnownValue, or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   * const isA = store.knownValueForValue(1);
+   * console.log(isA?.name()); // "isA"
+   * ```
+   */
+  knownValueForValue(rawValue: KnownValueInput): KnownValue | undefined;
+  /**
+   * Retrieves a KnownValue for a raw value, using a store if provided.
+   *
+   * This static method allows looking up a KnownValue by its raw numeric
+   * value:
+   * - If a store is provided and contains a mapping for the raw value, that
+   *   KnownValue is returned
+   * - Otherwise, a new KnownValue with no assigned name is created and
+   *   returned
+   *
+   * @param rawValue - The numeric value to look up (number or bigint)
+   * @param knownValues - Optional store to search in
+   * @returns The KnownValue from the store or a new unnamed KnownValue
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   *
+   * // Known value from store
+   * const isA = KnownValuesStore.knownValueForRawValue(1, store);
+   * console.log(isA.name()); // "isA"
+   *
+   * // Unknown value creates a new KnownValue
+   * const unknown = KnownValuesStore.knownValueForRawValue(999, store);
+   * console.log(unknown.name()); // "999"
+   *
+   * // No store provided also creates a new KnownValue
+   * const unknown2 = KnownValuesStore.knownValueForRawValue(1, undefined);
+   * console.log(unknown2.name()); // "1"
+   * ```
+   */
+  static knownValueForRawValue(rawValue: KnownValueInput, knownValues?: KnownValuesStore): KnownValue;
+  /**
+   * Attempts to find a KnownValue by its name, using a store if provided.
+   *
+   * This static method allows looking up a KnownValue by its name:
+   * - If a store is provided and contains a mapping for the name, that
+   *   KnownValue is returned
+   * - Otherwise, undefined is returned
+   *
+   * @param name - The name to look up
+   * @param knownValues - Optional store to search in
+   * @returns The KnownValue if found, or undefined
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   *
+   * // Known value from store
+   * const isA = KnownValuesStore.knownValueForName('isA', store);
+   * console.log(isA?.value()); // 1
+   *
+   * // Unknown name returns undefined
+   * console.log(KnownValuesStore.knownValueForName('unknown', store)); // undefined
+   *
+   * // No store provided also returns undefined
+   * console.log(KnownValuesStore.knownValueForName('isA', undefined)); // undefined
+   * ```
+   */
+  static knownValueForName(name: string, knownValues?: KnownValuesStore): KnownValue | undefined;
+  /**
+   * Returns a human-readable name for a KnownValue, using a store if provided.
+   *
+   * This static method allows getting a name for a KnownValue:
+   * - If a store is provided and contains a mapping for the KnownValue, its
+   *   assigned name is returned
+   * - Otherwise, the KnownValue's default name (which may be its numeric
+   *   value as a string) is returned
+   *
+   * @param knownValue - The KnownValue to get the name for
+   * @param knownValues - Optional store to use for lookup
+   * @returns The name (assigned or numeric)
+   *
+   * @example
+   * ```typescript
+   * import { KnownValuesStore, IS_A } from '@bcts/known-values';
+   *
+   * const store = new KnownValuesStore([IS_A]);
+   *
+   * // Known value from store
+   * let name = KnownValuesStore.nameForKnownValue(IS_A, store);
+   * console.log(name); // "isA"
+   *
+   * // Unknown value in store uses KnownValue's name method
+   * name = KnownValuesStore.nameForKnownValue(new KnownValue(999), store);
+   * console.log(name); // "999"
+   *
+   * // No store provided also uses KnownValue's name method
+   * name = KnownValuesStore.nameForKnownValue(IS_A, undefined);
+   * console.log(name); // "isA"
+   * ```
+   */
+  static nameForKnownValue(knownValue: KnownValue, knownValues?: KnownValuesStore): string;
+  /**
+   * Creates a shallow clone of this store.
+   *
+   * @returns A new KnownValuesStore with the same entries
+   */
+  clone(): KnownValuesStore;
+  /**
+   * Internal helper method to insert a KnownValue into the store's maps.
+   */
+  private _insert;
+}
+//#endregion
+//#region src/known-values-registry.d.ts
+declare const UNIT: KnownValue;
+declare const IS_A: KnownValue;
+declare const ID: KnownValue;
+declare const SIGNED: KnownValue;
+declare const NOTE: KnownValue;
+declare const HAS_RECIPIENT: KnownValue;
+declare const SSKR_SHARE: KnownValue;
+declare const CONTROLLER: KnownValue;
+declare const KEY: KnownValue;
+declare const DEREFERENCE_VIA: KnownValue;
+declare const ENTITY: KnownValue;
+declare const NAME: KnownValue;
+declare const LANGUAGE: KnownValue;
+declare const ISSUER: KnownValue;
+declare const HOLDER: KnownValue;
+declare const SALT: KnownValue;
+declare const DATE: KnownValue;
+declare const UNKNOWN_VALUE: KnownValue;
+declare const VERSION_VALUE: KnownValue;
+declare const HAS_SECRET: KnownValue;
+declare const DIFF_EDITS: KnownValue;
+declare const VALID_FROM: KnownValue;
+declare const VALID_UNTIL: KnownValue;
+declare const POSITION: KnownValue;
+declare const NICKNAME: KnownValue;
+declare const ATTACHMENT: KnownValue;
+declare const VENDOR: KnownValue;
+declare const CONFORMS_TO: KnownValue;
+declare const ALLOW: KnownValue;
+declare const DENY: KnownValue;
+declare const ENDPOINT: KnownValue;
+declare const DELEGATE: KnownValue;
+declare const PROVENANCE: KnownValue;
+declare const PRIVATE_KEY: KnownValue;
+declare const SERVICE: KnownValue;
+declare const CAPABILITY: KnownValue;
+declare const PROVENANCE_GENERATOR: KnownValue;
+declare const PRIVILEGE_ALL: KnownValue;
+declare const PRIVILEGE_AUTH: KnownValue;
+declare const PRIVILEGE_SIGN: KnownValue;
+declare const PRIVILEGE_ENCRYPT: KnownValue;
+declare const PRIVILEGE_ELIDE: KnownValue;
+declare const PRIVILEGE_ISSUE: KnownValue;
+declare const PRIVILEGE_ACCESS: KnownValue;
+declare const PRIVILEGE_DELEGATE: KnownValue;
+declare const PRIVILEGE_VERIFY: KnownValue;
+declare const PRIVILEGE_UPDATE: KnownValue;
+declare const PRIVILEGE_TRANSFER: KnownValue;
+declare const PRIVILEGE_ELECT: KnownValue;
+declare const PRIVILEGE_BURN: KnownValue;
+declare const PRIVILEGE_REVOKE: KnownValue;
+declare const BODY: KnownValue;
+declare const RESULT: KnownValue;
+declare const ERROR: KnownValue;
+declare const OK_VALUE: KnownValue;
+declare const PROCESSING_VALUE: KnownValue;
+declare const SENDER: KnownValue;
+declare const SENDER_CONTINUATION: KnownValue;
+declare const RECIPIENT_CONTINUATION: KnownValue;
+declare const CONTENT: KnownValue;
+declare const SEED_TYPE: KnownValue;
+declare const PRIVATE_KEY_TYPE: KnownValue;
+declare const PUBLIC_KEY_TYPE: KnownValue;
+declare const MASTER_KEY_TYPE: KnownValue;
+declare const ASSET: KnownValue;
+declare const BITCOIN_VALUE: KnownValue;
+declare const ETHEREUM_VALUE: KnownValue;
+declare const TEZOS_VALUE: KnownValue;
+declare const NETWORK: KnownValue;
+declare const MAIN_NET_VALUE: KnownValue;
+declare const TEST_NET_VALUE: KnownValue;
+declare const BIP32_KEY_TYPE: KnownValue;
+declare const CHAIN_CODE: KnownValue;
+declare const DERIVATION_PATH_TYPE: KnownValue;
+declare const PARENT_PATH: KnownValue;
+declare const CHILDREN_PATH: KnownValue;
+declare const PARENT_FINGERPRINT: KnownValue;
+declare const PSBT_TYPE: KnownValue;
+declare const OUTPUT_DESCRIPTOR_TYPE: KnownValue;
+declare const OUTPUT_DESCRIPTOR: KnownValue;
+declare const GRAPH: KnownValue;
+declare const SOURCE_TARGET_GRAPH: KnownValue;
+declare const PARENT_CHILD_GRAPH: KnownValue;
+declare const DIGRAPH: KnownValue;
+declare const ACYCLIC_GRAPH: KnownValue;
+declare const MULTIGRAPH: KnownValue;
+declare const PSEUDOGRAPH: KnownValue;
+declare const GRAPH_FRAGMENT: KnownValue;
+declare const DAG: KnownValue;
+declare const TREE: KnownValue;
+declare const FOREST: KnownValue;
+declare const COMPOUND_GRAPH: KnownValue;
+declare const HYPERGRAPH: KnownValue;
+declare const DIHYPERGRAPH: KnownValue;
+declare const NODE: KnownValue;
+declare const EDGE: KnownValue;
+declare const SOURCE: KnownValue;
+declare const TARGET: KnownValue;
+declare const PARENT: KnownValue;
+declare const CHILD: KnownValue;
+/**
+ * A lazily initialized singleton that holds the global registry of known
+ * values.
+ *
+ * This class provides thread-safe, lazy initialization of the global
+ * KnownValuesStore that contains all the predefined Known Values in the
+ * registry. The store is created only when first accessed, and subsequent
+ * accesses reuse the same instance.
+ *
+ * This is used internally by the crate and should not typically be needed by
+ * users of the API, who should access Known Values through the constants
+ * exposed in the `known_values` module.
+ */
+declare class LazyKnownValues {
+  private _data;
+  /**
+   * Gets the global KnownValuesStore, initializing it if necessary.
+   *
+   * This method guarantees that initialization occurs exactly once.
+   */
+  get(): KnownValuesStore;
+}
+/**
+ * The global registry of Known Values.
+ *
+ * This static instance provides access to all standard Known Values defined in
+ * the registry specification. It is lazily initialized on first access.
+ *
+ * Most users should not need to interact with this directly, as the predefined
+ * Known Values are exposed as constants in the `known_values` module.
+ *
+ * @example
+ * ```typescript
+ * import { KNOWN_VALUES } from '@bcts/known-values';
+ *
+ * // Access the global store
+ * const knownValues = KNOWN_VALUES.get();
+ *
+ * // Look up a Known Value by name
+ * const isA = knownValues.knownValueNamed('isA');
+ * console.log(isA?.value()); // 1
+ * ```
+ */
+declare const KNOWN_VALUES: LazyKnownValues;
+//#endregion
+export { ACYCLIC_GRAPH, ALLOW, ASSET, ATTACHMENT, BIP32_KEY_TYPE, BITCOIN_VALUE, BODY, CAPABILITY, CHAIN_CODE, CHILD, CHILDREN_PATH, COMPOUND_GRAPH, CONFORMS_TO, CONTENT, CONTROLLER, DAG, DATE, DELEGATE, DENY, DEREFERENCE_VIA, DERIVATION_PATH_TYPE, DIFF_EDITS, DIGRAPH, DIHYPERGRAPH, EDGE, ENDPOINT, ENTITY, ERROR, ETHEREUM_VALUE, FOREST, GRAPH, GRAPH_FRAGMENT, HAS_RECIPIENT, HAS_SECRET, HOLDER, HYPERGRAPH, ID, ISSUER, IS_A, KEY, KNOWN_VALUES, KNOWN_VALUE_TAG, KnownValue, type KnownValueInput, KnownValuesStore, LANGUAGE, LazyKnownValues, MAIN_NET_VALUE, MASTER_KEY_TYPE, MULTIGRAPH, NAME, NETWORK, NICKNAME, NODE, NOTE, OK_VALUE, OUTPUT_DESCRIPTOR, OUTPUT_DESCRIPTOR_TYPE, PARENT, PARENT_CHILD_GRAPH, PARENT_FINGERPRINT, PARENT_PATH, POSITION, PRIVATE_KEY, PRIVATE_KEY_TYPE, PRIVILEGE_ACCESS, PRIVILEGE_ALL, PRIVILEGE_AUTH, PRIVILEGE_BURN, PRIVILEGE_DELEGATE, PRIVILEGE_ELECT, PRIVILEGE_ELIDE, PRIVILEGE_ENCRYPT, PRIVILEGE_ISSUE, PRIVILEGE_REVOKE, PRIVILEGE_SIGN, PRIVILEGE_TRANSFER, PRIVILEGE_UPDATE, PRIVILEGE_VERIFY, PROCESSING_VALUE, PROVENANCE, PROVENANCE_GENERATOR, PSBT_TYPE, PSEUDOGRAPH, PUBLIC_KEY_TYPE, RECIPIENT_CONTINUATION, RESULT, SALT, SEED_TYPE, SENDER, SENDER_CONTINUATION, SERVICE, SIGNED, SOURCE, SOURCE_TARGET_GRAPH, SSKR_SHARE, TAG_KNOWN_VALUE, TARGET, TEST_NET_VALUE, TEZOS_VALUE, TREE, UNIT, UNKNOWN_VALUE, VALID_FROM, VALID_UNTIL, VENDOR, VERSION_VALUE };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/known-value.ts","../src/known-values-store.ts","../src/known-values-registry.ts"],"sourcesContent":[],"mappings":"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2EqD;AAsBvD,cEhGR,UFgGQ,EEhGE,UFgGF;AAoGL,cEnMH,GFmMG,EEnMA,UFmMA;AAkCF,cEpOD,eFoOC,EEpOc,UFoOd;AAWI,cE9OL,MF8OK,EE9OC,UF8OD;AAkBF,cE/PH,IF+PG,EE/PC,UF+PD;AAmBA,cEjRH,QFiRG,EEjRK,UFiRL;AAOI,cEvRP,MFuRO,EEvRD,UFuRC;AAgBU,cEtSjB,MFsSiB,EEtSX,UFsSW;AAAO,cErSxB,IFqSwB,EErSpB,UFqSoB;AAYT,cEhTf,IFgTe,EEhTX,UFgTW;AAAO,cE/StB,aF+SsB,EE/ST,UF+SS;AAsBE,cEpUxB,aFoUwB,EEpUX,UFoUW;AAAO,cEnU/B,UFmU+B,EEnUrB,UFmUqB;AAoBT,cEtVtB,UFsVsB,EEtVZ,UFsVY;AAAO,cErV7B,UFqV6B,EErVnB,UFqVmB;AA2Bd,cE/Wf,WF+We,EE/WJ,UF+WI;AAAa,cE9W5B,QF8W4B,EE9WpB,UF8WoB;AAoBZ,cEjYhB,QFiYgB,EEjYR,UFiYQ;AAAO,cE1XvB,UF0XuB,EE1Xb,UF0Xa;AAxUD,cEjDtB,MFiDsB,EEjDhB,UFiDgB;AAAqB,cEhD3C,WFgD2C,EEhDhC,UFgDgC;AAAmB,cEzC9D,KFyC8D,EEzCzD,UFyCyD;cExC9D,MAAI;cACJ,UAAQ;cACR,UAAQ;ADdR,cCeA,UDfgB,ECeN,UDfM;AA0BO,cCVvB,WDUuB,ECVZ,UDUY;AAAT,cCTd,ODSc,ECTP,UDSO;AA2BN,cCnCR,UDmCQ,ECnCE,UDmCF;AAmBM,cCrDd,oBDqDc,ECrDM,UDqDN;AAuBR,cCrEN,aDqEM,ECrEO,UDqEP;AA0BsB,cC9F5B,cD8F4B,EC9Fd,UD8Fc;AAmBV,cChHlB,cDgHkB,EChHJ,UDgHI;AAAkB,cC/GpC,iBD+GoC,EC/GnB,UD+GmB;AAuCnC,cCrJD,eDqJC,ECrJc,UDqJd;AACI,cCrJL,eDqJK,ECrJU,UDqJV;AACb,cCrJQ,gBDqJR,ECrJwB,UDqJxB;AAuCkD,cC1L1C,kBD0L0C,EC1LxB,UD0LwB;AAAmB,cCzL7D,gBDyL6D,ECzL7C,UDyL6C;AAoCnC,cC5N1B,gBD4N0B,EC5NV,UD4NU;AAA0B,cC3NpD,kBD2NoD,EC3NlC,UD2NkC;AAetD,cCzOE,eDyOF,ECzOiB,UDyOjB;AAAgB,cCxOd,cDwOc,ECxOA,UDwOA;cCvOd,kBAAgB;cAOhB,MAAI;cACJ,QAAM;AA7EN,cA8EA,KA9EI,EA8EC,UA9EuB;AAC5B,cA8EA,QA9EI,EA8EI,UA9EuB;AAC/B,cA8EA,gBA9E4B,EA8EZ,UA9EY;AAC5B,cA8EA,MA9EM,EA8EA,UA9E8B;AACpC,cA8EA,mBA9EgC,EA8Eb,UA9Ea;AAChC,cA8EA,sBA9EiD,EA8E3B,UA9E2B;AACjD,cA8EA,OA9EU,EA8EH,UA9EoC;AAC3C,cAoFA,SApFU,EAoFD,UApFmC;AAC5C,cAoFA,gBApF8B,EAoFd,UApFc;AAC9B,cAoFA,eApFe,EAoFA,UApFsC;AACrD,cAoFA,eApFqC,EAoFtB,UApFsB;AACrC,cA0FA,KA1FI,EA0FC,UA1F4B;AACjC,cA0FA,aA1FQ,EA0FK,UA1F4B;AACzC,cA0FA,cA1FM,EA0FQ,UA1FuB;AACrC,cA0FA,WA1FM,EA0FK,UA1F0B;AACrC,cAgGA,OAhGI,EAgGG,UAhG0B;AACjC,cAgGA,cAhGiC,EAgGnB,UAhGmB;AACjC,cAgGA,cAhGa,EAgGC,UAhG+B;AAC7C,cAsGA,cAtGa,EAsGC,UAtG+B;AAC7C,cAsGA,UAtGU,EAsGA,UAtGkC;AAC5C,cAsGA,oBAtGwC,EAsGpB,UAtGoB;AACxC,cAsGA,WAtGU,EAsGC,UAtGiC;AAC5C,cAsGA,aAtGW,EAsGE,UAtGiC;AAC9C,cAsGA,kBAtGyC,EAsGvB,UAtGuB;AACzC,cAsGA,SAtGQ,EAsGC,UAtGgC;AAOzC,cAgGA,sBAhG6C,EAgGvB,UAhGuB;AAC7C,cAgGA,iBAhGqC,EAgGpB,UAhGoB;AACrC,cAsGA,KAtG8C,EAsGzC,UAtGM;AAOX,cAgGA,mBAhGmC,EAgGhB,UAhGgB;AACnC,cAgGA,kBAhGiC,EAgGf,UAhGe;AACjC,cAgGA,OAhGQ,EAgGD,UAhGkC;AACzC,cAgGA,aAhGQ,EAgGK,UAhG4B;AACzC,cAgGA,UAhGU,EAgGA,UAhGmC;AAC7C,cAgGA,WAhGW,EAgGA,UAhGmC;AAC9C,cAgGA,cAhGO,EAgGO,UAhGyB;AACvC,cAgGA,GAhG6C,EAgG1C,UAhGO;AACV,cAgGA,IAhGA,EAgGI,UAhG4D;AAOhE,cA0FA,MA1FyC,EA0FnC,UA1FO;AACb,cA0FA,cA1Fc,EA0FA,UA1F6B;AAC3C,cA0FA,UA1F2C,EA0FjC,UA1FI;AACd,cA0FA,YA1FiD,EA0FrC,UA1FK;AACjB,cA2FA,IA3F6C,EA2FzC,UA3FW;AACf,cA2FA,IA3F6C,EA2FzC,UA3FW;AACf,cA2FA,MA3F+C,EA2FzC,UA3FU;AAEhB,cA0FA,MA1FmD,EA0F7C,UA1FY;AAClB,cA0FA,MA1F+C,EA0FzC,UA1FU;AAChB,cA0FA,KA1F+C,EA0F1C,UA1FW;AAC7B;AACA;AACA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOa,cAgFA,eAAA,CAhFS;EACT,QAAA,KAAA;EACA;AACb;AAOA;AACA;AACA;EACa,GAAA,CAAA,CAAA,EA2EJ,gBA3E4C;AAOrD;AACA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACa,cAkKA,YAlKM,EAkKM,eAlK0B"}