@bcts/envelope 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/index.d.cts

@@ -21,17 +21,17 @@ interface DigestProvider {
 //#endregion
 //#region src/base/envelope-encodable.d.ts
 interface EnvelopeEncodable {
-  intoEnvelope(): Envelope$1;
+  intoEnvelope(): Envelope;
 }
 declare function isEnvelopeEncodable(value: unknown): value is EnvelopeEncodable;
-type EnvelopeEncodableValue = EnvelopeEncodable | string | number | boolean | bigint | Uint8Array | null | undefined | Envelope$1;
+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$1, object: EnvelopeEncodable | Envelope$1);
-  predicate(): Envelope$1;
-  object(): Envelope$1;
+  constructor(predicate: EnvelopeEncodable | Envelope, object: EnvelopeEncodable | Envelope);
+  predicate(): Envelope;
+  object(): Envelope;
   digest(): Digest;
   equals(other: Assertion): boolean;
   toCbor(): Cbor;
@@ -41,255 +41,6 @@ declare class Assertion implements DigestProvider {
   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",
@@ -305,29 +56,6 @@ type ObscureAction = {
   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 {
@@ -339,115 +67,45 @@ declare enum EdgeType {
   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;
-  }
-}
+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";
-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;
-  }
+//#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;
 }
-//# sourceMappingURL=salt.d.ts.map
-
+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
 /**
@@ -585,66 +243,6 @@ declare class SignatureMetadata {
    */
   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
 /**
@@ -685,14 +283,14 @@ declare class Attachments {
    * @param digest - The unique digest of the attachment to retrieve
    * @returns The envelope if found, or undefined
    */
-  get(digest: Digest): Envelope$1 | 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$1 | undefined;
+  remove(digest: Digest): Envelope | undefined;
   /**
    * Removes all attachments from the container.
    */
@@ -707,94 +305,15 @@ declare class Attachments {
    * @param envelope - The envelope to add attachments to
    * @returns A new envelope with all attachments added as assertions
    */
-  addToEnvelope(envelope: Envelope$1): Envelope$1;
+  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$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;
-  }
+  static fromEnvelope(envelope: Envelope): Attachments;
 }
-//# sourceMappingURL=attachment.d.ts.map
 //#endregion
 //#region src/extension/recipient.d.ts
 declare const HAS_RECIPIENT = "hasRecipient";
@@ -825,17 +344,6 @@ declare class SealedMessage {
   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;
@@ -872,7 +380,7 @@ declare class Function {
   id(): FunctionID;
   isNumeric(): boolean;
   isString(): boolean;
-  envelope(): Envelope$1;
+  envelope(): Envelope;
   withParameter(param: ParameterID, value: EnvelopeEncodableValue): Expression;
   static fromNumeric(id: number): Function;
   static fromString(name: string): Function;
@@ -880,12 +388,12 @@ declare class Function {
 }
 declare class Parameter {
   #private;
-  constructor(id: ParameterID, value: Envelope$1);
+  constructor(id: ParameterID, value: Envelope);
   id(): ParameterID;
-  value(): Envelope$1;
+  value(): Envelope;
   isNumeric(): boolean;
   isString(): boolean;
-  envelope(): Envelope$1;
+  envelope(): Envelope;
   static blank(value: EnvelopeEncodableValue): Parameter;
   static lhs(value: EnvelopeEncodableValue): Parameter;
   static rhs(value: EnvelopeEncodableValue): Parameter;
@@ -898,10 +406,10 @@ declare class Expression {
   parameters(): Parameter[];
   withParameter(param: ParameterID, value: EnvelopeEncodableValue): Expression;
   withParameters(params: Record<string, EnvelopeEncodableValue>): Expression;
-  getParameter(param: ParameterID): Envelope$1 | undefined;
+  getParameter(param: ParameterID): Envelope | undefined;
   hasParameter(param: ParameterID): boolean;
-  envelope(): Envelope$1;
-  static fromEnvelope(envelope: Envelope$1): Expression;
+  envelope(): Envelope;
+  static fromEnvelope(envelope: Envelope): Expression;
   toString(): string;
 }
 declare function add(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue): Expression;
@@ -916,14 +424,310 @@ declare function and(lhs: EnvelopeEncodableValue, rhs: EnvelopeEncodableValue):
 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;
-  }
+//#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
@@ -974,5 +778,5 @@ declare global {
 //#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 };
+export { ATTACHMENT, Assertion, Attachments, CBOR_TAG_FUNCTION, CBOR_TAG_PARAMETER, CBOR_TAG_PLACEHOLDER, CBOR_TAG_REPLACEMENT, CONFORMS_TO, Compressed, Digest, DigestProvider, EdgeType, EncryptedMessage, Envelope, EnvelopeCBORTagged, EnvelopeCBORTaggedDecodable, EnvelopeCBORTaggedEncodable, EnvelopeCase, EnvelopeDecoder, EnvelopeEncodable, EnvelopeEncodableValue, EnvelopeError, ErrorCode, Expression, FUNCTION_IDS, Function, FunctionID, HAS_RECIPIENT, IS_A, NOTE, ObscureAction, ObscureType, PARAMETER_IDS, Parameter, ParameterID, PrivateKeyBase, PublicKeyBase, SALT, SIGNED, SealedMessage, Signature, SignatureMetadata, Signer, SigningPrivateKey, SigningPublicKey, SymmetricKey, TreeFormatOptions, VENDOR, VERIFIED_BY, VERSION, Verifier, 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.cts.map