@bcts/envelope 1.0.0-alpha.10

package/dist/index.d.mts

@@ -0,0 +1,782 @@
+import { Cbor, CborMap, CborTagged, CborTaggedDecodable, CborTaggedEncodable, tagsForValues } from "@bcts/dcbor";
+import { KnownValue } from "@bcts/known-values";
+
+//#region src/base/digest.d.ts
+declare class Digest {
+  #private;
+  constructor(data: Uint8Array);
+  data(): Uint8Array;
+  static fromImage(image: Uint8Array): Digest;
+  static fromDigests(digests: Digest[]): Digest;
+  hex(): string;
+  short(): string;
+  static fromHex(hex: string): Digest;
+  equals(other: Digest): boolean;
+  toString(): string;
+  clone(): Digest;
+}
+interface DigestProvider {
+  digest(): Digest;
+}
+//#endregion
+//#region src/base/envelope-encodable.d.ts
+interface EnvelopeEncodable {
+  intoEnvelope(): Envelope;
+}
+declare function isEnvelopeEncodable(value: unknown): value is EnvelopeEncodable;
+type EnvelopeEncodableValue = EnvelopeEncodable | string | number | boolean | bigint | Uint8Array | null | undefined | Envelope;
+//#endregion
+//#region src/base/assertion.d.ts
+declare class Assertion implements DigestProvider {
+  #private;
+  constructor(predicate: EnvelopeEncodable | Envelope, object: EnvelopeEncodable | Envelope);
+  predicate(): Envelope;
+  object(): Envelope;
+  digest(): Digest;
+  equals(other: Assertion): boolean;
+  toCbor(): Cbor;
+  static fromCbor(cbor: Cbor): Assertion;
+  static fromCborMap(map: CborMap): Assertion;
+  toString(): string;
+  clone(): Assertion;
+}
+//#endregion
+//#region src/base/elide.d.ts
+declare enum ObscureType {
+  Elided = "elided",
+  Encrypted = "encrypted",
+  Compressed = "compressed",
+}
+type ObscureAction = {
+  type: "elide";
+} | {
+  type: "encrypt";
+  key: unknown;
+} | {
+  type: "compress";
+};
+declare function elideAction(): ObscureAction;
+//#endregion
+//#region src/base/walk.d.ts
+declare enum EdgeType {
+  None = "none",
+  Subject = "subject",
+  Assertion = "assertion",
+  Predicate = "predicate",
+  Object = "object",
+  Content = "content",
+}
+declare function edgeLabel(edgeType: EdgeType): string | undefined;
+type Visitor<State> = (envelope: Envelope, level: number, incomingEdge: EdgeType, state: State) => [State, boolean];
+//#endregion
+//#region src/extension/types.d.ts
+declare const IS_A = "isA";
+//#endregion
+//#region src/extension/salt.d.ts
+declare const SALT = "salt";
+//#endregion
+//#region src/extension/compress.d.ts
+declare class Compressed {
+  #private;
+  constructor(compressedData: Uint8Array, digest?: Digest);
+  static fromDecompressedData(decompressedData: Uint8Array, digest?: Digest): Compressed;
+  compressedData(): Uint8Array;
+  digestOpt(): Digest | undefined;
+  decompress(): Uint8Array;
+}
+declare function registerCompressExtension(): void;
+//#endregion
+//#region src/extension/encrypt.d.ts
+declare class SymmetricKey {
+  #private;
+  constructor(key: Uint8Array);
+  static generate(): SymmetricKey;
+  static from(key: Uint8Array): SymmetricKey;
+  data(): Uint8Array;
+  encrypt(plaintext: Uint8Array, digest: Digest): EncryptedMessage;
+  decrypt(message: EncryptedMessage): Uint8Array;
+}
+declare class EncryptedMessage {
+  #private;
+  constructor(ciphertext: Uint8Array, nonce: Uint8Array, authTag: Uint8Array, aadDigest?: Digest);
+  ciphertext(): Uint8Array;
+  nonce(): Uint8Array;
+  authTag(): Uint8Array;
+  aadDigest(): Digest | undefined;
+  digest(): Digest;
+}
+declare function registerEncryptExtension(): void;
+//#endregion
+//#region src/extension/signature.d.ts
+/**
+ * Signature Extension for Gordian Envelope
+ *
+ * Provides functionality for digitally signing Envelopes and verifying signatures,
+ * with optional metadata support.
+ *
+ * The signature extension allows:
+ * - Signing envelope subjects to validate their authenticity
+ * - Adding metadata to signatures (e.g., signer identity, date, purpose)
+ * - Verification of signatures, both with and without metadata
+ * - Support for multiple signatures on a single envelope
+ */
+/**
+ * Known value for the 'signed' predicate.
+ * This is the standard predicate used for signature assertions.
+ */
+declare const SIGNED = "signed";
+/**
+ * Known value for the 'verifiedBy' predicate.
+ * Used to indicate verification status.
+ */
+declare const VERIFIED_BY = "verifiedBy";
+/**
+ * Known value for the 'note' predicate.
+ * Used for adding notes/comments to signatures.
+ */
+declare const NOTE = "note";
+/**
+ * Represents a cryptographic signature.
+ */
+declare class Signature {
+  #private;
+  constructor(data: Uint8Array);
+  /**
+   * Returns the raw signature bytes.
+   */
+  data(): Uint8Array;
+  /**
+   * Returns the hex-encoded signature.
+   */
+  hex(): string;
+  /**
+   * Creates a Signature from hex string.
+   */
+  static fromHex(hex: string): Signature;
+}
+/**
+ * Interface for types that can sign data.
+ */
+interface Signer {
+  /**
+   * Signs the provided data and returns a Signature.
+   */
+  sign(data: Uint8Array): Signature;
+}
+/**
+ * Interface for types that can verify signatures.
+ */
+interface Verifier {
+  /**
+   * Verifies a signature against the provided data.
+   * Returns true if the signature is valid.
+   */
+  verify(data: Uint8Array, signature: Signature): boolean;
+}
+/**
+ * ECDSA signing key using secp256k1 curve.
+ * Uses @bcts/crypto functions.
+ */
+declare class SigningPrivateKey implements Signer {
+  #private;
+  constructor(privateKey: Uint8Array);
+  /**
+   * Generates a new random private key.
+   */
+  static generate(): SigningPrivateKey;
+  /**
+   * Creates a private key from hex string.
+   */
+  static fromHex(hex: string): SigningPrivateKey;
+  /**
+   * Returns the corresponding public key.
+   */
+  publicKey(): SigningPublicKey;
+  /**
+   * Signs data and returns a Signature.
+   */
+  sign(data: Uint8Array): Signature;
+  /**
+   * Returns the raw private key bytes.
+   */
+  data(): Uint8Array;
+}
+/**
+ * ECDSA public key for signature verification using secp256k1 curve.
+ * Uses @bcts/crypto functions.
+ */
+declare class SigningPublicKey implements Verifier {
+  #private;
+  constructor(publicKey: Uint8Array);
+  /**
+   * Creates a public key from hex string.
+   */
+  static fromHex(hex: string): SigningPublicKey;
+  /**
+   * Verifies a signature against the provided data.
+   */
+  verify(data: Uint8Array, signature: Signature): boolean;
+  /**
+   * Returns the raw public key bytes.
+   */
+  data(): Uint8Array;
+  /**
+   * Returns the hex-encoded public key.
+   */
+  hex(): string;
+}
+/**
+ * Metadata that can be attached to a signature.
+ */
+declare class SignatureMetadata {
+  #private;
+  /**
+   * Adds an assertion to the metadata.
+   */
+  withAssertion(predicate: string, object: unknown): SignatureMetadata;
+  /**
+   * Returns all assertions in the metadata.
+   */
+  assertions(): [string, unknown][];
+  /**
+   * Returns true if this metadata has any assertions.
+   */
+  hasAssertions(): boolean;
+}
+//#endregion
+//#region src/extension/attachment.d.ts
+/**
+ * Known value for the 'attachment' predicate.
+ */
+declare const ATTACHMENT = "attachment";
+/**
+ * Known value for the 'vendor' predicate.
+ */
+declare const VENDOR = "vendor";
+/**
+ * Known value for the 'conformsTo' predicate.
+ */
+declare const CONFORMS_TO = "conformsTo";
+/**
+ * A container for vendor-specific metadata attachments.
+ *
+ * Attachments provides a flexible mechanism for attaching arbitrary metadata
+ * to envelopes without modifying their core structure.
+ */
+declare class Attachments {
+  #private;
+  /**
+   * Creates a new empty attachments container.
+   */
+  constructor();
+  /**
+   * Adds a new attachment with the specified payload and metadata.
+   *
+   * @param payload - The data to attach
+   * @param vendor - A string identifying the entity that defined the attachment format
+   * @param conformsTo - Optional URI identifying the structure the payload conforms to
+   */
+  add(payload: EnvelopeEncodableValue, vendor: string, conformsTo?: string): void;
+  /**
+   * Retrieves an attachment by its digest.
+   *
+   * @param digest - The unique digest of the attachment to retrieve
+   * @returns The envelope if found, or undefined
+   */
+  get(digest: Digest): Envelope | undefined;
+  /**
+   * Removes an attachment by its digest.
+   *
+   * @param digest - The unique digest of the attachment to remove
+   * @returns The removed envelope if found, or undefined
+   */
+  remove(digest: Digest): Envelope | undefined;
+  /**
+   * Removes all attachments from the container.
+   */
+  clear(): void;
+  /**
+   * Returns whether the container has any attachments.
+   */
+  isEmpty(): boolean;
+  /**
+   * Adds all attachments from this container to an envelope.
+   *
+   * @param envelope - The envelope to add attachments to
+   * @returns A new envelope with all attachments added as assertions
+   */
+  addToEnvelope(envelope: Envelope): Envelope;
+  /**
+   * Creates an Attachments container from an envelope's attachment assertions.
+   *
+   * @param envelope - The envelope to extract attachments from
+   * @returns A new Attachments container with the envelope's attachments
+   */
+  static fromEnvelope(envelope: Envelope): Attachments;
+}
+//#endregion
+//#region src/extension/recipient.d.ts
+declare const HAS_RECIPIENT = "hasRecipient";
+declare class PublicKeyBase {
+  #private;
+  constructor(publicKey: Uint8Array);
+  data(): Uint8Array;
+  hex(): string;
+  static fromHex(hex: string): PublicKeyBase;
+}
+declare class PrivateKeyBase {
+  #private;
+  private constructor();
+  static generate(): PrivateKeyBase;
+  static fromBytes(privateKey: Uint8Array, publicKey: Uint8Array): PrivateKeyBase;
+  static fromHex(privateHex: string, publicHex: string): PrivateKeyBase;
+  publicKeys(): PublicKeyBase;
+  data(): Uint8Array;
+  hex(): string;
+  unseal(sealedMessage: SealedMessage): SymmetricKey;
+}
+declare class SealedMessage {
+  #private;
+  constructor(data: Uint8Array);
+  static seal(contentKey: SymmetricKey, recipientPublicKey: PublicKeyBase): SealedMessage;
+  decrypt(recipientPrivate: Uint8Array, _recipientPublic: Uint8Array): Uint8Array;
+  data(): Uint8Array;
+  hex(): string;
+  static fromHex(hex: string): SealedMessage;
+}
+//#endregion
+//#region src/extension/expression.d.ts
+declare const CBOR_TAG_FUNCTION = 40006;
+declare const CBOR_TAG_PARAMETER = 40007;
+declare const CBOR_TAG_PLACEHOLDER = 40008;
+declare const CBOR_TAG_REPLACEMENT = 40009;
+declare const FUNCTION_IDS: {
+  readonly ADD: 1;
+  readonly SUB: 2;
+  readonly MUL: 3;
+  readonly DIV: 4;
+  readonly NEG: 5;
+  readonly LT: 6;
+  readonly LE: 7;
+  readonly GT: 8;
+  readonly GE: 9;
+  readonly EQ: 10;
+  readonly NE: 11;
+  readonly AND: 12;
+  readonly OR: 13;
+  readonly XOR: 14;
+  readonly NOT: 15;
+};
+declare const PARAMETER_IDS: {
+  readonly BLANK: 1;
+  readonly LHS: 2;
+  readonly RHS: 3;
+};
+type FunctionID = number | string;
+type ParameterID = number | string;
+declare class Function {
+  #private;
+  constructor(id: FunctionID);
+  id(): FunctionID;
+  isNumeric(): boolean;
+  isString(): boolean;
+  envelope(): Envelope;
+  withParameter(param: ParameterID, value: EnvelopeEncodableValue): Expression;
+  static fromNumeric(id: number): Function;
+  static fromString(name: string): Function;
+  toString(): string;
+}
+declare class Parameter {
+  #private;
+  constructor(id: ParameterID, value: Envelope);
+  id(): ParameterID;
+  value(): Envelope;
+  isNumeric(): boolean;
+  isString(): boolean;
+  envelope(): Envelope;
+  static blank(value: EnvelopeEncodableValue): Parameter;
+  static lhs(value: EnvelopeEncodableValue): Parameter;
+  static rhs(value: EnvelopeEncodableValue): Parameter;
+  toString(): string;
+}
+declare class Expression {
+  #private;
+  constructor(func: Function);
+  function(): Function;
+  parameters(): Parameter[];
+  withParameter(param: ParameterID, value: EnvelopeEncodableValue): Expression;
+  withParameters(params: Record<string, EnvelopeEncodableValue>): Expression;
+  getParameter(param: ParameterID): Envelope | undefined;
+  hasParameter(param: ParameterID): boolean;
+  envelope(): Envelope;
+  static fromEnvelope(envelope: Envelope): Expression;
+  toString(): string;
+}
+declare function add(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function sub(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function mul(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function div(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function neg(value: EnvelopeEncodableValue): Expression;
+declare function lt(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function gt(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function eq(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function and(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function or(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
+declare function not(value: EnvelopeEncodableValue): Expression;
+//#endregion
+//#region src/base/envelope.d.ts
+type EnvelopeCase = {
+  type: "node";
+  subject: Envelope;
+  assertions: Envelope[];
+  digest: Digest;
+} | {
+  type: "leaf";
+  cbor: Cbor;
+  digest: Digest;
+} | {
+  type: "wrapped";
+  envelope: Envelope;
+  digest: Digest;
+} | {
+  type: "assertion";
+  assertion: Assertion;
+} | {
+  type: "elided";
+  digest: Digest;
+} | {
+  type: "knownValue";
+  value: KnownValue;
+  digest: Digest;
+} | {
+  type: "encrypted";
+  message: EncryptedMessage;
+} | {
+  type: "compressed";
+  value: Compressed;
+};
+declare class Envelope implements DigestProvider {
+  #private;
+  private constructor();
+  case(): EnvelopeCase;
+  static new(subject: EnvelopeEncodableValue): Envelope;
+  static newOrNull(subject: EnvelopeEncodableValue | undefined): Envelope;
+  static newOrNone(subject: EnvelopeEncodableValue | undefined): Envelope | undefined;
+  static fromCase(envelopeCase: EnvelopeCase): Envelope;
+  static newAssertion(predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue): Envelope;
+  static null(): Envelope;
+  static newWithUncheckedAssertions(subject: Envelope, uncheckedAssertions: Envelope[]): Envelope;
+  static newWithAssertions(subject: Envelope, assertions: Envelope[]): Envelope;
+  static newWithAssertion(assertion: Assertion): Envelope;
+  static newWithKnownValue(value: KnownValue | number | bigint): Envelope;
+  static newWithEncrypted(encryptedMessage: EncryptedMessage): Envelope;
+  static newWithCompressed(compressed: Compressed): Envelope;
+  static newElided(digest: Digest): Envelope;
+  static newLeaf(value: unknown): Envelope;
+  static newWrapped(envelope: Envelope): Envelope;
+  digest(): Digest;
+  subject(): Envelope;
+  isSubjectAssertion(): boolean;
+  isSubjectObscured(): boolean;
+  private static valueToCbor;
+  private static cborToBytes;
+  untaggedCbor(): Cbor;
+  taggedCbor(): Cbor;
+  static fromUntaggedCbor(cbor: Cbor): Envelope;
+  static fromTaggedCbor(cbor: Cbor): Envelope;
+  addAssertion(predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue): Envelope;
+  addAssertionEnvelope(assertion: Envelope): Envelope;
+  toString(): string;
+  clone(): Envelope;
+  treeFormat: (options?: {
+    hideNodes?: boolean;
+    highlightDigests?: Set<string>;
+    digestDisplay?: "short" | "full";
+  }) => string;
+  shortId: (format?: "short" | "full") => string;
+  summary: (maxLength?: number) => string;
+  hex: () => string;
+  cborBytes: () => Uint8Array;
+  diagnostic: () => string;
+  addAssertionEnvelopes: (assertions: Envelope[]) => Envelope;
+  addOptionalAssertionEnvelope: (assertion: Envelope | undefined) => Envelope;
+  addOptionalAssertion: (predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue | undefined) => Envelope;
+  addNonemptyStringAssertion: (predicate: EnvelopeEncodableValue, str: string) => Envelope;
+  addAssertions: (envelopes: Envelope[]) => Envelope;
+  addAssertionIf: (condition: boolean, predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue) => Envelope;
+  addAssertionEnvelopeIf: (condition: boolean, assertionEnvelope: Envelope) => Envelope;
+  removeAssertion: (target: Envelope) => Envelope;
+  replaceAssertion: (assertion: Envelope, newAssertion: Envelope) => Envelope;
+  replaceSubject: (subject: Envelope) => Envelope;
+  elide: () => Envelope;
+  elideRemovingSetWithAction: (target: Set<Digest>, action: ObscureAction) => Envelope;
+  elideRemovingSet: (target: Set<Digest>) => Envelope;
+  elideRemovingArrayWithAction: (target: DigestProvider[], action: ObscureAction) => Envelope;
+  elideRemovingArray: (target: DigestProvider[]) => Envelope;
+  elideRemovingTargetWithAction: (target: DigestProvider, action: ObscureAction) => Envelope;
+  elideRemovingTarget: (target: DigestProvider) => Envelope;
+  elideRevealingSetWithAction: (target: Set<Digest>, action: ObscureAction) => Envelope;
+  elideRevealingSet: (target: Set<Digest>) => Envelope;
+  elideRevealingArrayWithAction: (target: DigestProvider[], action: ObscureAction) => Envelope;
+  elideRevealingArray: (target: DigestProvider[]) => Envelope;
+  elideRevealingTargetWithAction: (target: DigestProvider, action: ObscureAction) => Envelope;
+  elideRevealingTarget: (target: DigestProvider) => Envelope;
+  unelide: (envelope: Envelope) => Envelope;
+  nodesMatching: (targetDigests: Set<Digest> | undefined, obscureTypes: ObscureType[]) => Set<Digest>;
+  walkUnelide: (envelopes: Envelope[]) => Envelope;
+  walkReplace: (target: Set<Digest>, replacement: Envelope) => Envelope;
+  isIdenticalTo: (other: Envelope) => boolean;
+  tryLeaf: () => Cbor;
+  extractString: () => string;
+  extractNumber: () => number;
+  extractBoolean: () => boolean;
+  extractBytes: () => Uint8Array;
+  extractNull: () => null;
+  isFalse: () => boolean;
+  isTrue: () => boolean;
+  isBool: () => boolean;
+  isNumber: () => boolean;
+  isSubjectNumber: () => boolean;
+  isNaN: () => boolean;
+  isSubjectNaN: () => boolean;
+  isNull: () => boolean;
+  tryByteString: () => Uint8Array;
+  asByteString: () => Uint8Array | undefined;
+  asArray: () => readonly Cbor[] | undefined;
+  asMap: () => CborMap | undefined;
+  asText: () => string | undefined;
+  asLeaf: () => Cbor | undefined;
+  hasAssertions: () => boolean;
+  asAssertion: () => Envelope | undefined;
+  tryAssertion: () => Envelope;
+  asPredicate: () => Envelope | undefined;
+  tryPredicate: () => Envelope;
+  asObject: () => Envelope | undefined;
+  tryObject: () => Envelope;
+  isAssertion: () => boolean;
+  isElided: () => boolean;
+  isLeaf: () => boolean;
+  isNode: () => boolean;
+  isWrapped: () => boolean;
+  isInternal: () => boolean;
+  isObscured: () => boolean;
+  assertions: () => Envelope[];
+  assertionsWithPredicate: (predicate: EnvelopeEncodableValue) => Envelope[];
+  assertionWithPredicate: (predicate: EnvelopeEncodableValue) => Envelope;
+  optionalAssertionWithPredicate: (predicate: EnvelopeEncodableValue) => Envelope | undefined;
+  objectForPredicate: (predicate: EnvelopeEncodableValue) => Envelope;
+  optionalObjectForPredicate: (predicate: EnvelopeEncodableValue) => Envelope | undefined;
+  objectsForPredicate: (predicate: EnvelopeEncodableValue) => Envelope[];
+  elementsCount: () => number;
+  walk: <State>(hideNodes: boolean, state: State, visit: Visitor<State>) => void;
+  wrap: () => Envelope;
+  tryUnwrap: () => Envelope;
+  unwrap: () => Envelope;
+  addAttachment: (payload: EnvelopeEncodableValue, vendor: string, conformsTo?: string) => Envelope;
+  attachmentPayload: () => Envelope;
+  attachmentVendor: () => string;
+  attachmentConformsTo: () => string | undefined;
+  attachments: () => Envelope[];
+  attachmentsWithVendorAndConformsTo: (vendor?: string, conformsTo?: string) => Envelope[];
+  compress: () => Envelope;
+  decompress: () => Envelope;
+  compressSubject: () => Envelope;
+  decompressSubject: () => Envelope;
+  isCompressed: () => boolean;
+  encryptSubject: (key: SymmetricKey) => Envelope;
+  decryptSubject: (key: SymmetricKey) => Envelope;
+  encrypt: (key: SymmetricKey) => Envelope;
+  decrypt: (key: SymmetricKey) => Envelope;
+  isEncrypted: () => boolean;
+  proofContainsSet: (target: Set<Digest>) => Envelope | undefined;
+  proofContainsTarget: (target: Envelope) => Envelope | undefined;
+  confirmContainsSet: (target: Set<Digest>, proof: Envelope) => boolean;
+  confirmContainsTarget: (target: Envelope, proof: Envelope) => boolean;
+  encryptSubjectToRecipient: (recipientPublicKey: PublicKeyBase) => Envelope;
+  encryptSubjectToRecipients: (recipients: PublicKeyBase[]) => Envelope;
+  addRecipient: (recipientPublicKey: PublicKeyBase, contentKey: SymmetricKey) => Envelope;
+  decryptSubjectToRecipient: (recipientPrivateKey: PrivateKeyBase) => Envelope;
+  decryptToRecipient: (recipientPrivateKey: PrivateKeyBase) => Envelope;
+  encryptToRecipients: (recipients: PublicKeyBase[]) => Envelope;
+  recipients: () => SealedMessage[];
+  addSalt: () => Envelope;
+  addSaltWithLength: (count: number) => Envelope;
+  addSaltBytes: (saltBytes: Uint8Array) => Envelope;
+  addSaltInRange: (min: number, max: number) => Envelope;
+  addSignature: (signer: Signer) => Envelope;
+  addSignatureWithMetadata: (signer: Signer, metadata?: SignatureMetadata) => Envelope;
+  addSignatures: (signers: Signer[]) => Envelope;
+  hasSignatureFrom: (verifier: Verifier) => boolean;
+  verifySignatureFrom: (verifier: Verifier) => Envelope;
+  signatures: () => Envelope[];
+  addType: (object: EnvelopeEncodableValue) => Envelope;
+  types: () => Envelope[];
+  getType: () => Envelope;
+  hasType: (t: EnvelopeEncodableValue) => boolean;
+  checkType: (t: EnvelopeEncodableValue) => void;
+  static newAttachment: (payload: EnvelopeEncodableValue, vendor: string, conformsTo?: string) => Envelope;
+}
+//#endregion
+//#region src/base/error.d.ts
+declare enum ErrorCode {
+  ALREADY_ELIDED = "ALREADY_ELIDED",
+  AMBIGUOUS_PREDICATE = "AMBIGUOUS_PREDICATE",
+  INVALID_DIGEST = "INVALID_DIGEST",
+  INVALID_FORMAT = "INVALID_FORMAT",
+  MISSING_DIGEST = "MISSING_DIGEST",
+  NONEXISTENT_PREDICATE = "NONEXISTENT_PREDICATE",
+  NOT_WRAPPED = "NOT_WRAPPED",
+  NOT_LEAF = "NOT_LEAF",
+  NOT_ASSERTION = "NOT_ASSERTION",
+  INVALID_ASSERTION = "INVALID_ASSERTION",
+  INVALID_ATTACHMENT = "INVALID_ATTACHMENT",
+  NONEXISTENT_ATTACHMENT = "NONEXISTENT_ATTACHMENT",
+  AMBIGUOUS_ATTACHMENT = "AMBIGUOUS_ATTACHMENT",
+  ALREADY_COMPRESSED = "ALREADY_COMPRESSED",
+  NOT_COMPRESSED = "NOT_COMPRESSED",
+  ALREADY_ENCRYPTED = "ALREADY_ENCRYPTED",
+  NOT_ENCRYPTED = "NOT_ENCRYPTED",
+  NOT_KNOWN_VALUE = "NOT_KNOWN_VALUE",
+  UNKNOWN_RECIPIENT = "UNKNOWN_RECIPIENT",
+  UNKNOWN_SECRET = "UNKNOWN_SECRET",
+  UNVERIFIED_SIGNATURE = "UNVERIFIED_SIGNATURE",
+  INVALID_OUTER_SIGNATURE_TYPE = "INVALID_OUTER_SIGNATURE_TYPE",
+  INVALID_INNER_SIGNATURE_TYPE = "INVALID_INNER_SIGNATURE_TYPE",
+  UNVERIFIED_INNER_SIGNATURE = "UNVERIFIED_INNER_SIGNATURE",
+  INVALID_SIGNATURE_TYPE = "INVALID_SIGNATURE_TYPE",
+  INVALID_SHARES = "INVALID_SHARES",
+  SSKR = "SSKR",
+  INVALID_TYPE = "INVALID_TYPE",
+  AMBIGUOUS_TYPE = "AMBIGUOUS_TYPE",
+  UNEXPECTED_RESPONSE_ID = "UNEXPECTED_RESPONSE_ID",
+  INVALID_RESPONSE = "INVALID_RESPONSE",
+  CBOR = "CBOR",
+  COMPONENTS = "COMPONENTS",
+  GENERAL = "GENERAL",
+}
+declare class EnvelopeError extends Error {
+  readonly code: ErrorCode;
+  readonly cause?: Error;
+  constructor(code: ErrorCode, message: string, cause?: Error);
+  static alreadyElided(): EnvelopeError;
+  static ambiguousPredicate(): EnvelopeError;
+  static invalidDigest(): EnvelopeError;
+  static invalidFormat(): EnvelopeError;
+  static missingDigest(): EnvelopeError;
+  static nonexistentPredicate(): EnvelopeError;
+  static notWrapped(): EnvelopeError;
+  static notLeaf(): EnvelopeError;
+  static notAssertion(): EnvelopeError;
+  static invalidAssertion(): EnvelopeError;
+  static invalidAttachment(): EnvelopeError;
+  static nonexistentAttachment(): EnvelopeError;
+  static ambiguousAttachment(): EnvelopeError;
+  static alreadyCompressed(): EnvelopeError;
+  static notCompressed(): EnvelopeError;
+  static alreadyEncrypted(): EnvelopeError;
+  static notEncrypted(): EnvelopeError;
+  static notKnownValue(): EnvelopeError;
+  static unknownRecipient(): EnvelopeError;
+  static unknownSecret(): EnvelopeError;
+  static unverifiedSignature(): EnvelopeError;
+  static invalidOuterSignatureType(): EnvelopeError;
+  static invalidInnerSignatureType(): EnvelopeError;
+  static unverifiedInnerSignature(): EnvelopeError;
+  static invalidSignatureType(): EnvelopeError;
+  static invalidShares(): EnvelopeError;
+  static sskr(message: string, cause?: Error): EnvelopeError;
+  static invalidType(): EnvelopeError;
+  static ambiguousType(): EnvelopeError;
+  static unexpectedResponseId(): EnvelopeError;
+  static invalidResponse(): EnvelopeError;
+  static cbor(message: string, cause?: Error): EnvelopeError;
+  static components(message: string, cause?: Error): EnvelopeError;
+  static general(message: string, cause?: Error): EnvelopeError;
+  static msg(message: string): EnvelopeError;
+}
+//#endregion
+//#region src/base/cbor.d.ts
+declare class EnvelopeCBORTagged implements CborTagged {
+  cborTags(): ReturnType<typeof tagsForValues>;
+  static cborTags(): number[];
+}
+declare class EnvelopeCBORTaggedEncodable implements CborTaggedEncodable {
+  private readonly envelope;
+  constructor(envelope: Envelope);
+  cborTags(): ReturnType<typeof tagsForValues>;
+  untaggedCbor(): Cbor;
+  taggedCbor(): Cbor;
+}
+declare class EnvelopeCBORTaggedDecodable<T = Envelope> implements CborTaggedDecodable<T> {
+  cborTags(): ReturnType<typeof tagsForValues>;
+  static fromUntaggedCbor(cbor: Cbor): Envelope;
+  static fromTaggedCbor(cbor: Cbor): Envelope;
+  fromUntaggedCbor(cbor: Cbor): T;
+  fromTaggedCbor(cbor: Cbor): T;
+}
+declare function envelopeToCbor(envelope: Envelope): Cbor;
+declare function envelopeFromCbor(cbor: Cbor): Envelope;
+declare function envelopeToBytes(envelope: Envelope): Uint8Array;
+declare function envelopeFromBytes(bytes: Uint8Array): Envelope;
+//#endregion
+//#region src/base/envelope-decodable.d.ts
+declare function extractString(envelope: Envelope): string;
+declare function extractNumber(envelope: Envelope): number;
+declare function extractBoolean(envelope: Envelope): boolean;
+declare function extractBytes(envelope: Envelope): Uint8Array;
+declare function extractNull(envelope: Envelope): null;
+declare class EnvelopeDecoder {
+  static tryFromCbor(cbor: Cbor): Envelope;
+  static tryFromCborData(data: Uint8Array): Envelope;
+}
+//#endregion
+//#region src/format/tree.d.ts
+interface TreeFormatOptions {
+  hideNodes?: boolean;
+  highlightDigests?: Set<string>;
+  digestDisplay?: "short" | "full";
+}
+//#endregion
+//#region src/utils/string.d.ts
+/**
+ * String utility functions used throughout the envelope library.
+ *
+ * Provides helper methods for string formatting and manipulation.
+ */
+/**
+ * Flanks a string with specified left and right delimiters.
+ *
+ * @param str - The string to flank
+ * @param left - The left delimiter
+ * @param right - The right delimiter
+ * @returns The flanked string
+ *
+ * @example
+ * ```typescript
+ * flanked('hello', '"', '"')  // Returns: "hello"
+ * flanked('name', "'", "'")   // Returns: 'name'
+ * flanked('item', '[', ']')   // Returns: [item]
+ * ```
+ */
+declare function flanked(str: string, left: string, right: string): string;
+/**
+ * Extension methods for String objects to support fluent API style.
+ */
+declare global {
+  interface String {
+    /**
+     * Flanks this string with specified left and right delimiters.
+     *
+     * @param left - The left delimiter
+     * @param right - The right delimiter
+     * @returns The flanked string
+     */
+    flankedBy(left: string, right: string): string;
+  }
+}
+//#endregion
+//#region src/index.d.ts
+declare const VERSION = "0.37.0";
+//#endregion
+export { ATTACHMENT, Assertion, Attachments, CBOR_TAG_FUNCTION, CBOR_TAG_PARAMETER, CBOR_TAG_PLACEHOLDER, CBOR_TAG_REPLACEMENT, CONFORMS_TO, Compressed, Digest, type DigestProvider, EdgeType, EncryptedMessage, Envelope, EnvelopeCBORTagged, EnvelopeCBORTaggedDecodable, EnvelopeCBORTaggedEncodable, type EnvelopeCase, EnvelopeDecoder, type EnvelopeEncodable, type EnvelopeEncodableValue, EnvelopeError, ErrorCode, Expression, FUNCTION_IDS, Function, type FunctionID, HAS_RECIPIENT, IS_A, NOTE, type ObscureAction, ObscureType, PARAMETER_IDS, Parameter, type ParameterID, PrivateKeyBase, PublicKeyBase, SALT, SIGNED, SealedMessage, Signature, SignatureMetadata, type Signer, SigningPrivateKey, SigningPublicKey, SymmetricKey, TreeFormatOptions, VENDOR, VERIFIED_BY, VERSION, type Verifier, type Visitor, add, and, div, edgeLabel, elideAction, envelopeFromBytes, envelopeFromCbor, envelopeToBytes, envelopeToCbor, eq, extractBoolean, extractBytes, extractNull, extractNumber, extractString, flanked, gt, isEnvelopeEncodable, lt, mul, neg, not, or, registerCompressExtension, registerEncryptExtension, sub };
+//# sourceMappingURL=index.d.mts.map