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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/envelope",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "type": "module",
   "description": "Gordian Envelope for TypeScript",
   "license": "BSD-2-Clause-Patent",
@@ -59,8 +59,8 @@
     "node": ">=18.0.0"
   },
   "devDependencies": {
-    "@bcts/eslint": "workspace:*",
-    "@bcts/tsconfig": "workspace:*",
+    "@bcts/eslint": "^0.1.0",
+    "@bcts/tsconfig": "^0.1.0",
     "@eslint/js": "^9.39.1",
     "@types/node": "^24.10.1",
     "@types/pako": "^2.0.3",
@@ -73,12 +73,12 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@bcts/components": "workspace:*",
-    "@bcts/crypto": "workspace:*",
-    "@bcts/dcbor": "workspace:*",
-    "@bcts/known-values": "workspace:*",
-    "@bcts/rand": "workspace:*",
-    "@bcts/uniform-resources": "workspace:*",
+    "@bcts/components": "^1.0.0-alpha.9",
+    "@bcts/crypto": "^1.0.0-alpha.9",
+    "@bcts/dcbor": "^1.0.0-alpha.9",
+    "@bcts/known-values": "^1.0.0-alpha.9",
+    "@bcts/rand": "^1.0.0-alpha.9",
+    "@bcts/uniform-resources": "^1.0.0-alpha.9",
     "pako": "^2.1.0"
   }
 }

package/src/base/assertions.ts

@@ -11,157 +11,6 @@ import { EnvelopeError } from "./error";
 /// These methods extend the Envelope class to provide a rich API for
 /// working with assertions, matching the Rust bc-envelope implementation.
 
-declare module "./envelope" {
-  interface Envelope {
-    /// Returns a new envelope with multiple assertion envelopes added.
-    ///
-    /// This is a convenience method for adding multiple assertions at once.
-    /// Each assertion in the array must be a valid assertion envelope or an
-    /// obscured variant of one.
-    ///
-    /// @param assertions - An array of valid assertion envelopes to add
-    /// @returns A new envelope with all the assertions added
-    /// @throws {EnvelopeError} If any of the provided envelopes are not valid
-    ///   assertion envelopes
-    addAssertionEnvelopes(assertions: Envelope[]): Envelope;
-
-    /// Adds an optional assertion envelope to this envelope.
-    ///
-    /// If the optional assertion is present, adds it to the envelope.
-    /// Otherwise, returns the envelope unchanged. This method is particularly
-    /// useful when working with functions that may or may not return an
-    /// assertion.
-    ///
-    /// The method also ensures that duplicate assertions (with the same digest)
-    /// are not added, making it idempotent.
-    ///
-    /// @param assertion - An optional assertion envelope to add
-    /// @returns A new envelope with the assertion added if provided, or the
-    ///   original envelope if no assertion was provided or it was a duplicate
-    /// @throws {EnvelopeError} If the provided envelope is not a valid assertion
-    ///   envelope or an obscured variant
-    addOptionalAssertionEnvelope(assertion: Envelope | undefined): Envelope;
-
-    /// Adds an assertion with the given predicate and optional object.
-    ///
-    /// This method is useful when you have a predicate but may or may not have
-    /// an object value to associate with it. If the object is present, an
-    /// assertion is created and added to the envelope. Otherwise, the
-    /// envelope is returned unchanged.
-    ///
-    /// @param predicate - The predicate for the assertion
-    /// @param object - An optional object value for the assertion
-    /// @returns A new envelope with the assertion added if the object was
-    ///   provided, or the original envelope if no object was provided
-    addOptionalAssertion(
-      predicate: EnvelopeEncodableValue,
-      object: EnvelopeEncodableValue | undefined,
-    ): Envelope;
-
-    /// Adds an assertion with the given predicate and string value, but only if
-    /// the string is non-empty.
-    ///
-    /// This is a convenience method that only adds an assertion if the string
-    /// value is non-empty. It's particularly useful when working with user
-    /// input or optional text fields that should only be included if they
-    /// contain actual content.
-    ///
-    /// @param predicate - The predicate for the assertion
-    /// @param str - The string value for the assertion
-    /// @returns A new envelope with the assertion added if the string is
-    ///   non-empty, or the original envelope if the string is empty
-    addNonemptyStringAssertion(predicate: EnvelopeEncodableValue, str: string): Envelope;
-
-    /// Returns a new envelope with the given array of assertions added.
-    ///
-    /// Similar to `addAssertionEnvelopes` but doesn't throw errors. This is
-    /// useful when you're certain all envelopes in the array are valid
-    /// assertion envelopes and don't need to handle errors.
-    ///
-    /// @param envelopes - An array of assertion envelopes to add
-    /// @returns A new envelope with all the valid assertions added
-    addAssertions(envelopes: Envelope[]): Envelope;
-
-    /// Adds an assertion only if the provided condition is true.
-    ///
-    /// This method allows for conditional inclusion of assertions based on a
-    /// boolean condition. It's a convenient way to add assertions only in
-    /// certain circumstances without requiring separate conditional logic.
-    ///
-    /// @param condition - Boolean that determines whether to add the assertion
-    /// @param predicate - The predicate for the assertion
-    /// @param object - The object value for the assertion
-    /// @returns A new envelope with the assertion added if the condition is
-    ///   true, or the original envelope if the condition is false
-    addAssertionIf(
-      condition: boolean,
-      predicate: EnvelopeEncodableValue,
-      object: EnvelopeEncodableValue,
-    ): Envelope;
-
-    /// Adds an assertion envelope only if the provided condition is true.
-    ///
-    /// Similar to `addAssertionIf` but works with pre-constructed assertion
-    /// envelopes. This is useful when you have already created an assertion
-    /// envelope separately and want to conditionally add it.
-    ///
-    /// @param condition - Boolean that determines whether to add the assertion
-    ///   envelope
-    /// @param assertionEnvelope - The assertion envelope to add
-    /// @returns A new envelope with the assertion added if the condition is
-    ///   true, or the original envelope if the condition is false
-    /// @throws {EnvelopeError} If the provided envelope is not a valid assertion
-    ///   envelope or an obscured variant and the condition is true
-    addAssertionEnvelopeIf(condition: boolean, assertionEnvelope: Envelope): Envelope;
-
-    /// Returns a new envelope with the given assertion removed.
-    ///
-    /// Finds and removes an assertion matching the target assertion's digest.
-    /// If the assertion doesn't exist, returns the same envelope unchanged.
-    /// If removing the assertion would leave the envelope with no assertions,
-    /// returns just the subject as a new envelope.
-    ///
-    /// @param target - The assertion envelope to remove
-    /// @returns A new envelope with the specified assertion removed if found,
-    ///   or the original envelope if not found
-    removeAssertion(target: Envelope): Envelope;
-
-    /// Returns a new envelope with the given assertion replaced by a new one.
-    ///
-    /// This method removes the specified assertion and adds a new one in its
-    /// place. If the targeted assertion does not exist, returns the same
-    /// envelope with the new assertion added.
-    ///
-    /// @param assertion - The assertion envelope to replace
-    /// @param newAssertion - The new assertion envelope to add
-    /// @returns A new envelope with the assertion replaced if found, or the
-    ///   original envelope with the new assertion added if not found
-    /// @throws {EnvelopeError} If the new assertion is not a valid assertion
-    ///   envelope or an obscured variant
-    replaceAssertion(assertion: Envelope, newAssertion: Envelope): Envelope;
-
-    /// Returns a new envelope with its subject replaced by the provided one.
-    ///
-    /// This method preserves all assertions from the original envelope but
-    /// applies them to a new subject. It effectively creates a new envelope
-    /// with the provided subject and copies over all assertions from the
-    /// current envelope.
-    ///
-    /// @param subject - The new subject for the envelope
-    /// @returns A new envelope with the new subject and all assertions from the
-    ///   original envelope
-    replaceSubject(subject: Envelope): Envelope;
-
-    /// Returns the assertions of this envelope.
-    ///
-    /// For a node envelope, returns the array of assertion envelopes.
-    /// For all other envelope types, returns an empty array.
-    ///
-    /// @returns An array of assertion envelopes
-    assertions(): Envelope[];
-  }
-}
-
 /// Implementation of addAssertionEnvelopes
 Envelope.prototype.addAssertionEnvelopes = function (
   this: Envelope,

package/src/base/elide.ts

@@ -33,142 +33,6 @@ export function elideAction(): ObscureAction {
   return { type: "elide" };
 }
 
-/// Support for eliding elements from envelopes.
-declare module "./envelope" {
-  interface Envelope {
-    /// Returns the elided variant of this envelope.
-    ///
-    /// Elision replaces an envelope with just its digest, hiding its content
-    /// while maintaining the integrity of the envelope's digest tree.
-    ///
-    /// @returns The elided envelope
-    elide(): Envelope;
-
-    /// Returns a version of this envelope with elements in the target set
-    /// obscured using the specified action.
-    ///
-    /// @param target - The set of digests that identify elements to be obscured
-    /// @param action - The action to perform on the targeted elements
-    /// @returns The modified envelope
-    elideRemovingSetWithAction(target: Set<Digest>, action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with elements in the target set
-    /// elided.
-    ///
-    /// @param target - The set of digests that identify elements to be elided
-    /// @returns The modified envelope
-    elideRemovingSet(target: Set<Digest>): Envelope;
-
-    /// Returns a version of this envelope with elements in the target array
-    /// obscured using the specified action.
-    ///
-    /// @param target - An array of DigestProviders
-    /// @param action - The action to perform
-    /// @returns The modified envelope
-    elideRemovingArrayWithAction(target: DigestProvider[], action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with elements in the target array
-    /// elided.
-    ///
-    /// @param target - An array of DigestProviders
-    /// @returns The modified envelope
-    elideRemovingArray(target: DigestProvider[]): Envelope;
-
-    /// Returns a version of this envelope with the target element obscured.
-    ///
-    /// @param target - A DigestProvider
-    /// @param action - The action to perform
-    /// @returns The modified envelope
-    elideRemovingTargetWithAction(target: DigestProvider, action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with the target element elided.
-    ///
-    /// @param target - A DigestProvider
-    /// @returns The modified envelope
-    elideRemovingTarget(target: DigestProvider): Envelope;
-
-    /// Returns a version of this envelope with only elements in the target set
-    /// revealed, and all other elements obscured.
-    ///
-    /// @param target - The set of digests that identify elements to be revealed
-    /// @param action - The action to perform on other elements
-    /// @returns The modified envelope
-    elideRevealingSetWithAction(target: Set<Digest>, action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with only elements in the target set
-    /// revealed.
-    ///
-    /// @param target - The set of digests that identify elements to be revealed
-    /// @returns The modified envelope
-    elideRevealingSet(target: Set<Digest>): Envelope;
-
-    /// Returns a version of this envelope with elements not in the target array
-    /// obscured.
-    ///
-    /// @param target - An array of DigestProviders
-    /// @param action - The action to perform
-    /// @returns The modified envelope
-    elideRevealingArrayWithAction(target: DigestProvider[], action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with elements not in the target array
-    /// elided.
-    ///
-    /// @param target - An array of DigestProviders
-    /// @returns The modified envelope
-    elideRevealingArray(target: DigestProvider[]): Envelope;
-
-    /// Returns a version of this envelope with all elements except the target
-    /// element obscured.
-    ///
-    /// @param target - A DigestProvider
-    /// @param action - The action to perform
-    /// @returns The modified envelope
-    elideRevealingTargetWithAction(target: DigestProvider, action: ObscureAction): Envelope;
-
-    /// Returns a version of this envelope with all elements except the target
-    /// element elided.
-    ///
-    /// @param target - A DigestProvider
-    /// @returns The modified envelope
-    elideRevealingTarget(target: DigestProvider): Envelope;
-
-    /// Returns the unelided variant of this envelope by revealing the original
-    /// content.
-    ///
-    /// @param envelope - The original unelided envelope
-    /// @returns The revealed envelope
-    /// @throws {EnvelopeError} If digests don't match
-    unelide(envelope: Envelope): Envelope;
-
-    /// Returns the set of digests of nodes matching the specified criteria.
-    ///
-    /// @param targetDigests - Optional set of digests to filter by
-    /// @param obscureTypes - Array of ObscureType values to match against
-    /// @returns A Set of matching digests
-    nodesMatching(targetDigests: Set<Digest> | undefined, obscureTypes: ObscureType[]): Set<Digest>;
-
-    /// Returns a new envelope with elided nodes restored from the provided set.
-    ///
-    /// @param envelopes - An array of envelopes that may match elided nodes
-    /// @returns The envelope with restored nodes
-    walkUnelide(envelopes: Envelope[]): Envelope;
-
-    /// Returns a new envelope with nodes matching target digests replaced.
-    ///
-    /// @param target - Set of digests identifying nodes to replace
-    /// @param replacement - The envelope to use for replacement
-    /// @returns The modified envelope
-    /// @throws {EnvelopeError} If replacement is invalid
-    walkReplace(target: Set<Digest>, replacement: Envelope): Envelope;
-
-    /// Checks if two envelopes are identical (same structure and content).
-    ///
-    /// @param other - The other envelope to compare with
-    /// @returns `true` if identical
-    isIdenticalTo(other: Envelope): boolean;
-  }
-}
-
 /// Implementation of elide()
 Envelope.prototype.elide = function (this: Envelope): Envelope {
   const c = this.case();

package/src/base/envelope-decodable.ts

@@ -117,49 +117,6 @@ export function extractNull(envelope: Envelope): null {
   throw EnvelopeError.cbor("envelope does not contain null");
 }
 
-/// Extension methods for Envelope to support CBOR decoding.
-///
-/// These methods are added to the Envelope class prototype to match
-/// the Rust API.
-declare module "./envelope" {
-  interface Envelope {
-    /// Attempts to extract the leaf CBOR value from this envelope.
-    ///
-    /// @returns The CBOR value contained in the leaf
-    /// @throws {EnvelopeError} If the envelope is not a leaf
-    tryLeaf(): Cbor;
-
-    /// Converts this envelope to a string.
-    ///
-    /// @returns The string value
-    /// @throws {EnvelopeError} If the envelope cannot be converted
-    extractString(): string;
-
-    /// Converts this envelope to a number.
-    ///
-    /// @returns The number value
-    /// @throws {EnvelopeError} If the envelope cannot be converted
-    extractNumber(): number;
-
-    /// Converts this envelope to a boolean.
-    ///
-    /// @returns The boolean value
-    /// @throws {EnvelopeError} If the envelope cannot be converted
-    extractBoolean(): boolean;
-
-    /// Converts this envelope to a byte array.
-    ///
-    /// @returns The byte array value
-    /// @throws {EnvelopeError} If the envelope cannot be converted
-    extractBytes(): Uint8Array;
-
-    /// Extracts null from this envelope.
-    ///
-    /// @throws {EnvelopeError} If the envelope does not contain null
-    extractNull(): null;
-  }
-}
-
 /// Static methods for creating envelopes from CBOR data.
 ///
 /// These are convenience methods that mirror the Rust implementation.

package/src/base/envelope.ts

@@ -3,7 +3,7 @@ import { Assertion } from "./assertion";
 import { EnvelopeError } from "./error";
 import type { EnvelopeEncodableValue } from "./envelope-encodable";
 import { KnownValue } from "@bcts/known-values";
-import type { Cbor } from "@bcts/dcbor";
+import type { Cbor, CborMap } from "@bcts/dcbor";
 import {
   cbor,
   cborData,
@@ -18,6 +18,20 @@ import {
 } from "@bcts/dcbor";
 import { ENVELOPE, LEAF, ENCRYPTED, COMPRESSED } from "@bcts/components";
 
+// Type imports for extension method declarations
+// These are imported as types only to avoid circular dependencies at runtime
+import type { ObscureAction, ObscureType } from "./elide";
+import type { Visitor } from "./walk";
+import type {
+  SymmetricKey,
+  SealedMessage,
+  PublicKeyBase,
+  PrivateKeyBase,
+  Signer,
+  Verifier,
+  SignatureMetadata,
+} from "../extension";
+
 /// Import tag values from the tags registry
 /// These match the Rust reference implementation in bc-tags-rust
 const TAG_ENVELOPE = ENVELOPE.value;
@@ -787,4 +801,188 @@ export class Envelope implements DigestProvider {
   ///
   /// @returns A diagnostic string
   declare diagnostic: () => string;
+
+  //
+  // Extension methods (implemented via prototype extension in extension modules)
+  // These declarations ensure TypeScript recognizes the methods when consuming the package
+  //
+
+  // From assertions.ts
+  declare addAssertionEnvelopes: (assertions: Envelope[]) => Envelope;
+  declare addOptionalAssertionEnvelope: (assertion: Envelope | undefined) => Envelope;
+  declare addOptionalAssertion: (
+    predicate: EnvelopeEncodableValue,
+    object: EnvelopeEncodableValue | undefined,
+  ) => Envelope;
+  declare addNonemptyStringAssertion: (predicate: EnvelopeEncodableValue, str: string) => Envelope;
+  declare addAssertions: (envelopes: Envelope[]) => Envelope;
+  declare addAssertionIf: (
+    condition: boolean,
+    predicate: EnvelopeEncodableValue,
+    object: EnvelopeEncodableValue,
+  ) => Envelope;
+  declare addAssertionEnvelopeIf: (condition: boolean, assertionEnvelope: Envelope) => Envelope;
+  declare removeAssertion: (target: Envelope) => Envelope;
+  declare replaceAssertion: (assertion: Envelope, newAssertion: Envelope) => Envelope;
+  declare replaceSubject: (subject: Envelope) => Envelope;
+
+  // From elide.ts
+  declare elide: () => Envelope;
+  declare elideRemovingSetWithAction: (target: Set<Digest>, action: ObscureAction) => Envelope;
+  declare elideRemovingSet: (target: Set<Digest>) => Envelope;
+  declare elideRemovingArrayWithAction: (
+    target: DigestProvider[],
+    action: ObscureAction,
+  ) => Envelope;
+  declare elideRemovingArray: (target: DigestProvider[]) => Envelope;
+  declare elideRemovingTargetWithAction: (
+    target: DigestProvider,
+    action: ObscureAction,
+  ) => Envelope;
+  declare elideRemovingTarget: (target: DigestProvider) => Envelope;
+  declare elideRevealingSetWithAction: (target: Set<Digest>, action: ObscureAction) => Envelope;
+  declare elideRevealingSet: (target: Set<Digest>) => Envelope;
+  declare elideRevealingArrayWithAction: (
+    target: DigestProvider[],
+    action: ObscureAction,
+  ) => Envelope;
+  declare elideRevealingArray: (target: DigestProvider[]) => Envelope;
+  declare elideRevealingTargetWithAction: (
+    target: DigestProvider,
+    action: ObscureAction,
+  ) => Envelope;
+  declare elideRevealingTarget: (target: DigestProvider) => Envelope;
+  declare unelide: (envelope: Envelope) => Envelope;
+  declare nodesMatching: (
+    targetDigests: Set<Digest> | undefined,
+    obscureTypes: ObscureType[],
+  ) => Set<Digest>;
+  declare walkUnelide: (envelopes: Envelope[]) => Envelope;
+  declare walkReplace: (target: Set<Digest>, replacement: Envelope) => Envelope;
+  declare isIdenticalTo: (other: Envelope) => boolean;
+
+  // From leaf.ts
+  declare tryLeaf: () => Cbor;
+  declare extractString: () => string;
+  declare extractNumber: () => number;
+  declare extractBoolean: () => boolean;
+  declare extractBytes: () => Uint8Array;
+  declare extractNull: () => null;
+
+  // From queries.ts
+  declare isFalse: () => boolean;
+  declare isTrue: () => boolean;
+  declare isBool: () => boolean;
+  declare isNumber: () => boolean;
+  declare isSubjectNumber: () => boolean;
+  declare isNaN: () => boolean;
+  declare isSubjectNaN: () => boolean;
+  declare isNull: () => boolean;
+  declare tryByteString: () => Uint8Array;
+  declare asByteString: () => Uint8Array | undefined;
+  declare asArray: () => readonly Cbor[] | undefined;
+  declare asMap: () => CborMap | undefined;
+  declare asText: () => string | undefined;
+  declare asLeaf: () => Cbor | undefined;
+  declare hasAssertions: () => boolean;
+  declare asAssertion: () => Envelope | undefined;
+  declare tryAssertion: () => Envelope;
+  declare asPredicate: () => Envelope | undefined;
+  declare tryPredicate: () => Envelope;
+  declare asObject: () => Envelope | undefined;
+  declare tryObject: () => Envelope;
+  declare isAssertion: () => boolean;
+  declare isElided: () => boolean;
+  declare isLeaf: () => boolean;
+  declare isNode: () => boolean;
+  declare isWrapped: () => boolean;
+  declare isInternal: () => boolean;
+  declare isObscured: () => boolean;
+  declare assertions: () => Envelope[];
+  declare assertionsWithPredicate: (predicate: EnvelopeEncodableValue) => Envelope[];
+  declare assertionWithPredicate: (predicate: EnvelopeEncodableValue) => Envelope;
+  declare optionalAssertionWithPredicate: (
+    predicate: EnvelopeEncodableValue,
+  ) => Envelope | undefined;
+  declare objectForPredicate: (predicate: EnvelopeEncodableValue) => Envelope;
+  declare optionalObjectForPredicate: (predicate: EnvelopeEncodableValue) => Envelope | undefined;
+  declare objectsForPredicate: (predicate: EnvelopeEncodableValue) => Envelope[];
+  declare elementsCount: () => number;
+
+  // From walk.ts
+  declare walk: <State>(hideNodes: boolean, state: State, visit: Visitor<State>) => void;
+
+  // From wrap.ts
+  declare wrap: () => Envelope;
+  declare tryUnwrap: () => Envelope;
+  declare unwrap: () => Envelope;
+
+  // From attachment.ts
+  declare addAttachment: (
+    payload: EnvelopeEncodableValue,
+    vendor: string,
+    conformsTo?: string,
+  ) => Envelope;
+  declare attachmentPayload: () => Envelope;
+  declare attachmentVendor: () => string;
+  declare attachmentConformsTo: () => string | undefined;
+  declare attachments: () => Envelope[];
+  declare attachmentsWithVendorAndConformsTo: (vendor?: string, conformsTo?: string) => Envelope[];
+
+  // From compress.ts
+  declare compress: () => Envelope;
+  declare decompress: () => Envelope;
+  declare compressSubject: () => Envelope;
+  declare decompressSubject: () => Envelope;
+  declare isCompressed: () => boolean;
+
+  // From encrypt.ts
+  declare encryptSubject: (key: SymmetricKey) => Envelope;
+  declare decryptSubject: (key: SymmetricKey) => Envelope;
+  declare encrypt: (key: SymmetricKey) => Envelope;
+  declare decrypt: (key: SymmetricKey) => Envelope;
+  declare isEncrypted: () => boolean;
+
+  // From proof.ts
+  declare proofContainsSet: (target: Set<Digest>) => Envelope | undefined;
+  declare proofContainsTarget: (target: Envelope) => Envelope | undefined;
+  declare confirmContainsSet: (target: Set<Digest>, proof: Envelope) => boolean;
+  declare confirmContainsTarget: (target: Envelope, proof: Envelope) => boolean;
+
+  // From recipient.ts
+  declare encryptSubjectToRecipient: (recipientPublicKey: PublicKeyBase) => Envelope;
+  declare encryptSubjectToRecipients: (recipients: PublicKeyBase[]) => Envelope;
+  declare addRecipient: (recipientPublicKey: PublicKeyBase, contentKey: SymmetricKey) => Envelope;
+  declare decryptSubjectToRecipient: (recipientPrivateKey: PrivateKeyBase) => Envelope;
+  declare decryptToRecipient: (recipientPrivateKey: PrivateKeyBase) => Envelope;
+  declare encryptToRecipients: (recipients: PublicKeyBase[]) => Envelope;
+  declare recipients: () => SealedMessage[];
+
+  // From salt.ts
+  declare addSalt: () => Envelope;
+  declare addSaltWithLength: (count: number) => Envelope;
+  declare addSaltBytes: (saltBytes: Uint8Array) => Envelope;
+  declare addSaltInRange: (min: number, max: number) => Envelope;
+
+  // From signature.ts
+  declare addSignature: (signer: Signer) => Envelope;
+  declare addSignatureWithMetadata: (signer: Signer, metadata?: SignatureMetadata) => Envelope;
+  declare addSignatures: (signers: Signer[]) => Envelope;
+  declare hasSignatureFrom: (verifier: Verifier) => boolean;
+  declare verifySignatureFrom: (verifier: Verifier) => Envelope;
+  declare signatures: () => Envelope[];
+
+  // From types.ts
+  declare addType: (object: EnvelopeEncodableValue) => Envelope;
+  declare types: () => Envelope[];
+  declare getType: () => Envelope;
+  declare hasType: (t: EnvelopeEncodableValue) => boolean;
+  declare checkType: (t: EnvelopeEncodableValue) => void;
+
+  // Static methods from extensions
+  declare static newAttachment: (
+    payload: EnvelopeEncodableValue,
+    vendor: string,
+    conformsTo?: string,
+  ) => Envelope;
 }