@storacha/encrypt-upload-client 1.1.58 → 1.1.59

package/dist/crypto/adapters/kms-crypto-adapter.d.ts

@@ -7,176 +7,141 @@
  * @implements {Type.CryptoAdapter}
  */
 export class KMSCryptoAdapter implements Type.CryptoAdapter {
-  /**
-   * Create a new KMS crypto adapter
-   *
-   * @param {Type.SymmetricCrypto} symmetricCrypto - The symmetric crypto implementation (browser or node)
-   * @param {URL|string} keyManagerServiceURL - The key manager service URL
-   * @param {`did:${string}:${string}`} keyManagerServiceDID - The key manager service DID
-   * @param {object} [options] - Optional configuration
-   * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
-   */
-  constructor(
-    symmetricCrypto: Type.SymmetricCrypto,
-    keyManagerServiceURL: URL | string,
-    keyManagerServiceDID: `did:${string}:${string}`,
-    options?: {
-      allowInsecureHttp?: boolean | undefined
-    }
-  )
-  symmetricCrypto: Type.SymmetricCrypto
-  keyManagerServiceURL: URL
-  keyManagerServiceDID: import('@ucanto/client').PrincipalView<`did:${string}:${string}`>
-  /**
-   * Encrypt a stream of data using the symmetric crypto
-   *
-   * @param {Type.BlobLike} data
-   */
-  encryptStream(data: Type.BlobLike): Promise<Type.EncryptOutput>
-  /**
-   * Decrypt a stream of data using the symmetric crypto
-   *
-   * @param {ReadableStream} encryptedData
-   * @param {Uint8Array} key
-   * @param {Uint8Array} iv
-   */
-  decryptStream(
-    encryptedData: ReadableStream,
-    key: Uint8Array,
-    iv: Uint8Array
-  ): Promise<ReadableStream<any>>
-  /**
-   * Encrypt a symmetric key using the KMS
-   *
-   * @param {Uint8Array} key
-   * @param {Uint8Array} iv
-   * @param {Type.EncryptionConfig} encryptionConfig
-   * @returns {Promise<Type.EncryptedKeyResult>}
-   */
-  encryptSymmetricKey(
-    key: Uint8Array,
-    iv: Uint8Array,
-    encryptionConfig: Type.EncryptionConfig
-  ): Promise<Type.EncryptedKeyResult>
-  /**
-   * @param {string} encryptedKey
-   * @param {object} configs
-   * @param {Type.DecryptionConfig} configs.decryptionConfig
-   * @param {Type.ExtractedMetadata} configs.metadata
-   * @param {Type.AnyLink} configs.resourceCID
-   * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} configs.issuer
-   * @param {import('@storacha/client/types').DID} configs.audience
-   */
-  decryptSymmetricKey(
-    encryptedKey: string,
-    configs: {
-      decryptionConfig: Type.DecryptionConfig
-      metadata: Type.ExtractedMetadata
-      resourceCID: Type.AnyLink
-      issuer: import('@storacha/client/types').Signer<
-        import('@storacha/client/types').DID,
-        import('@storacha/client/types').SigAlg
-      >
-      audience: import('@storacha/client/types').DID
-    }
-  ): Promise<{
-    key: Uint8Array
-    iv: Uint8Array
-  }>
-  /**
-   * Get decrypted symmetric key in base64 string from KMS via private gateway
-   *
-   * @param {string} encryptedSymmetricKey - The encrypted symmetric key (base64-encoded)
-   * @param {Type.SpaceDID} spaceDID - The space DID
-   * @param {import('@ucanto/interface').Proof} decryptionProof - The decryption delegation proof
-   * @param {import('@ucanto/interface').Proof[]} proofs - The proofs to access the space
-   * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} issuer - The issuer
-   * @returns {Promise<{decryptedSymmetricKey: string}>} - The decrypted symmetric key (base64-encoded)
-   */
-  getDecryptedSymmetricKey(
-    encryptedSymmetricKey: string,
-    spaceDID: Type.SpaceDID,
-    decryptionProof: import('@ucanto/interface').Proof,
-    proofs: import('@ucanto/interface').Proof[],
-    issuer: import('@storacha/client/types').Signer<
-      import('@storacha/client/types').DID,
-      import('@storacha/client/types').SigAlg
-    >
-  ): Promise<{
-    decryptedSymmetricKey: string
-  }>
-  /**
-   * Extract the encrypted metadata from the CAR file
-   * KMS adapter only handles KMS format (encrypted-metadata@0.2)
-   *
-   * @param {Uint8Array} car
-   * @returns {Type.ExtractedMetadata}
-   */
-  extractEncryptedMetadata(car: Uint8Array): Type.ExtractedMetadata
-  /**
-   * @param {Type.ExtractedMetadata} metadata
-   * @returns {string}
-   */
-  getEncryptedKey(metadata: Type.ExtractedMetadata): string
-  /**
-   * Encode metadata for upload
-   *
-   * @param {string} encryptedDataCID - The CID of the encrypted data
-   * @param {string} encryptedKey - The encrypted key
-   * @param {Type.KMSKeyMetadata} metadata - The metadata to encode
-   * @returns {Promise<{ cid: import('@storacha/upload-client/types').AnyLink, bytes: Uint8Array }>} - The encoded metadata
-   */
-  encodeMetadata(
-    encryptedDataCID: string,
-    encryptedKey: string,
-    metadata: Type.KMSKeyMetadata
-  ): Promise<{
-    cid: import('@storacha/upload-client/types').AnyLink
-    bytes: Uint8Array
-  }>
-  /**
-   * Get the RSA public key from the space/encryption/setup
-   *
-   * @param {Type.EncryptionConfig} encryptionConfig
-   * @returns {Promise<{ publicKey: string, provider: string, algorithm: string }>}
-   */
-  getSpacePublicKey(encryptionConfig: Type.EncryptionConfig): Promise<{
-    publicKey: string
-    provider: string
-    algorithm: string
-  }>
-  /**
-   * Get the Web Crypto API SubtleCrypto interface (universal compatibility)
-   *
-   * @returns {SubtleCrypto} - The SubtleCrypto interface
-   */
-  getSubtleCrypto(): SubtleCrypto
-  /**
-   * Encrypt data with RSA-OAEP using the public key
-   *
-   * @param {Uint8Array} dataToEncrypt
-   * @param {string} publicKeyPem
-   * @returns {Promise<Uint8Array>}
-   */
-  encryptWithRSA(
-    dataToEncrypt: Uint8Array,
-    publicKeyPem: string
-  ): Promise<Uint8Array>
-  /**
-   * Convert PEM-encoded public key to ArrayBuffer for Web Crypto API
-   *
-   * @param {string} pem - PEM-encoded public key string
-   * @returns {ArrayBuffer} - DER-encoded key data for crypto.subtle.importKey()
-   */
-  pemToArrayBuffer(pem: string): ArrayBuffer
-  newKeyManagerServiceConnection(): import('@ucanto/interface').ConnectionView<any>
-  /**
-   * Sanitize the space DID for the KMS key ID
-   *
-   * @param {Type.SpaceDID} spaceDID
-   * @returns {string}
-   */
-  sanitizeSpaceDIDForKMSKeyId(spaceDID: Type.SpaceDID): string
+    /**
+     * Create a new KMS crypto adapter
+     *
+     * @param {Type.SymmetricCrypto} symmetricCrypto - The symmetric crypto implementation (browser or node)
+     * @param {URL|string} keyManagerServiceURL - The key manager service URL
+     * @param {`did:${string}:${string}`} keyManagerServiceDID - The key manager service DID
+     * @param {object} [options] - Optional configuration
+     * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
+     */
+    constructor(symmetricCrypto: Type.SymmetricCrypto, keyManagerServiceURL: URL | string, keyManagerServiceDID: `did:${string}:${string}`, options?: {
+        allowInsecureHttp?: boolean | undefined;
+    });
+    symmetricCrypto: Type.SymmetricCrypto;
+    keyManagerServiceURL: URL;
+    keyManagerServiceDID: import("@ucanto/client").PrincipalView<`did:${string}:${string}`>;
+    /**
+     * Encrypt a stream of data using the symmetric crypto
+     *
+     * @param {Type.BlobLike} data
+     */
+    encryptStream(data: Type.BlobLike): Promise<Type.EncryptOutput>;
+    /**
+     * Decrypt a stream of data using the symmetric crypto
+     *
+     * @param {ReadableStream} encryptedData
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     */
+    decryptStream(encryptedData: ReadableStream, key: Uint8Array, iv: Uint8Array): Promise<ReadableStream<any>>;
+    /**
+     * Encrypt a symmetric key using the KMS
+     *
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     * @param {Type.EncryptionConfig} encryptionConfig
+     * @returns {Promise<Type.EncryptedKeyResult>}
+     */
+    encryptSymmetricKey(key: Uint8Array, iv: Uint8Array, encryptionConfig: Type.EncryptionConfig): Promise<Type.EncryptedKeyResult>;
+    /**
+     * @param {string} encryptedKey
+     * @param {object} configs
+     * @param {Type.DecryptionConfig} configs.decryptionConfig
+     * @param {Type.ExtractedMetadata} configs.metadata
+     * @param {Type.AnyLink} configs.resourceCID
+     * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} configs.issuer
+     * @param {import('@storacha/client/types').DID} configs.audience
+     */
+    decryptSymmetricKey(encryptedKey: string, configs: {
+        decryptionConfig: Type.DecryptionConfig;
+        metadata: Type.ExtractedMetadata;
+        resourceCID: Type.AnyLink;
+        issuer: import("@storacha/client/types").Signer<import("@storacha/client/types").DID, import("@storacha/client/types").SigAlg>;
+        audience: import("@storacha/client/types").DID;
+    }): Promise<{
+        key: Uint8Array;
+        iv: Uint8Array;
+    }>;
+    /**
+     * Get decrypted symmetric key in base64 string from KMS via private gateway
+     *
+     * @param {string} encryptedSymmetricKey - The encrypted symmetric key (base64-encoded)
+     * @param {Type.SpaceDID} spaceDID - The space DID
+     * @param {import('@ucanto/interface').Proof} decryptionProof - The decryption delegation proof
+     * @param {import('@ucanto/interface').Proof[]} proofs - The proofs to access the space
+     * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} issuer - The issuer
+     * @returns {Promise<{decryptedSymmetricKey: string}>} - The decrypted symmetric key (base64-encoded)
+     */
+    getDecryptedSymmetricKey(encryptedSymmetricKey: string, spaceDID: Type.SpaceDID, decryptionProof: import("@ucanto/interface").Proof, proofs: import("@ucanto/interface").Proof[], issuer: import("@storacha/client/types").Signer<import("@storacha/client/types").DID, import("@storacha/client/types").SigAlg>): Promise<{
+        decryptedSymmetricKey: string;
+    }>;
+    /**
+     * Extract the encrypted metadata from the CAR file
+     * KMS adapter only handles KMS format (encrypted-metadata@0.2)
+     *
+     * @param {Uint8Array} car
+     * @returns {Type.ExtractedMetadata}
+     */
+    extractEncryptedMetadata(car: Uint8Array): Type.ExtractedMetadata;
+    /**
+     * @param {Type.ExtractedMetadata} metadata
+     * @returns {string}
+     */
+    getEncryptedKey(metadata: Type.ExtractedMetadata): string;
+    /**
+     * Encode metadata for upload
+     *
+     * @param {string} encryptedDataCID - The CID of the encrypted data
+     * @param {string} encryptedKey - The encrypted key
+     * @param {Type.KMSKeyMetadata} metadata - The metadata to encode
+     * @returns {Promise<{ cid: import('@storacha/upload-client/types').AnyLink, bytes: Uint8Array }>} - The encoded metadata
+     */
+    encodeMetadata(encryptedDataCID: string, encryptedKey: string, metadata: Type.KMSKeyMetadata): Promise<{
+        cid: import("@storacha/upload-client/types").AnyLink;
+        bytes: Uint8Array;
+    }>;
+    /**
+     * Get the RSA public key from the space/encryption/setup
+     *
+     * @param {Type.EncryptionConfig} encryptionConfig
+     * @returns {Promise<{ publicKey: string, provider: string, algorithm: string }>}
+     */
+    getSpacePublicKey(encryptionConfig: Type.EncryptionConfig): Promise<{
+        publicKey: string;
+        provider: string;
+        algorithm: string;
+    }>;
+    /**
+     * Get the Web Crypto API SubtleCrypto interface (universal compatibility)
+     *
+     * @returns {SubtleCrypto} - The SubtleCrypto interface
+     */
+    getSubtleCrypto(): SubtleCrypto;
+    /**
+     * Encrypt data with RSA-OAEP using the public key
+     *
+     * @param {Uint8Array} dataToEncrypt
+     * @param {string} publicKeyPem
+     * @returns {Promise<Uint8Array>}
+     */
+    encryptWithRSA(dataToEncrypt: Uint8Array, publicKeyPem: string): Promise<Uint8Array>;
+    /**
+     * Convert PEM-encoded public key to ArrayBuffer for Web Crypto API
+     *
+     * @param {string} pem - PEM-encoded public key string
+     * @returns {ArrayBuffer} - DER-encoded key data for crypto.subtle.importKey()
+     */
+    pemToArrayBuffer(pem: string): ArrayBuffer;
+    newKeyManagerServiceConnection(): import("@ucanto/interface").ConnectionView<any>;
+    /**
+     * Sanitize the space DID for the KMS key ID
+     *
+     * @param {Type.SpaceDID} spaceDID
+     * @returns {string}
+     */
+    sanitizeSpaceDIDForKMSKeyId(spaceDID: Type.SpaceDID): string;
 }
-import * as Type from '../../types.js'
-//# sourceMappingURL=kms-crypto-adapter.d.ts.map
+import * as Type from '../../types.js';
+//# sourceMappingURL=kms-crypto-adapter.d.ts.map

package/dist/crypto/adapters/lit-crypto-adapter.d.ts

@@ -7,111 +7,90 @@
  * @implements {Type.CryptoAdapter}
  */
 export class LitCryptoAdapter implements Type.CryptoAdapter {
-  /**
-   * Create a new Lit crypto adapter
-   *
-   * @param {Type.SymmetricCrypto} symmetricCrypto - The symmetric crypto implementation (browser or node)
-   * @param {import('@lit-protocol/lit-node-client').LitNodeClient} litClient - The Lit client instance
-   */
-  constructor(
-    symmetricCrypto: Type.SymmetricCrypto,
-    litClient: import('@lit-protocol/lit-node-client').LitNodeClient
-  )
-  symmetricCrypto: Type.SymmetricCrypto
-  litClient: import('@lit-protocol/lit-node-client').LitNodeClient
-  /**
-   * Encrypt a stream of data using the symmetric crypto implementation
-   *
-   * @param {Type.BlobLike} data - The data to encrypt
-   * @returns {Promise<Type.EncryptOutput>} - The encrypted data
-   */
-  encryptStream(data: Type.BlobLike): Promise<Type.EncryptOutput>
-  /**
-   * Decrypt a stream of data using the symmetric crypto implementation
-   *
-   * @param {ReadableStream} encryptedData - The encrypted data to decrypt
-   * @param {Uint8Array} key - The key to use for decryption
-   * @param {Uint8Array} iv - The initialization vector to use for decryption
-   * @returns {Promise<ReadableStream>} - The decrypted data
-   */
-  decryptStream(
-    encryptedData: ReadableStream,
-    key: Uint8Array,
-    iv: Uint8Array
-  ): Promise<ReadableStream>
-  /**
-   * Encrypt a symmetric key using the Lit crypto adapter
-   *
-   * @param {Uint8Array} key - The symmetric key to encrypt
-   * @param {Uint8Array} iv - The initialization vector to encrypt
-   * @param {Type.EncryptionConfig} encryptionConfig - The encryption configuration
-   * @returns {Promise<Type.EncryptedKeyResult>} - The encrypted key result
-   */
-  encryptSymmetricKey(
-    key: Uint8Array,
-    iv: Uint8Array,
-    encryptionConfig: Type.EncryptionConfig
-  ): Promise<Type.EncryptedKeyResult>
-  /**
-   * Decrypt a symmetric key using the Lit crypto adapter
-   *
-   * @param {string} encryptedKey - The encrypted key to decrypt
-   * @param {object} configs - The decryption configuration
-   * @param {Type.DecryptionConfig} configs.decryptionConfig - The decryption config
-   * @param {Type.ExtractedMetadata} configs.metadata - The extracted metadata
-   * @param {import('@ucanto/interface').Proof} configs.decryptDelegation - The delegation that gives permission to decrypt (required for both strategies)
-   * @param {Type.AnyLink} configs.resourceCID - The resource CID
-   * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} configs.issuer - The issuer
-   * @param {import('@storacha/client/types').DID} configs.audience - The audience
-   * @returns {Promise<{ key: Uint8Array, iv: Uint8Array }>} - The decrypted key and IV
-   */
-  decryptSymmetricKey(
-    encryptedKey: string,
-    configs: {
-      decryptionConfig: Type.DecryptionConfig
-      metadata: Type.ExtractedMetadata
-      decryptDelegation: import('@ucanto/interface').Proof
-      resourceCID: Type.AnyLink
-      issuer: import('@storacha/client/types').Signer<
-        import('@storacha/client/types').DID,
-        import('@storacha/client/types').SigAlg
-      >
-      audience: import('@storacha/client/types').DID
-    }
-  ): Promise<{
-    key: Uint8Array
-    iv: Uint8Array
-  }>
-  /**
-   * Extract encrypted metadata from a CAR file
-   *
-   * @param {Uint8Array} car - The CAR file to extract metadata from
-   * @returns {Type.ExtractedMetadata} - The extracted metadata
-   */
-  extractEncryptedMetadata(car: Uint8Array): Type.ExtractedMetadata
-  /**
-   * Get the encrypted key from the metadata
-   *
-   * @param {Type.ExtractedMetadata} metadata - The metadata to get the encrypted key from
-   * @returns {string} - The encrypted key
-   */
-  getEncryptedKey(metadata: Type.ExtractedMetadata): string
-  /**
-   * Encode metadata for upload
-   *
-   * @param {string} encryptedDataCID - The CID of the encrypted data
-   * @param {string} encryptedKey - The encrypted key
-   * @param {Type.LitKeyMetadata} metadata - The metadata to encode
-   * @returns {Promise<{ cid: import('@storacha/upload-client/types').AnyLink, bytes: Uint8Array }>} - The encoded metadata
-   */
-  encodeMetadata(
-    encryptedDataCID: string,
-    encryptedKey: string,
-    metadata: Type.LitKeyMetadata
-  ): Promise<{
-    cid: import('@storacha/upload-client/types').AnyLink
-    bytes: Uint8Array
-  }>
+    /**
+     * Create a new Lit crypto adapter
+     *
+     * @param {Type.SymmetricCrypto} symmetricCrypto - The symmetric crypto implementation (browser or node)
+     * @param {import('@lit-protocol/lit-node-client').LitNodeClient} litClient - The Lit client instance
+     */
+    constructor(symmetricCrypto: Type.SymmetricCrypto, litClient: import("@lit-protocol/lit-node-client").LitNodeClient);
+    symmetricCrypto: Type.SymmetricCrypto;
+    litClient: import("@lit-protocol/lit-node-client").LitNodeClient;
+    /**
+     * Encrypt a stream of data using the symmetric crypto implementation
+     *
+     * @param {Type.BlobLike} data - The data to encrypt
+     * @returns {Promise<Type.EncryptOutput>} - The encrypted data
+     */
+    encryptStream(data: Type.BlobLike): Promise<Type.EncryptOutput>;
+    /**
+     * Decrypt a stream of data using the symmetric crypto implementation
+     *
+     * @param {ReadableStream} encryptedData - The encrypted data to decrypt
+     * @param {Uint8Array} key - The key to use for decryption
+     * @param {Uint8Array} iv - The initialization vector to use for decryption
+     * @returns {Promise<ReadableStream>} - The decrypted data
+     */
+    decryptStream(encryptedData: ReadableStream, key: Uint8Array, iv: Uint8Array): Promise<ReadableStream>;
+    /**
+     * Encrypt a symmetric key using the Lit crypto adapter
+     *
+     * @param {Uint8Array} key - The symmetric key to encrypt
+     * @param {Uint8Array} iv - The initialization vector to encrypt
+     * @param {Type.EncryptionConfig} encryptionConfig - The encryption configuration
+     * @returns {Promise<Type.EncryptedKeyResult>} - The encrypted key result
+     */
+    encryptSymmetricKey(key: Uint8Array, iv: Uint8Array, encryptionConfig: Type.EncryptionConfig): Promise<Type.EncryptedKeyResult>;
+    /**
+     * Decrypt a symmetric key using the Lit crypto adapter
+     *
+     * @param {string} encryptedKey - The encrypted key to decrypt
+     * @param {object} configs - The decryption configuration
+     * @param {Type.DecryptionConfig} configs.decryptionConfig - The decryption config
+     * @param {Type.ExtractedMetadata} configs.metadata - The extracted metadata
+     * @param {import('@ucanto/interface').Proof} configs.decryptDelegation - The delegation that gives permission to decrypt (required for both strategies)
+     * @param {Type.AnyLink} configs.resourceCID - The resource CID
+     * @param {import('@storacha/client/types').Signer<import('@storacha/client/types').DID, import('@storacha/client/types').SigAlg>} configs.issuer - The issuer
+     * @param {import('@storacha/client/types').DID} configs.audience - The audience
+     * @returns {Promise<{ key: Uint8Array, iv: Uint8Array }>} - The decrypted key and IV
+     */
+    decryptSymmetricKey(encryptedKey: string, configs: {
+        decryptionConfig: Type.DecryptionConfig;
+        metadata: Type.ExtractedMetadata;
+        decryptDelegation: import("@ucanto/interface").Proof;
+        resourceCID: Type.AnyLink;
+        issuer: import("@storacha/client/types").Signer<import("@storacha/client/types").DID, import("@storacha/client/types").SigAlg>;
+        audience: import("@storacha/client/types").DID;
+    }): Promise<{
+        key: Uint8Array;
+        iv: Uint8Array;
+    }>;
+    /**
+     * Extract encrypted metadata from a CAR file
+     *
+     * @param {Uint8Array} car - The CAR file to extract metadata from
+     * @returns {Type.ExtractedMetadata} - The extracted metadata
+     */
+    extractEncryptedMetadata(car: Uint8Array): Type.ExtractedMetadata;
+    /**
+     * Get the encrypted key from the metadata
+     *
+     * @param {Type.ExtractedMetadata} metadata - The metadata to get the encrypted key from
+     * @returns {string} - The encrypted key
+     */
+    getEncryptedKey(metadata: Type.ExtractedMetadata): string;
+    /**
+     * Encode metadata for upload
+     *
+     * @param {string} encryptedDataCID - The CID of the encrypted data
+     * @param {string} encryptedKey - The encrypted key
+     * @param {Type.LitKeyMetadata} metadata - The metadata to encode
+     * @returns {Promise<{ cid: import('@storacha/upload-client/types').AnyLink, bytes: Uint8Array }>} - The encoded metadata
+     */
+    encodeMetadata(encryptedDataCID: string, encryptedKey: string, metadata: Type.LitKeyMetadata): Promise<{
+        cid: import("@storacha/upload-client/types").AnyLink;
+        bytes: Uint8Array;
+    }>;
 }
-import * as Type from '../../types.js'
-//# sourceMappingURL=lit-crypto-adapter.d.ts.map
+import * as Type from '../../types.js';
+//# sourceMappingURL=lit-crypto-adapter.d.ts.map

package/dist/crypto/factories.browser.d.ts

@@ -8,12 +8,8 @@
  * @param {object} [options] - Optional configuration
  * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
  */
-export function createGenericKMSAdapter(
-  keyManagerServiceURL: URL | string,
-  keyManagerServiceDID: string,
-  options?: {
-    allowInsecureHttp?: boolean | undefined
-  }
-): KMSCryptoAdapter
-import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js'
-//# sourceMappingURL=factories.browser.d.ts.map
+export function createGenericKMSAdapter(keyManagerServiceURL: URL | string, keyManagerServiceDID: string, options?: {
+    allowInsecureHttp?: boolean | undefined;
+}): KMSCryptoAdapter;
+import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js';
+//# sourceMappingURL=factories.browser.d.ts.map

package/dist/crypto/factories.browser.js

@@ -1,5 +1,5 @@
-import { GenericAesCtrStreamingCrypto } from './symmetric/generic-aes-ctr-streaming-crypto.js'
-import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js'
+import { GenericAesCtrStreamingCrypto } from './symmetric/generic-aes-ctr-streaming-crypto.js';
+import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js';
 /**
  * Create a KMS crypto adapter for browser environments
  * Uses the generic AES-CTR streaming crypto implementation
@@ -10,17 +10,9 @@ import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js'
  * @param {object} [options] - Optional configuration
  * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
  */
-export function createGenericKMSAdapter(
-  keyManagerServiceURL,
-  keyManagerServiceDID,
-  options = {}
-) {
-  const symmetricCrypto = new GenericAesCtrStreamingCrypto()
-  return new KMSCryptoAdapter(
-    symmetricCrypto,
-    keyManagerServiceURL,
-    /** @type {`did:${string}:${string}`} */ (keyManagerServiceDID),
-    options
-  )
+export function createGenericKMSAdapter(keyManagerServiceURL, keyManagerServiceDID, options = {}) {
+    const symmetricCrypto = new GenericAesCtrStreamingCrypto();
+    return new KMSCryptoAdapter(symmetricCrypto, keyManagerServiceURL, 
+    /** @type {`did:${string}:${string}`} */ (keyManagerServiceDID), options);
 }
-//# sourceMappingURL=factories.browser.js.map
+//# sourceMappingURL=factories.browser.js.map

package/dist/crypto/factories.node.d.ts

@@ -5,10 +5,7 @@
  * @param {URL|string} keyManagerServiceURL
  * @param {string} keyManagerServiceDID
  */
-export function createGenericKMSAdapter(
-  keyManagerServiceURL: URL | string,
-  keyManagerServiceDID: string
-): KMSCryptoAdapter
+export function createGenericKMSAdapter(keyManagerServiceURL: URL | string, keyManagerServiceDID: string): KMSCryptoAdapter;
 /**
  * Create a Lit crypto adapter for Node.js using AES-CBC (legacy).
  * Compatible with previous versions of the library.
@@ -16,18 +13,14 @@ export function createGenericKMSAdapter(
  * @deprecated Use createGenericLitAdapter instead for new uploads.
  * @param {import('@lit-protocol/lit-node-client').LitNodeClient} litClient
  */
-export function createNodeLitAdapter(
-  litClient: import('@lit-protocol/lit-node-client').LitNodeClient
-): LitCryptoAdapter
+export function createNodeLitAdapter(litClient: import("@lit-protocol/lit-node-client").LitNodeClient): LitCryptoAdapter;
 /**
  * Create a Lit crypto adapter for Node.js using the generic AES-CTR streaming crypto.
  * Works in Node.js & browser environments.
  *
  * @param {import('@lit-protocol/lit-node-client').LitNodeClient} litClient
  */
-export function createGenericLitAdapter(
-  litClient: import('@lit-protocol/lit-node-client').LitNodeClient
-): LitCryptoAdapter
-import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js'
-import { LitCryptoAdapter } from './adapters/lit-crypto-adapter.js'
-//# sourceMappingURL=factories.node.d.ts.map
+export function createGenericLitAdapter(litClient: import("@lit-protocol/lit-node-client").LitNodeClient): LitCryptoAdapter;
+import { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js';
+import { LitCryptoAdapter } from './adapters/lit-crypto-adapter.js';
+//# sourceMappingURL=factories.node.d.ts.map