@wireapp/core-crypto 9.3.2 → 9.3.4

package/src/corecrypto.js

@@ -345,16 +345,9 @@ 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 ciphersuiteDefault() {
+  const ret = wasm.ciphersuiteDefault();
+  return ret;
 }
 function takeFromExternrefTable0(idx) {
   const value = wasm.__wbindgen_export_4.get(idx);
@@ -368,9 +361,16 @@ function ciphersuiteFromU16(discriminant) {
   }
   return ret[0];
 }
-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;
@@ -381,6 +381,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 +406,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 +422,17 @@ function build_metadata() {
   const ret = wasm.build_metadata();
   return BuildMetadata.__wrap(ret);
 }
-function __wbg_adapter_16(arg0, arg1, arg2) {
-  wasm.closure2906_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_8(arg0, arg1, arg2) {
+  wasm.closure2505_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_23(arg0, arg1, arg2) {
-  wasm.closure2597_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_19(arg0, arg1, arg2) {
+  wasm.closure2882_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_26(arg0, arg1, arg2) {
-  wasm.closure1026_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_22(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.closure2985_externref_shim(arg0, arg1, arg2, arg3);
 }
 var Ciphersuite = Object.freeze({
   MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1,
@@ -801,6 +801,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 +815,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 +943,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 +957,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 +980,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 +1047,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 +1057,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 +1082,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 +1114,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 +1128,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 +1168,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 +1197,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 +1311,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 +1521,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);
+  proteus_new_prekey_auto() {
+    const ret = wasm.corecryptocontext_proteus_new_prekey_auto(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 +1541,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 +1589,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 +1637,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 +1657,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 +1680,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 +1700,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 +1874,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 +1888,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 +1911,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 +1937,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_create_dpop_token(this.__wbg_ptr, expiry_secs, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_directory_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_authz_response(authz) {
+    const ptr0 = passArray8ToWasm0(authz, 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_authz_response(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
-  new_dpop_challenge_response(challenge) {
-    const ptr0 = passArray8ToWasm0(challenge, wasm.__wbindgen_malloc);
+  new_order_response(order) {
+    const ptr0 = passArray8ToWasm0(order, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ffiwiree2eidentity_new_dpop_challenge_response(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.ffiwiree2eidentity_new_order_response(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  certificate_request(previous_nonce) {
+    const ptr0 = passStringToWasm0(previous_nonce, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ffiwiree2eidentity_certificate_request(this.__wbg_ptr, ptr0, len0);
     return ret;
   }
   check_order_request(order_url, previous_nonce) {
@@ -1983,28 +1975,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 +2009,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 +2044,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 +2058,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 +2152,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 +2165,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 +2204,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 +2218,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 +2259,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 +2267,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;
@@ -2466,6 +2466,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 +2480,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 +2503,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 +2517,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 +2541,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 +2898,7 @@ function __wbg_get_imports() {
       wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
   };
-  imports.wbg.__wbg_execute_2b5645696ac713e6 = function() {
+  imports.wbg.__wbg_execute_c1e831ee9e01a6ab = function() {
     return handleError(function(arg0, arg1) {
       const ret = arg0.execute(CoreCryptoContext.__wrap(arg1));
       return ret;
@@ -3151,7 +3151,7 @@ function __wbg_get_imports() {
         const a = state0.a;
         state0.a = 0;
         try {
-          return __wbg_adapter_511(a, state0.b, arg02, arg12);
+          return __wbg_adapter_479(a, state0.b, arg02, arg12);
         } finally {
           state0.a = a;
         }
@@ -3546,6 +3546,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_22);
+    return ret;
+  };
   imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
     const ret = BigInt.asUintN(64, arg0);
     return ret;
@@ -3556,8 +3560,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_26);
+  imports.wbg.__wbindgen_cast_497f9f19c9eb4ede = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 2504, __wbg_adapter_8);
     return ret;
   };
   imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function(arg0, arg1) {
@@ -3566,20 +3570,16 @@ 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_16);
-    return ret;
-  };
-  imports.wbg.__wbindgen_cast_a834b411bd2663eb = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, 2596, __wbg_adapter_23);
-    return ret;
-  };
   imports.wbg.__wbindgen_cast_b77aa29fa8fe8560 = function(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
     const ret = v0;
     return ret;
   };
+  imports.wbg.__wbindgen_cast_bfd87b187f67b730 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, 2881, __wbg_adapter_19);
+    return ret;
+  };
   imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;