@storacha/encrypt-upload-client 1.1.76-rc.2 → 1.1.76-rc.4

package/dist/config/service.d.ts

@@ -1,14 +1,14 @@
-export const accessServiceURL: URL
-export const accessServicePrincipal: client.PrincipalView<'did:web:web3.storage'>
-export const accessServiceConnection: client.ConnectionView<any>
-export const uploadServiceURL: URL
-export const uploadServicePrincipal: client.PrincipalView<'did:web:web3.storage'>
-export const uploadServiceConnection: client.ConnectionView<any>
-export const filecoinServiceURL: URL
-export const filecoinServicePrincipal: client.PrincipalView<'did:web:web3.storage'>
-export const filecoinServiceConnection: client.ConnectionView<any>
+export const accessServiceURL: URL;
+export const accessServicePrincipal: client.PrincipalView<"did:web:web3.storage">;
+export const accessServiceConnection: client.ConnectionView<any>;
+export const uploadServiceURL: URL;
+export const uploadServicePrincipal: client.PrincipalView<"did:web:web3.storage">;
+export const uploadServiceConnection: client.ConnectionView<any>;
+export const filecoinServiceURL: URL;
+export const filecoinServicePrincipal: client.PrincipalView<"did:web:web3.storage">;
+export const filecoinServiceConnection: client.ConnectionView<any>;
 /** @type {import('@storacha/client/types').ServiceConf} */
-export const serviceConf: import('@storacha/client/types').ServiceConf
-export const receiptsEndpoint: URL
-import * as client from '@ucanto/client'
-//# sourceMappingURL=service.d.ts.map
+export const serviceConf: import("@storacha/client/types").ServiceConf;
+export const receiptsEndpoint: URL;
+import * as client from '@ucanto/client';
+//# sourceMappingURL=service.d.ts.map

package/dist/core/client.d.ts

@@ -1,57 +1,44 @@
 /** @implements {Type.EncryptedClient} */
 export class EncryptedClient implements Type.EncryptedClient {
-  /**
-   * @param {import('@storacha/client').Client} storachaClient
-   * @param {Type.CryptoAdapter} cryptoAdapter
-   * @param {URL} gatewayURL
-   */
-  constructor(
-    storachaClient: import('@storacha/client').Client,
-    cryptoAdapter: Type.CryptoAdapter,
-    gatewayURL: URL
-  )
-  /**
-   * @type {Type.CryptoAdapter}
-   * @protected
-   */
-  protected _cryptoAdapter: Type.CryptoAdapter
-  /**
-   * @type {import('@storacha/client').Client}
-   * @protected
-   */
-  protected _storachaClient: import('@storacha/client').Client
-  /**
-   * @type {URL}
-   * @protected
-   */
-  protected _gatewayURL: URL
-  /**
-   * Encrypt and upload a file to the Storacha network
-   *
-   * @param {Type.BlobLike} file - The file to upload
-   * @param {Type.EncryptionConfig} encryptionConfig - User-provided encryption configuration
-   * @param {Type.UploadOptions} [uploadOptions] - User-provided upload options
-   * @returns {Promise<Type.AnyLink>} - The link to the uploaded file
-   */
-  encryptAndUploadFile(
-    file: Type.BlobLike,
-    encryptionConfig: Type.EncryptionConfig,
-    uploadOptions?: Type.UploadOptions
-  ): Promise<Type.AnyLink>
-  /**
-   * Retrieve and decrypt a file from the Storacha network
-   *
-   * @param {Type.AnyLink} cid - The link to the file to retrieve
-   * @param {Type.DecryptionConfig} decryptionConfig - User-provided decryption config
-   * @returns {Promise<Type.DecryptionResult>} - The decrypted file with metadata
-   */
-  retrieveAndDecryptFile(
-    cid: Type.AnyLink,
-    decryptionConfig: Type.DecryptionConfig
-  ): Promise<Type.DecryptionResult>
+    /**
+     * @param {import('@storacha/client').Client} storachaClient
+     * @param {Type.CryptoAdapter} cryptoAdapter
+     * @param {URL} gatewayURL
+     */
+    constructor(storachaClient: import("@storacha/client").Client, cryptoAdapter: Type.CryptoAdapter, gatewayURL: URL);
+    /**
+     * @type {Type.CryptoAdapter}
+     * @protected
+     */
+    protected _cryptoAdapter: Type.CryptoAdapter;
+    /**
+     * @type {import('@storacha/client').Client}
+     * @protected
+     */
+    protected _storachaClient: import("@storacha/client").Client;
+    /**
+     * @type {URL}
+     * @protected
+     */
+    protected _gatewayURL: URL;
+    /**
+     * Encrypt and upload a file to the Storacha network
+     *
+     * @param {Type.BlobLike} file - The file to upload
+     * @param {Type.EncryptionConfig} encryptionConfig - User-provided encryption configuration
+     * @param {Type.UploadOptions} [uploadOptions] - User-provided upload options
+     * @returns {Promise<Type.AnyLink>} - The link to the uploaded file
+     */
+    encryptAndUploadFile(file: Type.BlobLike, encryptionConfig: Type.EncryptionConfig, uploadOptions?: Type.UploadOptions): Promise<Type.AnyLink>;
+    /**
+     * Retrieve and decrypt a file from the Storacha network
+     *
+     * @param {Type.AnyLink} cid - The link to the file to retrieve
+     * @param {Type.DecryptionConfig} decryptionConfig - User-provided decryption config
+     * @returns {Promise<Type.DecryptionResult>} - The decrypted file with metadata
+     */
+    retrieveAndDecryptFile(cid: Type.AnyLink, decryptionConfig: Type.DecryptionConfig): Promise<Type.DecryptionResult>;
 }
-export function create(
-  options: Type.EncryptedClientOptions
-): Promise<EncryptedClient>
-import * as Type from '../types.js'
-//# sourceMappingURL=client.d.ts.map
+export function create(options: Type.EncryptedClientOptions): Promise<EncryptedClient>;
+import * as Type from '../types.js';
+//# sourceMappingURL=client.d.ts.map

package/dist/core/errors.d.ts

@@ -1,8 +1,8 @@
 export class UnknownFormat extends Failure {
-  /** @param {string} [reason] */
-  constructor(reason?: string)
-  name: 'UnknownFormat'
-  #private
+    /** @param {string} [reason] */
+    constructor(reason?: string);
+    name: "UnknownFormat";
+    #private;
 }
-import { Failure } from '@ucanto/core'
-//# sourceMappingURL=errors.d.ts.map
+import { Failure } from '@ucanto/core';
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/metadata/kms-metadata.d.ts

@@ -1,68 +1,36 @@
-export const version: 'encrypted-metadata@0.2'
-export const KMSMetadataSchema: Schema.VariantSchema<
-  {
-    'encrypted-metadata@0.2': Schema.StructSchema<
-      {
-        encryptedDataCID: Schema.Schema<
-          Link.Link<unknown, number, number, 0 | 1>,
-          any
-        >
-        encryptedSymmetricKey: Schema.StringSchema<string, unknown>
-        space: Schema.StringSchema<string, unknown>
-        kms: Schema.StructSchema<
-          {
-            provider: Schema.StringSchema<string, unknown>
-            keyId: Schema.StringSchema<string, unknown>
-            algorithm: Schema.StringSchema<string, unknown>
-          },
-          any
-        >
-      },
-      unknown
-    >
-  },
-  unknown
->
-export const KMSMetadataInputSchema: Schema.StructSchema<
-  {
-    encryptedDataCID: Schema.StringSchema<string, unknown>
-    encryptedSymmetricKey: Schema.StringSchema<string, unknown>
-    space: Schema.StringSchema<string, unknown>
-    kms: Schema.StructSchema<
-      {
-        provider: Schema.StringSchema<string, unknown>
-        keyId: Schema.StringSchema<string, unknown>
-        algorithm: Schema.StringSchema<string, unknown>
-      },
-      any
-    >
-  },
-  unknown
->
-export function create(
-  kmsMetadataInput: Types.KMSMetadata | Types.KMSMetadataInput
-): Types.KMSMetadataView
-export function toJSON(
-  kmsMetadata: Types.KMSMetadataView
-): Types.KMSMetadataInput
-export function parse(
-  kmsMetadataInput: Types.KMSMetadataInput
-): Types.KMSMetadata
-export function archiveBlock(
-  kmsMetadataInput: Types.KMSMetadata
-): Promise<import('@ucanto/interface').Block>
-export function archive(
-  kmsMetadata: Types.KMSMetadata
-): Promise<Types.Result<Uint8Array>>
-export function extract(
-  archive: Uint8Array
-): Types.Result<Types.KMSMetadataView, Types.UnknownFormat>
-export function view({
-  root,
-}: {
-  root: Types.IPLDBlock
-}): Types.Result<Types.KMSMetadataView, Types.UnknownFormat>
-import * as Link from 'multiformats/link'
-import { Schema } from '@ucanto/core'
-import * as Types from '../../types.js'
-//# sourceMappingURL=kms-metadata.d.ts.map
+export const version: "encrypted-metadata@0.2";
+export const KMSMetadataSchema: Schema.VariantSchema<{
+    "encrypted-metadata@0.2": Schema.StructSchema<{
+        encryptedDataCID: Schema.Schema<Link.Link<unknown, number, number, 0 | 1>, any>;
+        encryptedSymmetricKey: Schema.StringSchema<string, unknown>;
+        space: Schema.StringSchema<string, unknown>;
+        kms: Schema.StructSchema<{
+            provider: Schema.StringSchema<string, unknown>;
+            keyId: Schema.StringSchema<string, unknown>;
+            algorithm: Schema.StringSchema<string, unknown>;
+        }, any>;
+    }, unknown>;
+}, unknown>;
+export const KMSMetadataInputSchema: Schema.StructSchema<{
+    encryptedDataCID: Schema.StringSchema<string, unknown>;
+    encryptedSymmetricKey: Schema.StringSchema<string, unknown>;
+    space: Schema.StringSchema<string, unknown>;
+    kms: Schema.StructSchema<{
+        provider: Schema.StringSchema<string, unknown>;
+        keyId: Schema.StringSchema<string, unknown>;
+        algorithm: Schema.StringSchema<string, unknown>;
+    }, any>;
+}, unknown>;
+export function create(kmsMetadataInput: Types.KMSMetadata | Types.KMSMetadataInput): Types.KMSMetadataView;
+export function toJSON(kmsMetadata: Types.KMSMetadataView): Types.KMSMetadataInput;
+export function parse(kmsMetadataInput: Types.KMSMetadataInput): Types.KMSMetadata;
+export function archiveBlock(kmsMetadataInput: Types.KMSMetadata): Promise<import("@ucanto/interface").Block>;
+export function archive(kmsMetadata: Types.KMSMetadata): Promise<Types.Result<Uint8Array>>;
+export function extract(archive: Uint8Array): Types.Result<Types.KMSMetadataView, Types.UnknownFormat>;
+export function view({ root }: {
+    root: Types.IPLDBlock;
+}): Types.Result<Types.KMSMetadataView, Types.UnknownFormat>;
+import * as Link from 'multiformats/link';
+import { Schema } from '@ucanto/core';
+import * as Types from '../../types.js';
+//# sourceMappingURL=kms-metadata.d.ts.map

package/dist/core/metadata/lit-metadata.d.ts

@@ -1,63 +1,28 @@
-export const version: 'encrypted-metadata@0.1'
-export const LitMetadataSchema: Schema.VariantSchema<
-  {
-    'encrypted-metadata@0.1': Schema.StructSchema<
-      {
-        encryptedDataCID: Schema.Schema<
-          Link.Link<unknown, number, number, 0 | 1>,
-          any
-        >
-        identityBoundCiphertext: Schema.Schema<
-          Uint8Array<ArrayBufferLike>,
-          unknown
-        >
-        plaintextKeyHash: Schema.Schema<Uint8Array<ArrayBufferLike>, unknown>
-        accessControlConditions: Schema.Schema<
-          Schema.Dictionary<string, unknown>[],
-          unknown
-        >
-      },
-      unknown
-    >
-  },
-  unknown
->
-export const LitMetadataInputSchema: Schema.StructSchema<
-  {
-    encryptedDataCID: Schema.StringSchema<string, unknown>
-    identityBoundCiphertext: Schema.StringSchema<string, unknown>
-    plaintextKeyHash: Schema.StringSchema<string, unknown>
-    accessControlConditions: Schema.Schema<
-      Schema.Dictionary<string, unknown>[],
-      unknown
-    >
-  },
-  unknown
->
-export function create(
-  encryptedMetadataInput: Types.LitMetadata | Types.LitMetadataInput
-): Types.LitMetadataView
-export function toJSON(
-  encryptedMetadata: Types.LitMetadataView
-): Types.LitMetadataInput
-export function parse(
-  encryptedMetadataInput: Types.LitMetadataInput
-): Types.LitMetadata
-export function archiveBlock(
-  encryptedMetadataInput: Types.LitMetadata
-): Promise<import('@ucanto/interface').Block>
-export function archive(
-  encryptedMetadata: Types.LitMetadata
-): Promise<Types.Result<Uint8Array>>
-export function extract(
-  archive: Uint8Array
-): Types.Result<Types.LitMetadataView, Types.UnknownFormat>
-export function view({
-  root,
-}: {
-  root: Types.IPLDBlock
-}): Types.Result<Types.LitMetadataView, Types.UnknownFormat>
-import * as Link from 'multiformats/link'
-import { Schema } from '@ucanto/core'
-import * as Types from '../../types.js'
-//# sourceMappingURL=lit-metadata.d.ts.map
+export const version: "encrypted-metadata@0.1";
+export const LitMetadataSchema: Schema.VariantSchema<{
+    "encrypted-metadata@0.1": Schema.StructSchema<{
+        encryptedDataCID: Schema.Schema<Link.Link<unknown, number, number, 0 | 1>, any>;
+        identityBoundCiphertext: Schema.Schema<Uint8Array<ArrayBufferLike>, unknown>;
+        plaintextKeyHash: Schema.Schema<Uint8Array<ArrayBufferLike>, unknown>;
+        accessControlConditions: Schema.Schema<Schema.Dictionary<string, unknown>[], unknown>;
+    }, unknown>;
+}, unknown>;
+export const LitMetadataInputSchema: Schema.StructSchema<{
+    encryptedDataCID: Schema.StringSchema<string, unknown>;
+    identityBoundCiphertext: Schema.StringSchema<string, unknown>;
+    plaintextKeyHash: Schema.StringSchema<string, unknown>;
+    accessControlConditions: Schema.Schema<Schema.Dictionary<string, unknown>[], unknown>;
+}, unknown>;
+export function create(encryptedMetadataInput: Types.LitMetadata | Types.LitMetadataInput): Types.LitMetadataView;
+export function toJSON(encryptedMetadata: Types.LitMetadataView): Types.LitMetadataInput;
+export function parse(encryptedMetadataInput: Types.LitMetadataInput): Types.LitMetadata;
+export function archiveBlock(encryptedMetadataInput: Types.LitMetadata): Promise<import("@ucanto/interface").Block>;
+export function archive(encryptedMetadata: Types.LitMetadata): Promise<Types.Result<Uint8Array>>;
+export function extract(archive: Uint8Array): Types.Result<Types.LitMetadataView, Types.UnknownFormat>;
+export function view({ root }: {
+    root: Types.IPLDBlock;
+}): Types.Result<Types.LitMetadataView, Types.UnknownFormat>;
+import * as Link from 'multiformats/link';
+import { Schema } from '@ucanto/core';
+import * as Types from '../../types.js';
+//# sourceMappingURL=lit-metadata.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.node.d.ts

@@ -4,8 +4,12 @@
  *
  * @param {URL|string} keyManagerServiceURL
  * @param {string} keyManagerServiceDID
+ * @param {object} [options] - Optional configuration
+ * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
  */
-export function createGenericKMSAdapter(keyManagerServiceURL: URL | string, keyManagerServiceDID: string): KMSCryptoAdapter;
+export function createGenericKMSAdapter(keyManagerServiceURL: URL | string, keyManagerServiceDID: string, options?: {
+    allowInsecureHttp?: boolean | undefined;
+}): KMSCryptoAdapter;
 /**
  * Create a Lit crypto adapter for Node.js using the generic AES-CTR streaming crypto.
  * Works in Node.js & browser environments.

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

@@ -1 +1 @@
-{"version":3,"file":"factories.node.d.ts","sourceRoot":"","sources":["../../src/crypto/factories.node.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,8DAHW,GAAG,GAAC,MAAM,wBACV,MAAM,oBAYhB;AAED;;;;;;GAMG;AACH,mDAHW,OAAO,0BAA0B,EAAE,aAAa,eAChD,IAAI,CAAC,WAAW,oBAK1B;iCAjCgC,kCAAkC;sBAE7C,aAAa;iCADF,kCAAkC"}
+{"version":3,"file":"factories.node.d.ts","sourceRoot":"","sources":["../../src/crypto/factories.node.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,8DALW,GAAG,GAAC,MAAM,wBACV,MAAM,YAEd;IAA0B,iBAAiB;CAC7C,oBAaA;AAED;;;;;;GAMG;AACH,mDAHW,OAAO,0BAA0B,EAAE,aAAa,eAChD,IAAI,CAAC,WAAW,oBAK1B;iCArCgC,kCAAkC;sBAE7C,aAAa;iCADF,kCAAkC"}

package/dist/crypto/factories.node.js

@@ -8,11 +8,13 @@ import * as Type from '../types.js';
  *
  * @param {URL|string} keyManagerServiceURL
  * @param {string} keyManagerServiceDID
+ * @param {object} [options] - Optional configuration
+ * @param {boolean} [options.allowInsecureHttp] - Allow HTTP for testing (NOT for production)
  */
-export function createGenericKMSAdapter(keyManagerServiceURL, keyManagerServiceDID) {
+export function createGenericKMSAdapter(keyManagerServiceURL, keyManagerServiceDID, options = {}) {
     const symmetricCrypto = new GenericAesCtrStreamingCrypto();
     return new KMSCryptoAdapter(symmetricCrypto, keyManagerServiceURL, 
-    /** @type {`did:${string}:${string}`} */ (keyManagerServiceDID));
+    /** @type {`did:${string}:${string}`} */ (keyManagerServiceDID), options);
 }
 /**
  * Create a Lit crypto adapter for Node.js using the generic AES-CTR streaming crypto.

package/dist/crypto/index.d.ts

@@ -1,5 +1,5 @@
-export { GenericAesCtrStreamingCrypto } from './symmetric/generic-aes-ctr-streaming-crypto.js'
-export { NodeAesCbcCrypto } from './symmetric/node-aes-cbc-crypto.js'
-export { LitCryptoAdapter } from './adapters/lit-crypto-adapter.js'
-export { KMSCryptoAdapter } from './adapters/kms-crypto-adapter.js'
-//# sourceMappingURL=index.d.ts.map
+export { GenericAesCtrStreamingCrypto } from "./symmetric/generic-aes-ctr-streaming-crypto.js";
+export { NodeAesCbcCrypto } from "./symmetric/node-aes-cbc-crypto.js";
+export { LitCryptoAdapter } from "./adapters/lit-crypto-adapter.js";
+export { KMSCryptoAdapter } from "./adapters/kms-crypto-adapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/crypto/symmetric/generic-aes-ctr-streaming-crypto.d.ts

@@ -19,62 +19,58 @@
  * @implements {Type.SymmetricCrypto}
  */
 export class GenericAesCtrStreamingCrypto implements Type.SymmetricCrypto {
-  /**
-   * Generate a random AES key
-   *
-   * @returns {Promise<Uint8Array>} A random AES key
-   */
-  generateKey(): Promise<Uint8Array>
-  /**
-   * Properly increment AES-CTR counter with 128-bit arithmetic
-   *
-   * @param {Uint8Array} counter - The base counter (16 bytes)
-   * @param {number} increment - The value to add
-   * @returns {Uint8Array} - New counter with proper carry propagation
-   */
-  incrementCounter(counter: Uint8Array, increment: number): Uint8Array
-  /**
-   * Encrypt a stream of data using AES-CTR with TRUE streaming (no buffering).
-   *
-   * @param {Blob} data The data to encrypt.
-   * @returns {Promise<{ key: Uint8Array, iv: Uint8Array, encryptedStream: ReadableStream }>}
-   */
-  encryptStream(data: Blob): Promise<{
-    key: Uint8Array
-    iv: Uint8Array
-    encryptedStream: ReadableStream
-  }>
-  /**
-   * Decrypt a stream of data using AES-CTR with TRUE streaming (no buffering).
-   *
-   * @param {ReadableStream} encryptedData The encrypted data stream.
-   * @param {Uint8Array} key The encryption key.
-   * @param {Uint8Array} iv The initialization vector (counter).
-   * @returns {Promise<ReadableStream>} A stream of decrypted data.
-   */
-  decryptStream(
-    encryptedData: ReadableStream,
-    key: Uint8Array,
-    iv: Uint8Array
-  ): Promise<ReadableStream>
-  /**
-   * Combine key and IV into a single array for AES-CTR
-   *
-   * @param {Uint8Array} key - The AES key (KEY_LENGTH/8 bytes)
-   * @param {Uint8Array} iv - The AES-CTR IV (IV_LENGTH bytes)
-   * @returns {Uint8Array} Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
-   */
-  combineKeyAndIV(key: Uint8Array, iv: Uint8Array): Uint8Array
-  /**
-   * Split combined key and IV for AES-CTR
-   *
-   * @param {Uint8Array} combined - Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
-   * @returns {{ key: Uint8Array, iv: Uint8Array }} Separated key and IV
-   */
-  splitKeyAndIV(combined: Uint8Array): {
-    key: Uint8Array
-    iv: Uint8Array
-  }
+    /**
+     * Generate a random AES key
+     *
+     * @returns {Promise<Uint8Array>} A random AES key
+     */
+    generateKey(): Promise<Uint8Array>;
+    /**
+     * Properly increment AES-CTR counter with 128-bit arithmetic
+     *
+     * @param {Uint8Array} counter - The base counter (16 bytes)
+     * @param {number} increment - The value to add
+     * @returns {Uint8Array} - New counter with proper carry propagation
+     */
+    incrementCounter(counter: Uint8Array, increment: number): Uint8Array;
+    /**
+     * Encrypt a stream of data using AES-CTR with TRUE streaming (no buffering).
+     *
+     * @param {Blob} data The data to encrypt.
+     * @returns {Promise<{ key: Uint8Array, iv: Uint8Array, encryptedStream: ReadableStream }>}
+     */
+    encryptStream(data: Blob): Promise<{
+        key: Uint8Array;
+        iv: Uint8Array;
+        encryptedStream: ReadableStream;
+    }>;
+    /**
+     * Decrypt a stream of data using AES-CTR with TRUE streaming (no buffering).
+     *
+     * @param {ReadableStream} encryptedData The encrypted data stream.
+     * @param {Uint8Array} key The encryption key.
+     * @param {Uint8Array} iv The initialization vector (counter).
+     * @returns {Promise<ReadableStream>} A stream of decrypted data.
+     */
+    decryptStream(encryptedData: ReadableStream, key: Uint8Array, iv: Uint8Array): Promise<ReadableStream>;
+    /**
+     * Combine key and IV into a single array for AES-CTR
+     *
+     * @param {Uint8Array} key - The AES key (KEY_LENGTH/8 bytes)
+     * @param {Uint8Array} iv - The AES-CTR IV (IV_LENGTH bytes)
+     * @returns {Uint8Array} Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
+     */
+    combineKeyAndIV(key: Uint8Array, iv: Uint8Array): Uint8Array;
+    /**
+     * Split combined key and IV for AES-CTR
+     *
+     * @param {Uint8Array} combined - Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
+     * @returns {{ key: Uint8Array, iv: Uint8Array }} Separated key and IV
+     */
+    splitKeyAndIV(combined: Uint8Array): {
+        key: Uint8Array;
+        iv: Uint8Array;
+    };
 }
-import * as Type from '../../types.js'
-//# sourceMappingURL=generic-aes-ctr-streaming-crypto.d.ts.map
+import * as Type from '../../types.js';
+//# sourceMappingURL=generic-aes-ctr-streaming-crypto.d.ts.map

package/dist/crypto/symmetric/node-aes-cbc-crypto.d.ts

@@ -8,40 +8,36 @@
  * @implements {Type.SymmetricCrypto}
  */
 export class NodeAesCbcCrypto implements Type.SymmetricCrypto {
-  /** @param {Type.BlobLike} data  */
-  encryptStream(data: Type.BlobLike): Promise<{
-    key: Buffer<ArrayBufferLike>
-    iv: Buffer<ArrayBufferLike>
-    encryptedStream: ReadableStream<any>
-  }>
-  /**
-   * @param {ReadableStream} encryptedData
-   * @param {Uint8Array} key
-   * @param {Uint8Array} iv
-   */
-  decryptStream(
-    encryptedData: ReadableStream,
-    key: Uint8Array,
-    iv: Uint8Array
-  ): Promise<ReadableStream<any>>
-  /**
-   * Combine key and IV into a single array for AES-CBC
-   *
-   * @param {Uint8Array} key - The AES key (KEY_LENGTH/8 bytes)
-   * @param {Uint8Array} iv - The AES-CBC IV (IV_LENGTH bytes)
-   * @returns {Uint8Array} Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
-   */
-  combineKeyAndIV(key: Uint8Array, iv: Uint8Array): Uint8Array
-  /**
-   * Split combined key and IV for AES-CBC
-   *
-   * @param {Uint8Array} combined - Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
-   * @returns {{ key: Uint8Array, iv: Uint8Array }} Separated key and IV
-   */
-  splitKeyAndIV(combined: Uint8Array): {
-    key: Uint8Array
-    iv: Uint8Array
-  }
+    /** @param {Type.BlobLike} data  */
+    encryptStream(data: Type.BlobLike): Promise<{
+        key: Buffer<ArrayBufferLike>;
+        iv: Buffer<ArrayBufferLike>;
+        encryptedStream: ReadableStream<any>;
+    }>;
+    /**
+     * @param {ReadableStream} encryptedData
+     * @param {Uint8Array} key
+     * @param {Uint8Array} iv
+     */
+    decryptStream(encryptedData: ReadableStream, key: Uint8Array, iv: Uint8Array): Promise<ReadableStream<any>>;
+    /**
+     * Combine key and IV into a single array for AES-CBC
+     *
+     * @param {Uint8Array} key - The AES key (KEY_LENGTH/8 bytes)
+     * @param {Uint8Array} iv - The AES-CBC IV (IV_LENGTH bytes)
+     * @returns {Uint8Array} Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
+     */
+    combineKeyAndIV(key: Uint8Array, iv: Uint8Array): Uint8Array;
+    /**
+     * Split combined key and IV for AES-CBC
+     *
+     * @param {Uint8Array} combined - Combined key and IV (KEY_LENGTH/8 + IV_LENGTH bytes)
+     * @returns {{ key: Uint8Array, iv: Uint8Array }} Separated key and IV
+     */
+    splitKeyAndIV(combined: Uint8Array): {
+        key: Uint8Array;
+        iv: Uint8Array;
+    };
 }
-import * as Type from '../../types.js'
-//# sourceMappingURL=node-aes-cbc-crypto.d.ts.map
+import * as Type from '../../types.js';
+//# sourceMappingURL=node-aes-cbc-crypto.d.ts.map

package/dist/examples/decrypt-test.d.ts

@@ -1,2 +1,2 @@
-export {}
-//# sourceMappingURL=decrypt-test.d.ts.map
+export {};
+//# sourceMappingURL=decrypt-test.d.ts.map

package/dist/handlers/encrypt-handler.d.ts

@@ -1,9 +1,3 @@
-export function encryptAndUpload(
-  storachaClient: import('@storacha/client').Client,
-  cryptoAdapter: Type.CryptoAdapter,
-  file: Type.BlobLike,
-  encryptionConfig: Type.EncryptionConfig,
-  uploadOptions?: Type.UploadOptions
-): Promise<Type.AnyLink>
-import * as Type from '../types.js'
-//# sourceMappingURL=encrypt-handler.d.ts.map
+export function encryptAndUpload(storachaClient: import("@storacha/client").Client, cryptoAdapter: Type.CryptoAdapter, file: Type.BlobLike, encryptionConfig: Type.EncryptionConfig, uploadOptions?: Type.UploadOptions): Promise<Type.AnyLink>;
+import * as Type from '../types.js';
+//# sourceMappingURL=encrypt-handler.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { create } from './core/client.js'
-//# sourceMappingURL=index.d.ts.map
+export { create } from "./core/client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/test/cid-verification.spec.d.ts

@@ -1,2 +1,2 @@
-export {}
-//# sourceMappingURL=cid-verification.spec.d.ts.map
+export {};
+//# sourceMappingURL=cid-verification.spec.d.ts.map