@bcts/envelope 1.0.0-alpha.5

package/dist/index.d.mts

@@ -0,0 +1,978 @@
+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$1;
+}
+declare function isEnvelopeEncodable(value: unknown): value is EnvelopeEncodable;
+type EnvelopeEncodableValue = EnvelopeEncodable | string | number | boolean | bigint | Uint8Array | null | undefined | Envelope$1;
+//#endregion
+//#region src/base/assertion.d.ts
+declare class Assertion implements DigestProvider {
+  #private;
+  constructor(predicate: EnvelopeEncodable | Envelope$1, object: EnvelopeEncodable | Envelope$1);
+  predicate(): Envelope$1;
+  object(): Envelope$1;
+  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/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 module "../base/envelope" {
+  interface Envelope {
+    compress(): Envelope;
+    decompress(): Envelope;
+    compressSubject(): Envelope;
+    decompressSubject(): Envelope;
+    isCompressed(): boolean;
+  }
+}
+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 module "../base/envelope" {
+  interface Envelope {
+    encryptSubject(key: SymmetricKey): Envelope;
+    decryptSubject(key: SymmetricKey): Envelope;
+    encrypt(key: SymmetricKey): Envelope;
+    decrypt(key: SymmetricKey): Envelope;
+    isEncrypted(): boolean;
+  }
+}
+declare function registerEncryptExtension(): void;
+//#endregion
+//#region src/base/envelope.d.ts
+type EnvelopeCase = {
+  type: "node";
+  subject: Envelope$1;
+  assertions: Envelope$1[];
+  digest: Digest;
+} | {
+  type: "leaf";
+  cbor: Cbor;
+  digest: Digest;
+} | {
+  type: "wrapped";
+  envelope: Envelope$1;
+  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$1 implements DigestProvider {
+  #private;
+  private constructor();
+  case(): EnvelopeCase;
+  static new(subject: EnvelopeEncodableValue): Envelope$1;
+  static newOrNull(subject: EnvelopeEncodableValue | undefined): Envelope$1;
+  static newOrNone(subject: EnvelopeEncodableValue | undefined): Envelope$1 | undefined;
+  static fromCase(envelopeCase: EnvelopeCase): Envelope$1;
+  static newAssertion(predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue): Envelope$1;
+  static null(): Envelope$1;
+  static newWithUncheckedAssertions(subject: Envelope$1, uncheckedAssertions: Envelope$1[]): Envelope$1;
+  static newWithAssertions(subject: Envelope$1, assertions: Envelope$1[]): Envelope$1;
+  static newWithAssertion(assertion: Assertion): Envelope$1;
+  static newWithKnownValue(value: KnownValue | number | bigint): Envelope$1;
+  static newWithEncrypted(encryptedMessage: EncryptedMessage): Envelope$1;
+  static newWithCompressed(compressed: Compressed): Envelope$1;
+  static newElided(digest: Digest): Envelope$1;
+  static newLeaf(value: unknown): Envelope$1;
+  static newWrapped(envelope: Envelope$1): Envelope$1;
+  digest(): Digest;
+  subject(): Envelope$1;
+  isSubjectAssertion(): boolean;
+  isSubjectObscured(): boolean;
+  private static valueToCbor;
+  private static cborToBytes;
+  untaggedCbor(): Cbor;
+  taggedCbor(): Cbor;
+  static fromUntaggedCbor(cbor: Cbor): Envelope$1;
+  static fromTaggedCbor(cbor: Cbor): Envelope$1;
+  addAssertion(predicate: EnvelopeEncodableValue, object: EnvelopeEncodableValue): Envelope$1;
+  addAssertionEnvelope(assertion: Envelope$1): Envelope$1;
+  toString(): string;
+  clone(): Envelope$1;
+  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;
+}
+//#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$1);
+  cborTags(): ReturnType<typeof tagsForValues>;
+  untaggedCbor(): Cbor;
+  taggedCbor(): Cbor;
+}
+declare class EnvelopeCBORTaggedDecodable<T = Envelope$1> implements CborTaggedDecodable<T> {
+  cborTags(): ReturnType<typeof tagsForValues>;
+  static fromUntaggedCbor(cbor: Cbor): Envelope$1;
+  static fromTaggedCbor(cbor: Cbor): Envelope$1;
+  fromUntaggedCbor(cbor: Cbor): T;
+  fromTaggedCbor(cbor: Cbor): T;
+}
+declare function envelopeToCbor(envelope: Envelope$1): Cbor;
+declare function envelopeFromCbor(cbor: Cbor): Envelope$1;
+declare function envelopeToBytes(envelope: Envelope$1): Uint8Array;
+declare function envelopeFromBytes(bytes: Uint8Array): Envelope$1;
+//#endregion
+//#region src/base/envelope-decodable.d.ts
+declare function extractString(envelope: Envelope$1): string;
+declare function extractNumber(envelope: Envelope$1): number;
+declare function extractBoolean(envelope: Envelope$1): boolean;
+declare function extractBytes(envelope: Envelope$1): Uint8Array;
+declare function extractNull(envelope: Envelope$1): null;
+declare module "./envelope" {
+  interface Envelope {
+    tryLeaf(): Cbor;
+    extractString(): string;
+    extractNumber(): number;
+    extractBoolean(): boolean;
+    extractBytes(): Uint8Array;
+    extractNull(): null;
+  }
+}
+declare class EnvelopeDecoder {
+  static tryFromCbor(cbor: Cbor): Envelope$1;
+  static tryFromCborData(data: Uint8Array): Envelope$1;
+}
+//#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;
+declare module "./envelope" {
+  interface 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;
+  }
+}
+//# sourceMappingURL=elide.d.ts.map
+//#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$1, level: number, incomingEdge: EdgeType, state: State) => [State, boolean];
+declare module "./envelope" {
+  interface Envelope {
+    walk<State>(hideNodes: boolean, state: State, visit: Visitor<State>): void;
+  }
+}
+//# sourceMappingURL=walk.d.ts.map
+//#endregion
+//#region src/base/assertions.d.ts
+declare module "./envelope" {
+  interface Envelope {
+    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;
+    assertions(): Envelope[];
+  }
+}
+//# sourceMappingURL=assertions.d.ts.map
+//#endregion
+//#region src/base/leaf.d.ts
+declare module "./envelope" {
+  interface Envelope {
+    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;
+  }
+}
+//# sourceMappingURL=leaf.d.ts.map
+//#endregion
+//#region src/base/queries.d.ts
+declare module "./envelope" {
+  interface Envelope {
+    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;
+    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;
+  }
+}
+//# sourceMappingURL=queries.d.ts.map
+//#endregion
+//#region src/base/wrap.d.ts
+declare module "./envelope" {
+  interface Envelope {
+    wrap(): Envelope;
+    tryUnwrap(): Envelope;
+    unwrap(): Envelope;
+  }
+}
+//#endregion
+//#region src/extension/types.d.ts
+declare const IS_A = "isA";
+declare module "../base/envelope" {
+  interface Envelope {
+    addType(object: EnvelopeEncodableValue): Envelope;
+    types(): Envelope[];
+    getType(): Envelope;
+    hasType(t: EnvelopeEncodableValue): boolean;
+    checkType(t: EnvelopeEncodableValue): void;
+  }
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/extension/salt.d.ts
+declare const SALT = "salt";
+declare module "../base/envelope" {
+  interface Envelope {
+    addSalt(): Envelope;
+    addSaltWithLength(count: number): Envelope;
+    addSaltBytes(saltBytes: Uint8Array): Envelope;
+    addSaltInRange(min: number, max: number): Envelope;
+  }
+}
+//# sourceMappingURL=salt.d.ts.map
+
+//#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;
+}
+/**
+ * Support for signing envelopes and verifying signatures.
+ */
+declare module "../base/envelope" {
+  interface Envelope {
+    /**
+     * Creates a signature for the envelope's subject and returns a new
+     * envelope with a 'signed': Signature assertion.
+     *
+     * @param signer - The signing key
+     * @returns The signed envelope
+     *
+     * @example
+     * ```typescript
+     * const privateKey = SigningPrivateKey.generate();
+     * const envelope = Envelope.new("Hello, world!");
+     * const signed = envelope.addSignature(privateKey);
+     * ```
+     */
+    addSignature(signer: Signer): Envelope;
+    /**
+     * Creates a signature for the envelope's subject with optional metadata.
+     *
+     * @param signer - The signing key
+     * @param metadata - Optional metadata to attach to the signature
+     * @returns The signed envelope
+     */
+    addSignatureWithMetadata(signer: Signer, metadata?: SignatureMetadata): Envelope;
+    /**
+     * Creates multiple signatures for the envelope's subject.
+     *
+     * @param signers - Array of signing keys
+     * @returns The envelope with multiple signatures
+     */
+    addSignatures(signers: Signer[]): Envelope;
+    /**
+     * Returns whether this envelope has a valid signature from the given verifier.
+     *
+     * @param verifier - The public key to verify against
+     * @returns True if a valid signature from this verifier exists
+     */
+    hasSignatureFrom(verifier: Verifier): boolean;
+    /**
+     * Verifies that this envelope has a valid signature from the given verifier
+     * and returns the envelope.
+     *
+     * @param verifier - The public key to verify against
+     * @returns The verified envelope
+     * @throws {EnvelopeError} If no valid signature is found
+     */
+    verifySignatureFrom(verifier: Verifier): Envelope;
+    /**
+     * Returns all signature assertions in this envelope.
+     *
+     * @returns Array of signature envelopes
+     */
+    signatures(): Envelope[];
+  }
+}
+//# sourceMappingURL=signature.d.ts.map
+//#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$1 | 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$1 | 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$1): Envelope$1;
+  /**
+   * 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$1): Attachments;
+}
+/**
+ * Support for attachments in envelopes.
+ */
+declare module "../base/envelope" {
+  interface Envelope {
+    /**
+     * Creates a new envelope with an attachment as its subject.
+     *
+     * The attachment consists of:
+     * - The predicate 'attachment'
+     * - An object that is a wrapped envelope containing:
+     *   - The payload (as the subject)
+     *   - A required 'vendor': String assertion
+     *   - An optional 'conformsTo': String assertion
+     *
+     * @param payload - The content of the attachment
+     * @param vendor - A string identifying the entity (typically reverse domain name)
+     * @param conformsTo - Optional URI identifying the format of the attachment
+     * @returns A new attachment envelope
+     *
+     * @example
+     * ```typescript
+     * const attachment = Envelope.newAttachment(
+     *   "Custom data",
+     *   "com.example",
+     *   "https://example.com/format/v1"
+     * );
+     * ```
+     */
+    addAttachment(payload: EnvelopeEncodableValue, vendor: string, conformsTo?: string): Envelope$1;
+    /**
+     * Returns the payload of an attachment envelope.
+     *
+     * @returns The payload envelope
+     * @throws {EnvelopeError} If the envelope is not a valid attachment
+     */
+    attachmentPayload(): Envelope$1;
+    /**
+     * Returns the vendor identifier of an attachment envelope.
+     *
+     * @returns The vendor string
+     * @throws {EnvelopeError} If the envelope is not a valid attachment
+     */
+    attachmentVendor(): string;
+    /**
+     * Returns the optional conformsTo URI of an attachment envelope.
+     *
+     * @returns The conformsTo string if present, or undefined
+     * @throws {EnvelopeError} If the envelope is not a valid attachment
+     */
+    attachmentConformsTo(): string | undefined;
+    /**
+     * Returns all attachment assertions in this envelope.
+     *
+     * @returns Array of attachment envelopes
+     */
+    attachments(): Envelope$1[];
+    /**
+     * Searches for attachments matching the given vendor and conformsTo.
+     *
+     * @param vendor - Optional vendor identifier to match
+     * @param conformsTo - Optional conformsTo URI to match
+     * @returns Array of matching attachment envelopes
+     */
+    attachmentsWithVendorAndConformsTo(vendor?: string, conformsTo?: string): Envelope$1[];
+  }
+  namespace Envelope {
+    /**
+     * Creates a new attachment envelope.
+     *
+     * @param payload - The content of the attachment
+     * @param vendor - A string identifying the entity
+     * @param conformsTo - Optional URI identifying the format
+     * @returns A new attachment envelope
+     */
+    function newAttachment(payload: EnvelopeEncodableValue, vendor: string, conformsTo?: string): Envelope$1;
+  }
+}
+//# sourceMappingURL=attachment.d.ts.map
+//#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;
+}
+declare module "../base/envelope" {
+  interface Envelope {
+    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[];
+  }
+}
+//#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$1;
+  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$1);
+  id(): ParameterID;
+  value(): Envelope$1;
+  isNumeric(): boolean;
+  isString(): boolean;
+  envelope(): Envelope$1;
+  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$1 | undefined;
+  hasParameter(param: ParameterID): boolean;
+  envelope(): Envelope$1;
+  static fromEnvelope(envelope: Envelope$1): 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/extension/proof.d.ts
+declare module "../base/envelope" {
+  interface Envelope {
+    proofContainsSet(target: Set<Digest>): Envelope | undefined;
+    proofContainsTarget(target: Envelope): Envelope | undefined;
+    confirmContainsSet(target: Set<Digest>, proof: Envelope): boolean;
+    confirmContainsTarget(target: Envelope, proof: Envelope): boolean;
+  }
+}
+//#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$1 as 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