@bitwarden/sdk-internal 0.2.0-main.148 → 0.2.0-main.149

package/VERSION

@@ -1 +1 @@
-9e581dae038b39e5e88eb62de1c45e98866dc42c
+8014451f6b9d8a3701be63b37eecc8f8ac79277e

package/bitwarden_wasm_internal.d.ts

@@ -924,6 +924,14 @@ export interface TestError extends Error {
 
 export function isTestError(error: any): error is TestError;
 
+export class AttachmentsClient {
+  private constructor();
+  free(): void;
+  /**
+   * Decrypts an attachment's encrypted content
+   */
+  decrypt_buffer(cipher: Cipher, attachment: Attachment, encrypted_buffer: Uint8Array): Uint8Array;
+}
 export class BitwardenClient {
   free(): void;
   constructor(settings?: ClientSettings | null);
@@ -945,15 +953,7 @@ export class BitwardenClient {
   generator(): GeneratorClient;
   exporters(): ExporterClient;
 }
-export class ClientAttachments {
-  private constructor();
-  free(): void;
-  /**
-   * Decrypts an attachment's encrypted content
-   */
-  decrypt_buffer(cipher: Cipher, attachment: Attachment, encrypted_buffer: Uint8Array): Uint8Array;
-}
-export class ClientCiphers {
+export class CiphersClient {
   private constructor();
   free(): void;
   /**
@@ -1015,33 +1015,6 @@ export class ClientCiphers {
    */
   decrypt_fido2_private_key(cipher_view: CipherView): string;
 }
-export class ClientFolders {
-  private constructor();
-  free(): void;
-  /**
-   * Decrypt folder
-   */
-  decrypt(folder: Folder): FolderView;
-}
-export class ClientTotp {
-  private constructor();
-  free(): void;
-  /**
-   * Generates a TOTP code from a provided key
-   *
-   * # Arguments
-   * - `key` - Can be:
-   *     - A base32 encoded string
-   *     - OTP Auth URI
-   *     - Steam URI
-   * - `time_ms` - Optional timestamp in milliseconds
-   *
-   * # Returns
-   * - `Ok(TotpResponse)` containing the generated code and period
-   * - `Err(TotpError)` if code generation fails
-   */
-  generate_totp(key: string, time_ms?: number | null): TotpResponse;
-}
 export class CryptoClient {
   private constructor();
   free(): void;
@@ -1095,6 +1068,14 @@ export class ExporterClient {
    */
   import_cxf(payload: string): Cipher[];
 }
+export class FoldersClient {
+  private constructor();
+  free(): void;
+  /**
+   * Decrypt folder
+   */
+  decrypt(folder: Folder): FolderView;
+}
 export class GeneratorClient {
   private constructor();
   free(): void;
@@ -1185,11 +1166,30 @@ export class SendError {
   crypto: any;
   communication: any;
 }
+export class TotpClient {
+  private constructor();
+  free(): void;
+  /**
+   * Generates a TOTP code from a provided key
+   *
+   * # Arguments
+   * - `key` - Can be:
+   *     - A base32 encoded string
+   *     - OTP Auth URI
+   *     - Steam URI
+   * - `time_ms` - Optional timestamp in milliseconds
+   *
+   * # Returns
+   * - `Ok(TotpResponse)` containing the generated code and period
+   * - `Err(TotpError)` if code generation fails
+   */
+  generate_totp(key: string, time_ms?: number | null): TotpResponse;
+}
 export class VaultClient {
   private constructor();
   free(): void;
-  attachments(): ClientAttachments;
-  ciphers(): ClientCiphers;
-  folders(): ClientFolders;
-  totp(): ClientTotp;
+  attachments(): AttachmentsClient;
+  ciphers(): CiphersClient;
+  folders(): FoldersClient;
+  totp(): TotpClient;
 }

package/bitwarden_wasm_internal_bg.js

@@ -739,6 +739,67 @@ const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
 
+const AttachmentsClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_attachmentsclient_free(ptr >>> 0, 1));
+
+export class AttachmentsClient {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(AttachmentsClient.prototype);
+    obj.__wbg_ptr = ptr;
+    AttachmentsClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AttachmentsClientFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_attachmentsclient_free(ptr, 0);
+  }
+  /**
+   * Decrypts an attachment's encrypted content
+   * @param {Cipher} cipher
+   * @param {Attachment} attachment
+   * @param {Uint8Array} encrypted_buffer
+   * @returns {Uint8Array}
+   */
+  decrypt_buffer(cipher, attachment, encrypted_buffer) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(encrypted_buffer, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.attachmentsclient_decrypt_buffer(
+        retptr,
+        this.__wbg_ptr,
+        addHeapObject(cipher),
+        addHeapObject(attachment),
+        ptr0,
+        len0,
+      );
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+
 const BitwardenClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -867,91 +928,30 @@ export class BitwardenClient {
   }
 }
 
-const ClientAttachmentsFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientattachments_free(ptr >>> 0, 1));
-
-export class ClientAttachments {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ClientAttachments.prototype);
-    obj.__wbg_ptr = ptr;
-    ClientAttachmentsFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    ClientAttachmentsFinalization.unregister(this);
-    return ptr;
-  }
-
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientattachments_free(ptr, 0);
-  }
-  /**
-   * Decrypts an attachment's encrypted content
-   * @param {Cipher} cipher
-   * @param {Attachment} attachment
-   * @param {Uint8Array} encrypted_buffer
-   * @returns {Uint8Array}
-   */
-  decrypt_buffer(cipher, attachment, encrypted_buffer) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(encrypted_buffer, wasm.__wbindgen_malloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.clientattachments_decrypt_buffer(
-        retptr,
-        this.__wbg_ptr,
-        addHeapObject(cipher),
-        addHeapObject(attachment),
-        ptr0,
-        len0,
-      );
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-      if (r3) {
-        throw takeObject(r2);
-      }
-      var v2 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v2;
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
-}
-
-const ClientCiphersFinalization =
+const CiphersClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientciphers_free(ptr >>> 0, 1));
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ciphersclient_free(ptr >>> 0, 1));
 
-export class ClientCiphers {
+export class CiphersClient {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(ClientCiphers.prototype);
+    const obj = Object.create(CiphersClient.prototype);
     obj.__wbg_ptr = ptr;
-    ClientCiphersFinalization.register(obj, obj.__wbg_ptr, obj);
+    CiphersClientFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
 
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    ClientCiphersFinalization.unregister(this);
+    CiphersClientFinalization.unregister(this);
     return ptr;
   }
 
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientciphers_free(ptr, 0);
+    wasm.__wbg_ciphersclient_free(ptr, 0);
   }
   /**
    * Encrypt cipher
@@ -968,7 +968,7 @@ export class ClientCiphers {
   encrypt(cipher_view) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientciphers_encrypt(retptr, this.__wbg_ptr, addHeapObject(cipher_view));
+      wasm.ciphersclient_encrypt(retptr, this.__wbg_ptr, addHeapObject(cipher_view));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -995,7 +995,7 @@ export class ClientCiphers {
   decrypt(cipher) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientciphers_decrypt(retptr, this.__wbg_ptr, addHeapObject(cipher));
+      wasm.ciphersclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(cipher));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1024,7 +1024,7 @@ export class ClientCiphers {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
       const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      wasm.clientciphers_decrypt_list(retptr, this.__wbg_ptr, ptr0, len0);
+      wasm.ciphersclient_decrypt_list(retptr, this.__wbg_ptr, ptr0, len0);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1054,7 +1054,7 @@ export class ClientCiphers {
   decrypt_fido2_credentials(cipher_view) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientciphers_decrypt_fido2_credentials(
+      wasm.ciphersclient_decrypt_fido2_credentials(
         retptr,
         this.__wbg_ptr,
         addHeapObject(cipher_view),
@@ -1093,7 +1093,7 @@ export class ClientCiphers {
     let deferred2_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientciphers_decrypt_fido2_private_key(
+      wasm.ciphersclient_decrypt_fido2_private_key(
         retptr,
         this.__wbg_ptr,
         addHeapObject(cipher_view),
@@ -1119,121 +1119,6 @@ export class ClientCiphers {
   }
 }
 
-const ClientFoldersFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clientfolders_free(ptr >>> 0, 1));
-
-export class ClientFolders {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ClientFolders.prototype);
-    obj.__wbg_ptr = ptr;
-    ClientFoldersFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    ClientFoldersFinalization.unregister(this);
-    return ptr;
-  }
-
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clientfolders_free(ptr, 0);
-  }
-  /**
-   * Decrypt folder
-   * @param {Folder} folder
-   * @returns {FolderView}
-   */
-  decrypt(folder) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.clientfolders_decrypt(retptr, this.__wbg_ptr, addHeapObject(folder));
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return takeObject(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
-}
-
-const ClientTotpFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_clienttotp_free(ptr >>> 0, 1));
-
-export class ClientTotp {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ClientTotp.prototype);
-    obj.__wbg_ptr = ptr;
-    ClientTotpFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    ClientTotpFinalization.unregister(this);
-    return ptr;
-  }
-
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_clienttotp_free(ptr, 0);
-  }
-  /**
-   * Generates a TOTP code from a provided key
-   *
-   * # Arguments
-   * - `key` - Can be:
-   *     - A base32 encoded string
-   *     - OTP Auth URI
-   *     - Steam URI
-   * - `time_ms` - Optional timestamp in milliseconds
-   *
-   * # Returns
-   * - `Ok(TotpResponse)` containing the generated code and period
-   * - `Err(TotpError)` if code generation fails
-   * @param {string} key
-   * @param {number | null} [time_ms]
-   * @returns {TotpResponse}
-   */
-  generate_totp(key, time_ms) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.clienttotp_generate_totp(
-        retptr,
-        this.__wbg_ptr,
-        ptr0,
-        len0,
-        !isLikeNone(time_ms),
-        isLikeNone(time_ms) ? 0 : time_ms,
-      );
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return takeObject(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
-}
-
 const CryptoClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1507,6 +1392,53 @@ export class ExporterClient {
   }
 }
 
+const FoldersClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_foldersclient_free(ptr >>> 0, 1));
+
+export class FoldersClient {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(FoldersClient.prototype);
+    obj.__wbg_ptr = ptr;
+    FoldersClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    FoldersClientFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_foldersclient_free(ptr, 0);
+  }
+  /**
+   * Decrypt folder
+   * @param {Folder} folder
+   * @returns {FolderView}
+   */
+  decrypt(folder) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.foldersclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(folder));
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+
 const GeneratorClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -2226,6 +2158,74 @@ export class SendError {
   }
 }
 
+const TotpClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_totpclient_free(ptr >>> 0, 1));
+
+export class TotpClient {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(TotpClient.prototype);
+    obj.__wbg_ptr = ptr;
+    TotpClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TotpClientFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_totpclient_free(ptr, 0);
+  }
+  /**
+   * Generates a TOTP code from a provided key
+   *
+   * # Arguments
+   * - `key` - Can be:
+   *     - A base32 encoded string
+   *     - OTP Auth URI
+   *     - Steam URI
+   * - `time_ms` - Optional timestamp in milliseconds
+   *
+   * # Returns
+   * - `Ok(TotpResponse)` containing the generated code and period
+   * - `Err(TotpError)` if code generation fails
+   * @param {string} key
+   * @param {number | null} [time_ms]
+   * @returns {TotpResponse}
+   */
+  generate_totp(key, time_ms) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.totpclient_generate_totp(
+        retptr,
+        this.__wbg_ptr,
+        ptr0,
+        len0,
+        !isLikeNone(time_ms),
+        isLikeNone(time_ms) ? 0 : time_ms,
+      );
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+
 const VaultClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -2252,32 +2252,32 @@ export class VaultClient {
     wasm.__wbg_vaultclient_free(ptr, 0);
   }
   /**
-   * @returns {ClientAttachments}
+   * @returns {AttachmentsClient}
    */
   attachments() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return ClientAttachments.__wrap(ret);
+    return AttachmentsClient.__wrap(ret);
   }
   /**
-   * @returns {ClientCiphers}
+   * @returns {CiphersClient}
    */
   ciphers() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return ClientCiphers.__wrap(ret);
+    return CiphersClient.__wrap(ret);
   }
   /**
-   * @returns {ClientFolders}
+   * @returns {FoldersClient}
    */
   folders() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return ClientFolders.__wrap(ret);
+    return FoldersClient.__wrap(ret);
   }
   /**
-   * @returns {ClientTotp}
+   * @returns {TotpClient}
    */
   totp() {
     const ret = wasm.vaultclient_totp(this.__wbg_ptr);
-    return ClientTotp.__wrap(ret);
+    return TotpClient.__wrap(ret);
   }
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -146,8 +146,8 @@ export const purecrypto_symmetric_encrypt_to_array_buffer: (
 ) => void;
 export const generate_ssh_key: (a: number, b: number) => void;
 export const import_ssh_key: (a: number, b: number, c: number, d: number, e: number) => void;
-export const __wbg_clientattachments_free: (a: number, b: number) => void;
-export const clientattachments_decrypt_buffer: (
+export const __wbg_attachmentsclient_free: (a: number, b: number) => void;
+export const attachmentsclient_decrypt_buffer: (
   a: number,
   b: number,
   c: number,
@@ -155,13 +155,13 @@ export const clientattachments_decrypt_buffer: (
   e: number,
   f: number,
 ) => void;
-export const clientciphers_encrypt: (a: number, b: number, c: number) => void;
-export const clientciphers_decrypt: (a: number, b: number, c: number) => void;
-export const clientciphers_decrypt_list: (a: number, b: number, c: number, d: number) => void;
-export const clientciphers_decrypt_fido2_credentials: (a: number, b: number, c: number) => void;
-export const clientciphers_decrypt_fido2_private_key: (a: number, b: number, c: number) => void;
-export const clientfolders_decrypt: (a: number, b: number, c: number) => void;
-export const clienttotp_generate_totp: (
+export const ciphersclient_encrypt: (a: number, b: number, c: number) => void;
+export const ciphersclient_decrypt: (a: number, b: number, c: number) => void;
+export const ciphersclient_decrypt_list: (a: number, b: number, c: number, d: number) => void;
+export const ciphersclient_decrypt_fido2_credentials: (a: number, b: number, c: number) => void;
+export const ciphersclient_decrypt_fido2_private_key: (a: number, b: number, c: number) => void;
+export const foldersclient_decrypt: (a: number, b: number, c: number) => void;
+export const totpclient_generate_totp: (
   a: number,
   b: number,
   c: number,
@@ -178,9 +178,9 @@ export const vaultclient_ciphers: (a: number) => number;
 export const vaultclient_folders: (a: number) => number;
 export const __wbg_generatorclient_free: (a: number, b: number) => void;
 export const __wbg_vaultclient_free: (a: number, b: number) => void;
-export const __wbg_clienttotp_free: (a: number, b: number) => void;
-export const __wbg_clientfolders_free: (a: number, b: number) => void;
-export const __wbg_clientciphers_free: (a: number, b: number) => void;
+export const __wbg_foldersclient_free: (a: number, b: number) => void;
+export const __wbg_ciphersclient_free: (a: number, b: number) => void;
+export const __wbg_totpclient_free: (a: number, b: number) => void;
 export const __wbg_cryptoclient_free: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;