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

package/src/extension/recipient.ts

@@ -286,123 +286,6 @@ export class SealedMessage {
   }
 }
 
-declare module "../base/envelope" {
-  interface Envelope {
-    /// Encrypts the envelope's subject to a single recipient.
-    ///
-    /// Generates a random content key, encrypts the subject with it,
-    /// and adds a sealed message containing the content key encrypted
-    /// to the recipient's public key.
-    ///
-    /// @param recipientPublicKey - The recipient's public key
-    /// @returns A new envelope with encrypted subject and recipient assertion
-    ///
-    /// @example
-    /// ```typescript
-    /// const bob = PrivateKeyBase.generate();
-    /// const encrypted = envelope.encryptSubjectToRecipient(bob.publicKeys());
-    /// ```
-    encryptSubjectToRecipient(recipientPublicKey: PublicKeyBase): Envelope;
-
-    /// Encrypts the envelope's subject to multiple recipients.
-    ///
-    /// Each recipient gets their own sealed message containing the same
-    /// content key encrypted to their public key. Recipients must try
-    /// each sealed message until one decrypts successfully.
-    ///
-    /// @param recipients - Array of recipient public keys
-    /// @returns A new envelope with encrypted subject and multiple recipient assertions
-    ///
-    /// @example
-    /// ```typescript
-    /// const encrypted = envelope.encryptSubjectToRecipients([
-    ///   alice.publicKeys(),
-    ///   bob.publicKeys(),
-    ///   charlie.publicKeys()
-    /// ]);
-    /// ```
-    encryptSubjectToRecipients(recipients: PublicKeyBase[]): Envelope;
-
-    /// Adds a recipient to an already encrypted envelope.
-    ///
-    /// The envelope must already be encrypted with a content key.
-    /// This method adds another recipient who can decrypt using the
-    /// same content key.
-    ///
-    /// @param recipientPublicKey - The new recipient's public key
-    /// @param contentKey - The symmetric key used to encrypt the subject
-    /// @returns A new envelope with an additional recipient assertion
-    ///
-    /// @example
-    /// ```typescript
-    /// const dave = PrivateKeyBase.generate();
-    /// const withDave = encrypted.addRecipient(dave.publicKeys(), contentKey);
-    /// ```
-    addRecipient(recipientPublicKey: PublicKeyBase, contentKey: SymmetricKey): Envelope;
-
-    /// Decrypts an envelope's subject using a recipient's private key.
-    ///
-    /// Tries each `hasRecipient` assertion until one unseals successfully,
-    /// then uses the recovered content key to decrypt the subject.
-    ///
-    /// @param recipientPrivateKey - The recipient's private key
-    /// @returns A new envelope with decrypted subject
-    /// @throws {EnvelopeError} If not a valid recipient or subject not encrypted
-    ///
-    /// @example
-    /// ```typescript
-    /// const decrypted = encrypted.decryptSubjectToRecipient(bob);
-    /// ```
-    decryptSubjectToRecipient(recipientPrivateKey: PrivateKeyBase): Envelope;
-
-    /// Convenience method to decrypt and unwrap an envelope.
-    ///
-    /// Useful when the entire envelope was wrapped and encrypted.
-    /// Decrypts the subject and then unwraps it.
-    ///
-    /// @param recipientPrivateKey - The recipient's private key
-    /// @returns The original decrypted and unwrapped envelope
-    /// @throws {EnvelopeError} If not a valid recipient, subject not encrypted, or cannot unwrap
-    ///
-    /// @example
-    /// ```typescript
-    /// const original = wrappedEncrypted.decryptToRecipient(alice);
-    /// ```
-    decryptToRecipient(recipientPrivateKey: PrivateKeyBase): Envelope;
-
-    /// Convenience method to encrypt an entire envelope to recipients.
-    ///
-    /// Wraps the envelope first, then encrypts it to the recipients.
-    /// This encrypts both the subject and all assertions.
-    ///
-    /// @param recipients - Array of recipient public keys
-    /// @returns A new encrypted envelope
-    ///
-    /// @example
-    /// ```typescript
-    /// const encrypted = envelope.encryptToRecipients([
-    ///   alice.publicKeys(),
-    ///   bob.publicKeys()
-    /// ]);
-    /// ```
-    encryptToRecipients(recipients: PublicKeyBase[]): Envelope;
-
-    /// Returns all sealed messages (recipient assertions) in the envelope.
-    ///
-    /// Each sealed message represents one recipient who can decrypt
-    /// the envelope's subject.
-    ///
-    /// @returns Array of sealed messages
-    ///
-    /// @example
-    /// ```typescript
-    /// const recipients = envelope.recipients();
-    /// console.log(`Envelope has ${recipients.length} recipients`);
-    /// ```
-    recipients(): SealedMessage[];
-  }
-}
-
 /// Implementation of encryptSubjectToRecipient()
 // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
 if (Envelope?.prototype) {

package/src/extension/salt.ts

@@ -60,115 +60,6 @@ function calculateProportionalSaltSize(envelopeSize: number, rng?: RandomNumberG
   return rngNextInClosedRangeI32(actualRng, minSize, maxSize);
 }
 
-declare module "../base/envelope" {
-  interface Envelope {
-    /// Adds a proportionally-sized salt assertion to decorrelate the envelope.
-    ///
-    /// This method adds random salt bytes as an assertion to the envelope. The
-    /// size of the salt is proportional to the size of the envelope being
-    /// salted:
-    /// - For small envelopes: 8-16 bytes
-    /// - For larger envelopes: 5-25% of the envelope's size
-    ///
-    /// Salt is added as an assertion with the predicate 'salt' and an object
-    /// containing random bytes. This changes the digest of the envelope while
-    /// preserving its semantic content, making it impossible to correlate with
-    /// other envelopes containing the same information.
-    ///
-    /// @returns A new envelope with the salt assertion added
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create an envelope with personally identifiable information
-    /// const alice = Envelope.new("Alice")
-    ///   .addAssertion("email", "alice@example.com")
-    ///   .addAssertion("ssn", "123-45-6789");
-    ///
-    /// // Create a second envelope with the same information
-    /// const alice2 = Envelope.new("Alice")
-    ///   .addAssertion("email", "alice@example.com")
-    ///   .addAssertion("ssn", "123-45-6789");
-    ///
-    /// // The envelopes have the same digest
-    /// console.log(alice.digest().equals(alice2.digest())); // true
-    ///
-    /// // Add salt to both envelopes
-    /// const aliceSalted = alice.addSalt();
-    /// const alice2Salted = alice2.addSalt();
-    ///
-    /// // Now the envelopes have different digests, preventing correlation
-    /// console.log(aliceSalted.digest().equals(alice2Salted.digest())); // false
-    /// ```
-    addSalt(): Envelope;
-
-    /// Adds salt of a specific byte length to the envelope.
-    ///
-    /// This method adds salt of a specified number of bytes to decorrelate the
-    /// envelope. It requires that the byte count be at least 8 bytes (64 bits)
-    /// to ensure sufficient entropy for effective decorrelation.
-    ///
-    /// @param count - The exact number of salt bytes to add
-    /// @returns A new envelope with salt added
-    /// @throws {EnvelopeError} If the byte count is less than 8
-    ///
-    /// @example
-    /// ```typescript
-    /// const envelope = Envelope.new("Hello");
-    ///
-    /// // Add exactly 16 bytes of salt
-    /// const salted = envelope.addSaltWithLength(16);
-    ///
-    /// // Trying to add less than 8 bytes will throw an error
-    /// try {
-    ///   envelope.addSaltWithLength(7);
-    /// } catch (e) {
-    ///   console.log("Error: salt must be at least 8 bytes");
-    /// }
-    /// ```
-    addSaltWithLength(count: number): Envelope;
-
-    /// Adds the given salt bytes as an assertion to the envelope.
-    ///
-    /// This method attaches specific salt bytes as an assertion to the
-    /// envelope, using 'salt' as the predicate. This is useful when you need
-    /// to control the specific salt content being added.
-    ///
-    /// @param saltBytes - A Uint8Array containing salt bytes
-    /// @returns A new envelope with the salt assertion added
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create salt with specific bytes
-    /// const salt = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
-    ///
-    /// // Add this specific salt to an envelope
-    /// const envelope = Envelope.new("Hello");
-    /// const salted = envelope.addSaltBytes(salt);
-    /// ```
-    addSaltBytes(saltBytes: Uint8Array): Envelope;
-
-    /// Adds salt with a byte length randomly chosen from the given range.
-    ///
-    /// This method adds salt with a length randomly selected from the specified
-    /// range to decorrelate the envelope. This provides additional
-    /// decorrelation by varying the size of the salt itself.
-    ///
-    /// @param min - Minimum number of salt bytes (must be at least 8)
-    /// @param max - Maximum number of salt bytes
-    /// @returns A new envelope with salt added
-    /// @throws {EnvelopeError} If min is less than 8 or max is less than min
-    ///
-    /// @example
-    /// ```typescript
-    /// const envelope = Envelope.new("Hello");
-    ///
-    /// // Add salt with a length randomly chosen between 16 and 32 bytes
-    /// const salted = envelope.addSaltInRange(16, 32);
-    /// ```
-    addSaltInRange(min: number, max: number): Envelope;
-  }
-}
-
 /// Implementation of addSalt()
 // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
 if (Envelope?.prototype) {

package/src/extension/signature.ts

@@ -247,71 +247,6 @@ export class SignatureMetadata {
   }
 }
 
-/**
- * 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[];
-  }
-}
-
 // Implementation
 // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
 if (Envelope?.prototype) {

package/src/extension/types.ts

@@ -53,136 +53,6 @@ import { EnvelopeError } from "../base/error";
 /// The standard predicate for type assertions
 export const IS_A = "isA";
 
-declare module "../base/envelope" {
-  interface Envelope {
-    /// Adds a type assertion to the envelope using the `'isA'` predicate.
-    ///
-    /// This method provides a convenient way to declare the type of an envelope
-    /// using the standard `'isA'` predicate. The type can be any value that can
-    /// be converted to an envelope, typically a string.
-    ///
-    /// @param object - The type to assign to this envelope
-    /// @returns A new envelope with the type assertion added
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create a document and declare its type
-    /// const document = Envelope.new("Important Content").addType("Document");
-    ///
-    /// // Verify the type was added
-    /// assert(document.hasType("Document"));
-    /// ```
-    addType(object: EnvelopeEncodableValue): Envelope;
-
-    /// Returns all type objects from the envelope's `'isA'` assertions.
-    ///
-    /// This method retrieves all objects of assertions that use the `'isA'`
-    /// predicate. Each returned envelope represents a type that has been
-    /// assigned to this envelope.
-    ///
-    /// @returns An array of envelopes, each representing a type assigned to
-    ///   this envelope
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create an envelope with multiple types
-    /// const multiTyped = Envelope.new("Versatile Entity")
-    ///   .addType("Person")
-    ///   .addType("Employee")
-    ///   .addType("Manager");
-    ///
-    /// // Get all the type objects
-    /// const types = multiTyped.types();
-    ///
-    /// // There should be 3 types
-    /// console.log(types.length); // 3
-    /// ```
-    types(): Envelope[];
-
-    /// Gets a single type object from the envelope's `'isA'` assertions.
-    ///
-    /// This method is useful when an envelope is expected to have exactly one
-    /// type. It throws an error if the envelope has zero or multiple types.
-    ///
-    /// @returns The single type object if exactly one exists
-    /// @throws {EnvelopeError} If multiple types exist or no types exist
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create an envelope with a single type
-    /// const person = Envelope.new("Alice").addType("Person");
-    ///
-    /// // Get the type
-    /// const typeObj = person.getType();
-    /// const typeString = typeObj.extractString();
-    /// console.log(typeString); // "Person"
-    /// ```
-    getType(): Envelope;
-
-    /// Checks if the envelope has a specific type, using an envelope as the
-    /// type identifier.
-    ///
-    /// This method compares the digest of each type object with the digest of
-    /// the provided value to determine if the envelope has the specified type.
-    ///
-    /// @param t - The type to check for, which will be converted to an envelope
-    /// @returns `true` if the envelope has the specified type, `false`
-    ///   otherwise
-    ///
-    /// @example
-    /// ```typescript
-    /// // Create a typed envelope
-    /// const document = Envelope.new("Contract")
-    ///   .addType("LegalDocument")
-    ///   .addAssertion("status", "Draft");
-    ///
-    /// // Check for various types
-    /// console.log(document.hasType("LegalDocument")); // true
-    /// console.log(document.hasType("Spreadsheet")); // false
-    /// ```
-    hasType(t: EnvelopeEncodableValue): boolean;
-
-    /// Verifies that the envelope has a specific type.
-    ///
-    /// This method is similar to `hasType` but throws an error instead of
-    /// returning false, making it suitable for use in validation chains.
-    ///
-    /// @param t - The type to check for, which will be converted to an envelope
-    /// @throws {EnvelopeError} If the envelope does not have the specified type
-    ///
-    /// @example
-    /// ```typescript
-    /// // Function that processes a person
-    /// function processPerson(envelope: Envelope): string {
-    ///   // Verify this is a person
-    ///   envelope.checkType("Person");
-    ///
-    ///   // Extract the name
-    ///   const name = envelope.subject().extractString();
-    ///   return name;
-    /// }
-    ///
-    /// // Create a person envelope
-    /// const person = Envelope.new("Alice").addType("Person");
-    ///
-    /// // Process the person
-    /// const result = processPerson(person);
-    /// console.log(result); // "Alice"
-    ///
-    /// // Create a non-person envelope
-    /// const document = Envelope.new("Contract").addType("Document");
-    ///
-    /// // Processing will throw an error
-    /// try {
-    ///   processPerson(document);
-    /// } catch (e) {
-    ///   console.log("Not a person!");
-    /// }
-    /// ```
-    checkType(t: EnvelopeEncodableValue): void;
-  }
-}
-
 /// Implementation of addType()
 // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
 if (Envelope?.prototype) {