@bitwarden/commercial-sdk-internal 0.2.0-main.410 → 0.2.0-main.412

package/bitwarden_wasm_internal_bg.js

@@ -256,12 +256,6 @@ function getArrayJsValueFromWasm0(ptr, len) {
   }
   return result;
 }
-/**
- * @param {LogLevel | null} [log_level]
- */
-export function init_sdk(log_level) {
-  wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
-}
 
 function passArray8ToWasm0(arg, malloc) {
   const ptr = malloc(arg.length * 1, 1) >>> 0;
@@ -270,21 +264,33 @@ function passArray8ToWasm0(arg, malloc) {
   return ptr;
 }
 /**
- * Generate a new SSH key pair
+ * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
+ * to an OpenSSH private key with public key and fingerprint
  *
  * # Arguments
- * - `key_algorithm` - The algorithm to use for the key pair
+ * - `imported_key` - The private key to convert
+ * - `password` - The password to use for decrypting the key
  *
  * # Returns
- * - `Ok(SshKey)` if the key was successfully generated
- * - `Err(KeyGenerationError)` if the key could not be generated
- * @param {KeyAlgorithm} key_algorithm
+ * - `Ok(SshKey)` if the key was successfully coneverted
+ * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
+ * - `Err(WrongPassword)` if the password provided is incorrect
+ * - `Err(ParsingError)` if the key could not be parsed
+ * - `Err(UnsupportedKeyType)` if the key type is not supported
+ * @param {string} imported_key
+ * @param {string | null} [password]
  * @returns {SshKeyView}
  */
-export function generate_ssh_key(key_algorithm) {
+export function import_ssh_key(imported_key, password) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.generate_ssh_key(retptr, addHeapObject(key_algorithm));
+    const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(password)
+      ? 0
+      : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    wasm.import_ssh_key(retptr, ptr0, len0, ptr1, len1);
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -298,33 +304,21 @@ export function generate_ssh_key(key_algorithm) {
 }
 
 /**
- * Convert a PCKS8 or OpenSSH encrypted or unencrypted private key
- * to an OpenSSH private key with public key and fingerprint
+ * Generate a new SSH key pair
  *
  * # Arguments
- * - `imported_key` - The private key to convert
- * - `password` - The password to use for decrypting the key
+ * - `key_algorithm` - The algorithm to use for the key pair
  *
  * # Returns
- * - `Ok(SshKey)` if the key was successfully coneverted
- * - `Err(PasswordRequired)` if the key is encrypted and no password was provided
- * - `Err(WrongPassword)` if the password provided is incorrect
- * - `Err(ParsingError)` if the key could not be parsed
- * - `Err(UnsupportedKeyType)` if the key type is not supported
- * @param {string} imported_key
- * @param {string | null} [password]
+ * - `Ok(SshKey)` if the key was successfully generated
+ * - `Err(KeyGenerationError)` if the key could not be generated
+ * @param {KeyAlgorithm} key_algorithm
  * @returns {SshKeyView}
  */
-export function import_ssh_key(imported_key, password) {
+export function generate_ssh_key(key_algorithm) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    const ptr0 = passStringToWasm0(imported_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(password)
-      ? 0
-      : passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    wasm.import_ssh_key(retptr, ptr0, len0, ptr1, len1);
+    wasm.generate_ssh_key(retptr, addHeapObject(key_algorithm));
     var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
     var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
     var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -337,6 +331,13 @@ export function import_ssh_key(imported_key, password) {
   }
 }
 
+/**
+ * @param {LogLevel | null} [log_level]
+ */
+export function init_sdk(log_level) {
+  wasm.init_sdk(isLikeNone(log_level) ? 5 : log_level);
+}
+
 let stack_pointer = 128;
 
 function addBorrowedObject(obj) {
@@ -387,9 +388,9 @@ export function isMasterPasswordError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isDeriveKeyConnectorError(error) {
+export function isAccountCryptographyInitializationError(error) {
   try {
-    const ret = wasm.isDeriveKeyConnectorError(addBorrowedObject(error));
+    const ret = wasm.isAccountCryptographyInitializationError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -400,9 +401,9 @@ export function isDeriveKeyConnectorError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isEnrollAdminPasswordResetError(error) {
+export function isCryptoClientError(error) {
   try {
-    const ret = wasm.isEnrollAdminPasswordResetError(addBorrowedObject(error));
+    const ret = wasm.isCryptoClientError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -413,9 +414,9 @@ export function isEnrollAdminPasswordResetError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isCryptoClientError(error) {
+export function isDeriveKeyConnectorError(error) {
   try {
-    const ret = wasm.isCryptoClientError(addBorrowedObject(error));
+    const ret = wasm.isDeriveKeyConnectorError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -426,9 +427,9 @@ export function isCryptoClientError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isAccountCryptographyInitializationError(error) {
+export function isEnrollAdminPasswordResetError(error) {
   try {
-    const ret = wasm.isAccountCryptographyInitializationError(addBorrowedObject(error));
+    const ret = wasm.isEnrollAdminPasswordResetError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -500,9 +501,9 @@ export function isExportError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isUsernameError(error) {
+export function isPasswordError(error) {
   try {
-    const ret = wasm.isUsernameError(addBorrowedObject(error));
+    const ret = wasm.isPasswordError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -513,56 +514,22 @@ export function isUsernameError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isPasswordError(error) {
+export function isUsernameError(error) {
   try {
-    const ret = wasm.isPasswordError(addBorrowedObject(error));
+    const ret = wasm.isUsernameError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
   }
 }
 
-function _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
-/**
- * Registers a DiscoverHandler so that the client can respond to DiscoverRequests.
- * @param {IpcClient} ipc_client
- * @param {DiscoverResponse} response
- * @returns {Promise<void>}
- */
-export function ipcRegisterDiscoverHandler(ipc_client, response) {
-  _assertClass(ipc_client, IpcClient);
-  const ret = wasm.ipcRegisterDiscoverHandler(ipc_client.__wbg_ptr, addHeapObject(response));
-  return takeObject(ret);
-}
-
-/**
- * Sends a DiscoverRequest to the specified destination and returns the response.
- * @param {IpcClient} ipc_client
- * @param {Endpoint} destination
- * @param {AbortSignal | null} [abort_signal]
- * @returns {Promise<DiscoverResponse>}
- */
-export function ipcRequestDiscover(ipc_client, destination, abort_signal) {
-  _assertClass(ipc_client, IpcClient);
-  const ret = wasm.ipcRequestDiscover(
-    ipc_client.__wbg_ptr,
-    addHeapObject(destination),
-    isLikeNone(abort_signal) ? 0 : addHeapObject(abort_signal),
-  );
-  return takeObject(ret);
-}
-
 /**
  * @param {any} error
  * @returns {boolean}
  */
-export function isChannelError(error) {
+export function isRequestError(error) {
   try {
-    const ret = wasm.isChannelError(addBorrowedObject(error));
+    const ret = wasm.isRequestError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -573,9 +540,9 @@ export function isChannelError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isDeserializeError(error) {
+export function isTypedReceiveError(error) {
   try {
-    const ret = wasm.isDeserializeError(addBorrowedObject(error));
+    const ret = wasm.isTypedReceiveError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -586,9 +553,9 @@ export function isDeserializeError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isRequestError(error) {
+export function isSubscribeError(error) {
   try {
-    const ret = wasm.isRequestError(addBorrowedObject(error));
+    const ret = wasm.isSubscribeError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -599,22 +566,27 @@ export function isRequestError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isTypedReceiveError(error) {
+export function isReceiveError(error) {
   try {
-    const ret = wasm.isTypedReceiveError(addBorrowedObject(error));
+    const ret = wasm.isReceiveError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
   }
 }
 
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
 /**
  * @param {any} error
  * @returns {boolean}
  */
-export function isReceiveError(error) {
+export function isDeserializeError(error) {
   try {
-    const ret = wasm.isReceiveError(addBorrowedObject(error));
+    const ret = wasm.isDeserializeError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -625,22 +597,51 @@ export function isReceiveError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isSubscribeError(error) {
+export function isChannelError(error) {
   try {
-    const ret = wasm.isSubscribeError(addBorrowedObject(error));
+    const ret = wasm.isChannelError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
   }
 }
 
+/**
+ * Sends a DiscoverRequest to the specified destination and returns the response.
+ * @param {IpcClient} ipc_client
+ * @param {Endpoint} destination
+ * @param {AbortSignal | null} [abort_signal]
+ * @returns {Promise<DiscoverResponse>}
+ */
+export function ipcRequestDiscover(ipc_client, destination, abort_signal) {
+  _assertClass(ipc_client, IpcClient);
+  const ret = wasm.ipcRequestDiscover(
+    ipc_client.__wbg_ptr,
+    addHeapObject(destination),
+    isLikeNone(abort_signal) ? 0 : addHeapObject(abort_signal),
+  );
+  return takeObject(ret);
+}
+
+/**
+ * Registers a DiscoverHandler so that the client can respond to DiscoverRequests.
+ * @param {IpcClient} ipc_client
+ * @param {DiscoverResponse} response
+ * @returns {Promise<void>}
+ */
+export function ipcRegisterDiscoverHandler(ipc_client, response) {
+  _assertClass(ipc_client, IpcClient);
+  const ret = wasm.ipcRegisterDiscoverHandler(ipc_client.__wbg_ptr, addHeapObject(response));
+  return takeObject(ret);
+}
+
 /**
  * @param {any} error
  * @returns {boolean}
  */
-export function isSshKeyExportError(error) {
+export function isKeyGenerationError(error) {
   try {
-    const ret = wasm.isSshKeyExportError(addBorrowedObject(error));
+    const ret = wasm.isKeyGenerationError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -651,9 +652,9 @@ export function isSshKeyExportError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isSshKeyImportError(error) {
+export function isSshKeyExportError(error) {
   try {
-    const ret = wasm.isSshKeyImportError(addBorrowedObject(error));
+    const ret = wasm.isSshKeyExportError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -664,9 +665,9 @@ export function isSshKeyImportError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isKeyGenerationError(error) {
+export function isSshKeyImportError(error) {
   try {
-    const ret = wasm.isKeyGenerationError(addBorrowedObject(error));
+    const ret = wasm.isSshKeyImportError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -716,9 +717,9 @@ export function isCallError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isDecryptError(error) {
+export function isCipherRiskError(error) {
   try {
-    const ret = wasm.isDecryptError(addBorrowedObject(error));
+    const ret = wasm.isCipherRiskError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -729,9 +730,9 @@ export function isDecryptError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isEncryptError(error) {
+export function isTotpError(error) {
   try {
-    const ret = wasm.isEncryptError(addBorrowedObject(error));
+    const ret = wasm.isTotpError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -742,9 +743,9 @@ export function isEncryptError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isTotpError(error) {
+export function isEncryptError(error) {
   try {
-    const ret = wasm.isTotpError(addBorrowedObject(error));
+    const ret = wasm.isEncryptError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -755,9 +756,9 @@ export function isTotpError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isGetFolderError(error) {
+export function isDecryptError(error) {
   try {
-    const ret = wasm.isGetFolderError(addBorrowedObject(error));
+    const ret = wasm.isDecryptError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -768,9 +769,9 @@ export function isGetFolderError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isEditFolderError(error) {
+export function isGetCipherError(error) {
   try {
-    const ret = wasm.isEditFolderError(addBorrowedObject(error));
+    const ret = wasm.isGetCipherError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -781,9 +782,9 @@ export function isEditFolderError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isCreateFolderError(error) {
+export function isEditCipherError(error) {
   try {
-    const ret = wasm.isCreateFolderError(addBorrowedObject(error));
+    const ret = wasm.isEditCipherError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -794,9 +795,9 @@ export function isCreateFolderError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isCipherRiskError(error) {
+export function isCreateCipherError(error) {
   try {
-    const ret = wasm.isCipherRiskError(addBorrowedObject(error));
+    const ret = wasm.isCreateCipherError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -807,9 +808,9 @@ export function isCipherRiskError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isGetCipherError(error) {
+export function isEncryptFileError(error) {
   try {
-    const ret = wasm.isGetCipherError(addBorrowedObject(error));
+    const ret = wasm.isEncryptFileError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -820,9 +821,9 @@ export function isGetCipherError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isEditCipherError(error) {
+export function isDecryptFileError(error) {
   try {
-    const ret = wasm.isEditCipherError(addBorrowedObject(error));
+    const ret = wasm.isDecryptFileError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -833,9 +834,9 @@ export function isEditCipherError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isCreateCipherError(error) {
+export function isCipherError(error) {
   try {
-    const ret = wasm.isCreateCipherError(addBorrowedObject(error));
+    const ret = wasm.isCipherError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -846,9 +847,9 @@ export function isCreateCipherError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isCipherError(error) {
+export function isEditFolderError(error) {
   try {
-    const ret = wasm.isCipherError(addBorrowedObject(error));
+    const ret = wasm.isEditFolderError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -859,9 +860,9 @@ export function isCipherError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isDecryptFileError(error) {
+export function isCreateFolderError(error) {
   try {
-    const ret = wasm.isDecryptFileError(addBorrowedObject(error));
+    const ret = wasm.isCreateFolderError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
@@ -872,31 +873,31 @@ export function isDecryptFileError(error) {
  * @param {any} error
  * @returns {boolean}
  */
-export function isEncryptFileError(error) {
+export function isGetFolderError(error) {
   try {
-    const ret = wasm.isEncryptFileError(addBorrowedObject(error));
+    const ret = wasm.isGetFolderError(addBorrowedObject(error));
     return ret !== 0;
   } finally {
     heap[stack_pointer++] = undefined;
   }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h092300064b8afb1e(arg0, arg1) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h092300064b8afb1e(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h4eff94a44eff58c2(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h4eff94a44eff58c2(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h3f3903322ff045ff(arg0, arg1, arg2) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h3f3903322ff045ff(
+function wasm_bindgen__convert__closures_____invoke__ha3eecaeccbf508bc(arg0, arg1, arg2) {
+  wasm.wasm_bindgen__convert__closures_____invoke__ha3eecaeccbf508bc(
     arg0,
     arg1,
     addHeapObject(arg2),
   );
 }
 
-function wasm_bindgen__convert__closures_____invoke__h35a8188fc7e541fe(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures_____invoke__h86320ba04bc5bce5(arg0, arg1, arg2) {
   try {
     const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-    wasm.wasm_bindgen__convert__closures_____invoke__h35a8188fc7e541fe(
+    wasm.wasm_bindgen__convert__closures_____invoke__h86320ba04bc5bce5(
       retptr,
       arg0,
       arg1,
@@ -912,8 +913,8 @@ function wasm_bindgen__convert__closures_____invoke__h35a8188fc7e541fe(arg0, arg
   }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h43dfd80678632d6f(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h43dfd80678632d6f(
+function wasm_bindgen__convert__closures_____invoke__h0cb536241502fe83(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h0cb536241502fe83(
     arg0,
     arg1,
     addHeapObject(arg2),
@@ -1185,14 +1186,6 @@ export class AuthClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_authclient_free(ptr, 0);
   }
-  /**
-   * Client for identity functionality
-   * @returns {IdentityClient}
-   */
-  identity() {
-    const ret = wasm.authclient_identity(this.__wbg_ptr);
-    return IdentityClient.__wrap(ret);
-  }
   /**
    * Client for send access functionality
    * @returns {SendAccessClient}
@@ -1209,9 +1202,17 @@ export class AuthClient {
     const ret = wasm.authclient_identity(this.__wbg_ptr);
     return RegistrationClient.__wrap(ret);
   }
-}
-if (Symbol.dispose) AuthClient.prototype[Symbol.dispose] = AuthClient.prototype.free;
-
+  /**
+   * Client for identity functionality
+   * @returns {IdentityClient}
+   */
+  identity() {
+    const ret = wasm.authclient_identity(this.__wbg_ptr);
+    return IdentityClient.__wrap(ret);
+  }
+}
+if (Symbol.dispose) AuthClient.prototype[Symbol.dispose] = AuthClient.prototype.free;
+
 const CipherRiskClientFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -1239,21 +1240,6 @@ export class CipherRiskClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_cipherriskclient_free(ptr, 0);
   }
-  /**
-   * Build password reuse map for a list of login ciphers.
-   *
-   * Returns a map where keys are passwords and values are the number of times
-   * each password appears in the provided list. This map can be passed to `compute_risk()`
-   * to enable password reuse detection.
-   * @param {CipherLoginDetails[]} login_details
-   * @returns {PasswordReuseMap}
-   */
-  password_reuse_map(login_details) {
-    const ptr0 = passArrayJsValueToWasm0(login_details, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.cipherriskclient_password_reuse_map(this.__wbg_ptr, ptr0, len0);
-    return takeObject(ret);
-  }
   /**
    * Evaluate security risks for multiple login ciphers concurrently.
    *
@@ -1292,6 +1278,21 @@ export class CipherRiskClient {
     );
     return takeObject(ret);
   }
+  /**
+   * Build password reuse map for a list of login ciphers.
+   *
+   * Returns a map where keys are passwords and values are the number of times
+   * each password appears in the provided list. This map can be passed to `compute_risk()`
+   * to enable password reuse detection.
+   * @param {CipherLoginDetails[]} login_details
+   * @returns {PasswordReuseMap}
+   */
+  password_reuse_map(login_details) {
+    const ptr0 = passArrayJsValueToWasm0(login_details, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cipherriskclient_password_reuse_map(this.__wbg_ptr, ptr0, len0);
+    return takeObject(ret);
+  }
 }
 if (Symbol.dispose) CipherRiskClient.prototype[Symbol.dispose] = CipherRiskClient.prototype.free;
 
@@ -1320,24 +1321,6 @@ export class CiphersClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_ciphersclient_free(ptr, 0);
   }
-  /**
-   * Create a new [Cipher] and save it to the server.
-   * @param {CipherCreateRequest} request
-   * @returns {Promise<CipherView>}
-   */
-  create(request) {
-    const ret = wasm.ciphersclient_create(this.__wbg_ptr, addHeapObject(request));
-    return takeObject(ret);
-  }
-  /**
-   * Edit an existing [Cipher] and save it to the server.
-   * @param {CipherEditRequest} request
-   * @returns {Promise<CipherView>}
-   */
-  edit(request) {
-    const ret = wasm.ciphersclient_edit(this.__wbg_ptr, addHeapObject(request));
-    return takeObject(ret);
-  }
   /**
    * Moves a cipher into an organization, adds it to collections, and calls the share_cipher API.
    * @param {CipherView} cipher_view
@@ -1382,79 +1365,6 @@ export class CiphersClient {
     );
     return takeObject(ret);
   }
-  /**
-   * @param {CipherView} cipher_view
-   * @returns {EncryptionContext}
-   */
-  encrypt(cipher_view) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      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);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return takeObject(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
-  /**
-   * Encrypt a cipher with the provided key. This should only be used when rotating encryption
-   * keys in the Web client.
-   *
-   * Until key rotation is fully implemented in the SDK, this method must be provided the new
-   * symmetric key in base64 format. See PM-23084
-   *
-   * If the cipher has a CipherKey, it will be re-encrypted with the new key.
-   * If the cipher does not have a CipherKey and CipherKeyEncryption is enabled, one will be
-   * generated using the new key. Otherwise, the cipher's data will be encrypted with the new
-   * key directly.
-   * @param {CipherView} cipher_view
-   * @param {B64} new_key
-   * @returns {EncryptionContext}
-   */
-  encrypt_cipher_for_rotation(cipher_view, new_key) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ciphersclient_encrypt_cipher_for_rotation(
-        retptr,
-        this.__wbg_ptr,
-        addHeapObject(cipher_view),
-        addHeapObject(new_key),
-      );
-      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);
-    }
-  }
-  /**
-   * @param {Cipher} cipher
-   * @returns {CipherView}
-   */
-  decrypt(cipher) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      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);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return takeObject(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
   /**
    * @param {Cipher[]} ciphers
    * @returns {CipherListView[]}
@@ -1479,40 +1389,27 @@ export class CiphersClient {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
-  /**
-   * Decrypt cipher list with failures
-   * Returns both successfully decrypted ciphers and any that failed to decrypt
-   * @param {Cipher[]} ciphers
-   * @returns {DecryptCipherListResult}
-   */
-  decrypt_list_with_failures(ciphers) {
-    const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ciphersclient_decrypt_list_with_failures(this.__wbg_ptr, ptr0, len0);
-    return takeObject(ret);
-  }
   /**
    * @param {CipherView} cipher_view
-   * @returns {Fido2CredentialView[]}
+   * @param {OrganizationId} organization_id
+   * @returns {CipherView}
    */
-  decrypt_fido2_credentials(cipher_view) {
+  move_to_organization(cipher_view, organization_id) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ciphersclient_decrypt_fido2_credentials(
+      wasm.ciphersclient_move_to_organization(
         retptr,
         this.__wbg_ptr,
         addHeapObject(cipher_view),
+        addHeapObject(organization_id),
       );
       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);
+      if (r2) {
+        throw takeObject(r1);
       }
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      return takeObject(r0);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
@@ -1552,25 +1449,26 @@ export class CiphersClient {
   }
   /**
    * @param {CipherView} cipher_view
-   * @param {OrganizationId} organization_id
-   * @returns {CipherView}
+   * @returns {Fido2CredentialView[]}
    */
-  move_to_organization(cipher_view, organization_id) {
+  decrypt_fido2_credentials(cipher_view) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.ciphersclient_move_to_organization(
+      wasm.ciphersclient_decrypt_fido2_credentials(
         retptr,
         this.__wbg_ptr,
         addHeapObject(cipher_view),
-        addHeapObject(organization_id),
       );
       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);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
       }
-      return takeObject(r0);
+      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 4, 4);
+      return v1;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
@@ -1608,71 +1506,174 @@ export class CiphersClient {
       wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
   }
-}
-if (Symbol.dispose) CiphersClient.prototype[Symbol.dispose] = CiphersClient.prototype.free;
-
-const CollectionViewNodeItemFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_collectionviewnodeitem_free(ptr >>> 0, 1));
-
-export class CollectionViewNodeItem {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(CollectionViewNodeItem.prototype);
-    obj.__wbg_ptr = ptr;
-    CollectionViewNodeItemFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    CollectionViewNodeItemFinalization.unregister(this);
-    return ptr;
-  }
-
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_collectionviewnodeitem_free(ptr, 0);
-  }
-  /**
-   * @returns {CollectionView}
-   */
-  get_item() {
-    const ret = wasm.collectionviewnodeitem_get_item(this.__wbg_ptr);
-    return takeObject(ret);
-  }
   /**
-   * @returns {CollectionView | undefined}
+   * Decrypt cipher list with failures
+   * Returns both successfully decrypted ciphers and any that failed to decrypt
+   * @param {Cipher[]} ciphers
+   * @returns {DecryptCipherListResult}
    */
-  get_parent() {
-    const ret = wasm.collectionviewnodeitem_get_parent(this.__wbg_ptr);
+  decrypt_list_with_failures(ciphers) {
+    const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ciphersclient_decrypt_list_with_failures(this.__wbg_ptr, ptr0, len0);
     return takeObject(ret);
   }
   /**
-   * @returns {CollectionView[]}
+   * Encrypt a cipher with the provided key. This should only be used when rotating encryption
+   * keys in the Web client.
+   *
+   * Until key rotation is fully implemented in the SDK, this method must be provided the new
+   * symmetric key in base64 format. See PM-23084
+   *
+   * If the cipher has a CipherKey, it will be re-encrypted with the new key.
+   * If the cipher does not have a CipherKey and CipherKeyEncryption is enabled, one will be
+   * generated using the new key. Otherwise, the cipher's data will be encrypted with the new
+   * key directly.
+   * @param {CipherView} cipher_view
+   * @param {B64} new_key
+   * @returns {EncryptionContext}
    */
-  get_children() {
+  encrypt_cipher_for_rotation(cipher_view, new_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.collectionviewnodeitem_get_children(retptr, this.__wbg_ptr);
+      wasm.ciphersclient_encrypt_cipher_for_rotation(
+        retptr,
+        this.__wbg_ptr,
+        addHeapObject(cipher_view),
+        addHeapObject(new_key),
+      );
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v1;
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * @returns {AncestorMap}
+   * @param {Cipher} cipher
+   * @returns {CipherView}
+   */
+  decrypt(cipher) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      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);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {CipherView} cipher_view
+   * @returns {EncryptionContext}
+   */
+  encrypt(cipher_view) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      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);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Edit an existing [Cipher] and save it to the server.
+   * @param {CipherEditRequest} request
+   * @returns {Promise<CipherView>}
+   */
+  edit(request) {
+    const ret = wasm.ciphersclient_edit(this.__wbg_ptr, addHeapObject(request));
+    return takeObject(ret);
+  }
+  /**
+   * Create a new [Cipher] and save it to the server.
+   * @param {CipherCreateRequest} request
+   * @returns {Promise<CipherView>}
+   */
+  create(request) {
+    const ret = wasm.ciphersclient_create(this.__wbg_ptr, addHeapObject(request));
+    return takeObject(ret);
+  }
+}
+if (Symbol.dispose) CiphersClient.prototype[Symbol.dispose] = CiphersClient.prototype.free;
+
+const CollectionViewNodeItemFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_collectionviewnodeitem_free(ptr >>> 0, 1));
+
+export class CollectionViewNodeItem {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(CollectionViewNodeItem.prototype);
+    obj.__wbg_ptr = ptr;
+    CollectionViewNodeItemFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    CollectionViewNodeItemFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_collectionviewnodeitem_free(ptr, 0);
+  }
+  /**
+   * @returns {CollectionView | undefined}
+   */
+  get_parent() {
+    const ret = wasm.collectionviewnodeitem_get_parent(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @returns {CollectionView[]}
+   */
+  get_children() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.collectionviewnodeitem_get_children(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 4, 4);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @returns {AncestorMap}
    */
   get_ancestors() {
     const ret = wasm.collectionviewnodeitem_get_ancestors(this.__wbg_ptr);
     return takeObject(ret);
   }
+  /**
+   * @returns {CollectionView}
+   */
+  get_item() {
+    const ret = wasm.collectionviewnodeitem_get_item(this.__wbg_ptr);
+    return takeObject(ret);
+  }
 }
 if (Symbol.dispose)
   CollectionViewNodeItem.prototype[Symbol.dispose] = CollectionViewNodeItem.prototype.free;
@@ -1702,24 +1703,13 @@ export class CollectionViewTree {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_collectionviewtree_free(ptr, 0);
   }
-  /**
-   * @param {CollectionView} collection_view
-   * @returns {CollectionViewNodeItem | undefined}
-   */
-  get_item_for_view(collection_view) {
-    const ret = wasm.collectionviewtree_get_item_for_view(
-      this.__wbg_ptr,
-      addHeapObject(collection_view),
-    );
-    return ret === 0 ? undefined : CollectionViewNodeItem.__wrap(ret);
-  }
   /**
    * @returns {CollectionViewNodeItem[]}
    */
-  get_root_items() {
+  get_flat_items() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.collectionviewtree_get_root_items(retptr, this.__wbg_ptr);
+      wasm.collectionviewtree_get_flat_items(retptr, this.__wbg_ptr);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
@@ -1732,10 +1722,10 @@ export class CollectionViewTree {
   /**
    * @returns {CollectionViewNodeItem[]}
    */
-  get_flat_items() {
+  get_root_items() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.collectionviewtree_get_flat_items(retptr, this.__wbg_ptr);
+      wasm.collectionviewtree_get_root_items(retptr, this.__wbg_ptr);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
@@ -1745,6 +1735,17 @@ export class CollectionViewTree {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * @param {CollectionView} collection_view
+   * @returns {CollectionViewNodeItem | undefined}
+   */
+  get_item_for_view(collection_view) {
+    const ret = wasm.collectionviewtree_get_item_for_view(
+      this.__wbg_ptr,
+      addHeapObject(collection_view),
+    );
+    return ret === 0 ? undefined : CollectionViewNodeItem.__wrap(ret);
+  }
 }
 if (Symbol.dispose)
   CollectionViewTree.prototype[Symbol.dispose] = CollectionViewTree.prototype.free;
@@ -1774,25 +1775,6 @@ export class CollectionsClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_collectionsclient_free(ptr, 0);
   }
-  /**
-   * @param {Collection} collection
-   * @returns {CollectionView}
-   */
-  decrypt(collection) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.collectionsclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(collection));
-      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);
-    }
-  }
   /**
    * @param {Collection[]} collections
    * @returns {CollectionView[]}
@@ -1830,6 +1812,25 @@ export class CollectionsClient {
     const ret = wasm.collectionsclient_get_collection_tree(this.__wbg_ptr, ptr0, len0);
     return CollectionViewTree.__wrap(ret);
   }
+  /**
+   * @param {Collection} collection
+   * @returns {CollectionView}
+   */
+  decrypt(collection) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.collectionsclient_decrypt(retptr, this.__wbg_ptr, addHeapObject(collection));
+      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);
+    }
+  }
 }
 if (Symbol.dispose) CollectionsClient.prototype[Symbol.dispose] = CollectionsClient.prototype.free;
 
@@ -1932,35 +1933,18 @@ export class CryptoClient {
     wasm.__wbg_cryptoclient_free(ptr, 0);
   }
   /**
-   * Initialization method for the user crypto. Needs to be called before any other crypto
-   * operations.
-   * @param {InitUserCryptoRequest} req
-   * @returns {Promise<void>}
-   */
-  initialize_user_crypto(req) {
-    const ret = wasm.cryptoclient_initialize_user_crypto(this.__wbg_ptr, addHeapObject(req));
-    return takeObject(ret);
-  }
-  /**
-   * Initialization method for the organization crypto. Needs to be called after
-   * `initialize_user_crypto` but before any other crypto operations.
-   * @param {InitOrgCryptoRequest} req
-   * @returns {Promise<void>}
-   */
-  initialize_org_crypto(req) {
-    const ret = wasm.cryptoclient_initialize_org_crypto(this.__wbg_ptr, addHeapObject(req));
-    return takeObject(ret);
-  }
-  /**
-   * Generates a new key pair and encrypts the private key with the provided user key.
-   * Crypto initialization not required.
-   * @param {B64} user_key
-   * @returns {MakeKeyPairResponse}
+   * Protects the current user key with the provided PIN. The result can be stored and later
+   * used to initialize another client instance by using the PIN and the PIN key with
+   * `initialize_user_crypto`.
+   * @param {string} pin
+   * @returns {EnrollPinResponse}
    */
-  make_key_pair(user_key) {
+  enroll_pin(pin) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.cryptoclient_make_key_pair(retptr, this.__wbg_ptr, addHeapObject(user_key));
+      const ptr0 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.cryptoclient_enroll_pin(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);
@@ -1973,16 +1957,15 @@ export class CryptoClient {
     }
   }
   /**
-   * Verifies a user's asymmetric keys by decrypting the private key with the provided user
-   * key. Returns if the private key is decryptable and if it is a valid matching key.
+   * Generates a new key pair and encrypts the private key with the provided user key.
    * Crypto initialization not required.
-   * @param {VerifyAsymmetricKeysRequest} request
-   * @returns {VerifyAsymmetricKeysResponse}
+   * @param {B64} user_key
+   * @returns {MakeKeyPairResponse}
    */
-  verify_asymmetric_keys(request) {
+  make_key_pair(user_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.cryptoclient_verify_asymmetric_keys(retptr, this.__wbg_ptr, addHeapObject(request));
+      wasm.cryptoclient_make_key_pair(retptr, this.__wbg_ptr, addHeapObject(user_key));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1995,13 +1978,19 @@ export class CryptoClient {
     }
   }
   /**
-   * Makes a new signing key pair and signs the public key for the user
-   * @returns {UserCryptoV2KeysResponse}
+   * Create the data necessary to update the user's kdf settings. The user's encryption key is
+   * re-encrypted for the password under the new kdf settings. This returns the re-encrypted
+   * user key and the new password hash but does not update sdk state.
+   * @param {string} password
+   * @param {Kdf} kdf
+   * @returns {UpdateKdfResponse}
    */
-  make_keys_for_user_crypto_v2() {
+  make_update_kdf(password, kdf) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.cryptoclient_make_keys_for_user_crypto_v2(retptr, this.__wbg_ptr);
+      const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.cryptoclient_make_update_kdf(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(kdf));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2014,16 +2003,39 @@ export class CryptoClient {
     }
   }
   /**
-   * Creates a rotated set of account keys for the current state
-   * @returns {UserCryptoV2KeysResponse}
+   * Initialization method for the organization crypto. Needs to be called after
+   * `initialize_user_crypto` but before any other crypto operations.
+   * @param {InitOrgCryptoRequest} req
+   * @returns {Promise<void>}
    */
-  get_v2_rotated_account_keys() {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.cryptoclient_get_v2_rotated_account_keys(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+  initialize_org_crypto(req) {
+    const ret = wasm.cryptoclient_initialize_org_crypto(this.__wbg_ptr, addHeapObject(req));
+    return takeObject(ret);
+  }
+  /**
+   * Initialization method for the user crypto. Needs to be called before any other crypto
+   * operations.
+   * @param {InitUserCryptoRequest} req
+   * @returns {Promise<void>}
+   */
+  initialize_user_crypto(req) {
+    const ret = wasm.cryptoclient_initialize_user_crypto(this.__wbg_ptr, addHeapObject(req));
+    return takeObject(ret);
+  }
+  /**
+   * Verifies a user's asymmetric keys by decrypting the private key with the provided user
+   * key. Returns if the private key is decryptable and if it is a valid matching key.
+   * Crypto initialization not required.
+   * @param {VerifyAsymmetricKeysRequest} request
+   * @returns {VerifyAsymmetricKeysResponse}
+   */
+  verify_asymmetric_keys(request) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.cryptoclient_verify_asymmetric_keys(retptr, this.__wbg_ptr, addHeapObject(request));
+      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);
       }
@@ -2033,19 +2045,13 @@ export class CryptoClient {
     }
   }
   /**
-   * Create the data necessary to update the user's kdf settings. The user's encryption key is
-   * re-encrypted for the password under the new kdf settings. This returns the re-encrypted
-   * user key and the new password hash but does not update sdk state.
-   * @param {string} password
-   * @param {Kdf} kdf
-   * @returns {UpdateKdfResponse}
+   * Creates a rotated set of account keys for the current state
+   * @returns {UserCryptoV2KeysResponse}
    */
-  make_update_kdf(password, kdf) {
+  get_v2_rotated_account_keys() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.cryptoclient_make_update_kdf(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(kdf));
+      wasm.cryptoclient_get_v2_rotated_account_keys(retptr, this.__wbg_ptr);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2058,18 +2064,13 @@ export class CryptoClient {
     }
   }
   /**
-   * Protects the current user key with the provided PIN. The result can be stored and later
-   * used to initialize another client instance by using the PIN and the PIN key with
-   * `initialize_user_crypto`.
-   * @param {string} pin
-   * @returns {EnrollPinResponse}
+   * Makes a new signing key pair and signs the public key for the user
+   * @returns {UserCryptoV2KeysResponse}
    */
-  enroll_pin(pin) {
+  make_keys_for_user_crypto_v2() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(pin, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.cryptoclient_enroll_pin(retptr, this.__wbg_ptr, ptr0, len0);
+      wasm.cryptoclient_make_keys_for_user_crypto_v2(retptr, this.__wbg_ptr);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2173,6 +2174,74 @@ export class ExporterClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_exporterclient_free(ptr, 0);
   }
+  /**
+   * Credential Exchange Format (CXF)
+   *
+   * *Warning:* Expect this API to be unstable, and it will change in the future.
+   *
+   * For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
+   * Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
+   * @param {Account} account
+   * @param {Cipher[]} ciphers
+   * @returns {string}
+   */
+  export_cxf(account, ciphers) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.exporterclient_export_cxf(retptr, this.__wbg_ptr, addHeapObject(account), 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);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * Credential Exchange Format (CXF)
+   *
+   * *Warning:* Expect this API to be unstable, and it will change in the future.
+   *
+   * For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
+   * Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
+   * @param {string} payload
+   * @returns {Cipher[]}
+   */
+  import_cxf(payload) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.exporterclient_import_cxf(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);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 4, 4);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
   /**
    * @param {Folder[]} folders
    * @param {Cipher[]} ciphers
@@ -2259,74 +2328,6 @@ export class ExporterClient {
       wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
-  /**
-   * Credential Exchange Format (CXF)
-   *
-   * *Warning:* Expect this API to be unstable, and it will change in the future.
-   *
-   * For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
-   * Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
-   * @param {Account} account
-   * @param {Cipher[]} ciphers
-   * @returns {string}
-   */
-  export_cxf(account, ciphers) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArrayJsValueToWasm0(ciphers, wasm.__wbindgen_malloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.exporterclient_export_cxf(retptr, this.__wbg_ptr, addHeapObject(account), 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);
-      var ptr2 = r0;
-      var len2 = r1;
-      if (r3) {
-        ptr2 = 0;
-        len2 = 0;
-        throw takeObject(r2);
-      }
-      deferred3_0 = ptr2;
-      deferred3_1 = len2;
-      return getStringFromWasm0(ptr2, len2);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
-  }
-  /**
-   * Credential Exchange Format (CXF)
-   *
-   * *Warning:* Expect this API to be unstable, and it will change in the future.
-   *
-   * For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
-   * Ideally, the input should be immediately serialized from [ASImportableAccount](https://developer.apple.com/documentation/authenticationservices/asimportableaccount).
-   * @param {string} payload
-   * @returns {Cipher[]}
-   */
-  import_cxf(payload) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(payload, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.exporterclient_import_cxf(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);
-      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-      if (r3) {
-        throw takeObject(r2);
-      }
-      var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 4, 4);
-      return v2;
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
 }
 if (Symbol.dispose) ExporterClient.prototype[Symbol.dispose] = ExporterClient.prototype.free;
 
@@ -2357,46 +2358,6 @@ export class FoldersClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_foldersclient_free(ptr, 0);
   }
-  /**
-   * Encrypt a [FolderView] to a [Folder].
-   * @param {FolderView} folder_view
-   * @returns {Folder}
-   */
-  encrypt(folder_view) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.foldersclient_encrypt(retptr, this.__wbg_ptr, addHeapObject(folder_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);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return takeObject(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
-  /**
-   * Encrypt a [Folder] to [FolderView].
-   * @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);
-    }
-  }
   /**
    * Decrypt a list of [Folder]s to a list of [FolderView]s.
    * @param {Folder[]} folders
@@ -2422,14 +2383,6 @@ export class FoldersClient {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
-  /**
-   * Get all folders from state and decrypt them to a list of [FolderView].
-   * @returns {Promise<FolderView[]>}
-   */
-  list() {
-    const ret = wasm.foldersclient_list(this.__wbg_ptr);
-    return takeObject(ret);
-  }
   /**
    * Get a specific [Folder] by its ID from state and decrypt it to a [FolderView].
    * @param {FolderId} folder_id
@@ -2439,15 +2392,6 @@ export class FoldersClient {
     const ret = wasm.foldersclient_get(this.__wbg_ptr, addHeapObject(folder_id));
     return takeObject(ret);
   }
-  /**
-   * Create a new [Folder] and save it to the server.
-   * @param {FolderAddEditRequest} request
-   * @returns {Promise<FolderView>}
-   */
-  create(request) {
-    const ret = wasm.foldersclient_create(this.__wbg_ptr, addHeapObject(request));
-    return takeObject(ret);
-  }
   /**
    * Edit the [Folder] and save it to the server.
    * @param {FolderId} folder_id
@@ -2462,14 +2406,71 @@ export class FoldersClient {
     );
     return takeObject(ret);
   }
-}
-if (Symbol.dispose) FoldersClient.prototype[Symbol.dispose] = FoldersClient.prototype.free;
-
-const GeneratorClientFinalization =
-  typeof FinalizationRegistry === "undefined"
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry((ptr) => wasm.__wbg_generatorclient_free(ptr >>> 0, 1));
-
+  /**
+   * Get all folders from state and decrypt them to a list of [FolderView].
+   * @returns {Promise<FolderView[]>}
+   */
+  list() {
+    const ret = wasm.foldersclient_list(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * Create a new [Folder] and save it to the server.
+   * @param {FolderAddEditRequest} request
+   * @returns {Promise<FolderView>}
+   */
+  create(request) {
+    const ret = wasm.foldersclient_create(this.__wbg_ptr, addHeapObject(request));
+    return takeObject(ret);
+  }
+  /**
+   * Encrypt a [Folder] to [FolderView].
+   * @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);
+    }
+  }
+  /**
+   * Encrypt a [FolderView] to a [Folder].
+   * @param {FolderView} folder_view
+   * @returns {Folder}
+   */
+  encrypt(folder_view) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.foldersclient_encrypt(retptr, this.__wbg_ptr, addHeapObject(folder_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);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+if (Symbol.dispose) FoldersClient.prototype[Symbol.dispose] = FoldersClient.prototype.free;
+
+const GeneratorClientFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_generatorclient_free(ptr >>> 0, 1));
+
 export class GeneratorClient {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
@@ -2491,38 +2492,38 @@ export class GeneratorClient {
     wasm.__wbg_generatorclient_free(ptr, 0);
   }
   /**
-   * Generates a random password.
+   * Generates a random passphrase.
+   * A passphrase is a combination of random words separated by a character.
+   * An example of passphrase is `correct horse battery staple`.
    *
-   * The character sets and password length can be customized using the `input` parameter.
+   * The number of words and their case, the word separator, and the inclusion of
+   * a number in the passphrase can be customized using the `input` parameter.
    *
    * # Examples
    *
    * ```
    * use bitwarden_core::Client;
-   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
    *
    * async fn test() -> Result<(), PassphraseError> {
-   *     let input = PasswordGeneratorRequest {
-   *         lowercase: true,
-   *         uppercase: true,
-   *         numbers: true,
-   *         length: 20,
+   *     let input = PassphraseGeneratorRequest {
+   *         num_words: 4,
    *         ..Default::default()
    *     };
-   *     let password = Client::new(None).generator().password(input).unwrap();
-   *     println!("{}", password);
+   *     let passphrase = Client::new(None).generator().passphrase(input).unwrap();
+   *     println!("{}", passphrase);
    *     Ok(())
    * }
    * ```
-   * @param {PasswordGeneratorRequest} input
+   * @param {PassphraseGeneratorRequest} input
    * @returns {string}
    */
-  password(input) {
+  passphrase(input) {
     let deferred2_0;
     let deferred2_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.generatorclient_password(retptr, this.__wbg_ptr, addHeapObject(input));
+      wasm.generatorclient_passphrase(retptr, this.__wbg_ptr, addHeapObject(input));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2543,38 +2544,38 @@ export class GeneratorClient {
     }
   }
   /**
-   * Generates a random passphrase.
-   * A passphrase is a combination of random words separated by a character.
-   * An example of passphrase is `correct horse battery staple`.
+   * Generates a random password.
    *
-   * The number of words and their case, the word separator, and the inclusion of
-   * a number in the passphrase can be customized using the `input` parameter.
+   * The character sets and password length can be customized using the `input` parameter.
    *
    * # Examples
    *
    * ```
    * use bitwarden_core::Client;
-   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PassphraseGeneratorRequest};
+   * use bitwarden_generators::{GeneratorClientsExt, PassphraseError, PasswordGeneratorRequest};
    *
    * async fn test() -> Result<(), PassphraseError> {
-   *     let input = PassphraseGeneratorRequest {
-   *         num_words: 4,
+   *     let input = PasswordGeneratorRequest {
+   *         lowercase: true,
+   *         uppercase: true,
+   *         numbers: true,
+   *         length: 20,
    *         ..Default::default()
    *     };
-   *     let passphrase = Client::new(None).generator().passphrase(input).unwrap();
-   *     println!("{}", passphrase);
+   *     let password = Client::new(None).generator().password(input).unwrap();
+   *     println!("{}", password);
    *     Ok(())
    * }
    * ```
-   * @param {PassphraseGeneratorRequest} input
+   * @param {PasswordGeneratorRequest} input
    * @returns {string}
    */
-  passphrase(input) {
+  password(input) {
     let deferred2_0;
     let deferred2_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.generatorclient_passphrase(retptr, this.__wbg_ptr, addHeapObject(input));
+      wasm.generatorclient_password(retptr, this.__wbg_ptr, addHeapObject(input));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -2652,6 +2653,39 @@ export class IncomingMessage {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_incomingmessage_free(ptr, 0);
   }
+  /**
+   * Try to parse the payload as JSON.
+   * @returns {any} The parsed JSON value, or undefined if the payload is not valid JSON.
+   */
+  parse_payload_as_json() {
+    const ret = wasm.incomingmessage_parse_payload_as_json(this.__wbg_ptr);
+    return takeObject(ret);
+  }
+  /**
+   * @param {Uint8Array} payload
+   * @param {Endpoint} destination
+   * @param {Endpoint} source
+   * @param {string | null} [topic]
+   */
+  constructor(payload, destination, source, topic) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(topic)
+      ? 0
+      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.incomingmessage_new(
+      ptr0,
+      len0,
+      addHeapObject(destination),
+      addHeapObject(source),
+      ptr1,
+      len1,
+    );
+    this.__wbg_ptr = ret >>> 0;
+    IncomingMessageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
   /**
    * @returns {Uint8Array}
    */
@@ -2731,39 +2765,6 @@ export class IncomingMessage {
     var len0 = WASM_VECTOR_LEN;
     wasm.__wbg_set_incomingmessage_topic(this.__wbg_ptr, ptr0, len0);
   }
-  /**
-   * @param {Uint8Array} payload
-   * @param {Endpoint} destination
-   * @param {Endpoint} source
-   * @param {string | null} [topic]
-   */
-  constructor(payload, destination, source, topic) {
-    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(topic)
-      ? 0
-      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.incomingmessage_new(
-      ptr0,
-      len0,
-      addHeapObject(destination),
-      addHeapObject(source),
-      ptr1,
-      len1,
-    );
-    this.__wbg_ptr = ret >>> 0;
-    IncomingMessageFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-  /**
-   * Try to parse the payload as JSON.
-   * @returns {any} The parsed JSON value, or undefined if the payload is not valid JSON.
-   */
-  parse_payload_as_json() {
-    const ret = wasm.incomingmessage_parse_payload_as_json(this.__wbg_ptr);
-    return takeObject(ret);
-  }
 }
 if (Symbol.dispose) IncomingMessage.prototype[Symbol.dispose] = IncomingMessage.prototype.free;
 
@@ -2795,6 +2796,13 @@ export class IpcClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_ipcclient_free(ptr, 0);
   }
+  /**
+   * @returns {Promise<boolean>}
+   */
+  isRunning() {
+    const ret = wasm.ipcclient_isRunning(this.__wbg_ptr);
+    return takeObject(ret);
+  }
   /**
    * Create a new `IpcClient` instance with an in-memory session repository for saving
    * sessions within the SDK.
@@ -2821,20 +2829,6 @@ export class IpcClient {
     );
     return IpcClient.__wrap(ret);
   }
-  /**
-   * @returns {Promise<void>}
-   */
-  start() {
-    const ret = wasm.ipcclient_start(this.__wbg_ptr);
-    return takeObject(ret);
-  }
-  /**
-   * @returns {Promise<boolean>}
-   */
-  isRunning() {
-    const ret = wasm.ipcclient_isRunning(this.__wbg_ptr);
-    return takeObject(ret);
-  }
   /**
    * @param {OutgoingMessage} message
    * @returns {Promise<void>}
@@ -2845,6 +2839,13 @@ export class IpcClient {
     const ret = wasm.ipcclient_send(this.__wbg_ptr, ptr0);
     return takeObject(ret);
   }
+  /**
+   * @returns {Promise<void>}
+   */
+  start() {
+    const ret = wasm.ipcclient_start(this.__wbg_ptr);
+    return takeObject(ret);
+  }
   /**
    * @returns {Promise<IpcClientSubscription>}
    */
@@ -2976,28 +2977,77 @@ export class OutgoingMessage {
     wasm.__wbg_outgoingmessage_free(ptr, 0);
   }
   /**
-   * @returns {Uint8Array}
+   * Create a new message and encode the payload as JSON.
+   * @param {any} payload
+   * @param {Endpoint} destination
+   * @param {string | null} [topic]
+   * @returns {OutgoingMessage}
    */
-  get payload() {
+  static new_json_payload(payload, destination, topic) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.__wbg_get_outgoingmessage_payload(retptr, this.__wbg_ptr);
+      var ptr0 = isLikeNone(topic)
+        ? 0
+        : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len0 = WASM_VECTOR_LEN;
+      wasm.outgoingmessage_new_json_payload(
+        retptr,
+        addHeapObject(payload),
+        addHeapObject(destination),
+        ptr0,
+        len0,
+      );
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v1;
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return OutgoingMessage.__wrap(r0);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * @param {Uint8Array} arg0
+   * @param {Uint8Array} payload
+   * @param {Endpoint} destination
+   * @param {string | null} [topic]
    */
-  set payload(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+  constructor(payload, destination, topic) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_outgoingmessage_payload(this.__wbg_ptr, ptr0, len0);
+    var ptr1 = isLikeNone(topic)
+      ? 0
+      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.outgoingmessage_new(ptr0, len0, addHeapObject(destination), ptr1, len1);
+    this.__wbg_ptr = ret >>> 0;
+    OutgoingMessageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @returns {Uint8Array}
+   */
+  get payload() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_outgoingmessage_payload(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * @param {Uint8Array} arg0
+   */
+  set payload(arg0) {
+    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.__wbg_set_outgoingmessage_payload(this.__wbg_ptr, ptr0, len0);
   }
   /**
    * @returns {Endpoint}
@@ -3041,55 +3091,6 @@ export class OutgoingMessage {
     var len0 = WASM_VECTOR_LEN;
     wasm.__wbg_set_outgoingmessage_topic(this.__wbg_ptr, ptr0, len0);
   }
-  /**
-   * @param {Uint8Array} payload
-   * @param {Endpoint} destination
-   * @param {string | null} [topic]
-   */
-  constructor(payload, destination, topic) {
-    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(topic)
-      ? 0
-      : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.outgoingmessage_new(ptr0, len0, addHeapObject(destination), ptr1, len1);
-    this.__wbg_ptr = ret >>> 0;
-    OutgoingMessageFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-  /**
-   * Create a new message and encode the payload as JSON.
-   * @param {any} payload
-   * @param {Endpoint} destination
-   * @param {string | null} [topic]
-   * @returns {OutgoingMessage}
-   */
-  static new_json_payload(payload, destination, topic) {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      var ptr0 = isLikeNone(topic)
-        ? 0
-        : passStringToWasm0(topic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      var len0 = WASM_VECTOR_LEN;
-      wasm.outgoingmessage_new_json_payload(
-        retptr,
-        addHeapObject(payload),
-        addHeapObject(destination),
-        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);
-      if (r2) {
-        throw takeObject(r1);
-      }
-      return OutgoingMessage.__wrap(r0);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-  }
 }
 if (Symbol.dispose) OutgoingMessage.prototype[Symbol.dispose] = OutgoingMessage.prototype.free;
 
@@ -3112,6 +3113,14 @@ export class PasswordManagerClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_passwordmanagerclient_free(ptr, 0);
   }
+  /**
+   * Bitwarden licensed operations.
+   * @returns {CommercialPasswordManagerClient}
+   */
+  commercial() {
+    const ret = wasm.passwordmanagerclient_commercial(this.__wbg_ptr);
+    return CommercialPasswordManagerClient.__wrap(ret);
+  }
   /**
    * Initialize a new instance of the SDK client
    * @param {any} token_provider
@@ -3126,6 +3135,14 @@ export class PasswordManagerClient {
     PasswordManagerClientFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
+  /**
+   * Auth related operations.
+   * @returns {AuthClient}
+   */
+  auth() {
+    const ret = wasm.passwordmanagerclient_auth(this.__wbg_ptr);
+    return AuthClient.__wrap(ret);
+  }
   /**
    * Test method, echoes back the input
    * @param {string} msg
@@ -3149,26 +3166,6 @@ export class PasswordManagerClient {
       wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
   }
-  /**
-   * Returns the current SDK version
-   * @returns {string}
-   */
-  version() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.passwordmanagerclient_version(retptr, this.__wbg_ptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      deferred1_0 = r0;
-      deferred1_1 = r1;
-      return getStringFromWasm0(r0, r1);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-  }
   /**
    * Test method, always throws an error
    * @param {string} msg
@@ -3189,31 +3186,12 @@ export class PasswordManagerClient {
     }
   }
   /**
-   * Test method, calls http endpoint
-   * @param {string} url
-   * @returns {Promise<string>}
-   */
-  http_get(url) {
-    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.passwordmanagerclient_http_get(this.__wbg_ptr, ptr0, len0);
-    return takeObject(ret);
-  }
-  /**
-   * Auth related operations.
-   * @returns {AuthClient}
-   */
-  auth() {
-    const ret = wasm.passwordmanagerclient_auth(this.__wbg_ptr);
-    return AuthClient.__wrap(ret);
-  }
-  /**
-   * Bitwarden licensed operations.
-   * @returns {CommercialPasswordManagerClient}
+   * Vault item related operations.
+   * @returns {VaultClient}
    */
-  commercial() {
-    const ret = wasm.passwordmanagerclient_commercial(this.__wbg_ptr);
-    return CommercialPasswordManagerClient.__wrap(ret);
+  vault() {
+    const ret = wasm.passwordmanagerclient_vault(this.__wbg_ptr);
+    return VaultClient.__wrap(ret);
   }
   /**
    * Crypto related operations.
@@ -3224,12 +3202,35 @@ export class PasswordManagerClient {
     return CryptoClient.__wrap(ret);
   }
   /**
-   * Vault item related operations.
-   * @returns {VaultClient}
+   * Returns the current SDK version
+   * @returns {string}
    */
-  vault() {
-    const ret = wasm.passwordmanagerclient_vault(this.__wbg_ptr);
-    return VaultClient.__wrap(ret);
+  version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.passwordmanagerclient_version(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      deferred1_0 = r0;
+      deferred1_1 = r1;
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Test method, calls http endpoint
+   * @param {string} url
+   * @returns {Promise<string>}
+   */
+  http_get(url) {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.passwordmanagerclient_http_get(this.__wbg_ptr, ptr0, len0);
+    return takeObject(ret);
   }
   /**
    * Constructs a specific client for platform-specific functionality
@@ -3239,14 +3240,6 @@ export class PasswordManagerClient {
     const ret = wasm.passwordmanagerclient_platform(this.__wbg_ptr);
     return PlatformClient.__wrap(ret);
   }
-  /**
-   * Constructs a specific client for generating passwords and passphrases
-   * @returns {GeneratorClient}
-   */
-  generator() {
-    const ret = wasm.passwordmanagerclient_generator(this.__wbg_ptr);
-    return GeneratorClient.__wrap(ret);
-  }
   /**
    * Exporter related operations.
    * @returns {ExporterClient}
@@ -3255,6 +3248,14 @@ export class PasswordManagerClient {
     const ret = wasm.passwordmanagerclient_exporters(this.__wbg_ptr);
     return ExporterClient.__wrap(ret);
   }
+  /**
+   * Constructs a specific client for generating passwords and passphrases
+   * @returns {GeneratorClient}
+   */
+  generator() {
+    const ret = wasm.passwordmanagerclient_generator(this.__wbg_ptr);
+    return GeneratorClient.__wrap(ret);
+  }
 }
 if (Symbol.dispose)
   PasswordManagerClient.prototype[Symbol.dispose] = PasswordManagerClient.prototype.free;
@@ -3284,13 +3285,6 @@ export class PlatformClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_platformclient_free(ptr, 0);
   }
-  /**
-   * @returns {StateClient}
-   */
-  state() {
-    const ret = wasm.passwordmanagerclient_platform(this.__wbg_ptr);
-    return StateClient.__wrap(ret);
-  }
   /**
    * Load feature flags into the client
    * @param {FeatureFlags} flags
@@ -3308,6 +3302,13 @@ export class PlatformClient {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * @returns {StateClient}
+   */
+  state() {
+    const ret = wasm.passwordmanagerclient_platform(this.__wbg_ptr);
+    return StateClient.__wrap(ret);
+  }
 }
 if (Symbol.dispose) PlatformClient.prototype[Symbol.dispose] = PlatformClient.prototype.free;
 
@@ -3334,144 +3335,150 @@ export class PureCrypto {
     wasm.__wbg_purecrypto_free(ptr, 0);
   }
   /**
-   * DEPRECATED: Use `symmetric_decrypt_string` instead.
-   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
-   * @param {string} enc_string
-   * @param {Uint8Array} key
-   * @returns {string}
+   * Decrypts data using RSAES-OAEP with SHA-1
+   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
+   * @param {Uint8Array} encrypted_data
+   * @param {Uint8Array} private_key
+   * @returns {Uint8Array}
    */
-  static symmetric_decrypt(enc_string, key) {
-    let deferred4_0;
-    let deferred4_1;
+  static rsa_decrypt_data(encrypted_data, private_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passArray8ToWasm0(encrypted_data, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(private_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_rsa_decrypt_data(retptr, ptr0, len0, ptr1, len1);
       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);
-      var ptr3 = r0;
-      var len3 = r1;
       if (r3) {
-        ptr3 = 0;
-        len3 = 0;
         throw takeObject(r2);
       }
-      deferred4_0 = ptr3;
-      deferred4_1 = len3;
-      return getStringFromWasm0(ptr3, len3);
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * @param {string} enc_string
-   * @param {Uint8Array} key
-   * @returns {string}
+   * Encrypts data using RSAES-OAEP with SHA-1
+   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
+   * @param {Uint8Array} plain_data
+   * @param {Uint8Array} public_key
+   * @returns {Uint8Array}
    */
-  static symmetric_decrypt_string(enc_string, key) {
-    let deferred4_0;
-    let deferred4_1;
+  static rsa_encrypt_data(plain_data, public_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passArray8ToWasm0(plain_data, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt_string(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_rsa_encrypt_data(retptr, ptr0, len0, ptr1, len1);
       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);
-      var ptr3 = r0;
-      var len3 = r1;
       if (r3) {
-        ptr3 = 0;
-        len3 = 0;
         throw takeObject(r2);
       }
-      deferred4_0 = ptr3;
-      deferred4_1 = len3;
-      return getStringFromWasm0(ptr3, len3);
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
+   * DEPRECATED: Use `symmetric_decrypt_string` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
    * @param {string} enc_string
    * @param {Uint8Array} key
-   * @returns {Uint8Array}
+   * @returns {string}
    */
-  static symmetric_decrypt_bytes(enc_string, key) {
+  static symmetric_decrypt(enc_string, key) {
+    let deferred4_0;
+    let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
       const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
       const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt_bytes(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_decrypt(retptr, ptr0, len0, ptr1, len1);
       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);
+      var ptr3 = r0;
+      var len3 = r1;
       if (r3) {
+        ptr3 = 0;
+        len3 = 0;
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * DEPRECATED: Use `symmetric_decrypt_filedata` instead.
-   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
-   * @param {Uint8Array} enc_bytes
-   * @param {Uint8Array} key
-   * @returns {Uint8Array}
+   * Wraps (encrypts) a symmetric key using a symmetric wrapping key, returning the wrapped key
+   * as an EncString.
+   * @param {Uint8Array} key_to_be_wrapped
+   * @param {Uint8Array} wrapping_key
+   * @returns {string}
    */
-  static symmetric_decrypt_array_buffer(enc_bytes, key) {
+  static wrap_symmetric_key(key_to_be_wrapped, wrapping_key) {
+    let deferred4_0;
+    let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(key_to_be_wrapped, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt_array_buffer(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_wrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
       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);
+      var ptr3 = r0;
+      var len3 = r1;
       if (r3) {
+        ptr3 = 0;
+        len3 = 0;
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * @param {Uint8Array} enc_bytes
-   * @param {Uint8Array} key
+   * Derive output of the KDF for a [bitwarden_crypto::Kdf] configuration.
+   * @param {Uint8Array} password
+   * @param {Uint8Array} salt
+   * @param {Kdf} kdf
    * @returns {Uint8Array}
    */
-  static symmetric_decrypt_filedata(enc_bytes, key) {
+  static derive_kdf_material(password, salt, kdf) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_decrypt_filedata(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_derive_kdf_material(retptr, ptr0, len0, ptr1, len1, addHeapObject(kdf));
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3487,87 +3494,70 @@ export class PureCrypto {
     }
   }
   /**
-   * @param {string} plain
-   * @param {Uint8Array} key
-   * @returns {string}
+   * Generates a new RSA key pair and returns the private key
+   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
+   * @returns {Uint8Array}
    */
-  static symmetric_encrypt_string(plain, key) {
-    let deferred4_0;
-    let deferred4_1;
+  static rsa_generate_keypair() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(plain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
-      const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_encrypt_string(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_rsa_generate_keypair(retptr);
       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);
-      var ptr3 = r0;
-      var len3 = r1;
       if (r3) {
-        ptr3 = 0;
-        len3 = 0;
         throw takeObject(r2);
       }
-      deferred4_0 = ptr3;
-      deferred4_1 = len3;
-      return getStringFromWasm0(ptr3, len3);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * DEPRECATED: Only used by send keys
-   * @param {Uint8Array} plain
-   * @param {Uint8Array} key
-   * @returns {string}
+   * Unwraps (decrypts) a wrapped symmetric key using a symmetric wrapping key, returning the
+   * unwrapped key as a serialized byte array.
+   * @param {string} wrapped_key
+   * @param {Uint8Array} wrapping_key
+   * @returns {Uint8Array}
    */
-  static symmetric_encrypt_bytes(plain, key) {
-    let deferred4_0;
-    let deferred4_1;
+  static unwrap_symmetric_key(wrapped_key, wrapping_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
+      const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_encrypt_bytes(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_unwrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
       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);
-      var ptr3 = r0;
-      var len3 = r1;
       if (r3) {
-        ptr3 = 0;
-        len3 = 0;
         throw takeObject(r2);
       }
-      deferred4_0 = ptr3;
-      deferred4_1 = len3;
-      return getStringFromWasm0(ptr3, len3);
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * @param {Uint8Array} plain
-   * @param {Uint8Array} key
+   * Given a decrypted private RSA key PKCS8 DER this
+   * returns the corresponding public RSA key in DER format.
+   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
+   * @param {Uint8Array} private_key
    * @returns {Uint8Array}
    */
-  static symmetric_encrypt_filedata(plain, key) {
+  static rsa_extract_public_key(private_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(private_key, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
-      const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_symmetric_encrypt_filedata(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_rsa_extract_public_key(retptr, 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);
@@ -3575,161 +3565,131 @@ export class PureCrypto {
       if (r3) {
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
       wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      return v2;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * @param {string} encrypted_user_key
-   * @param {string} master_password
-   * @param {string} email
-   * @param {Kdf} kdf
-   * @returns {Uint8Array}
+   * Wraps (encrypts) a PKCS8 DER encoded decapsulation (private) key using a symmetric wrapping
+   * key,
+   * @param {Uint8Array} decapsulation_key
+   * @param {Uint8Array} wrapping_key
+   * @returns {string}
    */
-  static decrypt_user_key_with_master_password(encrypted_user_key, master_password, email, kdf) {
+  static wrap_decapsulation_key(decapsulation_key, wrapping_key) {
+    let deferred4_0;
+    let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(
-        encrypted_user_key,
-        wasm.__wbindgen_malloc,
-        wasm.__wbindgen_realloc,
-      );
+      const ptr0 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passStringToWasm0(
-        master_password,
-        wasm.__wbindgen_malloc,
-        wasm.__wbindgen_realloc,
-      );
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len2 = WASM_VECTOR_LEN;
-      wasm.purecrypto_decrypt_user_key_with_master_password(
-        retptr,
-        ptr0,
-        len0,
-        ptr1,
-        len1,
-        ptr2,
-        len2,
-        addHeapObject(kdf),
-      );
+      wasm.purecrypto_wrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
       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);
+      var ptr3 = r0;
+      var len3 = r1;
       if (r3) {
+        ptr3 = 0;
+        len3 = 0;
         throw takeObject(r2);
       }
-      var v4 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v4;
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * @param {Uint8Array} user_key
-   * @param {string} master_password
-   * @param {string} email
-   * @param {Kdf} kdf
+   * Wraps (encrypts) an SPKI DER encoded encapsulation (public) key using a symmetric wrapping
+   * key. Note: Usually, a public key is - by definition - public, so this should not be
+   * used. The specific use-case for this function is to enable rotateable key sets, where
+   * the "public key" is not public, with the intent of preventing the server from being able
+   * to overwrite the user key unlocked by the rotateable keyset.
+   * @param {Uint8Array} encapsulation_key
+   * @param {Uint8Array} wrapping_key
    * @returns {string}
    */
-  static encrypt_user_key_with_master_password(user_key, master_password, email, kdf) {
-    let deferred5_0;
-    let deferred5_1;
+  static wrap_encapsulation_key(encapsulation_key, wrapping_key) {
+    let deferred4_0;
+    let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(user_key, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passStringToWasm0(
-        master_password,
-        wasm.__wbindgen_malloc,
-        wasm.__wbindgen_realloc,
-      );
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len2 = WASM_VECTOR_LEN;
-      wasm.purecrypto_encrypt_user_key_with_master_password(
-        retptr,
-        ptr0,
-        len0,
-        ptr1,
-        len1,
-        ptr2,
-        len2,
-        addHeapObject(kdf),
-      );
+      wasm.purecrypto_wrap_encapsulation_key(retptr, ptr0, len0, ptr1, len1);
       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);
-      var ptr4 = r0;
-      var len4 = r1;
+      var ptr3 = r0;
+      var len3 = r1;
       if (r3) {
-        ptr4 = 0;
-        len4 = 0;
+        ptr3 = 0;
+        len3 = 0;
         throw takeObject(r2);
       }
-      deferred5_0 = ptr4;
-      deferred5_1 = len4;
-      return getStringFromWasm0(ptr4, len4);
-    } finally {
-      wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
-    }
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  static make_user_key_aes256_cbc_hmac() {
-    try {
-      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.purecrypto_make_user_key_aes256_cbc_hmac(retptr);
-      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v1;
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
+   * @param {string} enc_string
+   * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static make_user_key_xchacha20_poly1305() {
+  static symmetric_decrypt_bytes(enc_string, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.purecrypto_make_user_key_xchacha20_poly1305(retptr);
+      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_symmetric_decrypt_bytes(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
       wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v1;
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * Wraps (encrypts) a symmetric key using a symmetric wrapping key, returning the wrapped key
-   * as an EncString.
-   * @param {Uint8Array} key_to_be_wrapped
-   * @param {Uint8Array} wrapping_key
+   * DEPRECATED: Only used by send keys
+   * @param {Uint8Array} plain
+   * @param {Uint8Array} key
    * @returns {string}
    */
-  static wrap_symmetric_key(key_to_be_wrapped, wrapping_key) {
+  static symmetric_encrypt_bytes(plain, key) {
     let deferred4_0;
     let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(key_to_be_wrapped, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_wrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_encrypt_bytes(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3750,20 +3710,25 @@ export class PureCrypto {
     }
   }
   /**
-   * Unwraps (decrypts) a wrapped symmetric key using a symmetric wrapping key, returning the
-   * unwrapped key as a serialized byte array.
-   * @param {string} wrapped_key
-   * @param {Uint8Array} wrapping_key
+   * Decapsulates (decrypts) a symmetric key using an decapsulation key (private key) in PKCS8
+   * DER format. Note: This is unsigned, so the sender's authenticity cannot be verified by the
+   * recipient.
+   * @param {string} encapsulated_key
+   * @param {Uint8Array} decapsulation_key
    * @returns {Uint8Array}
    */
-  static unwrap_symmetric_key(wrapped_key, wrapping_key) {
+  static decapsulate_key_unsigned(encapsulated_key, decapsulation_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(
+        encapsulated_key,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_unwrap_symmetric_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_decapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3779,25 +3744,23 @@ export class PureCrypto {
     }
   }
   /**
-   * Wraps (encrypts) an SPKI DER encoded encapsulation (public) key using a symmetric wrapping
-   * key. Note: Usually, a public key is - by definition - public, so this should not be
-   * used. The specific use-case for this function is to enable rotateable key sets, where
-   * the "public key" is not public, with the intent of preventing the server from being able
-   * to overwrite the user key unlocked by the rotateable keyset.
+   * Encapsulates (encrypts) a symmetric key using an asymmetric encapsulation key (public key)
+   * in SPKI format, returning the encapsulated key as a string. Note: This is unsigned, so
+   * the sender's authenticity cannot be verified by the recipient.
+   * @param {Uint8Array} shared_key
    * @param {Uint8Array} encapsulation_key
-   * @param {Uint8Array} wrapping_key
    * @returns {string}
    */
-  static wrap_encapsulation_key(encapsulation_key, wrapping_key) {
+  static encapsulate_key_unsigned(shared_key, encapsulation_key) {
     let deferred4_0;
     let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_wrap_encapsulation_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_encapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3818,51 +3781,54 @@ export class PureCrypto {
     }
   }
   /**
-   * Unwraps (decrypts) a wrapped SPKI DER encoded encapsulation (public) key using a symmetric
-   * wrapping key.
-   * @param {string} wrapped_key
-   * @param {Uint8Array} wrapping_key
-   * @returns {Uint8Array}
+   * @param {string} enc_string
+   * @param {Uint8Array} key
+   * @returns {string}
    */
-  static unwrap_encapsulation_key(wrapped_key, wrapping_key) {
+  static symmetric_decrypt_string(enc_string, key) {
+    let deferred4_0;
+    let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passStringToWasm0(enc_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_unwrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_decrypt_string(retptr, ptr0, len0, ptr1, len1);
       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);
+      var ptr3 = r0;
+      var len3 = r1;
       if (r3) {
+        ptr3 = 0;
+        len3 = 0;
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      deferred4_0 = ptr3;
+      deferred4_1 = len3;
+      return getStringFromWasm0(ptr3, len3);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * Wraps (encrypts) a PKCS8 DER encoded decapsulation (private) key using a symmetric wrapping
-   * key,
-   * @param {Uint8Array} decapsulation_key
-   * @param {Uint8Array} wrapping_key
+   * @param {string} plain
+   * @param {Uint8Array} key
    * @returns {string}
    */
-  static wrap_decapsulation_key(decapsulation_key, wrapping_key) {
+  static symmetric_encrypt_string(plain, key) {
     let deferred4_0;
     let deferred4_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
+      const ptr0 = passStringToWasm0(plain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_wrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_encrypt_string(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3912,62 +3878,47 @@ export class PureCrypto {
     }
   }
   /**
-   * Encapsulates (encrypts) a symmetric key using an asymmetric encapsulation key (public key)
-   * in SPKI format, returning the encapsulated key as a string. Note: This is unsigned, so
-   * the sender's authenticity cannot be verified by the recipient.
-   * @param {Uint8Array} shared_key
-   * @param {Uint8Array} encapsulation_key
-   * @returns {string}
+   * Unwraps (decrypts) a wrapped SPKI DER encoded encapsulation (public) key using a symmetric
+   * wrapping key.
+   * @param {string} wrapped_key
+   * @param {Uint8Array} wrapping_key
+   * @returns {Uint8Array}
    */
-  static encapsulate_key_unsigned(shared_key, encapsulation_key) {
-    let deferred4_0;
-    let deferred4_1;
+  static unwrap_encapsulation_key(wrapped_key, wrapping_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+      const ptr0 = passStringToWasm0(wrapped_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(encapsulation_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_encapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_unwrap_decapsulation_key(retptr, ptr0, len0, ptr1, len1);
       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);
-      var ptr3 = r0;
-      var len3 = r1;
       if (r3) {
-        ptr3 = 0;
-        len3 = 0;
         throw takeObject(r2);
       }
-      deferred4_0 = ptr3;
-      deferred4_1 = len3;
-      return getStringFromWasm0(ptr3, len3);
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
-      wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
   }
   /**
-   * Decapsulates (decrypts) a symmetric key using an decapsulation key (private key) in PKCS8
-   * DER format. Note: This is unsigned, so the sender's authenticity cannot be verified by the
-   * recipient.
-   * @param {string} encapsulated_key
-   * @param {Uint8Array} decapsulation_key
+   * @param {Uint8Array} enc_bytes
+   * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static decapsulate_key_unsigned(encapsulated_key, decapsulation_key) {
+  static symmetric_decrypt_filedata(enc_bytes, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(
-        encapsulated_key,
-        wasm.__wbindgen_malloc,
-        wasm.__wbindgen_realloc,
-      );
+      const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(decapsulation_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_decapsulate_key_unsigned(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_decrypt_filedata(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -3983,20 +3934,18 @@ export class PureCrypto {
     }
   }
   /**
-   * Given a wrapped signing key and the symmetric key it is wrapped with, this returns
-   * the corresponding verifying key.
-   * @param {string} signing_key
-   * @param {Uint8Array} wrapping_key
+   * @param {Uint8Array} plain
+   * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static verifying_key_for_signing_key(signing_key, wrapping_key) {
+  static symmetric_encrypt_filedata(plain, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passStringToWasm0(signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const ptr0 = passArray8ToWasm0(plain, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_verifying_key_for_signing_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_symmetric_encrypt_filedata(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4012,44 +3961,36 @@ export class PureCrypto {
     }
   }
   /**
-   * Returns the algorithm used for the given verifying key.
-   * @param {Uint8Array} verifying_key
-   * @returns {SignatureAlgorithm}
+   * @returns {Uint8Array}
    */
-  static key_algorithm_for_verifying_key(verifying_key) {
+  static make_user_key_aes256_cbc_hmac() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.purecrypto_key_algorithm_for_verifying_key(retptr, ptr0, len0);
+      wasm.purecrypto_make_user_key_aes256_cbc_hmac(retptr);
       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);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_free(r0, r1 * 1, 1);
+      return v1;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * For a given signing identity (verifying key), this function verifies that the signing
-   * identity claimed ownership of the public key. This is a one-sided claim and merely shows
-   * that the signing identity has the intent to receive messages encrypted to the public
-   * key.
-   * @param {Uint8Array} signed_public_key
-   * @param {Uint8Array} verifying_key
+   * Given a wrapped signing key and the symmetric key it is wrapped with, this returns
+   * the corresponding verifying key.
+   * @param {string} signing_key
+   * @param {Uint8Array} wrapping_key
    * @returns {Uint8Array}
    */
-  static verify_and_unwrap_signed_public_key(signed_public_key, verifying_key) {
+  static verifying_key_for_signing_key(signing_key, wrapping_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(signed_public_key, wasm.__wbindgen_malloc);
+      const ptr0 = passStringToWasm0(signing_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(wrapping_key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_verify_and_unwrap_signed_public_key(retptr, ptr0, len0, ptr1, len1);
+      wasm.purecrypto_verifying_key_for_signing_key(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4065,20 +4006,20 @@ export class PureCrypto {
     }
   }
   /**
-   * Derive output of the KDF for a [bitwarden_crypto::Kdf] configuration.
-   * @param {Uint8Array} password
-   * @param {Uint8Array} salt
-   * @param {Kdf} kdf
+   * DEPRECATED: Use `symmetric_decrypt_filedata` instead.
+   * Cleanup ticket: <https://bitwarden.atlassian.net/browse/PM-21247>
+   * @param {Uint8Array} enc_bytes
+   * @param {Uint8Array} key
    * @returns {Uint8Array}
    */
-  static derive_kdf_material(password, salt, kdf) {
+  static symmetric_decrypt_array_buffer(enc_bytes, key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(password, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(enc_bytes, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
+      const ptr1 = passArray8ToWasm0(key, wasm.__wbindgen_malloc);
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_derive_kdf_material(retptr, ptr0, len0, ptr1, len1, addHeapObject(kdf));
+      wasm.purecrypto_symmetric_decrypt_array_buffer(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4093,6 +4034,28 @@ export class PureCrypto {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * Returns the algorithm used for the given verifying key.
+   * @param {Uint8Array} verifying_key
+   * @returns {SignatureAlgorithm}
+   */
+  static key_algorithm_for_verifying_key(verifying_key) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.purecrypto_key_algorithm_for_verifying_key(retptr, 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);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
   /**
    * @param {string} encrypted_user_key
    * @param {Uint8Array} master_key
@@ -4125,41 +4088,38 @@ export class PureCrypto {
     }
   }
   /**
-   * Given a decrypted private RSA key PKCS8 DER this
-   * returns the corresponding public RSA key in DER format.
-   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
-   * @param {Uint8Array} private_key
    * @returns {Uint8Array}
    */
-  static rsa_extract_public_key(private_key) {
+  static make_user_key_xchacha20_poly1305() {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(private_key, wasm.__wbindgen_malloc);
-      const len0 = WASM_VECTOR_LEN;
-      wasm.purecrypto_rsa_extract_public_key(retptr, 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.purecrypto_make_user_key_xchacha20_poly1305(retptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayU8FromWasm0(r0, r1).slice();
       wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v2;
+      return v1;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * Generates a new RSA key pair and returns the private key
-   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
+   * For a given signing identity (verifying key), this function verifies that the signing
+   * identity claimed ownership of the public key. This is a one-sided claim and merely shows
+   * that the signing identity has the intent to receive messages encrypted to the public
+   * key.
+   * @param {Uint8Array} signed_public_key
+   * @param {Uint8Array} verifying_key
    * @returns {Uint8Array}
    */
-  static rsa_generate_keypair() {
+  static verify_and_unwrap_signed_public_key(signed_public_key, verifying_key) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      wasm.purecrypto_rsa_generate_keypair(retptr);
+      const ptr0 = passArray8ToWasm0(signed_public_key, wasm.__wbindgen_malloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.purecrypto_verify_and_unwrap_signed_public_key(retptr, ptr0, len0, ptr1, len1);
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4167,28 +4127,47 @@ export class PureCrypto {
       if (r3) {
         throw takeObject(r2);
       }
-      var v1 = getArrayU8FromWasm0(r0, r1).slice();
+      var v3 = getArrayU8FromWasm0(r0, r1).slice();
       wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v1;
+      return v3;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * Decrypts data using RSAES-OAEP with SHA-1
-   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
-   * @param {Uint8Array} encrypted_data
-   * @param {Uint8Array} private_key
+   * @param {string} encrypted_user_key
+   * @param {string} master_password
+   * @param {string} email
+   * @param {Kdf} kdf
    * @returns {Uint8Array}
    */
-  static rsa_decrypt_data(encrypted_data, private_key) {
+  static decrypt_user_key_with_master_password(encrypted_user_key, master_password, email, kdf) {
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(encrypted_data, wasm.__wbindgen_malloc);
+      const ptr0 = passStringToWasm0(
+        encrypted_user_key,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(private_key, wasm.__wbindgen_malloc);
+      const ptr1 = passStringToWasm0(
+        master_password,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_rsa_decrypt_data(retptr, ptr0, len0, ptr1, len1);
+      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len2 = WASM_VECTOR_LEN;
+      wasm.purecrypto_decrypt_user_key_with_master_password(
+        retptr,
+        ptr0,
+        len0,
+        ptr1,
+        len1,
+        ptr2,
+        len2,
+        addHeapObject(kdf),
+      );
       var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
       var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
       var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4196,40 +4175,62 @@ export class PureCrypto {
       if (r3) {
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
+      var v4 = getArrayU8FromWasm0(r0, r1).slice();
       wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      return v4;
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
   /**
-   * Encrypts data using RSAES-OAEP with SHA-1
-   * HAZMAT WARNING: Do not use outside of implementing cryptofunctionservice
-   * @param {Uint8Array} plain_data
-   * @param {Uint8Array} public_key
-   * @returns {Uint8Array}
+   * @param {Uint8Array} user_key
+   * @param {string} master_password
+   * @param {string} email
+   * @param {Kdf} kdf
+   * @returns {string}
    */
-  static rsa_encrypt_data(plain_data, public_key) {
+  static encrypt_user_key_with_master_password(user_key, master_password, email, kdf) {
+    let deferred5_0;
+    let deferred5_1;
     try {
       const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-      const ptr0 = passArray8ToWasm0(plain_data, wasm.__wbindgen_malloc);
+      const ptr0 = passArray8ToWasm0(user_key, wasm.__wbindgen_malloc);
       const len0 = WASM_VECTOR_LEN;
-      const ptr1 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
+      const ptr1 = passStringToWasm0(
+        master_password,
+        wasm.__wbindgen_malloc,
+        wasm.__wbindgen_realloc,
+      );
       const len1 = WASM_VECTOR_LEN;
-      wasm.purecrypto_rsa_encrypt_data(retptr, ptr0, len0, ptr1, len1);
+      const ptr2 = passStringToWasm0(email, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len2 = WASM_VECTOR_LEN;
+      wasm.purecrypto_encrypt_user_key_with_master_password(
+        retptr,
+        ptr0,
+        len0,
+        ptr1,
+        len1,
+        ptr2,
+        len2,
+        addHeapObject(kdf),
+      );
       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);
+      var ptr4 = r0;
+      var len4 = r1;
       if (r3) {
+        ptr4 = 0;
+        len4 = 0;
         throw takeObject(r2);
       }
-      var v3 = getArrayU8FromWasm0(r0, r1).slice();
-      wasm.__wbindgen_free(r0, r1 * 1, 1);
-      return v3;
+      deferred5_0 = ptr4;
+      deferred5_1 = len4;
+      return getStringFromWasm0(ptr4, len4);
     } finally {
       wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
     }
   }
 }
@@ -4333,6 +4334,15 @@ export class StateClient {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_stateclient_free(ptr, 0);
   }
+  /**
+   * Initialize the database for SDK managed repositories.
+   * @param {IndexedDbConfiguration} configuration
+   * @returns {Promise<void>}
+   */
+  initialize_state(configuration) {
+    const ret = wasm.stateclient_initialize_state(this.__wbg_ptr, addHeapObject(configuration));
+    return takeObject(ret);
+  }
   /**
    * @param {any} cipher_repository
    */
@@ -4354,15 +4364,6 @@ export class StateClient {
       addHeapObject(repositories),
     );
   }
-  /**
-   * Initialize the database for SDK managed repositories.
-   * @param {IndexedDbConfiguration} configuration
-   * @returns {Promise<void>}
-   */
-  initialize_state(configuration) {
-    const ret = wasm.stateclient_initialize_state(this.__wbg_ptr, addHeapObject(configuration));
-    return takeObject(ret);
-  }
 }
 if (Symbol.dispose) StateClient.prototype[Symbol.dispose] = StateClient.prototype.free;
 
@@ -4465,20 +4466,20 @@ export class VaultClient {
     return AttachmentsClient.__wrap(ret);
   }
   /**
-   * Cipher related operations.
-   * @returns {CiphersClient}
+   * Cipher risk evaluation operations.
+   * @returns {CipherRiskClient}
    */
-  ciphers() {
+  cipher_risk() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return CiphersClient.__wrap(ret);
+    return CipherRiskClient.__wrap(ret);
   }
   /**
-   * Folder related operations.
-   * @returns {FoldersClient}
+   * Collection related operations.
+   * @returns {CollectionsClient}
    */
-  folders() {
+  collections() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return FoldersClient.__wrap(ret);
+    return CollectionsClient.__wrap(ret);
   }
   /**
    * TOTP related operations.
@@ -4489,20 +4490,20 @@ export class VaultClient {
     return TotpClient.__wrap(ret);
   }
   /**
-   * Collection related operations.
-   * @returns {CollectionsClient}
+   * Cipher related operations.
+   * @returns {CiphersClient}
    */
-  collections() {
+  ciphers() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return CollectionsClient.__wrap(ret);
+    return CiphersClient.__wrap(ret);
   }
   /**
-   * Cipher risk evaluation operations.
-   * @returns {CipherRiskClient}
+   * Folder related operations.
+   * @returns {FoldersClient}
    */
-  cipher_risk() {
+  folders() {
     const ret = wasm.vaultclient_attachments(this.__wbg_ptr);
-    return CipherRiskClient.__wrap(ret);
+    return FoldersClient.__wrap(ret);
   }
 }
 if (Symbol.dispose) VaultClient.prototype[Symbol.dispose] = VaultClient.prototype.free;
@@ -4680,7 +4681,7 @@ export function __wbg_call_e762c39fa8ea36bf() {
   }, arguments);
 }
 
-export function __wbg_cipher_f01ad37fe153c74a(arg0) {
+export function __wbg_cipher_d41365b5935ef9f6(arg0) {
   const ret = getObject(arg0).cipher;
   return isLikeNone(ret) ? 0 : addHeapObject(ret);
 }
@@ -4773,7 +4774,7 @@ export function __wbg_fetch_f8ba0e29a9d6de0d(arg0, arg1) {
   return addHeapObject(ret);
 }
 
-export function __wbg_folder_b2f27ca5801406fe(arg0) {
+export function __wbg_folder_70cb2b2470bd6fb3(arg0) {
   const ret = getObject(arg0).folder;
   return isLikeNone(ret) ? 0 : addHeapObject(ret);
 }
@@ -4806,12 +4807,7 @@ export function __wbg_getTime_14776bfb48a1bff9(arg0) {
   return ret;
 }
 
-export function __wbg_get_7bed016f185add81(arg0, arg1) {
-  const ret = getObject(arg0)[arg1 >>> 0];
-  return addHeapObject(ret);
-}
-
-export function __wbg_get_7d24a56df19d62f6() {
+export function __wbg_get_02506dc16a509e18() {
   return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -4826,12 +4822,7 @@ export function __wbg_get_7d24a56df19d62f6() {
   }, arguments);
 }
 
-export function __wbg_get_access_token_f4e462d38899439f(arg0) {
-  const ret = getObject(arg0).get_access_token();
-  return addHeapObject(ret);
-}
-
-export function __wbg_get_cf7a5a169adcb6d4() {
+export function __wbg_get_27ecddc404eb5960() {
   return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -4846,6 +4837,16 @@ export function __wbg_get_cf7a5a169adcb6d4() {
   }, arguments);
 }
 
+export function __wbg_get_7bed016f185add81(arg0, arg1) {
+  const ret = getObject(arg0)[arg1 >>> 0];
+  return addHeapObject(ret);
+}
+
+export function __wbg_get_access_token_4c11d5b6b88e273c(arg0) {
+  const ret = getObject(arg0).get_access_token();
+  return addHeapObject(ret);
+}
+
 export function __wbg_get_efcb449f58ec27c2() {
   return handleError(function (arg0, arg1) {
     const ret = Reflect.get(getObject(arg0), getObject(arg1));
@@ -5037,14 +5038,14 @@ export function __wbg_length_cdd215e10d9dd507(arg0) {
   return ret;
 }
 
-export function __wbg_list_9632da36688eb013() {
+export function __wbg_list_30b9a7bffa62c29d() {
   return handleError(function (arg0) {
     const ret = getObject(arg0).list();
     return addHeapObject(ret);
   }, arguments);
 }
 
-export function __wbg_list_971afaee385941da() {
+export function __wbg_list_3e3162ec99984853() {
   return handleError(function (arg0) {
     const ret = getObject(arg0).list();
     return addHeapObject(ret);
@@ -5116,7 +5117,7 @@ export function __wbg_new_3c3d849046688a66(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return wasm_bindgen__convert__closures_____invoke__h43dfd80678632d6f(
+        return wasm_bindgen__convert__closures_____invoke__h0cb536241502fe83(
           a,
           state0.b,
           arg0,
@@ -5288,7 +5289,7 @@ export function __wbg_randomFillSync_ac0988aba3254290() {
   }, arguments);
 }
 
-export function __wbg_remove_0c50f1a372592522() {
+export function __wbg_remove_6f13f6b2aeaea191() {
   return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -5303,7 +5304,7 @@ export function __wbg_remove_0c50f1a372592522() {
   }, arguments);
 }
 
-export function __wbg_remove_d52ba16f05c98799() {
+export function __wbg_remove_b941496fdbe98774() {
   return handleError(function (arg0, arg1, arg2) {
     let deferred0_0;
     let deferred0_1;
@@ -5353,6 +5354,21 @@ export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
   getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 }
 
+export function __wbg_set_83ea0a967b99b5d2() {
+  return handleError(function (arg0, arg1, arg2, arg3) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+      deferred0_0 = arg1;
+      deferred0_1 = arg2;
+      const ret = getObject(arg0).set(getStringFromWasm0(arg1, arg2), takeObject(arg3));
+      return addHeapObject(ret);
+    } finally {
+      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+  }, arguments);
+}
+
 export function __wbg_set_907fb406c34a251d(arg0, arg1, arg2) {
   const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
   return addHeapObject(ret);
@@ -5373,7 +5389,7 @@ export function __wbg_set_c2abbebe8b9ebee1() {
   }, arguments);
 }
 
-export function __wbg_set_cf238f02b0469517() {
+export function __wbg_set_c93d3183f4c04f25() {
   return handleError(function (arg0, arg1, arg2, arg3) {
     let deferred0_0;
     let deferred0_1;
@@ -5392,21 +5408,6 @@ export function __wbg_set_credentials_f621cd2d85c0c228(arg0, arg1) {
   getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
 }
 
-export function __wbg_set_e87a8a3d69deff6e() {
-  return handleError(function (arg0, arg1, arg2, arg3) {
-    let deferred0_0;
-    let deferred0_1;
-    try {
-      deferred0_0 = arg1;
-      deferred0_1 = arg2;
-      const ret = getObject(arg0).set(getStringFromWasm0(arg1, arg2), takeObject(arg3));
-      return addHeapObject(ret);
-    } finally {
-      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-    }
-  }, arguments);
-}
-
 export function __wbg_set_headers_6926da238cd32ee4(arg0, arg1) {
   getObject(arg0).headers = getObject(arg1);
 }
@@ -5571,37 +5572,26 @@ export function __wbg_warn_8f5b5437666d0885(arg0, arg1, arg2, arg3) {
   console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 }
 
-export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
-  // Cast intrinsic for `Ref(String) -> Externref`.
-  const ret = getStringFromWasm0(arg0, arg1);
-  return addHeapObject(ret);
-}
-
-export function __wbindgen_cast_4042b341512ce63a(arg0, arg1) {
-  // Cast intrinsic for `Closure(Closure { dtor_idx: 41, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 44, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+export function __wbindgen_cast_0f3a80f9c6c81c16(arg0, arg1) {
+  // Cast intrinsic for `Closure(Closure { dtor_idx: 40, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 43, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
   const ret = makeMutClosure(
     arg0,
     arg1,
-    wasm.wasm_bindgen__closure__destroy__hba496874d56e8206,
-    wasm_bindgen__convert__closures_____invoke__h3f3903322ff045ff,
+    wasm.wasm_bindgen__closure__destroy__h0a76ff7104f80505,
+    wasm_bindgen__convert__closures_____invoke__ha3eecaeccbf508bc,
   );
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
-  // Cast intrinsic for `U64 -> Externref`.
-  const ret = BigInt.asUintN(64, arg0);
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+  // Cast intrinsic for `Ref(String) -> Externref`.
+  const ret = getStringFromWasm0(arg0, arg1);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_567ce6425eb96825(arg0, arg1) {
-  // Cast intrinsic for `Closure(Closure { dtor_idx: 551, function: Function { arguments: [], shim_idx: 305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-  const ret = makeMutClosure(
-    arg0,
-    arg1,
-    wasm.wasm_bindgen__closure__destroy__hfcb631b72e5e985c,
-    wasm_bindgen__convert__closures_____invoke__h092300064b8afb1e,
-  );
+export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
+  // Cast intrinsic for `U64 -> Externref`.
+  const ret = BigInt.asUintN(64, arg0);
   return addHeapObject(ret);
 }
 
@@ -5613,6 +5603,17 @@ export function __wbindgen_cast_5fea77eff9dd275c(arg0, arg1) {
   return addHeapObject(ret);
 }
 
+export function __wbindgen_cast_67d165bf11ca912a(arg0, arg1) {
+  // Cast intrinsic for `Closure(Closure { dtor_idx: 303, function: Function { arguments: [Externref], shim_idx: 43, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+  const ret = makeMutClosure(
+    arg0,
+    arg1,
+    wasm.wasm_bindgen__closure__destroy__h591e0f2efd143068,
+    wasm_bindgen__convert__closures_____invoke__ha3eecaeccbf508bc,
+  );
+  return addHeapObject(ret);
+}
+
 export function __wbindgen_cast_7a6d185652cd8149(arg0, arg1) {
   var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
   wasm.__wbindgen_free(arg0, arg1 * 4, 4);
@@ -5621,57 +5622,57 @@ export function __wbindgen_cast_7a6d185652cd8149(arg0, arg1) {
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_8340b5b160d85933(arg0, arg1) {
-  // Cast intrinsic for `Closure(Closure { dtor_idx: 304, function: Function { arguments: [], shim_idx: 305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+export function __wbindgen_cast_9ae0607507abb057(arg0) {
+  // Cast intrinsic for `I64 -> Externref`.
+  const ret = arg0;
+  return addHeapObject(ret);
+}
+
+export function __wbindgen_cast_9b35fe50b76611f9(arg0, arg1) {
+  // Cast intrinsic for `Closure(Closure { dtor_idx: 552, function: Function { arguments: [], shim_idx: 304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
   const ret = makeMutClosure(
     arg0,
     arg1,
-    wasm.wasm_bindgen__closure__destroy__h5bf455f3385c4f71,
-    wasm_bindgen__convert__closures_____invoke__h092300064b8afb1e,
+    wasm.wasm_bindgen__closure__destroy__he41cbbdbe831f2ac,
+    wasm_bindgen__convert__closures_____invoke__h4eff94a44eff58c2,
   );
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_9654b59eb60e619d(arg0, arg1) {
-  // Cast intrinsic for `Closure(Closure { dtor_idx: 304, function: Function { arguments: [Externref], shim_idx: 44, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+export function __wbindgen_cast_bfa5a190b0f2e981(arg0, arg1) {
+  // Cast intrinsic for `Closure(Closure { dtor_idx: 303, function: Function { arguments: [], shim_idx: 304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
   const ret = makeMutClosure(
     arg0,
     arg1,
-    wasm.wasm_bindgen__closure__destroy__h5bf455f3385c4f71,
-    wasm_bindgen__convert__closures_____invoke__h3f3903322ff045ff,
+    wasm.wasm_bindgen__closure__destroy__h591e0f2efd143068,
+    wasm_bindgen__convert__closures_____invoke__h4eff94a44eff58c2,
   );
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_9ae0607507abb057(arg0) {
-  // Cast intrinsic for `I64 -> Externref`.
-  const ret = arg0;
-  return addHeapObject(ret);
-}
-
 export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
   // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
   const ret = getArrayU8FromWasm0(arg0, arg1);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_d49c305f67640cb1(arg0, arg1) {
-  // Cast intrinsic for `Closure(Closure { dtor_idx: 41, function: Function { arguments: [NamedExternref("Event")], shim_idx: 42, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+  // Cast intrinsic for `F64 -> Externref`.
+  const ret = arg0;
+  return addHeapObject(ret);
+}
+
+export function __wbindgen_cast_e12aaa4ecde9c999(arg0, arg1) {
+  // Cast intrinsic for `Closure(Closure { dtor_idx: 40, function: Function { arguments: [NamedExternref("Event")], shim_idx: 41, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
   const ret = makeMutClosure(
     arg0,
     arg1,
-    wasm.wasm_bindgen__closure__destroy__hba496874d56e8206,
-    wasm_bindgen__convert__closures_____invoke__h35a8188fc7e541fe,
+    wasm.wasm_bindgen__closure__destroy__h0a76ff7104f80505,
+    wasm_bindgen__convert__closures_____invoke__h86320ba04bc5bce5,
   );
   return addHeapObject(ret);
 }
 
-export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
-  // Cast intrinsic for `F64 -> Externref`.
-  const ret = arg0;
-  return addHeapObject(ret);
-}
-
 export function __wbindgen_cast_ef90a087adb7475d(arg0, arg1) {
   var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
   wasm.__wbindgen_free(arg0, arg1 * 4, 4);