@wireapp/core-crypto 9.3.3 → 9.3.5

package/src/corecrypto.js

@@ -1,11 +1,3 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/CoreCryptoError.ts
 class CoreCryptoError extends Error {
   errorStack;
@@ -60,12 +52,12 @@ class CoreCryptoError extends Error {
   }
 }
 var ErrorType;
-((ErrorType2) => {
-  ErrorType2["Mls"] = "Mls";
-  ErrorType2["Proteus"] = "Proteus";
-  ErrorType2["E2ei"] = "E2ei";
-  ErrorType2["TransactionFailed"] = "TransactionFailed";
-  ErrorType2["Other"] = "Other";
+((ErrorType) => {
+  ErrorType["Mls"] = "Mls";
+  ErrorType["Proteus"] = "Proteus";
+  ErrorType["E2ei"] = "E2ei";
+  ErrorType["TransactionFailed"] = "TransactionFailed";
+  ErrorType["Other"] = "Other";
 })(ErrorType ||= {});
 function isCcErrorGeneric(error) {
   return typeof error === "object" && error !== null && "errorStack" in error && "context" in error && "type" in error;
@@ -83,20 +75,20 @@ function isOtherError(error) {
   return isCcError(error, "Other" /* Other */);
 }
 var MlsErrorType;
-((MlsErrorType2) => {
-  MlsErrorType2["ConversationAlreadyExists"] = "ConversationAlreadyExists";
-  MlsErrorType2["DuplicateMessage"] = "DuplicateMessage";
-  MlsErrorType2["BufferedFutureMessage"] = "BufferedFutureMessage";
-  MlsErrorType2["WrongEpoch"] = "WrongEpoch";
-  MlsErrorType2["BufferedCommit"] = "BufferedCommit";
-  MlsErrorType2["MessageEpochTooOld"] = "MessageEpochTooOld";
-  MlsErrorType2["SelfCommitIgnored"] = "SelfCommitIgnored";
-  MlsErrorType2["UnmergedPendingGroup"] = "UnmergedPendingGroup";
-  MlsErrorType2["StaleProposal"] = "StaleProposal";
-  MlsErrorType2["StaleCommit"] = "StaleCommit";
-  MlsErrorType2["OrphanWelcome"] = "OrphanWelcome";
-  MlsErrorType2["MessageRejected"] = "MessageRejected";
-  MlsErrorType2["Other"] = "Other";
+((MlsErrorType) => {
+  MlsErrorType["ConversationAlreadyExists"] = "ConversationAlreadyExists";
+  MlsErrorType["DuplicateMessage"] = "DuplicateMessage";
+  MlsErrorType["BufferedFutureMessage"] = "BufferedFutureMessage";
+  MlsErrorType["WrongEpoch"] = "WrongEpoch";
+  MlsErrorType["BufferedCommit"] = "BufferedCommit";
+  MlsErrorType["MessageEpochTooOld"] = "MessageEpochTooOld";
+  MlsErrorType["SelfCommitIgnored"] = "SelfCommitIgnored";
+  MlsErrorType["UnmergedPendingGroup"] = "UnmergedPendingGroup";
+  MlsErrorType["StaleProposal"] = "StaleProposal";
+  MlsErrorType["StaleCommit"] = "StaleCommit";
+  MlsErrorType["OrphanWelcome"] = "OrphanWelcome";
+  MlsErrorType["MessageRejected"] = "MessageRejected";
+  MlsErrorType["Other"] = "Other";
 })(MlsErrorType ||= {});
 function isMlsError(error, errorType) {
   return isCcError(error, "Mls" /* Mls */) && error.context !== undefined && error.context.type === errorType;
@@ -138,11 +130,11 @@ function isMlsOtherError(error) {
   return isMlsError(error, "Other" /* Other */);
 }
 var ProteusErrorType;
-((ProteusErrorType2) => {
-  ProteusErrorType2["SessionNotFound"] = "SessionNotFound";
-  ProteusErrorType2["DuplicateMessage"] = "DuplicateMessage";
-  ProteusErrorType2["RemoteIdentityChanged"] = "RemoteIdentityChanged";
-  ProteusErrorType2["Other"] = "Other";
+((ProteusErrorType) => {
+  ProteusErrorType["SessionNotFound"] = "SessionNotFound";
+  ProteusErrorType["DuplicateMessage"] = "DuplicateMessage";
+  ProteusErrorType["RemoteIdentityChanged"] = "RemoteIdentityChanged";
+  ProteusErrorType["Other"] = "Other";
 })(ProteusErrorType ||= {});
 function isProteusError(error, errorType) {
   return isCcError(error, "Proteus" /* Proteus */) && error.context !== undefined && error.context.type === errorType;
@@ -200,10 +192,10 @@ if (!("encodeInto" in cachedTextEncoder)) {
 function passStringToWasm0(arg, malloc, realloc) {
   if (realloc === undefined) {
     const buf = cachedTextEncoder.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
     WASM_VECTOR_LEN = buf.length;
-    return ptr2;
+    return ptr;
   }
   let len = arg.length;
   let ptr = malloc(len, 1) >>> 0;
@@ -345,17 +337,6 @@ function makeMutClosure(arg0, arg1, dtor, f) {
   CLOSURE_DTORS.register(real, state, state);
   return real;
 }
-function _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
-function passArray8ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 1, 1) >>> 0;
-  getUint8ArrayMemory0().set(arg, ptr / 1);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
-}
 function takeFromExternrefTable0(idx) {
   const value = wasm.__wbindgen_export_4.get(idx);
   wasm.__externref_table_dealloc(idx);
@@ -372,6 +353,17 @@ function ciphersuiteDefault() {
   const ret = wasm.ciphersuiteDefault();
   return ret;
 }
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
 function passArrayJsValueToWasm0(array, malloc) {
   const ptr = malloc(array.length * 4, 4) >>> 0;
   for (let i = 0;i < array.length; i++) {
@@ -381,6 +373,14 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
+function openDatabase(name, key) {
+  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  _assertClass(key, DatabaseKey);
+  var ptr1 = key.__destroy_into_raw();
+  const ret = wasm.openDatabase(ptr0, len0, ptr1);
+  return ret;
+}
 function migrateDatabaseKeyTypeToBytes(path, old_key, new_key) {
   const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -398,14 +398,6 @@ function updateDatabaseKey(name, old_key, new_key) {
   const ret = wasm.updateDatabaseKey(ptr0, len0, old_key.__wbg_ptr, new_key.__wbg_ptr);
   return ret;
 }
-function openDatabase(name, key) {
-  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(key, DatabaseKey);
-  var ptr1 = key.__destroy_into_raw();
-  const ret = wasm.openDatabase(ptr0, len0, ptr1);
-  return ret;
-}
 function version() {
   let deferred1_0;
   let deferred1_1;
@@ -422,17 +414,17 @@ function build_metadata() {
   const ret = wasm.build_metadata();
   return BuildMetadata.__wrap(ret);
 }
-function __wbg_adapter_24(arg0, arg1, arg2) {
-  wasm.closure2906_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_18(arg0, arg1, arg2) {
+  wasm.closure2505_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_27(arg0, arg1, arg2) {
-  wasm.closure1026_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_23(arg0, arg1, arg2) {
+  wasm.closure2883_externref_shim(arg0, arg1, arg2);
 }
 function __wbg_adapter_30(arg0, arg1, arg2) {
-  wasm.closure2597_externref_shim(arg0, arg1, arg2);
+  wasm.closure942_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_511(arg0, arg1, arg2, arg3) {
-  wasm.closure3008_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_479(arg0, arg1, arg2, arg3) {
+  wasm.closure2986_externref_shim(arg0, arg1, arg2, arg3);
 }
 var Ciphersuite = Object.freeze({
   MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1,
@@ -801,6 +793,12 @@ class ClientId {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_clientid_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.clientid_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -809,12 +807,6 @@ class ClientId {
     ClientIdFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.clientid_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   ClientId.prototype[Symbol.dispose] = ClientId.prototype.free;
@@ -943,6 +935,12 @@ class ConversationId {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_conversationid_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.conversationid_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -951,12 +949,6 @@ class ConversationId {
     ConversationIdFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.conversationid_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   ConversationId.prototype[Symbol.dispose] = ConversationId.prototype.free;
@@ -980,32 +972,66 @@ class CoreCrypto {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_corecrypto_free(ptr, 0);
   }
-  client_public_key(ciphersuite, credential_type) {
-    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
+  static deferred_init(path, key, entropy_seed) {
+    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(key, DatabaseKey);
+    var ptr1 = key.__destroy_into_raw();
+    var ptr2 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.corecrypto_deferred_init(ptr0, len0, ptr1, ptr2, len2);
     return ret;
   }
-  transaction(command) {
-    const ret = wasm.corecrypto_transaction(this.__wbg_ptr, command);
+  close() {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.corecrypto_close(ptr);
     return ret;
   }
-  conversation_epoch(conversation_id) {
+  static async_new(path, key, client_id, ciphersuites, entropy_seed, nb_key_package) {
+    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(key, DatabaseKey);
+    var ptr1 = key.__destroy_into_raw();
+    let ptr2 = 0;
+    if (!isLikeNone(client_id)) {
+      _assertClass(client_id, ClientId);
+      ptr2 = client_id.__destroy_into_raw();
+    }
+    var ptr3 = isLikeNone(ciphersuites) ? 0 : passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
+    var len3 = WASM_VECTOR_LEN;
+    var ptr4 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
+    var len4 = WASM_VECTOR_LEN;
+    const ret = wasm.corecrypto_async_new(ptr0, len0, ptr1, ptr2, ptr3, len3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
+    return ret;
+  }
+  reseed_rng(seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecrypto_reseed_rng(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  random_bytes(len) {
+    const ret = wasm.corecrypto_random_bytes(this.__wbg_ptr, len);
+    return ret;
+  }
+  get_client_ids(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  conversation_ciphersuite(conversation_id) {
+  export_secret_key(conversation_id, key_length) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
     return ret;
   }
-  conversation_exists(conversation_id) {
+  conversation_epoch(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  get_client_ids(conversation_id) {
+  conversation_exists(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   get_external_sender(conversation_id) {
@@ -1013,9 +1039,9 @@ class CoreCrypto {
     const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  export_secret_key(conversation_id, key_length) {
+  conversation_ciphersuite(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
+    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   is_history_sharing_enabled(conversation_id) {
@@ -1023,11 +1049,22 @@ class CoreCrypto {
     const ret = wasm.corecrypto_is_history_sharing_enabled(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  get_device_identities(conversation_id, device_ids) {
-    _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+  provide_transport(callbacks) {
+    _assertClass(callbacks, MlsTransport);
+    var ptr0 = callbacks.__destroy_into_raw();
+    const ret = wasm.corecrypto_provide_transport(this.__wbg_ptr, ptr0);
+    return ret;
+  }
+  register_epoch_observer(epoch_observer) {
+    _assertClass(epoch_observer, EpochObserver);
+    var ptr0 = epoch_observer.__destroy_into_raw();
+    const ret = wasm.corecrypto_register_epoch_observer(this.__wbg_ptr, ptr0);
+    return ret;
+  }
+  register_history_observer(history_observer) {
+    _assertClass(history_observer, HistoryObserver);
+    var ptr0 = history_observer.__destroy_into_raw();
+    const ret = wasm.corecrypto_register_history_observer(this.__wbg_ptr, ptr0);
     return ret;
   }
   get_user_identities(conversation_id, user_ids) {
@@ -1037,29 +1074,28 @@ class CoreCrypto {
     const ret = wasm.corecrypto_get_user_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  e2ei_is_pki_env_setup() {
-    const ret = wasm.corecrypto_e2ei_is_pki_env_setup(this.__wbg_ptr);
+  get_device_identities(conversation_id, device_ids) {
+    _assertClass(conversation_id, ConversationId);
+    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   e2ei_is_enabled(ciphersuite) {
     const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
     return ret;
   }
+  e2ei_is_pki_env_setup() {
+    const ret = wasm.corecrypto_e2ei_is_pki_env_setup(this.__wbg_ptr);
+    return ret;
+  }
   e2ei_conversation_state(conversation_id) {
     _assertClass(conversation_id, ConversationId);
     const ret = wasm.corecrypto_e2ei_conversation_state(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  register_epoch_observer(epoch_observer) {
-    _assertClass(epoch_observer, EpochObserver);
-    var ptr0 = epoch_observer.__destroy_into_raw();
-    const ret = wasm.corecrypto_register_epoch_observer(this.__wbg_ptr, ptr0);
-    return ret;
-  }
-  register_history_observer(history_observer) {
-    _assertClass(history_observer, HistoryObserver);
-    var ptr0 = history_observer.__destroy_into_raw();
-    const ret = wasm.corecrypto_register_history_observer(this.__wbg_ptr, ptr0);
+  client_public_key(ciphersuite, credential_type) {
+    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
   static set_logger(logger) {
@@ -1070,10 +1106,12 @@ class CoreCrypto {
   static set_max_log_level(level) {
     wasm.corecrypto_set_max_log_level(level);
   }
-  provide_transport(callbacks) {
-    _assertClass(callbacks, MlsTransport);
-    var ptr0 = callbacks.__destroy_into_raw();
-    const ret = wasm.corecrypto_provide_transport(this.__wbg_ptr, ptr0);
+  transaction(command) {
+    const ret = wasm.corecrypto_transaction(this.__wbg_ptr, command);
+    return ret;
+  }
+  proteus_fingerprint() {
+    const ret = wasm.corecrypto_proteus_fingerprint(this.__wbg_ptr);
     return ret;
   }
   proteus_session_exists(session_id) {
@@ -1082,10 +1120,6 @@ class CoreCrypto {
     const ret = wasm.corecrypto_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  proteus_fingerprint() {
-    const ret = wasm.corecrypto_proteus_fingerprint(this.__wbg_ptr);
-    return ret;
-  }
   proteus_fingerprint_local(session_id) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -1126,48 +1160,6 @@ class CoreCrypto {
       wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
   }
-  random_bytes(len) {
-    const ret = wasm.corecrypto_random_bytes(this.__wbg_ptr, len);
-    return ret;
-  }
-  reseed_rng(seed) {
-    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_reseed_rng(this.__wbg_ptr, ptr0, len0);
-    return ret;
-  }
-  static async_new(path, key, client_id, ciphersuites, entropy_seed, nb_key_package) {
-    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(key, DatabaseKey);
-    var ptr1 = key.__destroy_into_raw();
-    let ptr2 = 0;
-    if (!isLikeNone(client_id)) {
-      _assertClass(client_id, ClientId);
-      ptr2 = client_id.__destroy_into_raw();
-    }
-    var ptr3 = isLikeNone(ciphersuites) ? 0 : passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
-    var len3 = WASM_VECTOR_LEN;
-    var ptr4 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
-    var len4 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_async_new(ptr0, len0, ptr1, ptr2, ptr3, len3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
-    return ret;
-  }
-  static deferred_init(path, key, entropy_seed) {
-    const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(key, DatabaseKey);
-    var ptr1 = key.__destroy_into_raw();
-    var ptr2 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_deferred_init(ptr0, len0, ptr1, ptr2, len2);
-    return ret;
-  }
-  close() {
-    const ptr = this.__destroy_into_raw();
-    const ret = wasm.corecrypto_close(ptr);
-    return ret;
-  }
   static history_client(history_secret) {
     _assertClass(history_secret, HistorySecret);
     var ptr0 = history_secret.__destroy_into_raw();
@@ -1197,137 +1189,113 @@ class CoreCryptoContext {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_corecryptocontext_free(ptr, 0);
   }
-  e2ei_new_enrollment(client_id, display_name, handle, team, expiry_sec, ciphersuite) {
-    const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len2 = WASM_VECTOR_LEN;
-    var ptr3 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len3 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ciphersuite);
+  random_bytes(len) {
+    const ret = wasm.corecryptocontext_random_bytes(this.__wbg_ptr, len);
     return ret;
   }
-  e2ei_new_activation_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
-    const ptr0 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  get_data() {
+    const ret = wasm.corecryptocontext_get_data(this.__wbg_ptr);
+    return ret;
+  }
+  set_data(data) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
+    const ret = wasm.corecryptocontext_set_data(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  e2ei_new_rotate_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
-    var ptr0 = isLikeNone(display_name) ? 0 : passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(handle) ? 0 : passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
-    return ret;
-  }
-  e2ei_register_acme_ca(trust_anchor_pem) {
-    const ptr0 = passStringToWasm0(trust_anchor_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_register_acme_ca(this.__wbg_ptr, ptr0, len0);
+  get_client_ids(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  e2ei_register_intermediate_ca(cert_pem) {
-    const ptr0 = passStringToWasm0(cert_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  decrypt_message(conversation_id, payload) {
+    _assertClass(conversation_id, ConversationId);
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_register_intermediate_ca(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  e2ei_register_crl(crl_dp, crl_der) {
-    const ptr0 = passStringToWasm0(crl_dp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  encrypt_message(conversation_id, message) {
+    _assertClass(conversation_id, ConversationId);
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(crl_der, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_register_crl(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  e2ei_mls_init_only(enrollment, certificate_chain, nb_key_package) {
-    _assertClass(enrollment, FfiWireE2EIdentity);
-    var ptr0 = enrollment.__destroy_into_raw();
-    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_mls_init_only(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
+  client_public_key(ciphersuite, credential_type) {
+    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
-  e2ei_rotate(conversation_id) {
+  export_secret_key(conversation_id, key_length) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
     return ret;
   }
-  save_x509_credential(enrollment, certificate_chain) {
-    _assertClass(enrollment, FfiWireE2EIdentity);
-    var ptr0 = enrollment.__destroy_into_raw();
-    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_save_x509_credential(this.__wbg_ptr, ptr0, ptr1, len1);
+  wipe_conversation(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  delete_stale_key_packages(ciphersuite) {
-    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, ciphersuite);
+  client_keypackages(ciphersuite, credential_type, amount_requested) {
+    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ciphersuite, credential_type, amount_requested);
     return ret;
   }
-  e2ei_enrollment_stash(enrollment) {
-    _assertClass(enrollment, FfiWireE2EIdentity);
-    var ptr0 = enrollment.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_e2ei_enrollment_stash(this.__wbg_ptr, ptr0);
+  conversation_epoch(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  e2ei_enrollment_stash_pop(handle) {
-    const ptr0 = passArray8ToWasm0(handle, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_e2ei_enrollment_stash_pop(this.__wbg_ptr, ptr0, len0);
+  conversation_exists(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  e2ei_conversation_state(conversation_id) {
+  create_conversation(conversation_id, creator_credential_type, config) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    _assertClass(config, ConversationConfiguration);
+    var ptr0 = config.__destroy_into_raw();
+    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, creator_credential_type, ptr0);
     return ret;
   }
-  e2ei_is_enabled(ciphersuite) {
-    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
+  get_external_sender(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  get_device_identities(conversation_id, device_ids) {
+  enable_history_sharing(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_enable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  get_user_identities(conversation_id, user_ids) {
+  update_keying_material(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_get_user_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  e2ei_is_pki_env_setup() {
-    const ret = wasm.corecryptocontext_e2ei_is_pki_env_setup(this.__wbg_ptr);
+  disable_history_sharing(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_disable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  mls_init(client_id, ciphersuites, nb_key_package) {
-    _assertClass(client_id, ClientId);
-    var ptr0 = client_id.__destroy_into_raw();
-    const ptr1 = passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
+  join_by_external_commit(group_info, custom_configuration, credential_type) {
+    _assertClass(group_info, GroupInfo);
+    var ptr0 = group_info.__destroy_into_raw();
+    _assertClass(custom_configuration, CustomConfiguration);
+    var ptr1 = custom_configuration.__destroy_into_raw();
+    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, ptr1, credential_type);
     return ret;
   }
-  client_public_key(ciphersuite, credential_type) {
-    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
+  process_welcome_message(welcome_message, custom_configuration) {
+    _assertClass(welcome_message, Welcome);
+    var ptr0 = welcome_message.__destroy_into_raw();
+    _assertClass(custom_configuration, CustomConfiguration);
+    var ptr1 = custom_configuration.__destroy_into_raw();
+    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, ptr1);
     return ret;
   }
-  conversation_epoch(conversation_id) {
+  commit_pending_proposals(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   conversation_ciphersuite(conversation_id) {
@@ -1335,176 +1303,206 @@ class CoreCryptoContext {
     const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  conversation_exists(conversation_id) {
+  add_clients_to_conversation(conversation_id, key_packages) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ptr0 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  get_client_ids(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  mark_conversation_as_child_of(child_id, parent_id) {
+    _assertClass(child_id, ConversationId);
+    _assertClass(parent_id, ConversationId);
+    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id.__wbg_ptr, parent_id.__wbg_ptr);
     return ret;
   }
-  export_secret_key(conversation_id, key_length) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
+  client_valid_keypackages_count(ciphersuite, credential_type) {
+    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
-  get_external_sender(conversation_id) {
+  remove_clients_from_conversation(conversation_id, clients) {
     _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    const ptr0 = passArrayJsValueToWasm0(clients, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  client_keypackages(ciphersuite, credential_type, amount_requested) {
-    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ciphersuite, credential_type, amount_requested);
+  mls_init(client_id, ciphersuites, nb_key_package) {
+    _assertClass(client_id, ClientId);
+    var ptr0 = client_id.__destroy_into_raw();
+    const ptr1 = passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
     return ret;
   }
-  client_valid_keypackages_count(ciphersuite, credential_type) {
-    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite, credential_type);
+  e2ei_rotate(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
-  create_conversation(conversation_id, creator_credential_type, config) {
-    _assertClass(conversation_id, ConversationId);
-    _assertClass(config, ConversationConfiguration);
-    var ptr0 = config.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, creator_credential_type, ptr0);
+  e2ei_is_enabled(ciphersuite) {
+    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
     return ret;
   }
-  process_welcome_message(welcome_message, custom_configuration) {
-    _assertClass(welcome_message, Welcome);
-    var ptr0 = welcome_message.__destroy_into_raw();
-    _assertClass(custom_configuration, CustomConfiguration);
-    var ptr1 = custom_configuration.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, ptr1);
+  e2ei_register_crl(crl_dp, crl_der) {
+    const ptr0 = passStringToWasm0(crl_dp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(crl_der, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_register_crl(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  add_clients_to_conversation(conversation_id, key_packages) {
-    _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_malloc);
+  e2ei_mls_init_only(enrollment, certificate_chain, nb_key_package) {
+    _assertClass(enrollment, FfiWireE2EIdentity);
+    var ptr0 = enrollment.__destroy_into_raw();
+    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_mls_init_only(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
+    return ret;
+  }
+  e2ei_new_enrollment(client_id, display_name, handle, team, expiry_sec, ciphersuite) {
+    const ptr0 = passStringToWasm0(client_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ptr1 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    var ptr3 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len3 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ciphersuite);
     return ret;
   }
-  remove_clients_from_conversation(conversation_id, clients) {
+  get_user_identities(conversation_id, user_ids) {
     _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArrayJsValueToWasm0(clients, wasm.__wbindgen_malloc);
+    const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_get_user_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  mark_conversation_as_child_of(child_id, parent_id) {
-    _assertClass(child_id, ConversationId);
-    _assertClass(parent_id, ConversationId);
-    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id.__wbg_ptr, parent_id.__wbg_ptr);
+  save_x509_credential(enrollment, certificate_chain) {
+    _assertClass(enrollment, FfiWireE2EIdentity);
+    var ptr0 = enrollment.__destroy_into_raw();
+    const ptr1 = passStringToWasm0(certificate_chain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_save_x509_credential(this.__wbg_ptr, ptr0, ptr1, len1);
     return ret;
   }
-  update_keying_material(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  e2ei_enrollment_stash(enrollment) {
+    _assertClass(enrollment, FfiWireE2EIdentity);
+    var ptr0 = enrollment.__destroy_into_raw();
+    const ret = wasm.corecryptocontext_e2ei_enrollment_stash(this.__wbg_ptr, ptr0);
     return ret;
   }
-  commit_pending_proposals(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  e2ei_is_pki_env_setup() {
+    const ret = wasm.corecryptocontext_e2ei_is_pki_env_setup(this.__wbg_ptr);
     return ret;
   }
-  wipe_conversation(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  e2ei_register_acme_ca(trust_anchor_pem) {
+    const ptr0 = passStringToWasm0(trust_anchor_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_register_acme_ca(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  decrypt_message(conversation_id, payload) {
+  get_device_identities(conversation_id, device_ids) {
     _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  encrypt_message(conversation_id, message) {
+  e2ei_conversation_state(conversation_id) {
     _assertClass(conversation_id, ConversationId);
-    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    return ret;
+  }
+  delete_stale_key_packages(ciphersuite) {
+    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, ciphersuite);
+    return ret;
+  }
+  e2ei_enrollment_stash_pop(handle) {
+    const ptr0 = passArray8ToWasm0(handle, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
+    const ret = wasm.corecryptocontext_e2ei_enrollment_stash_pop(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  join_by_external_commit(group_info, custom_configuration, credential_type) {
-    _assertClass(group_info, GroupInfo);
-    var ptr0 = group_info.__destroy_into_raw();
-    _assertClass(custom_configuration, CustomConfiguration);
-    var ptr1 = custom_configuration.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, ptr1, credential_type);
+  e2ei_new_rotate_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
+    var ptr0 = isLikeNone(display_name) ? 0 : passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(handle) ? 0 : passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
     return ret;
   }
-  enable_history_sharing(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_enable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  e2ei_register_intermediate_ca(cert_pem) {
+    const ptr0 = passStringToWasm0(cert_pem, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_register_intermediate_ca(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  disable_history_sharing(conversation_id) {
-    _assertClass(conversation_id, ConversationId);
-    const ret = wasm.corecryptocontext_disable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
+  e2ei_new_activation_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
+    const ptr0 = passStringToWasm0(display_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
     return ret;
   }
   proteus_init() {
     const ret = wasm.corecryptocontext_proteus_init(this.__wbg_ptr);
     return ret;
   }
-  proteus_session_from_prekey(session_id, prekey) {
+  proteus_decrypt(session_id, ciphertext) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(prekey, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_session_from_prekey(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_proteus_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  proteus_session_from_message(session_id, envelope) {
+  proteus_encrypt(session_id, plaintext) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(envelope, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_session_from_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_proteus_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  proteus_session_save(session_id) {
-    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_session_save(this.__wbg_ptr, ptr0, len0);
+  proteus_new_prekey(prekey_id) {
+    const ret = wasm.corecryptocontext_proteus_new_prekey(this.__wbg_ptr, prekey_id);
     return ret;
   }
-  proteus_session_delete(session_id) {
-    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_session_delete(this.__wbg_ptr, ptr0, len0);
+  proteus_fingerprint() {
+    const ret = wasm.corecryptocontext_proteus_fingerprint(this.__wbg_ptr);
     return ret;
   }
-  proteus_session_exists(session_id) {
+  proteus_decrypt_safe(session_id, ciphertext) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_proteus_decrypt_safe(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  proteus_decrypt(session_id, ciphertext) {
+  proteus_session_save(session_id) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_proteus_session_save(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  proteus_decrypt_safe(session_id, ciphertext) {
+  proteus_session_delete(session_id) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_decrypt_safe(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_proteus_session_delete(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  proteus_encrypt(session_id, plaintext) {
+  proteus_session_exists(session_id) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_proteus_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.corecryptocontext_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
   proteus_encrypt_batched(sessions, plaintext) {
@@ -1515,20 +1513,12 @@ class CoreCryptoContext {
     const ret = wasm.corecryptocontext_proteus_encrypt_batched(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  proteus_new_prekey(prekey_id) {
-    const ret = wasm.corecryptocontext_proteus_new_prekey(this.__wbg_ptr, prekey_id);
-    return ret;
-  }
   proteus_new_prekey_auto() {
     const ret = wasm.corecryptocontext_proteus_new_prekey_auto(this.__wbg_ptr);
     return ret;
   }
-  proteus_last_resort_prekey() {
-    const ret = wasm.corecryptocontext_proteus_last_resort_prekey(this.__wbg_ptr);
-    return ret;
-  }
-  proteus_fingerprint() {
-    const ret = wasm.corecryptocontext_proteus_fingerprint(this.__wbg_ptr);
+  proteus_reload_sessions() {
+    const ret = wasm.corecryptocontext_proteus_reload_sessions(this.__wbg_ptr);
     return ret;
   }
   proteus_fingerprint_local(session_id) {
@@ -1543,8 +1533,24 @@ class CoreCryptoContext {
     const ret = wasm.corecryptocontext_proteus_fingerprint_remote(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  proteus_reload_sessions() {
-    const ret = wasm.corecryptocontext_proteus_reload_sessions(this.__wbg_ptr);
+  proteus_last_resort_prekey() {
+    const ret = wasm.corecryptocontext_proteus_last_resort_prekey(this.__wbg_ptr);
+    return ret;
+  }
+  proteus_session_from_prekey(session_id, prekey) {
+    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(prekey, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_proteus_session_from_prekey(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    return ret;
+  }
+  proteus_session_from_message(session_id, envelope) {
+    const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(envelope, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_proteus_session_from_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
   static proteus_last_resort_prekey_id() {
@@ -1575,20 +1581,6 @@ class CoreCryptoContext {
       wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
   }
-  set_data(data) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_set_data(this.__wbg_ptr, ptr0, len0);
-    return ret;
-  }
-  get_data() {
-    const ret = wasm.corecryptocontext_get_data(this.__wbg_ptr);
-    return ret;
-  }
-  random_bytes(len) {
-    const ret = wasm.corecryptocontext_random_bytes(this.__wbg_ptr, len);
-    return ret;
-  }
 }
 if (Symbol.dispose)
   CoreCryptoContext.prototype[Symbol.dispose] = CoreCryptoContext.prototype.free;
@@ -1637,6 +1629,12 @@ class CrlRegistration {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_crlregistration_free(ptr, 0);
   }
+  constructor(dirty, expiration) {
+    const ret = wasm.crlregistration_new(dirty, !isLikeNone(expiration), isLikeNone(expiration) ? BigInt(0) : expiration);
+    this.__wbg_ptr = ret >>> 0;
+    CrlRegistrationFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
   get dirty() {
     const ret = wasm.__wbg_get_crlregistration_dirty(this.__wbg_ptr);
     return ret !== 0;
@@ -1651,12 +1649,6 @@ class CrlRegistration {
   set expiration(arg0) {
     wasm.__wbg_set_crlregistration_expiration(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
   }
-  constructor(dirty, expiration) {
-    const ret = wasm.crlregistration_new(dirty, !isLikeNone(expiration), isLikeNone(expiration) ? BigInt(0) : expiration);
-    this.__wbg_ptr = ret >>> 0;
-    CrlRegistrationFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
 }
 if (Symbol.dispose)
   CrlRegistration.prototype[Symbol.dispose] = CrlRegistration.prototype.free;
@@ -1680,6 +1672,12 @@ class CustomConfiguration {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_customconfiguration_free(ptr, 0);
   }
+  constructor(key_rotation_span, wire_policy) {
+    const ret = wasm.customconfiguration_new(isLikeNone(key_rotation_span) ? 4294967297 : key_rotation_span >>> 0, isLikeNone(wire_policy) ? 0 : wire_policy);
+    this.__wbg_ptr = ret >>> 0;
+    CustomConfigurationFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
   get keyRotationSpan() {
     const ret = wasm.__wbg_get_customconfiguration_keyRotationSpan(this.__wbg_ptr);
     return ret === 4294967297 ? undefined : ret;
@@ -1694,12 +1692,6 @@ class CustomConfiguration {
   set wirePolicy(arg0) {
     wasm.__wbg_set_customconfiguration_wirePolicy(this.__wbg_ptr, isLikeNone(arg0) ? 0 : arg0);
   }
-  constructor(key_rotation_span, wire_policy) {
-    const ret = wasm.customconfiguration_new(isLikeNone(key_rotation_span) ? 4294967297 : key_rotation_span >>> 0, isLikeNone(wire_policy) ? 0 : wire_policy);
-    this.__wbg_ptr = ret >>> 0;
-    CustomConfigurationFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
 }
 if (Symbol.dispose)
   CustomConfiguration.prototype[Symbol.dispose] = CustomConfiguration.prototype.free;
@@ -1874,6 +1866,12 @@ class ExternalSenderKey {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_externalsenderkey_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.externalsenderkey_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -1882,12 +1880,6 @@ class ExternalSenderKey {
     ExternalSenderKeyFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.externalsenderkey_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   ExternalSenderKey.prototype[Symbol.dispose] = ExternalSenderKey.prototype.free;
@@ -1911,34 +1903,22 @@ class FfiWireE2EIdentity {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_ffiwiree2eidentity_free(ptr, 0);
   }
-  directory_response(directory) {
-    const ptr0 = passArray8ToWasm0(directory, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_directory_response(this.__wbg_ptr, ptr0, len0);
-    return ret;
-  }
-  new_account_request(previous_nonce) {
+  finalize_request(previous_nonce) {
     const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_account_request(this.__wbg_ptr, ptr0, len0);
-    return ret;
-  }
-  new_account_response(account) {
-    const ptr0 = passArray8ToWasm0(account, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_account_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_finalize_request(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  new_order_request(previous_nonce) {
-    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  create_dpop_token(expiry_secs, backend_nonce) {
+    const ptr0 = passStringToWasm0(backend_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_order_request(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_create_dpop_token(this.__wbg_ptr, expiry_secs, ptr0, len0);
     return ret;
   }
-  new_order_response(order) {
-    const ptr0 = passArray8ToWasm0(order, wasm.__wbindgen_malloc);
+  finalize_response(finalize) {
+    const ptr0 = passArray8ToWasm0(finalize, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_order_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_finalize_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
   new_authz_request(url, previous_nonce) {
@@ -1949,30 +1929,34 @@ class FfiWireE2EIdentity {
     const ret = wasm.ffiwiree2eidentity_new_authz_request(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  new_authz_response(authz) {
-    const ptr0 = passArray8ToWasm0(authz, wasm.__wbindgen_malloc);
+  new_order_request(previous_nonce) {
+    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_authz_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_new_order_request(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  create_dpop_token(expiry_secs, backend_nonce) {
-    const ptr0 = passStringToWasm0(backend_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  directory_response(directory) {
+    const ptr0 = passArray8ToWasm0(directory, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ffiwiree2eidentity_directory_response(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  new_authz_response(authz) {
+    const ptr0 = passArray8ToWasm0(authz, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_create_dpop_token(this.__wbg_ptr, expiry_secs, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_new_authz_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  new_dpop_challenge_request(access_token, previous_nonce) {
-    const ptr0 = passStringToWasm0(access_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  new_order_response(order) {
+    const ptr0 = passArray8ToWasm0(order, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_dpop_challenge_request(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    const ret = wasm.ffiwiree2eidentity_new_order_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  new_dpop_challenge_response(challenge) {
-    const ptr0 = passArray8ToWasm0(challenge, wasm.__wbindgen_malloc);
+  certificate_request(previous_nonce) {
+    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_dpop_challenge_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_certificate_request(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
   check_order_request(order_url, previous_nonce) {
@@ -1983,28 +1967,30 @@ class FfiWireE2EIdentity {
     const ret = wasm.ffiwiree2eidentity_check_order_request(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
-  check_order_response(order) {
-    const ptr0 = passArray8ToWasm0(order, wasm.__wbindgen_malloc);
+  new_account_request(previous_nonce) {
+    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_check_order_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_new_account_request(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  finalize_request(previous_nonce) {
-    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  check_order_response(order) {
+    const ptr0 = passArray8ToWasm0(order, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_finalize_request(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_check_order_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  finalize_response(finalize) {
-    const ptr0 = passArray8ToWasm0(finalize, wasm.__wbindgen_malloc);
+  new_account_response(account) {
+    const ptr0 = passArray8ToWasm0(account, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_finalize_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_new_account_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  certificate_request(previous_nonce) {
-    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  new_dpop_challenge_request(access_token, previous_nonce) {
+    const ptr0 = passStringToWasm0(access_token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_certificate_request(this.__wbg_ptr, ptr0, len0);
+    const ptr1 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.ffiwiree2eidentity_new_dpop_challenge_request(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
   new_oidc_challenge_request(id_token, previous_nonce) {
@@ -2015,6 +2001,12 @@ class FfiWireE2EIdentity {
     const ret = wasm.ffiwiree2eidentity_new_oidc_challenge_request(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     return ret;
   }
+  new_dpop_challenge_response(challenge) {
+    const ptr0 = passArray8ToWasm0(challenge, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ffiwiree2eidentity_new_dpop_challenge_response(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
   new_oidc_challenge_response(challenge) {
     const ptr0 = passArray8ToWasm0(challenge, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2044,6 +2036,12 @@ class GroupInfo {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_groupinfo_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.groupinfo_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2052,12 +2050,6 @@ class GroupInfo {
     GroupInfoFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.groupinfo_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   GroupInfo.prototype[Symbol.dispose] = GroupInfo.prototype.free;
@@ -2152,16 +2144,6 @@ class HistorySecret {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_historysecret_free(ptr, 0);
   }
-  get clientId() {
-    const ret = wasm.__wbg_get_historysecret_clientId(this.__wbg_ptr);
-    return ClientId.__wrap(ret);
-  }
-  get data() {
-    const ret = wasm.__wbg_get_historysecret_data(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
   constructor(client_id, data) {
     _assertClass(client_id, ClientId);
     var ptr0 = client_id.__destroy_into_raw();
@@ -2175,6 +2157,16 @@ class HistorySecret {
     HistorySecretFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
+  get clientId() {
+    const ret = wasm.__wbg_get_groupinfobundle_payload(this.__wbg_ptr);
+    return ClientId.__wrap(ret);
+  }
+  get data() {
+    const ret = wasm.__wbg_get_historysecret_data(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
 if (Symbol.dispose)
   HistorySecret.prototype[Symbol.dispose] = HistorySecret.prototype.free;
@@ -2204,6 +2196,12 @@ class KeyPackage {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_keypackage_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.keypackage_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2212,12 +2210,6 @@ class KeyPackage {
     KeyPackageFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.keypackage_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   KeyPackage.prototype[Symbol.dispose] = KeyPackage.prototype.free;
@@ -2259,12 +2251,6 @@ class MlsTransportData {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_mlstransportdata_free(ptr, 0);
   }
-  get data() {
-    const ret = wasm.__wbg_get_mlstransportdata_data(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
   constructor(buf) {
     const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2273,6 +2259,12 @@ class MlsTransportData {
     MlsTransportDataFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
+  get data() {
+    const ret = wasm.__wbg_get_mlstransportdata_data(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
 if (Symbol.dispose)
   MlsTransportData.prototype[Symbol.dispose] = MlsTransportData.prototype.free;
@@ -2331,7 +2323,6 @@ class MlsTransportResponse {
 if (Symbol.dispose)
   MlsTransportResponse.prototype[Symbol.dispose] = MlsTransportResponse.prototype.free;
 var NewAcmeAuthzFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_newacmeauthz_free(ptr >>> 0, 1));
-
 class NewAcmeAuthz {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
@@ -2466,6 +2457,12 @@ class SecretKey {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_secretkey_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.secretkey_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2474,12 +2471,6 @@ class SecretKey {
     SecretKeyFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.secretkey_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   SecretKey.prototype[Symbol.dispose] = SecretKey.prototype.free;
@@ -2503,6 +2494,12 @@ class Welcome {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_welcome_free(ptr, 0);
   }
+  copyBytes() {
+    const ret = wasm.welcome_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
   constructor(bytes) {
     const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2511,12 +2508,6 @@ class Welcome {
     WelcomeFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  copyBytes() {
-    const ret = wasm.welcome_copyBytes(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
 }
 if (Symbol.dispose)
   Welcome.prototype[Symbol.dispose] = Welcome.prototype.free;
@@ -2541,7 +2532,7 @@ class WelcomeBundle {
     wasm.__wbg_welcomebundle_free(ptr, 0);
   }
   get id() {
-    const ret = wasm.__wbg_get_welcomebundle_id(this.__wbg_ptr);
+    const ret = wasm.__wbg_get_groupinfobundle_payload(this.__wbg_ptr);
     return ConversationId.__wrap(ret);
   }
   get crlNewDistributionPoints() {
@@ -2898,7 +2889,7 @@ function __wbg_get_imports() {
       wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
   };
-  imports.wbg.__wbg_execute_df0397759f250cb7 = function() {
+  imports.wbg.__wbg_execute_92dfbdf51fadfa93 = function() {
     return handleError(function(arg0, arg1) {
       const ret = arg0.execute(CoreCryptoContext.__wrap(arg1));
       return ret;
@@ -3147,11 +3138,11 @@ function __wbg_get_imports() {
   imports.wbg.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
     try {
       var state0 = { a: arg0, b: arg1 };
-      var cb0 = (arg02, arg12) => {
+      var cb0 = (arg0, arg1) => {
         const a = state0.a;
         state0.a = 0;
         try {
-          return __wbg_adapter_511(a, state0.b, arg02, arg12);
+          return __wbg_adapter_479(a, state0.b, arg0, arg1);
         } finally {
           state0.a = a;
         }
@@ -3546,6 +3537,10 @@ function __wbg_get_imports() {
     const ret = v0;
     return ret;
   };
+  imports.wbg.__wbindgen_cast_3fda284bdcf7704e = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 941, __wbg_adapter_30);
+    return ret;
+  };
   imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
     const ret = BigInt.asUintN(64, arg0);
     return ret;
@@ -3556,8 +3551,8 @@ function __wbg_get_imports() {
     const ret = v0;
     return ret;
   };
-  imports.wbg.__wbindgen_cast_77ac86d8075f2f98 = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, 1025, __wbg_adapter_27);
+  imports.wbg.__wbindgen_cast_497f9f19c9eb4ede = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 2504, __wbg_adapter_18);
     return ret;
   };
   imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function(arg0, arg1) {
@@ -3566,12 +3561,8 @@ function __wbg_get_imports() {
     const ret = v0;
     return ret;
   };
-  imports.wbg.__wbindgen_cast_9366269b35ccbb69 = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, 2905, __wbg_adapter_24);
-    return ret;
-  };
-  imports.wbg.__wbindgen_cast_a834b411bd2663eb = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, 2596, __wbg_adapter_30);
+  imports.wbg.__wbindgen_cast_9d5cbea1975bde9f = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 2882, __wbg_adapter_23);
     return ret;
   };
   imports.wbg.__wbindgen_cast_b77aa29fa8fe8560 = function(arg0, arg1) {
@@ -3790,10 +3781,10 @@ class E2eiEnrollment {
   }
 }
 var E2eiConversationState2;
-((E2eiConversationState3) => {
-  E2eiConversationState3[E2eiConversationState3["Verified"] = 1] = "Verified";
-  E2eiConversationState3[E2eiConversationState3["NotVerified"] = 2] = "NotVerified";
-  E2eiConversationState3[E2eiConversationState3["NotEnabled"] = 3] = "NotEnabled";
+((E2eiConversationState) => {
+  E2eiConversationState[E2eiConversationState["Verified"] = 1] = "Verified";
+  E2eiConversationState[E2eiConversationState["NotVerified"] = 2] = "NotVerified";
+  E2eiConversationState[E2eiConversationState["NotEnabled"] = 3] = "NotEnabled";
 })(E2eiConversationState2 ||= {});
 
 // src/ConversationConfiguration.ts
@@ -4077,13 +4068,13 @@ function loggerIntoFfi(logger) {
   return new CoreCryptoLogger(logFn, logThis);
 }
 var CoreCryptoLogLevel2;
-((CoreCryptoLogLevel3) => {
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Off"] = 1] = "Off";
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Trace"] = 2] = "Trace";
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Debug"] = 3] = "Debug";
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Info"] = 4] = "Info";
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Warn"] = 5] = "Warn";
-  CoreCryptoLogLevel3[CoreCryptoLogLevel3["Error"] = 6] = "Error";
+((CoreCryptoLogLevel) => {
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Off"] = 1] = "Off";
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Trace"] = 2] = "Trace";
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Debug"] = 3] = "Debug";
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Info"] = 4] = "Info";
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Warn"] = 5] = "Warn";
+  CoreCryptoLogLevel[CoreCryptoLogLevel["Error"] = 6] = "Error";
 })(CoreCryptoLogLevel2 ||= {});
 function setMaxLogLevel(level) {
   CoreCrypto2.setMaxLogLevel(level);
@@ -4262,68 +4253,68 @@ async function initWasmModule(location = undefined) {
   }
 }
 export {
-  version2 as version,
-  updateDatabaseKey,
-  setMaxLogLevel,
-  setLogger,
-  openDatabase,
-  migrateDatabaseKeyTypeToBytes,
-  isTransactionFailedError,
-  isProteusSessionNotFoundError,
-  isProteusRemoteIdentityChangedError,
-  isProteusOtherError,
-  isProteusError,
-  isProteusDuplicateMessageError,
-  isOtherError,
-  isMlsWrongEpochError,
-  isMlsUnmergedPendingGroupError,
-  isMlsStaleProposalError,
-  isMlsStaleCommitError,
-  isMlsSelfCommitIgnoredError,
-  isMlsOtherError,
-  isMlsOrphanWelcomeError,
-  isMlsMessageRejectedError,
-  isMlsError,
-  isMlsDuplicateMessageError,
-  isMlsConversationAlreadyExistsError,
-  isMlsBufferedFutureMessageError,
-  isMlsBufferedCommitError,
-  isE2eiError,
-  isCcError,
-  initWasmModule,
-  ciphersuiteFromU16,
-  ciphersuiteDefault,
-  buildMetadata,
-  X509Identity2 as X509Identity,
-  WirePolicy,
-  WireIdentity4 as WireIdentity,
-  WelcomeBundle,
-  Welcome,
-  SecretKey,
-  MlsRatchetTreeType as RatchetTreeType,
-  ProteusErrorType,
-  NewAcmeOrder,
-  NewAcmeAuthz,
-  MlsTransportData,
-  MlsErrorType,
-  MlsGroupInfoEncryptionType as GroupInfoEncryptionType,
-  GroupInfo,
-  ExternalSenderKey,
-  ErrorType,
-  E2eiEnrollment,
-  E2eiConversationState2 as E2eiConversationState,
-  DeviceStatus,
-  DatabaseKey,
-  Database,
-  CustomConfiguration,
-  CredentialType,
-  CoreCryptoLogLevel2 as CoreCryptoLogLevel,
-  CoreCryptoError,
-  CoreCryptoContext2 as CoreCryptoContext,
-  CoreCrypto2 as CoreCrypto,
-  ConversationId,
-  ClientId,
-  Ciphersuite,
+  AcmeChallenge,
   BuildMetadata2 as BuildMetadata,
-  AcmeChallenge
+  Ciphersuite,
+  ClientId,
+  ConversationId,
+  CoreCrypto2 as CoreCrypto,
+  CoreCryptoContext2 as CoreCryptoContext,
+  CoreCryptoError,
+  CoreCryptoLogLevel2 as CoreCryptoLogLevel,
+  CredentialType,
+  CustomConfiguration,
+  Database,
+  DatabaseKey,
+  DeviceStatus,
+  E2eiConversationState2 as E2eiConversationState,
+  E2eiEnrollment,
+  ErrorType,
+  ExternalSenderKey,
+  GroupInfo,
+  MlsGroupInfoEncryptionType as GroupInfoEncryptionType,
+  MlsErrorType,
+  MlsTransportData,
+  NewAcmeAuthz,
+  NewAcmeOrder,
+  ProteusErrorType,
+  MlsRatchetTreeType as RatchetTreeType,
+  SecretKey,
+  Welcome,
+  WelcomeBundle,
+  WireIdentity4 as WireIdentity,
+  WirePolicy,
+  X509Identity2 as X509Identity,
+  buildMetadata,
+  ciphersuiteDefault,
+  ciphersuiteFromU16,
+  initWasmModule,
+  isCcError,
+  isE2eiError,
+  isMlsBufferedCommitError,
+  isMlsBufferedFutureMessageError,
+  isMlsConversationAlreadyExistsError,
+  isMlsDuplicateMessageError,
+  isMlsError,
+  isMlsMessageRejectedError,
+  isMlsOrphanWelcomeError,
+  isMlsOtherError,
+  isMlsSelfCommitIgnoredError,
+  isMlsStaleCommitError,
+  isMlsStaleProposalError,
+  isMlsUnmergedPendingGroupError,
+  isMlsWrongEpochError,
+  isOtherError,
+  isProteusDuplicateMessageError,
+  isProteusError,
+  isProteusOtherError,
+  isProteusRemoteIdentityChangedError,
+  isProteusSessionNotFoundError,
+  isTransactionFailedError,
+  migrateDatabaseKeyTypeToBytes,
+  openDatabase,
+  setLogger,
+  setMaxLogLevel,
+  updateDatabaseKey,
+  version2 as version
 };