@wireapp/core-crypto 10.2.0 → 10.3.0

package/dist/native/corecrypto.js

@@ -9,11 +9,7 @@ var DEFINITIONS = {
   },
   functions: {
     ffi_core_crypto_ffi_rust_future_poll_u8: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -33,11 +29,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_i8: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -57,11 +49,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_u16: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -81,11 +69,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_i16: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -105,11 +89,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_u32: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -129,11 +109,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_i32: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -153,11 +129,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_u64: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -177,11 +149,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_i64: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -201,11 +169,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_f32: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -225,11 +189,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_f64: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -249,11 +209,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_rust_buffer: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -273,11 +229,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     ffi_core_crypto_ffi_rust_future_poll_void: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("RustFutureContinuationCallback"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("RustFutureContinuationCallback"), FfiType.Handle],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -537,44 +489,32 @@ var DEFINITIONS = {
       hasRustCallStatus: true
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_corecryptocommand: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiCoreCryptoCommand"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiCoreCryptoCommand"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_corecryptologger: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiCoreCryptoLogger"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiCoreCryptoLogger"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_epochobserver: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiEpochObserver"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiEpochObserver"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_historyobserver: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiHistoryObserver"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiHistoryObserver"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_mlstransport: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiMlsTransport"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiMlsTransport"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_init_callback_vtable_pkienvironmenthooks: {
-      args: [
-        FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiPkiEnvironmentHooks"))
-      ],
+      args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceCoreCryptoFfiPkiEnvironmentHooks"))],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
@@ -754,12 +694,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_method_corecryptocontext_create_conversation: {
-      args: [
-        FfiType.Handle,
-        FfiType.Handle,
-        FfiType.Handle,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.Handle, FfiType.Handle, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: false
     },
@@ -1019,14 +954,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_method_corecryptoffi_find_credentials_ffi: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: false
     },
@@ -1111,12 +1039,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_method_corecryptologger_log: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
       ret: FfiType.Void,
       hasRustCallStatus: true
     },
@@ -1366,24 +1289,12 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_method_pkienvironmenthooks_http_request: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: false
     },
     uniffi_core_crypto_ffi_fn_method_pkienvironmenthooks_authenticate: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: false
     },
@@ -1473,12 +1384,7 @@ var DEFINITIONS = {
       hasRustCallStatus: true
     },
     uniffi_core_crypto_ffi_fn_constructor_x509credentialacquisition_new_from_credential_ref: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.Handle,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Handle, FfiType.RustBuffer],
       ret: FfiType.Handle,
       hasRustCallStatus: false
     },
@@ -2255,12 +2161,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiCoreCryptoCommandMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.Handle,
-        FfiType.Callback("ForeignFutureCompletevoid"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Handle, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
@@ -2276,12 +2177,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiCoreCryptoLoggerMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer],
       ret: FfiType.VoidPointer,
       hasRustCallStatus: true,
       outReturn: true
@@ -2297,13 +2193,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiEpochObserverMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.Handle,
-        FfiType.UInt64,
-        FfiType.Callback("ForeignFutureCompletevoid"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Handle, FfiType.UInt64, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
@@ -2319,13 +2209,7 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiHistoryObserverMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompletevoid"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
@@ -2341,31 +2225,18 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiMlsTransportMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompletevoid"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompletevoid"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
     },
     ForeignFutureCompleterust_buffer: {
-      args: [
-        FfiType.Handle,
-        FfiType.Struct("ForeignFutureResultRustBuffer")
-      ],
+      args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
       ret: FfiType.Void,
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiMlsTransportMethod1: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompleterust_buffer"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
@@ -2381,50 +2252,25 @@ var DEFINITIONS = {
       hasRustCallStatus: false
     },
     CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod0: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompleterust_buffer"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
     },
     CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod1: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompleterust_buffer"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
     },
     CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod2: {
-      args: [
-        FfiType.Handle,
-        FfiType.Callback("ForeignFutureCompleterust_buffer"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
     },
     CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod3: {
-      args: [
-        FfiType.Handle,
-        FfiType.RustBuffer,
-        FfiType.Callback("ForeignFutureCompleterust_buffer"),
-        FfiType.Handle
-      ],
+      args: [FfiType.Handle, FfiType.RustBuffer, FfiType.Callback("ForeignFutureCompleterust_buffer"), FfiType.Handle],
       ret: FfiType.Struct("ForeignFutureDroppedCallbackStruct"),
       hasRustCallStatus: false,
       outReturn: true
@@ -2443,117 +2289,48 @@ var DEFINITIONS = {
   structs: {
     ForeignFutureDroppedCallbackStruct: [
       { name: "handle", type: FfiType.Handle },
-      {
-        name: "free",
-        type: FfiType.Callback("ForeignFutureDroppedCallback")
-      }
+      { name: "free", type: FfiType.Callback("ForeignFutureDroppedCallback") }
     ],
     ForeignFutureResultVoid: [
       { name: "call_status", type: FfiType.RustCallStatus }
     ],
     VTableCallbackInterfaceCoreCryptoFfiCoreCryptoCommand: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_CoreCryptoCommand")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_CoreCryptoCommand")
-      },
-      {
-        name: "execute",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiCoreCryptoCommandMethod0")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_CoreCryptoCommand") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_CoreCryptoCommand") },
+      { name: "execute", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiCoreCryptoCommandMethod0") }
     ],
     VTableCallbackInterfaceCoreCryptoFfiCoreCryptoLogger: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_CoreCryptoLogger")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_CoreCryptoLogger")
-      },
-      {
-        name: "log",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiCoreCryptoLoggerMethod0")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_CoreCryptoLogger") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_CoreCryptoLogger") },
+      { name: "log", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiCoreCryptoLoggerMethod0") }
     ],
     VTableCallbackInterfaceCoreCryptoFfiEpochObserver: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_EpochObserver")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_EpochObserver")
-      },
-      {
-        name: "epoch_changed",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiEpochObserverMethod0")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_EpochObserver") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_EpochObserver") },
+      { name: "epoch_changed", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiEpochObserverMethod0") }
     ],
     VTableCallbackInterfaceCoreCryptoFfiHistoryObserver: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_HistoryObserver")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_HistoryObserver")
-      },
-      {
-        name: "history_client_created",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiHistoryObserverMethod0")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_HistoryObserver") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_HistoryObserver") },
+      { name: "history_client_created", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiHistoryObserverMethod0") }
     ],
     ForeignFutureResultRustBuffer: [
       { name: "return_value", type: FfiType.RustBuffer },
       { name: "call_status", type: FfiType.RustCallStatus }
     ],
     VTableCallbackInterfaceCoreCryptoFfiMlsTransport: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_MlsTransport")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_MlsTransport")
-      },
-      {
-        name: "send_commit_bundle",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiMlsTransportMethod0")
-      },
-      {
-        name: "prepare_for_transport",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiMlsTransportMethod1")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_MlsTransport") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_MlsTransport") },
+      { name: "send_commit_bundle", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiMlsTransportMethod0") },
+      { name: "prepare_for_transport", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiMlsTransportMethod1") }
     ],
     VTableCallbackInterfaceCoreCryptoFfiPkiEnvironmentHooks: [
-      {
-        name: "uniffi_free",
-        type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_PkiEnvironmentHooks")
-      },
-      {
-        name: "uniffi_clone",
-        type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_PkiEnvironmentHooks")
-      },
-      {
-        name: "http_request",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod0")
-      },
-      {
-        name: "authenticate",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod1")
-      },
-      {
-        name: "get_backend_nonce",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod2")
-      },
-      {
-        name: "fetch_backend_access_token",
-        type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod3")
-      }
+      { name: "uniffi_free", type: FfiType.Callback("CallbackInterfaceFreeCoreCryptoFfi_PkiEnvironmentHooks") },
+      { name: "uniffi_clone", type: FfiType.Callback("CallbackInterfaceCloneCoreCryptoFfi_PkiEnvironmentHooks") },
+      { name: "http_request", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod0") },
+      { name: "authenticate", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod1") },
+      { name: "get_backend_nonce", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod2") },
+      { name: "fetch_backend_access_token", type: FfiType.Callback("CallbackInterfaceCoreCryptoFfiPkiEnvironmentHooksMethod3") }
     ]
   }
 };
@@ -2588,6 +2365,7 @@ import {
   FfiConverterUInt64,
   FfiConverterUint8Array,
   UniffiAbstractObject,
+  UniffiEnum,
   UniffiError,
   UniffiInternalError,
   UniffiResult,
@@ -2695,101 +2473,6 @@ function version() {
     return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_func_version(callStatus);
   }, FfiConverterString.lift.bind(FfiConverterString)));
 }
-
-class Uuid extends UniffiAbstractObject {
-  [uniffiTypeNameSymbol] = "Uuid";
-  [destructorGuardSymbol];
-  [pointerLiteralSymbol];
-  constructor(uuid) {
-    super();
-    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_uuid_new(FfiConverterString.lower(uuid, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString));
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeUuidObjectFactory.bless(pointer);
-  }
-  toString() {
-    return ((__rb) => {
-      try {
-        return FfiConverterString.lift(__rb);
-      } finally {
-        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_display(uniffiTypeUuidObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  equals(other) {
-    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_eq_eq(uniffiTypeUuidObjectFactory.clonePointer(this), FfiConverterTypeUuid.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  hashCode() {
-    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_hash(uniffiTypeUuidObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  uniffiDestroy() {
-    const ptr = this[destructorGuardSymbol];
-    if (ptr !== undefined) {
-      const pointer = uniffiTypeUuidObjectFactory.pointer(this);
-      uniffiTypeUuidObjectFactory.freePointer(pointer);
-      uniffiTypeUuidObjectFactory.unbless(ptr);
-      delete this[destructorGuardSymbol];
-    }
-  }
-  static instanceOf(obj_) {
-    return uniffiTypeUuidObjectFactory.isConcreteType(obj_);
-  }
-}
-var uniffiTypeUuidObjectFactory = (() => {
-  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
-    uniffiTypeUuidObjectFactory.freePointer(heldValue);
-  }) : null;
-  return {
-    create(pointer) {
-      const instance = Object.create(Uuid.prototype);
-      instance[pointerLiteralSymbol] = pointer;
-      instance[destructorGuardSymbol] = this.bless(pointer);
-      instance[uniffiTypeNameSymbol] = "Uuid";
-      return instance;
-    },
-    bless(p) {
-      const ptr = {
-        p,
-        markDestroyed: () => {
-          return;
-        }
-      };
-      if (registry) {
-        registry.register(ptr, p, ptr);
-      }
-      return ptr;
-    },
-    unbless(ptr_) {
-      if (registry) {
-        registry.unregister(ptr_);
-      }
-    },
-    pointer(obj_) {
-      if (obj_[destructorGuardSymbol] === undefined) {
-        throw new UniffiInternalError.UnexpectedNullPointer;
-      }
-      return obj_[pointerLiteralSymbol];
-    },
-    clonePointer(obj_) {
-      const pointer = this.pointer(obj_);
-      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_uuid(pointer, callStatus), FfiConverterString.lift);
-    },
-    freePointer(pointer) {
-      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_uuid(pointer, callStatus), FfiConverterString.lift);
-    },
-    isConcreteType(obj_) {
-      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Uuid";
-    }
-  };
-})();
-var FfiConverterTypeUuid = new FfiConverterObject(uniffiTypeUuidObjectFactory);
 var stringConverter = (() => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
@@ -2805,112 +2488,7 @@ var stringConverter = (() => {
   };
 })();
 var FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
-
-class DeviceId extends UniffiAbstractObject {
-  [uniffiTypeNameSymbol] = "DeviceId";
-  [destructorGuardSymbol];
-  [pointerLiteralSymbol];
-  constructor(id) {
-    super();
-    const pointer = uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_new(FfiConverterUInt64.lower(id, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString));
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeDeviceIdObjectFactory.bless(pointer);
-  }
-  static fromHexString(hexString) {
-    return FfiConverterTypeDeviceId.lift(uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_from_hex_string(FfiConverterString.lower(hexString, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  toHexString() {
-    return ((__rb) => {
-      try {
-        return FfiConverterString.lift(__rb);
-      } finally {
-        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_hex_string(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  toU64() {
-    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_u64(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  equals(other) {
-    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_eq_eq(uniffiTypeDeviceIdObjectFactory.clonePointer(this), FfiConverterTypeDeviceId.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  hashCode() {
-    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_hash(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  uniffiDestroy() {
-    const ptr = this[destructorGuardSymbol];
-    if (ptr !== undefined) {
-      const pointer = uniffiTypeDeviceIdObjectFactory.pointer(this);
-      uniffiTypeDeviceIdObjectFactory.freePointer(pointer);
-      uniffiTypeDeviceIdObjectFactory.unbless(ptr);
-      delete this[destructorGuardSymbol];
-    }
-  }
-  static instanceOf(obj_) {
-    return uniffiTypeDeviceIdObjectFactory.isConcreteType(obj_);
-  }
-}
-var uniffiTypeDeviceIdObjectFactory = (() => {
-  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
-    uniffiTypeDeviceIdObjectFactory.freePointer(heldValue);
-  }) : null;
-  return {
-    create(pointer) {
-      const instance = Object.create(DeviceId.prototype);
-      instance[pointerLiteralSymbol] = pointer;
-      instance[destructorGuardSymbol] = this.bless(pointer);
-      instance[uniffiTypeNameSymbol] = "DeviceId";
-      return instance;
-    },
-    bless(p) {
-      const ptr = {
-        p,
-        markDestroyed: () => {
-          return;
-        }
-      };
-      if (registry) {
-        registry.register(ptr, p, ptr);
-      }
-      return ptr;
-    },
-    unbless(ptr_) {
-      if (registry) {
-        registry.unregister(ptr_);
-      }
-    },
-    pointer(obj_) {
-      if (obj_[destructorGuardSymbol] === undefined) {
-        throw new UniffiInternalError.UnexpectedNullPointer;
-      }
-      return obj_[pointerLiteralSymbol];
-    },
-    clonePointer(obj_) {
-      const pointer = this.pointer(obj_);
-      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_deviceid(pointer, callStatus), FfiConverterString.lift);
-    },
-    freePointer(pointer) {
-      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_deviceid(pointer, callStatus), FfiConverterString.lift);
-    },
-    isConcreteType(obj_) {
-      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "DeviceId";
-    }
-  };
-})();
-var FfiConverterTypeDeviceId = new FfiConverterObject(uniffiTypeDeviceIdObjectFactory);
-var DeserializedClientId = (() => {
+var BuildMetadata = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -2918,603 +2496,722 @@ var DeserializedClientId = (() => {
   return Object.freeze({
     create,
     new: create,
-    defaults: () => Object.freeze(defaults()),
-    toString(self_) {
-      return ((__rb) => {
-        try {
-          return FfiConverterString.lift(__rb);
-        } finally {
-          core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
-        }
-      })(uniffiCaller.rustCall((callStatus) => {
-        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deserializedclientid_uniffi_trait_display(FfiConverterTypeDeserializedClientId.lower(self_, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-      }, FfiConverterString.lift.bind(FfiConverterString)));
-    }
+    defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeDeserializedClientId = (() => {
+var FfiConverterTypeBuildMetadata = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        clientId: FfiConverterTypeClientId.read(from),
-        userId: FfiConverterTypeUuid.read(from),
-        deviceId: FfiConverterTypeDeviceId.read(from),
-        domain: FfiConverterString.read(from)
+        timestamp: FfiConverterString.read(from),
+        cargoDebug: FfiConverterString.read(from),
+        cargoFeatures: FfiConverterString.read(from),
+        optLevel: FfiConverterString.read(from),
+        targetTriple: FfiConverterString.read(from),
+        gitBranch: FfiConverterString.read(from),
+        gitDescribe: FfiConverterString.read(from),
+        gitSha: FfiConverterString.read(from),
+        gitDirty: FfiConverterString.read(from)
       };
     }
     write(value, into) {
-      FfiConverterTypeClientId.write(value.clientId, into);
-      FfiConverterTypeUuid.write(value.userId, into);
-      FfiConverterTypeDeviceId.write(value.deviceId, into);
-      FfiConverterString.write(value.domain, into);
+      FfiConverterString.write(value.timestamp, into);
+      FfiConverterString.write(value.cargoDebug, into);
+      FfiConverterString.write(value.cargoFeatures, into);
+      FfiConverterString.write(value.optLevel, into);
+      FfiConverterString.write(value.targetTriple, into);
+      FfiConverterString.write(value.gitBranch, into);
+      FfiConverterString.write(value.gitDescribe, into);
+      FfiConverterString.write(value.gitSha, into);
+      FfiConverterString.write(value.gitDirty, into);
     }
     allocationSize(value) {
-      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterTypeUuid.allocationSize(value.userId) + FfiConverterTypeDeviceId.allocationSize(value.deviceId) + FfiConverterString.allocationSize(value.domain);
+      return FfiConverterString.allocationSize(value.timestamp) + FfiConverterString.allocationSize(value.cargoDebug) + FfiConverterString.allocationSize(value.cargoFeatures) + FfiConverterString.allocationSize(value.optLevel) + FfiConverterString.allocationSize(value.targetTriple) + FfiConverterString.allocationSize(value.gitBranch) + FfiConverterString.allocationSize(value.gitDescribe) + FfiConverterString.allocationSize(value.gitSha) + FfiConverterString.allocationSize(value.gitDirty);
     }
   }
   return new FFIConverter;
 })();
-
-class ClientId extends UniffiAbstractObject {
-  [uniffiTypeNameSymbol] = "ClientId";
-  [destructorGuardSymbol];
-  [pointerLiteralSymbol];
-  constructor(userId, deviceId, domain) {
-    super();
-    const pointer = uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_clientid_new(FfiConverterTypeUuid.lower(userId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterTypeDeviceId.lower(deviceId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterString.lower(domain, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString));
-    this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeClientIdObjectFactory.bless(pointer);
-  }
-  copyBytes() {
-    return ((__rb) => {
-      try {
-        return FfiConverterUint8Array.lift(__rb);
-      } finally {
-        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_copy_bytes(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  deserialize() {
-    return ((__rb) => {
-      try {
-        return FfiConverterTypeDeserializedClientId.lift(__rb);
-      } finally {
-        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_deserialize(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
-  }
-  equals(other) {
-    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_uniffi_trait_eq_eq(uniffiTypeClientIdObjectFactory.clonePointer(this), FfiConverterTypeClientId.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
+var MlsError_Tags;
+((MlsError_Tags2) => {
+  MlsError_Tags2["ConversationAlreadyExists"] = "ConversationAlreadyExists";
+  MlsError_Tags2["DuplicateMessage"] = "DuplicateMessage";
+  MlsError_Tags2["BufferedFutureMessage"] = "BufferedFutureMessage";
+  MlsError_Tags2["WrongEpoch"] = "WrongEpoch";
+  MlsError_Tags2["BufferedCommit"] = "BufferedCommit";
+  MlsError_Tags2["MessageEpochTooOld"] = "MessageEpochTooOld";
+  MlsError_Tags2["SelfCommitIgnored"] = "SelfCommitIgnored";
+  MlsError_Tags2["UnmergedPendingGroup"] = "UnmergedPendingGroup";
+  MlsError_Tags2["StaleProposal"] = "StaleProposal";
+  MlsError_Tags2["StaleCommit"] = "StaleCommit";
+  MlsError_Tags2["OrphanWelcome"] = "OrphanWelcome";
+  MlsError_Tags2["MessageRejected"] = "MessageRejected";
+  MlsError_Tags2["Other"] = "Other";
+})(MlsError_Tags ||= {});
+var MlsError = (() => {
+
+  class ConversationAlreadyExists_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "ConversationAlreadyExists" /* ConversationAlreadyExists */;
+    inner;
+    constructor(inner) {
+      super("MlsError", "ConversationAlreadyExists");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ConversationAlreadyExists_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "ConversationAlreadyExists" /* ConversationAlreadyExists */;
+    }
+    static hasInner(obj) {
+      return ConversationAlreadyExists_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
   }
-  hashCode() {
-    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_uniffi_trait_hash(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
-    }, FfiConverterString.lift.bind(FfiConverterString)));
+
+  class DuplicateMessage_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "DuplicateMessage" /* DuplicateMessage */;
+    constructor() {
+      super("MlsError", "DuplicateMessage");
+    }
+    static new() {
+      return new DuplicateMessage_;
+    }
+    static instanceOf(obj) {
+      return obj.tag === "DuplicateMessage" /* DuplicateMessage */;
+    }
+    static hasInner(obj) {
+      return false;
+    }
   }
-  uniffiDestroy() {
-    const ptr = this[destructorGuardSymbol];
-    if (ptr !== undefined) {
-      const pointer = uniffiTypeClientIdObjectFactory.pointer(this);
-      uniffiTypeClientIdObjectFactory.freePointer(pointer);
-      uniffiTypeClientIdObjectFactory.unbless(ptr);
-      delete this[destructorGuardSymbol];
+
+  class BufferedFutureMessage_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "BufferedFutureMessage" /* BufferedFutureMessage */;
+    constructor() {
+      super("MlsError", "BufferedFutureMessage");
+    }
+    static new() {
+      return new BufferedFutureMessage_;
+    }
+    static instanceOf(obj) {
+      return obj.tag === "BufferedFutureMessage" /* BufferedFutureMessage */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  static instanceOf(obj_) {
-    return uniffiTypeClientIdObjectFactory.isConcreteType(obj_);
+
+  class WrongEpoch_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "WrongEpoch" /* WrongEpoch */;
+    constructor() {
+      super("MlsError", "WrongEpoch");
+    }
+    static new() {
+      return new WrongEpoch_;
+    }
+    static instanceOf(obj) {
+      return obj.tag === "WrongEpoch" /* WrongEpoch */;
+    }
+    static hasInner(obj) {
+      return false;
+    }
   }
-}
-var uniffiTypeClientIdObjectFactory = (() => {
-  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
-    uniffiTypeClientIdObjectFactory.freePointer(heldValue);
-  }) : null;
-  return {
-    create(pointer) {
-      const instance = Object.create(ClientId.prototype);
-      instance[pointerLiteralSymbol] = pointer;
-      instance[destructorGuardSymbol] = this.bless(pointer);
-      instance[uniffiTypeNameSymbol] = "ClientId";
-      return instance;
-    },
-    bless(p) {
-      const ptr = {
-        p,
-        markDestroyed: () => {
-          return;
-        }
-      };
-      if (registry) {
-        registry.register(ptr, p, ptr);
-      }
-      return ptr;
-    },
-    unbless(ptr_) {
-      if (registry) {
-        registry.unregister(ptr_);
-      }
-    },
-    pointer(obj_) {
-      if (obj_[destructorGuardSymbol] === undefined) {
-        throw new UniffiInternalError.UnexpectedNullPointer;
-      }
-      return obj_[pointerLiteralSymbol];
-    },
-    clonePointer(obj_) {
-      const pointer = this.pointer(obj_);
-      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_clientid(pointer, callStatus), FfiConverterString.lift);
-    },
-    freePointer(pointer) {
-      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_clientid(pointer, callStatus), FfiConverterString.lift);
-    },
-    isConcreteType(obj_) {
-      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ClientId";
+
+  class BufferedCommit_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "BufferedCommit" /* BufferedCommit */;
+    constructor() {
+      super("MlsError", "BufferedCommit");
     }
-  };
-})();
-var FfiConverterTypeClientId = new FfiConverterObject(uniffiTypeClientIdObjectFactory);
-var DeviceStatus;
-((DeviceStatus2) => {
-  DeviceStatus2[DeviceStatus2["Valid"] = 1] = "Valid";
-  DeviceStatus2[DeviceStatus2["Expired"] = 2] = "Expired";
-  DeviceStatus2[DeviceStatus2["Revoked"] = 3] = "Revoked";
-})(DeviceStatus ||= {});
-var FfiConverterTypeDeviceStatus = (() => {
-  const ordinalConverter = FfiConverterInt32;
+    static new() {
+      return new BufferedCommit_;
+    }
+    static instanceOf(obj) {
+      return obj.tag === "BufferedCommit" /* BufferedCommit */;
+    }
+    static hasInner(obj) {
+      return false;
+    }
+  }
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return 1 /* Valid */;
-        case 2:
-          return 2 /* Expired */;
-        case 3:
-          return 3 /* Revoked */;
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
-      }
+  class MessageEpochTooOld_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "MessageEpochTooOld" /* MessageEpochTooOld */;
+    constructor() {
+      super("MlsError", "MessageEpochTooOld");
     }
-    write(value, into) {
-      switch (value) {
-        case 1 /* Valid */:
-          return ordinalConverter.write(1, into);
-        case 2 /* Expired */:
-          return ordinalConverter.write(2, into);
-        case 3 /* Revoked */:
-          return ordinalConverter.write(3, into);
-      }
+    static new() {
+      return new MessageEpochTooOld_;
     }
-    allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+    static instanceOf(obj) {
+      return obj.tag === "MessageEpochTooOld" /* MessageEpochTooOld */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var CredentialType;
-((CredentialType2) => {
-  CredentialType2[CredentialType2["Basic"] = 1] = "Basic";
-  CredentialType2[CredentialType2["X509"] = 2] = "X509";
-})(CredentialType ||= {});
-var FfiConverterTypeCredentialType = (() => {
-  const ordinalConverter = FfiConverterInt32;
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return 1 /* Basic */;
-        case 2:
-          return 2 /* X509 */;
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
-      }
+  class SelfCommitIgnored_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "SelfCommitIgnored" /* SelfCommitIgnored */;
+    constructor() {
+      super("MlsError", "SelfCommitIgnored");
     }
-    write(value, into) {
-      switch (value) {
-        case 1 /* Basic */:
-          return ordinalConverter.write(1, into);
-        case 2 /* X509 */:
-          return ordinalConverter.write(2, into);
-      }
+    static new() {
+      return new SelfCommitIgnored_;
     }
-    allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+    static instanceOf(obj) {
+      return obj.tag === "SelfCommitIgnored" /* SelfCommitIgnored */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var FfiConverterTypeTimestamp = FfiConverterTimestamp;
-var X509Identity = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults())
-  });
-})();
-var FfiConverterTypeX509Identity = (() => {
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      return {
-        handle: FfiConverterString.read(from),
-        displayName: FfiConverterString.read(from),
-        domain: FfiConverterString.read(from),
-        certificate: FfiConverterString.read(from),
-        serialNumber: FfiConverterString.read(from),
-        notBefore: FfiConverterTypeTimestamp.read(from),
-        notAfter: FfiConverterTypeTimestamp.read(from)
-      };
+  class UnmergedPendingGroup_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "UnmergedPendingGroup" /* UnmergedPendingGroup */;
+    constructor() {
+      super("MlsError", "UnmergedPendingGroup");
     }
-    write(value, into) {
-      FfiConverterString.write(value.handle, into);
-      FfiConverterString.write(value.displayName, into);
-      FfiConverterString.write(value.domain, into);
-      FfiConverterString.write(value.certificate, into);
-      FfiConverterString.write(value.serialNumber, into);
-      FfiConverterTypeTimestamp.write(value.notBefore, into);
-      FfiConverterTypeTimestamp.write(value.notAfter, into);
+    static new() {
+      return new UnmergedPendingGroup_;
     }
-    allocationSize(value) {
-      return FfiConverterString.allocationSize(value.handle) + FfiConverterString.allocationSize(value.displayName) + FfiConverterString.allocationSize(value.domain) + FfiConverterString.allocationSize(value.certificate) + FfiConverterString.allocationSize(value.serialNumber) + FfiConverterTypeTimestamp.allocationSize(value.notBefore) + FfiConverterTypeTimestamp.allocationSize(value.notAfter);
+    static instanceOf(obj) {
+      return obj.tag === "UnmergedPendingGroup" /* UnmergedPendingGroup */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var WireIdentity = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults())
-  });
-})();
-var FfiConverterTypeWireIdentity = (() => {
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      return {
-        clientId: FfiConverterOptionalTypeClientId.read(from),
-        status: FfiConverterTypeDeviceStatus.read(from),
-        thumbprint: FfiConverterString.read(from),
-        credentialType: FfiConverterTypeCredentialType.read(from),
-        x509Identity: FfiConverterOptionalTypeX509Identity.read(from)
-      };
+  class StaleProposal_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "StaleProposal" /* StaleProposal */;
+    constructor() {
+      super("MlsError", "StaleProposal");
     }
-    write(value, into) {
-      FfiConverterOptionalTypeClientId.write(value.clientId, into);
-      FfiConverterTypeDeviceStatus.write(value.status, into);
-      FfiConverterString.write(value.thumbprint, into);
-      FfiConverterTypeCredentialType.write(value.credentialType, into);
-      FfiConverterOptionalTypeX509Identity.write(value.x509Identity, into);
+    static new() {
+      return new StaleProposal_;
     }
-    allocationSize(value) {
-      return FfiConverterOptionalTypeClientId.allocationSize(value.clientId) + FfiConverterTypeDeviceStatus.allocationSize(value.status) + FfiConverterString.allocationSize(value.thumbprint) + FfiConverterTypeCredentialType.allocationSize(value.credentialType) + FfiConverterOptionalTypeX509Identity.allocationSize(value.x509Identity);
+    static instanceOf(obj) {
+      return obj.tag === "StaleProposal" /* StaleProposal */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var BufferedDecryptedMessage = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults())
-  });
-})();
-var FfiConverterTypeBufferedDecryptedMessage = (() => {
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      return {
-        message: FfiConverterOptionalBytes.read(from),
-        isActive: FfiConverterBool.read(from),
-        commitDelay: FfiConverterOptionalUInt64.read(from),
-        senderClientId: FfiConverterOptionalTypeClientId.read(from),
-        identity: FfiConverterTypeWireIdentity.read(from)
-      };
+  class StaleCommit_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "StaleCommit" /* StaleCommit */;
+    constructor() {
+      super("MlsError", "StaleCommit");
     }
-    write(value, into) {
-      FfiConverterOptionalBytes.write(value.message, into);
-      FfiConverterBool.write(value.isActive, into);
-      FfiConverterOptionalUInt64.write(value.commitDelay, into);
-      FfiConverterOptionalTypeClientId.write(value.senderClientId, into);
-      FfiConverterTypeWireIdentity.write(value.identity, into);
+    static new() {
+      return new StaleCommit_;
     }
-    allocationSize(value) {
-      return FfiConverterOptionalBytes.allocationSize(value.message) + FfiConverterBool.allocationSize(value.isActive) + FfiConverterOptionalUInt64.allocationSize(value.commitDelay) + FfiConverterOptionalTypeClientId.allocationSize(value.senderClientId) + FfiConverterTypeWireIdentity.allocationSize(value.identity);
+    static instanceOf(obj) {
+      return obj.tag === "StaleCommit" /* StaleCommit */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var BuildMetadata = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults())
-  });
-})();
-var FfiConverterTypeBuildMetadata = (() => {
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      return {
-        timestamp: FfiConverterString.read(from),
-        cargoDebug: FfiConverterString.read(from),
-        cargoFeatures: FfiConverterString.read(from),
-        optLevel: FfiConverterString.read(from),
-        targetTriple: FfiConverterString.read(from),
-        gitBranch: FfiConverterString.read(from),
-        gitDescribe: FfiConverterString.read(from),
-        gitSha: FfiConverterString.read(from),
-        gitDirty: FfiConverterString.read(from)
-      };
+  class OrphanWelcome_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "MlsError";
+    tag = "OrphanWelcome" /* OrphanWelcome */;
+    constructor() {
+      super("MlsError", "OrphanWelcome");
     }
-    write(value, into) {
-      FfiConverterString.write(value.timestamp, into);
-      FfiConverterString.write(value.cargoDebug, into);
-      FfiConverterString.write(value.cargoFeatures, into);
-      FfiConverterString.write(value.optLevel, into);
-      FfiConverterString.write(value.targetTriple, into);
-      FfiConverterString.write(value.gitBranch, into);
-      FfiConverterString.write(value.gitDescribe, into);
-      FfiConverterString.write(value.gitSha, into);
-      FfiConverterString.write(value.gitDirty, into);
+    static new() {
+      return new OrphanWelcome_;
     }
-    allocationSize(value) {
-      return FfiConverterString.allocationSize(value.timestamp) + FfiConverterString.allocationSize(value.cargoDebug) + FfiConverterString.allocationSize(value.cargoFeatures) + FfiConverterString.allocationSize(value.optLevel) + FfiConverterString.allocationSize(value.targetTriple) + FfiConverterString.allocationSize(value.gitBranch) + FfiConverterString.allocationSize(value.gitDescribe) + FfiConverterString.allocationSize(value.gitSha) + FfiConverterString.allocationSize(value.gitDirty);
+    static instanceOf(obj) {
+      return obj.tag === "OrphanWelcome" /* OrphanWelcome */;
+    }
+    static hasInner(obj) {
+      return false;
     }
   }
-  return new FFIConverter;
-})();
-var MlsError_Tags;
-((MlsError_Tags2) => {
-  MlsError_Tags2["ConversationAlreadyExists"] = "ConversationAlreadyExists";
-  MlsError_Tags2["DuplicateMessage"] = "DuplicateMessage";
-  MlsError_Tags2["BufferedFutureMessage"] = "BufferedFutureMessage";
-  MlsError_Tags2["WrongEpoch"] = "WrongEpoch";
-  MlsError_Tags2["BufferedCommit"] = "BufferedCommit";
-  MlsError_Tags2["MessageEpochTooOld"] = "MessageEpochTooOld";
-  MlsError_Tags2["SelfCommitIgnored"] = "SelfCommitIgnored";
-  MlsError_Tags2["UnmergedPendingGroup"] = "UnmergedPendingGroup";
-  MlsError_Tags2["StaleProposal"] = "StaleProposal";
-  MlsError_Tags2["StaleCommit"] = "StaleCommit";
-  MlsError_Tags2["OrphanWelcome"] = "OrphanWelcome";
-  MlsError_Tags2["MessageRejected"] = "MessageRejected";
-  MlsError_Tags2["Other"] = "Other";
-})(MlsError_Tags ||= {});
-var MlsError = (() => {
 
-  class ConversationAlreadyExists_ extends UniffiError {
+  class MessageRejected_ extends UniffiError {
     [uniffiTypeNameSymbol] = "MlsError";
-    tag = "ConversationAlreadyExists" /* ConversationAlreadyExists */;
+    tag = "MessageRejected" /* MessageRejected */;
     inner;
     constructor(inner) {
-      super("MlsError", "ConversationAlreadyExists");
+      super("MlsError", "MessageRejected");
       this.inner = Object.freeze(inner);
     }
     static new(inner) {
-      return new ConversationAlreadyExists_(inner);
+      return new MessageRejected_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "ConversationAlreadyExists" /* ConversationAlreadyExists */;
+      return obj.tag === "MessageRejected" /* MessageRejected */;
     }
     static hasInner(obj) {
-      return ConversationAlreadyExists_.instanceOf(obj);
+      return MessageRejected_.instanceOf(obj);
     }
     static getInner(obj) {
       return obj.inner;
     }
   }
 
-  class DuplicateMessage_ extends UniffiError {
+  class Other_ extends UniffiError {
     [uniffiTypeNameSymbol] = "MlsError";
-    tag = "DuplicateMessage" /* DuplicateMessage */;
-    constructor() {
-      super("MlsError", "DuplicateMessage");
+    tag = "Other" /* Other */;
+    inner;
+    constructor(inner) {
+      super("MlsError", "Other");
+      this.inner = Object.freeze(inner);
     }
-    static new() {
-      return new DuplicateMessage_;
+    static new(inner) {
+      return new Other_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "DuplicateMessage" /* DuplicateMessage */;
+      return obj.tag === "Other" /* Other */;
     }
     static hasInner(obj) {
-      return false;
+      return Other_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
     }
   }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "MlsError";
+  }
+  return Object.freeze({
+    instanceOf,
+    ConversationAlreadyExists: ConversationAlreadyExists_,
+    DuplicateMessage: DuplicateMessage_,
+    BufferedFutureMessage: BufferedFutureMessage_,
+    WrongEpoch: WrongEpoch_,
+    BufferedCommit: BufferedCommit_,
+    MessageEpochTooOld: MessageEpochTooOld_,
+    SelfCommitIgnored: SelfCommitIgnored_,
+    UnmergedPendingGroup: UnmergedPendingGroup_,
+    StaleProposal: StaleProposal_,
+    StaleCommit: StaleCommit_,
+    OrphanWelcome: OrphanWelcome_,
+    MessageRejected: MessageRejected_,
+    Other: Other_
+  });
+})();
+var FfiConverterTypeMlsError = (() => {
+  const ordinalConverter = FfiConverterInt32;
 
-  class BufferedFutureMessage_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "BufferedFutureMessage" /* BufferedFutureMessage */;
-    constructor() {
-      super("MlsError", "BufferedFutureMessage");
-    }
-    static new() {
-      return new BufferedFutureMessage_;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new MlsError.ConversationAlreadyExists({ conversationId: FfiConverterUint8Array.read(from) });
+        case 2:
+          return new MlsError.DuplicateMessage;
+        case 3:
+          return new MlsError.BufferedFutureMessage;
+        case 4:
+          return new MlsError.WrongEpoch;
+        case 5:
+          return new MlsError.BufferedCommit;
+        case 6:
+          return new MlsError.MessageEpochTooOld;
+        case 7:
+          return new MlsError.SelfCommitIgnored;
+        case 8:
+          return new MlsError.UnmergedPendingGroup;
+        case 9:
+          return new MlsError.StaleProposal;
+        case 10:
+          return new MlsError.StaleCommit;
+        case 11:
+          return new MlsError.OrphanWelcome;
+        case 12:
+          return new MlsError.MessageRejected({ reason: FfiConverterString.read(from) });
+        case 13:
+          return new MlsError.Other({ msg: FfiConverterString.read(from) });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
-    static instanceOf(obj) {
-      return obj.tag === "BufferedFutureMessage" /* BufferedFutureMessage */;
+    write(value, into) {
+      switch (value.tag) {
+        case "ConversationAlreadyExists" /* ConversationAlreadyExists */: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterUint8Array.write(inner.conversationId, into);
+          return;
+        }
+        case "DuplicateMessage" /* DuplicateMessage */: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        case "BufferedFutureMessage" /* BufferedFutureMessage */: {
+          ordinalConverter.write(3, into);
+          return;
+        }
+        case "WrongEpoch" /* WrongEpoch */: {
+          ordinalConverter.write(4, into);
+          return;
+        }
+        case "BufferedCommit" /* BufferedCommit */: {
+          ordinalConverter.write(5, into);
+          return;
+        }
+        case "MessageEpochTooOld" /* MessageEpochTooOld */: {
+          ordinalConverter.write(6, into);
+          return;
+        }
+        case "SelfCommitIgnored" /* SelfCommitIgnored */: {
+          ordinalConverter.write(7, into);
+          return;
+        }
+        case "UnmergedPendingGroup" /* UnmergedPendingGroup */: {
+          ordinalConverter.write(8, into);
+          return;
+        }
+        case "StaleProposal" /* StaleProposal */: {
+          ordinalConverter.write(9, into);
+          return;
+        }
+        case "StaleCommit" /* StaleCommit */: {
+          ordinalConverter.write(10, into);
+          return;
+        }
+        case "OrphanWelcome" /* OrphanWelcome */: {
+          ordinalConverter.write(11, into);
+          return;
+        }
+        case "MessageRejected" /* MessageRejected */: {
+          ordinalConverter.write(12, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.reason, into);
+          return;
+        }
+        case "Other" /* Other */: {
+          ordinalConverter.write(13, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.msg, into);
+          return;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
-    static hasInner(obj) {
-      return false;
+    allocationSize(value) {
+      switch (value.tag) {
+        case "ConversationAlreadyExists" /* ConversationAlreadyExists */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterUint8Array.allocationSize(inner.conversationId);
+          return size;
+        }
+        case "DuplicateMessage" /* DuplicateMessage */: {
+          return ordinalConverter.allocationSize(2);
+        }
+        case "BufferedFutureMessage" /* BufferedFutureMessage */: {
+          return ordinalConverter.allocationSize(3);
+        }
+        case "WrongEpoch" /* WrongEpoch */: {
+          return ordinalConverter.allocationSize(4);
+        }
+        case "BufferedCommit" /* BufferedCommit */: {
+          return ordinalConverter.allocationSize(5);
+        }
+        case "MessageEpochTooOld" /* MessageEpochTooOld */: {
+          return ordinalConverter.allocationSize(6);
+        }
+        case "SelfCommitIgnored" /* SelfCommitIgnored */: {
+          return ordinalConverter.allocationSize(7);
+        }
+        case "UnmergedPendingGroup" /* UnmergedPendingGroup */: {
+          return ordinalConverter.allocationSize(8);
+        }
+        case "StaleProposal" /* StaleProposal */: {
+          return ordinalConverter.allocationSize(9);
+        }
+        case "StaleCommit" /* StaleCommit */: {
+          return ordinalConverter.allocationSize(10);
+        }
+        case "OrphanWelcome" /* OrphanWelcome */: {
+          return ordinalConverter.allocationSize(11);
+        }
+        case "MessageRejected" /* MessageRejected */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(12);
+          size += FfiConverterString.allocationSize(inner.reason);
+          return size;
+        }
+        case "Other" /* Other */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(13);
+          size += FfiConverterString.allocationSize(inner.msg);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
   }
+  return new FFIConverter;
+})();
+var ProteusError_Tags;
+((ProteusError_Tags2) => {
+  ProteusError_Tags2["SessionNotFound"] = "SessionNotFound";
+  ProteusError_Tags2["DuplicateMessage"] = "DuplicateMessage";
+  ProteusError_Tags2["RemoteIdentityChanged"] = "RemoteIdentityChanged";
+  ProteusError_Tags2["Other"] = "Other";
+})(ProteusError_Tags ||= {});
+var ProteusError = (() => {
 
-  class WrongEpoch_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "WrongEpoch" /* WrongEpoch */;
+  class SessionNotFound_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "ProteusError";
+    tag = "SessionNotFound" /* SessionNotFound */;
     constructor() {
-      super("MlsError", "WrongEpoch");
+      super("ProteusError", "SessionNotFound");
     }
     static new() {
-      return new WrongEpoch_;
+      return new SessionNotFound_;
     }
     static instanceOf(obj) {
-      return obj.tag === "WrongEpoch" /* WrongEpoch */;
+      return obj.tag === "SessionNotFound" /* SessionNotFound */;
     }
     static hasInner(obj) {
       return false;
     }
   }
 
-  class BufferedCommit_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "BufferedCommit" /* BufferedCommit */;
+  class DuplicateMessage_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "ProteusError";
+    tag = "DuplicateMessage" /* DuplicateMessage */;
     constructor() {
-      super("MlsError", "BufferedCommit");
+      super("ProteusError", "DuplicateMessage");
     }
     static new() {
-      return new BufferedCommit_;
+      return new DuplicateMessage_;
     }
     static instanceOf(obj) {
-      return obj.tag === "BufferedCommit" /* BufferedCommit */;
+      return obj.tag === "DuplicateMessage" /* DuplicateMessage */;
     }
     static hasInner(obj) {
       return false;
     }
   }
 
-  class MessageEpochTooOld_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "MessageEpochTooOld" /* MessageEpochTooOld */;
+  class RemoteIdentityChanged_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "ProteusError";
+    tag = "RemoteIdentityChanged" /* RemoteIdentityChanged */;
     constructor() {
-      super("MlsError", "MessageEpochTooOld");
+      super("ProteusError", "RemoteIdentityChanged");
     }
     static new() {
-      return new MessageEpochTooOld_;
+      return new RemoteIdentityChanged_;
     }
     static instanceOf(obj) {
-      return obj.tag === "MessageEpochTooOld" /* MessageEpochTooOld */;
+      return obj.tag === "RemoteIdentityChanged" /* RemoteIdentityChanged */;
     }
     static hasInner(obj) {
       return false;
     }
   }
 
-  class SelfCommitIgnored_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "SelfCommitIgnored" /* SelfCommitIgnored */;
-    constructor() {
-      super("MlsError", "SelfCommitIgnored");
+  class Other_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "ProteusError";
+    tag = "Other" /* Other */;
+    inner;
+    constructor(inner) {
+      super("ProteusError", "Other");
+      this.inner = Object.freeze(inner);
     }
-    static new() {
-      return new SelfCommitIgnored_;
+    static new(inner) {
+      return new Other_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "SelfCommitIgnored" /* SelfCommitIgnored */;
+      return obj.tag === "Other" /* Other */;
     }
     static hasInner(obj) {
-      return false;
+      return Other_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
     }
   }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "ProteusError";
+  }
+  return Object.freeze({
+    instanceOf,
+    SessionNotFound: SessionNotFound_,
+    DuplicateMessage: DuplicateMessage_,
+    RemoteIdentityChanged: RemoteIdentityChanged_,
+    Other: Other_
+  });
+})();
+var FfiConverterTypeProteusError = (() => {
+  const ordinalConverter = FfiConverterInt32;
 
-  class UnmergedPendingGroup_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "UnmergedPendingGroup" /* UnmergedPendingGroup */;
-    constructor() {
-      super("MlsError", "UnmergedPendingGroup");
-    }
-    static new() {
-      return new UnmergedPendingGroup_;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new ProteusError.SessionNotFound;
+        case 2:
+          return new ProteusError.DuplicateMessage;
+        case 3:
+          return new ProteusError.RemoteIdentityChanged;
+        case 4:
+          return new ProteusError.Other({ errorCode: FfiConverterUInt16.read(from) });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
-    static instanceOf(obj) {
-      return obj.tag === "UnmergedPendingGroup" /* UnmergedPendingGroup */;
+    write(value, into) {
+      switch (value.tag) {
+        case "SessionNotFound" /* SessionNotFound */: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case "DuplicateMessage" /* DuplicateMessage */: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        case "RemoteIdentityChanged" /* RemoteIdentityChanged */: {
+          ordinalConverter.write(3, into);
+          return;
+        }
+        case "Other" /* Other */: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterUInt16.write(inner.errorCode, into);
+          return;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
-    static hasInner(obj) {
-      return false;
+    allocationSize(value) {
+      switch (value.tag) {
+        case "SessionNotFound" /* SessionNotFound */: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case "DuplicateMessage" /* DuplicateMessage */: {
+          return ordinalConverter.allocationSize(2);
+        }
+        case "RemoteIdentityChanged" /* RemoteIdentityChanged */: {
+          return ordinalConverter.allocationSize(3);
+        }
+        case "Other" /* Other */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterUInt16.allocationSize(inner.errorCode);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
   }
+  return new FFIConverter;
+})();
+var CoreCryptoError_Tags;
+((CoreCryptoError_Tags2) => {
+  CoreCryptoError_Tags2["Mls"] = "Mls";
+  CoreCryptoError_Tags2["Proteus"] = "Proteus";
+  CoreCryptoError_Tags2["E2ei"] = "E2ei";
+  CoreCryptoError_Tags2["TransactionFailed"] = "TransactionFailed";
+  CoreCryptoError_Tags2["Other"] = "Other";
+})(CoreCryptoError_Tags ||= {});
+var CoreCryptoError = (() => {
 
-  class StaleProposal_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "StaleProposal" /* StaleProposal */;
-    constructor() {
-      super("MlsError", "StaleProposal");
+  class Mls_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "CoreCryptoError";
+    tag = "Mls" /* Mls */;
+    inner;
+    constructor(inner) {
+      super("CoreCryptoError", "Mls");
+      this.inner = Object.freeze(inner);
     }
-    static new() {
-      return new StaleProposal_;
+    static new(inner) {
+      return new Mls_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "StaleProposal" /* StaleProposal */;
+      return obj.tag === "Mls" /* Mls */;
     }
     static hasInner(obj) {
-      return false;
+      return Mls_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
     }
   }
 
-  class StaleCommit_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "StaleCommit" /* StaleCommit */;
-    constructor() {
-      super("MlsError", "StaleCommit");
+  class Proteus_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "CoreCryptoError";
+    tag = "Proteus" /* Proteus */;
+    inner;
+    constructor(inner) {
+      super("CoreCryptoError", "Proteus");
+      this.inner = Object.freeze(inner);
     }
-    static new() {
-      return new StaleCommit_;
+    static new(inner) {
+      return new Proteus_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "StaleCommit" /* StaleCommit */;
+      return obj.tag === "Proteus" /* Proteus */;
     }
     static hasInner(obj) {
-      return false;
+      return Proteus_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
     }
   }
 
-  class OrphanWelcome_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "OrphanWelcome" /* OrphanWelcome */;
-    constructor() {
-      super("MlsError", "OrphanWelcome");
+  class E2ei_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "CoreCryptoError";
+    tag = "E2ei" /* E2ei */;
+    inner;
+    constructor(inner) {
+      super("CoreCryptoError", "E2ei");
+      this.inner = Object.freeze(inner);
     }
-    static new() {
-      return new OrphanWelcome_;
+    static new(inner) {
+      return new E2ei_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "OrphanWelcome" /* OrphanWelcome */;
+      return obj.tag === "E2ei" /* E2ei */;
     }
     static hasInner(obj) {
-      return false;
+      return E2ei_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
     }
   }
 
-  class MessageRejected_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
-    tag = "MessageRejected" /* MessageRejected */;
+  class TransactionFailed_ extends UniffiError {
+    [uniffiTypeNameSymbol] = "CoreCryptoError";
+    tag = "TransactionFailed" /* TransactionFailed */;
     inner;
     constructor(inner) {
-      super("MlsError", "MessageRejected");
+      super("CoreCryptoError", "TransactionFailed");
       this.inner = Object.freeze(inner);
     }
     static new(inner) {
-      return new MessageRejected_(inner);
+      return new TransactionFailed_(inner);
     }
     static instanceOf(obj) {
-      return obj.tag === "MessageRejected" /* MessageRejected */;
+      return obj.tag === "TransactionFailed" /* TransactionFailed */;
     }
     static hasInner(obj) {
-      return MessageRejected_.instanceOf(obj);
+      return TransactionFailed_.instanceOf(obj);
     }
     static getInner(obj) {
       return obj.inner;
@@ -3522,11 +3219,11 @@ var MlsError = (() => {
   }
 
   class Other_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "MlsError";
+    [uniffiTypeNameSymbol] = "CoreCryptoError";
     tag = "Other" /* Other */;
     inner;
     constructor(inner) {
-      super("MlsError", "Other");
+      super("CoreCryptoError", "Other");
       this.inner = Object.freeze(inner);
     }
     static new(inner) {
@@ -3543,123 +3240,65 @@ var MlsError = (() => {
     }
   }
   function instanceOf(obj) {
-    return obj[uniffiTypeNameSymbol] === "MlsError";
+    return obj[uniffiTypeNameSymbol] === "CoreCryptoError";
   }
   return Object.freeze({
     instanceOf,
-    ConversationAlreadyExists: ConversationAlreadyExists_,
-    DuplicateMessage: DuplicateMessage_,
-    BufferedFutureMessage: BufferedFutureMessage_,
-    WrongEpoch: WrongEpoch_,
-    BufferedCommit: BufferedCommit_,
-    MessageEpochTooOld: MessageEpochTooOld_,
-    SelfCommitIgnored: SelfCommitIgnored_,
-    UnmergedPendingGroup: UnmergedPendingGroup_,
-    StaleProposal: StaleProposal_,
-    StaleCommit: StaleCommit_,
-    OrphanWelcome: OrphanWelcome_,
-    MessageRejected: MessageRejected_,
+    Mls: Mls_,
+    Proteus: Proteus_,
+    E2ei: E2ei_,
+    TransactionFailed: TransactionFailed_,
     Other: Other_
   });
 })();
-var FfiConverterTypeMlsError = (() => {
+var FfiConverterTypeCoreCryptoError = (() => {
   const ordinalConverter = FfiConverterInt32;
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       switch (ordinalConverter.read(from)) {
         case 1:
-          return new MlsError.ConversationAlreadyExists({
-            conversationId: FfiConverterUint8Array.read(from)
-          });
+          return new CoreCryptoError.Mls({ mlsError: FfiConverterTypeMlsError.read(from) });
         case 2:
-          return new MlsError.DuplicateMessage;
+          return new CoreCryptoError.Proteus({ exception: FfiConverterTypeProteusError.read(from) });
         case 3:
-          return new MlsError.BufferedFutureMessage;
+          return new CoreCryptoError.E2ei({ e2eiError: FfiConverterString.read(from) });
         case 4:
-          return new MlsError.WrongEpoch;
+          return new CoreCryptoError.TransactionFailed({ error: FfiConverterString.read(from) });
         case 5:
-          return new MlsError.BufferedCommit;
-        case 6:
-          return new MlsError.MessageEpochTooOld;
-        case 7:
-          return new MlsError.SelfCommitIgnored;
-        case 8:
-          return new MlsError.UnmergedPendingGroup;
-        case 9:
-          return new MlsError.StaleProposal;
-        case 10:
-          return new MlsError.StaleCommit;
-        case 11:
-          return new MlsError.OrphanWelcome;
-        case 12:
-          return new MlsError.MessageRejected({
-            reason: FfiConverterString.read(from)
-          });
-        case 13:
-          return new MlsError.Other({
-            msg: FfiConverterString.read(from)
-          });
+          return new CoreCryptoError.Other({ msg: FfiConverterString.read(from) });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase;
       }
     }
     write(value, into) {
       switch (value.tag) {
-        case "ConversationAlreadyExists" /* ConversationAlreadyExists */: {
+        case "Mls" /* Mls */: {
           ordinalConverter.write(1, into);
           const inner = value.inner;
-          FfiConverterUint8Array.write(inner.conversationId, into);
-          return;
-        }
-        case "DuplicateMessage" /* DuplicateMessage */: {
-          ordinalConverter.write(2, into);
-          return;
-        }
-        case "BufferedFutureMessage" /* BufferedFutureMessage */: {
-          ordinalConverter.write(3, into);
-          return;
-        }
-        case "WrongEpoch" /* WrongEpoch */: {
-          ordinalConverter.write(4, into);
-          return;
-        }
-        case "BufferedCommit" /* BufferedCommit */: {
-          ordinalConverter.write(5, into);
-          return;
-        }
-        case "MessageEpochTooOld" /* MessageEpochTooOld */: {
-          ordinalConverter.write(6, into);
-          return;
-        }
-        case "SelfCommitIgnored" /* SelfCommitIgnored */: {
-          ordinalConverter.write(7, into);
-          return;
-        }
-        case "UnmergedPendingGroup" /* UnmergedPendingGroup */: {
-          ordinalConverter.write(8, into);
-          return;
-        }
-        case "StaleProposal" /* StaleProposal */: {
-          ordinalConverter.write(9, into);
+          FfiConverterTypeMlsError.write(inner.mlsError, into);
           return;
         }
-        case "StaleCommit" /* StaleCommit */: {
-          ordinalConverter.write(10, into);
+        case "Proteus" /* Proteus */: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterTypeProteusError.write(inner.exception, into);
           return;
         }
-        case "OrphanWelcome" /* OrphanWelcome */: {
-          ordinalConverter.write(11, into);
+        case "E2ei" /* E2ei */: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.e2eiError, into);
           return;
         }
-        case "MessageRejected" /* MessageRejected */: {
-          ordinalConverter.write(12, into);
+        case "TransactionFailed" /* TransactionFailed */: {
+          ordinalConverter.write(4, into);
           const inner = value.inner;
-          FfiConverterString.write(inner.reason, into);
+          FfiConverterString.write(inner.error, into);
           return;
         }
         case "Other" /* Other */: {
-          ordinalConverter.write(13, into);
+          ordinalConverter.write(5, into);
           const inner = value.inner;
           FfiConverterString.write(inner.msg, into);
           return;
@@ -3670,51 +3309,33 @@ var FfiConverterTypeMlsError = (() => {
     }
     allocationSize(value) {
       switch (value.tag) {
-        case "ConversationAlreadyExists" /* ConversationAlreadyExists */: {
+        case "Mls" /* Mls */: {
           const inner = value.inner;
           let size = ordinalConverter.allocationSize(1);
-          size += FfiConverterUint8Array.allocationSize(inner.conversationId);
+          size += FfiConverterTypeMlsError.allocationSize(inner.mlsError);
           return size;
         }
-        case "DuplicateMessage" /* DuplicateMessage */: {
-          return ordinalConverter.allocationSize(2);
-        }
-        case "BufferedFutureMessage" /* BufferedFutureMessage */: {
-          return ordinalConverter.allocationSize(3);
-        }
-        case "WrongEpoch" /* WrongEpoch */: {
-          return ordinalConverter.allocationSize(4);
-        }
-        case "BufferedCommit" /* BufferedCommit */: {
-          return ordinalConverter.allocationSize(5);
-        }
-        case "MessageEpochTooOld" /* MessageEpochTooOld */: {
-          return ordinalConverter.allocationSize(6);
-        }
-        case "SelfCommitIgnored" /* SelfCommitIgnored */: {
-          return ordinalConverter.allocationSize(7);
-        }
-        case "UnmergedPendingGroup" /* UnmergedPendingGroup */: {
-          return ordinalConverter.allocationSize(8);
-        }
-        case "StaleProposal" /* StaleProposal */: {
-          return ordinalConverter.allocationSize(9);
-        }
-        case "StaleCommit" /* StaleCommit */: {
-          return ordinalConverter.allocationSize(10);
+        case "Proteus" /* Proteus */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterTypeProteusError.allocationSize(inner.exception);
+          return size;
         }
-        case "OrphanWelcome" /* OrphanWelcome */: {
-          return ordinalConverter.allocationSize(11);
+        case "E2ei" /* E2ei */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.e2eiError);
+          return size;
         }
-        case "MessageRejected" /* MessageRejected */: {
+        case "TransactionFailed" /* TransactionFailed */: {
           const inner = value.inner;
-          let size = ordinalConverter.allocationSize(12);
-          size += FfiConverterString.allocationSize(inner.reason);
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterString.allocationSize(inner.error);
           return size;
         }
         case "Other" /* Other */: {
           const inner = value.inner;
-          let size = ordinalConverter.allocationSize(13);
+          let size = ordinalConverter.allocationSize(5);
           size += FfiConverterString.allocationSize(inner.msg);
           return size;
         }
@@ -3725,449 +3346,496 @@ var FfiConverterTypeMlsError = (() => {
   }
   return new FFIConverter;
 })();
-var ProteusError_Tags;
-((ProteusError_Tags2) => {
-  ProteusError_Tags2["SessionNotFound"] = "SessionNotFound";
-  ProteusError_Tags2["DuplicateMessage"] = "DuplicateMessage";
-  ProteusError_Tags2["RemoteIdentityChanged"] = "RemoteIdentityChanged";
-  ProteusError_Tags2["Other"] = "Other";
-})(ProteusError_Tags ||= {});
-var ProteusError = (() => {
 
-  class SessionNotFound_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "ProteusError";
-    tag = "SessionNotFound" /* SessionNotFound */;
-    constructor() {
-      super("ProteusError", "SessionNotFound");
-    }
-    static new() {
-      return new SessionNotFound_;
-    }
-    static instanceOf(obj) {
-      return obj.tag === "SessionNotFound" /* SessionNotFound */;
-    }
-    static hasInner(obj) {
-      return false;
-    }
+class Welcome extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "Welcome";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(bytes) {
+    super();
+    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_welcome_new(FfiConverterUint8Array.lower(bytes, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeWelcomeObjectFactory.bless(pointer);
   }
-
-  class DuplicateMessage_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "ProteusError";
-    tag = "DuplicateMessage" /* DuplicateMessage */;
-    constructor() {
-      super("ProteusError", "DuplicateMessage");
-    }
-    static new() {
-      return new DuplicateMessage_;
-    }
-    static instanceOf(obj) {
-      return obj.tag === "DuplicateMessage" /* DuplicateMessage */;
-    }
-    static hasInner(obj) {
-      return false;
-    }
+  serialize() {
+    return ((__rb) => {
+      try {
+        return FfiConverterUint8Array.lift(__rb);
+      } finally {
+        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
+      }
+    })(uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_welcome_serialize(uniffiTypeWelcomeObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
   }
-
-  class RemoteIdentityChanged_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "ProteusError";
-    tag = "RemoteIdentityChanged" /* RemoteIdentityChanged */;
-    constructor() {
-      super("ProteusError", "RemoteIdentityChanged");
-    }
-    static new() {
-      return new RemoteIdentityChanged_;
-    }
-    static instanceOf(obj) {
-      return obj.tag === "RemoteIdentityChanged" /* RemoteIdentityChanged */;
-    }
-    static hasInner(obj) {
-      return false;
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeWelcomeObjectFactory.pointer(this);
+      uniffiTypeWelcomeObjectFactory.freePointer(pointer);
+      uniffiTypeWelcomeObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
     }
   }
-
-  class Other_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "ProteusError";
-    tag = "Other" /* Other */;
-    inner;
-    constructor(inner) {
-      super("ProteusError", "Other");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new Other_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "Other" /* Other */;
+  static instanceOf(obj_) {
+    return uniffiTypeWelcomeObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeWelcomeObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeWelcomeObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(Welcome.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Welcome";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_welcome(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_welcome(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Welcome";
     }
-    static hasInner(obj) {
-      return Other_.instanceOf(obj);
+  };
+})();
+var FfiConverterTypeWelcome = new FfiConverterObject(uniffiTypeWelcomeObjectFactory);
+var MlsGroupInfoEncryptionType;
+((MlsGroupInfoEncryptionType2) => {
+  MlsGroupInfoEncryptionType2[MlsGroupInfoEncryptionType2["Plaintext"] = 1] = "Plaintext";
+  MlsGroupInfoEncryptionType2[MlsGroupInfoEncryptionType2["JweEncrypted"] = 2] = "JweEncrypted";
+})(MlsGroupInfoEncryptionType ||= {});
+var FfiConverterTypeMlsGroupInfoEncryptionType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return 1 /* Plaintext */;
+        case 2:
+          return 2 /* JweEncrypted */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
-    static getInner(obj) {
-      return obj.inner;
+    write(value, into) {
+      switch (value) {
+        case 1 /* Plaintext */:
+          return ordinalConverter.write(1, into);
+        case 2 /* JweEncrypted */:
+          return ordinalConverter.write(2, into);
+      }
     }
-  }
-  function instanceOf(obj) {
-    return obj[uniffiTypeNameSymbol] === "ProteusError";
-  }
-  return Object.freeze({
-    instanceOf,
-    SessionNotFound: SessionNotFound_,
-    DuplicateMessage: DuplicateMessage_,
-    RemoteIdentityChanged: RemoteIdentityChanged_,
-    Other: Other_
-  });
+    allocationSize(value) {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter;
 })();
-var FfiConverterTypeProteusError = (() => {
+var MlsRatchetTreeType;
+((MlsRatchetTreeType2) => {
+  MlsRatchetTreeType2[MlsRatchetTreeType2["Full"] = 1] = "Full";
+  MlsRatchetTreeType2[MlsRatchetTreeType2["Delta"] = 2] = "Delta";
+  MlsRatchetTreeType2[MlsRatchetTreeType2["ByRef"] = 3] = "ByRef";
+})(MlsRatchetTreeType ||= {});
+var FfiConverterTypeMlsRatchetTreeType = (() => {
   const ordinalConverter = FfiConverterInt32;
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       switch (ordinalConverter.read(from)) {
         case 1:
-          return new ProteusError.SessionNotFound;
+          return 1 /* Full */;
         case 2:
-          return new ProteusError.DuplicateMessage;
+          return 2 /* Delta */;
         case 3:
-          return new ProteusError.RemoteIdentityChanged;
-        case 4:
-          return new ProteusError.Other({
-            errorCode: FfiConverterUInt16.read(from)
-          });
+          return 3 /* ByRef */;
         default:
           throw new UniffiInternalError.UnexpectedEnumCase;
       }
     }
     write(value, into) {
-      switch (value.tag) {
-        case "SessionNotFound" /* SessionNotFound */: {
-          ordinalConverter.write(1, into);
-          return;
-        }
-        case "DuplicateMessage" /* DuplicateMessage */: {
-          ordinalConverter.write(2, into);
-          return;
-        }
-        case "RemoteIdentityChanged" /* RemoteIdentityChanged */: {
-          ordinalConverter.write(3, into);
-          return;
-        }
-        case "Other" /* Other */: {
-          ordinalConverter.write(4, into);
-          const inner = value.inner;
-          FfiConverterUInt16.write(inner.errorCode, into);
-          return;
-        }
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
+      switch (value) {
+        case 1 /* Full */:
+          return ordinalConverter.write(1, into);
+        case 2 /* Delta */:
+          return ordinalConverter.write(2, into);
+        case 3 /* ByRef */:
+          return ordinalConverter.write(3, into);
       }
     }
     allocationSize(value) {
-      switch (value.tag) {
-        case "SessionNotFound" /* SessionNotFound */: {
-          return ordinalConverter.allocationSize(1);
-        }
-        case "DuplicateMessage" /* DuplicateMessage */: {
-          return ordinalConverter.allocationSize(2);
-        }
-        case "RemoteIdentityChanged" /* RemoteIdentityChanged */: {
-          return ordinalConverter.allocationSize(3);
-        }
-        case "Other" /* Other */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(4);
-          size += FfiConverterUInt16.allocationSize(inner.errorCode);
-          return size;
-        }
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
-      }
+      return ordinalConverter.allocationSize(0);
     }
   }
   return new FFIConverter;
 })();
-var CoreCryptoError_Tags;
-((CoreCryptoError_Tags2) => {
-  CoreCryptoError_Tags2["Mls"] = "Mls";
-  CoreCryptoError_Tags2["Proteus"] = "Proteus";
-  CoreCryptoError_Tags2["E2ei"] = "E2ei";
-  CoreCryptoError_Tags2["TransactionFailed"] = "TransactionFailed";
-  CoreCryptoError_Tags2["Other"] = "Other";
-})(CoreCryptoError_Tags ||= {});
-var CoreCryptoError = (() => {
+var GroupInfoBundle = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeGroupInfoBundle = (() => {
 
-  class Mls_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "CoreCryptoError";
-    tag = "Mls" /* Mls */;
-    inner;
-    constructor(inner) {
-      super("CoreCryptoError", "Mls");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new Mls_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "Mls" /* Mls */;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        encryptionType: FfiConverterTypeMlsGroupInfoEncryptionType.read(from),
+        ratchetTreeType: FfiConverterTypeMlsRatchetTreeType.read(from),
+        payload: FfiConverterUint8Array.read(from)
+      };
     }
-    static hasInner(obj) {
-      return Mls_.instanceOf(obj);
+    write(value, into) {
+      FfiConverterTypeMlsGroupInfoEncryptionType.write(value.encryptionType, into);
+      FfiConverterTypeMlsRatchetTreeType.write(value.ratchetTreeType, into);
+      FfiConverterUint8Array.write(value.payload, into);
     }
-    static getInner(obj) {
-      return obj.inner;
+    allocationSize(value) {
+      return FfiConverterTypeMlsGroupInfoEncryptionType.allocationSize(value.encryptionType) + FfiConverterTypeMlsRatchetTreeType.allocationSize(value.ratchetTreeType) + FfiConverterUint8Array.allocationSize(value.payload);
     }
   }
+  return new FFIConverter;
+})();
+var CommitBundle = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+var FfiConverterTypeCommitBundle = (() => {
 
-  class Proteus_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "CoreCryptoError";
-    tag = "Proteus" /* Proteus */;
-    inner;
-    constructor(inner) {
-      super("CoreCryptoError", "Proteus");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new Proteus_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "Proteus" /* Proteus */;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        welcome: FfiConverterOptionalTypeWelcome.read(from),
+        commit: FfiConverterUint8Array.read(from),
+        groupInfo: FfiConverterTypeGroupInfoBundle.read(from),
+        encryptedMessage: FfiConverterOptionalBytes.read(from)
+      };
     }
-    static hasInner(obj) {
-      return Proteus_.instanceOf(obj);
+    write(value, into) {
+      FfiConverterOptionalTypeWelcome.write(value.welcome, into);
+      FfiConverterUint8Array.write(value.commit, into);
+      FfiConverterTypeGroupInfoBundle.write(value.groupInfo, into);
+      FfiConverterOptionalBytes.write(value.encryptedMessage, into);
     }
-    static getInner(obj) {
-      return obj.inner;
+    allocationSize(value) {
+      return FfiConverterOptionalTypeWelcome.allocationSize(value.welcome) + FfiConverterUint8Array.allocationSize(value.commit) + FfiConverterTypeGroupInfoBundle.allocationSize(value.groupInfo) + FfiConverterOptionalBytes.allocationSize(value.encryptedMessage);
     }
   }
+  return new FFIConverter;
+})();
 
-  class E2ei_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "CoreCryptoError";
-    tag = "E2ei" /* E2ei */;
-    inner;
-    constructor(inner) {
-      super("CoreCryptoError", "E2ei");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new E2ei_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "E2ei" /* E2ei */;
-    }
-    static hasInner(obj) {
-      return E2ei_.instanceOf(obj);
-    }
-    static getInner(obj) {
-      return obj.inner;
-    }
+class ClientId extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "ClientId";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(userId, deviceId, domain) {
+    super();
+    const pointer = uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_clientid_new(FfiConverterTypeUuid.lower(userId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterTypeDeviceId.lower(deviceId, core_crypto_ffi_ffi_default().rustbuffer_alloc), FfiConverterString.lower(domain, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeClientIdObjectFactory.bless(pointer);
   }
-
-  class TransactionFailed_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "CoreCryptoError";
-    tag = "TransactionFailed" /* TransactionFailed */;
-    inner;
-    constructor(inner) {
-      super("CoreCryptoError", "TransactionFailed");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new TransactionFailed_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "TransactionFailed" /* TransactionFailed */;
-    }
-    static hasInner(obj) {
-      return TransactionFailed_.instanceOf(obj);
-    }
-    static getInner(obj) {
-      return obj.inner;
-    }
+  copyBytes() {
+    return ((__rb) => {
+      try {
+        return FfiConverterUint8Array.lift(__rb);
+      } finally {
+        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
+      }
+    })(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_copy_bytes(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
   }
-
-  class Other_ extends UniffiError {
-    [uniffiTypeNameSymbol] = "CoreCryptoError";
-    tag = "Other" /* Other */;
-    inner;
-    constructor(inner) {
-      super("CoreCryptoError", "Other");
-      this.inner = Object.freeze(inner);
-    }
-    static new(inner) {
-      return new Other_(inner);
-    }
-    static instanceOf(obj) {
-      return obj.tag === "Other" /* Other */;
-    }
-    static hasInner(obj) {
-      return Other_.instanceOf(obj);
-    }
-    static getInner(obj) {
-      return obj.inner;
+  deserialize() {
+    return ((__rb) => {
+      try {
+        return FfiConverterTypeDeserializedClientId.lift(__rb);
+      } finally {
+        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
+      }
+    })(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_deserialize(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  equals(other) {
+    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_uniffi_trait_eq_eq(uniffiTypeClientIdObjectFactory.clonePointer(this), FfiConverterTypeClientId.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  hashCode() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_clientid_uniffi_trait_hash(uniffiTypeClientIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeClientIdObjectFactory.pointer(this);
+      uniffiTypeClientIdObjectFactory.freePointer(pointer);
+      uniffiTypeClientIdObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
     }
   }
-  function instanceOf(obj) {
-    return obj[uniffiTypeNameSymbol] === "CoreCryptoError";
+  static instanceOf(obj_) {
+    return uniffiTypeClientIdObjectFactory.isConcreteType(obj_);
   }
-  return Object.freeze({
-    instanceOf,
-    Mls: Mls_,
-    Proteus: Proteus_,
-    E2ei: E2ei_,
-    TransactionFailed: TransactionFailed_,
-    Other: Other_
-  });
+}
+var uniffiTypeClientIdObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeClientIdObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(ClientId.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "ClientId";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
+          return;
+        }
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
+      }
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
+      }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_clientid(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_clientid(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ClientId";
+    }
+  };
 })();
-var FfiConverterTypeCoreCryptoError = (() => {
-  const ordinalConverter = FfiConverterInt32;
+var FfiConverterTypeClientId = new FfiConverterObject(uniffiTypeClientIdObjectFactory);
 
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return new CoreCryptoError.Mls({
-            mlsError: FfiConverterTypeMlsError.read(from)
-          });
-        case 2:
-          return new CoreCryptoError.Proteus({
-            exception: FfiConverterTypeProteusError.read(from)
-          });
-        case 3:
-          return new CoreCryptoError.E2ei({
-            e2eiError: FfiConverterString.read(from)
-          });
-        case 4:
-          return new CoreCryptoError.TransactionFailed({
-            error: FfiConverterString.read(from)
-          });
-        case 5:
-          return new CoreCryptoError.Other({
-            msg: FfiConverterString.read(from)
-          });
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
+class Uuid extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "Uuid";
+  [destructorGuardSymbol];
+  [pointerLiteralSymbol];
+  constructor(uuid) {
+    super();
+    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_uuid_new(FfiConverterString.lower(uuid, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString));
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeUuidObjectFactory.bless(pointer);
+  }
+  toString() {
+    return ((__rb) => {
+      try {
+        return FfiConverterString.lift(__rb);
+      } finally {
+        core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
       }
+    })(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_display(uniffiTypeUuidObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  equals(other) {
+    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_eq_eq(uniffiTypeUuidObjectFactory.clonePointer(this), FfiConverterTypeUuid.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  hashCode() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_uuid_uniffi_trait_hash(uniffiTypeUuidObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeUuidObjectFactory.pointer(this);
+      uniffiTypeUuidObjectFactory.freePointer(pointer);
+      uniffiTypeUuidObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
     }
-    write(value, into) {
-      switch (value.tag) {
-        case "Mls" /* Mls */: {
-          ordinalConverter.write(1, into);
-          const inner = value.inner;
-          FfiConverterTypeMlsError.write(inner.mlsError, into);
-          return;
-        }
-        case "Proteus" /* Proteus */: {
-          ordinalConverter.write(2, into);
-          const inner = value.inner;
-          FfiConverterTypeProteusError.write(inner.exception, into);
-          return;
-        }
-        case "E2ei" /* E2ei */: {
-          ordinalConverter.write(3, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner.e2eiError, into);
-          return;
-        }
-        case "TransactionFailed" /* TransactionFailed */: {
-          ordinalConverter.write(4, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner.error, into);
-          return;
-        }
-        case "Other" /* Other */: {
-          ordinalConverter.write(5, into);
-          const inner = value.inner;
-          FfiConverterString.write(inner.msg, into);
+  }
+  static instanceOf(obj_) {
+    return uniffiTypeUuidObjectFactory.isConcreteType(obj_);
+  }
+}
+var uniffiTypeUuidObjectFactory = (() => {
+  const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
+    uniffiTypeUuidObjectFactory.freePointer(heldValue);
+  }) : null;
+  return {
+    create(pointer) {
+      const instance = Object.create(Uuid.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Uuid";
+      return instance;
+    },
+    bless(p) {
+      const ptr = {
+        p,
+        markDestroyed: () => {
           return;
         }
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
+      };
+      if (registry) {
+        registry.register(ptr, p, ptr);
       }
-    }
-    allocationSize(value) {
-      switch (value.tag) {
-        case "Mls" /* Mls */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(1);
-          size += FfiConverterTypeMlsError.allocationSize(inner.mlsError);
-          return size;
-        }
-        case "Proteus" /* Proteus */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterTypeProteusError.allocationSize(inner.exception);
-          return size;
-        }
-        case "E2ei" /* E2ei */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(3);
-          size += FfiConverterString.allocationSize(inner.e2eiError);
-          return size;
-        }
-        case "TransactionFailed" /* TransactionFailed */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(4);
-          size += FfiConverterString.allocationSize(inner.error);
-          return size;
-        }
-        case "Other" /* Other */: {
-          const inner = value.inner;
-          let size = ordinalConverter.allocationSize(5);
-          size += FfiConverterString.allocationSize(inner.msg);
-          return size;
-        }
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
+      return ptr;
+    },
+    unbless(ptr_) {
+      if (registry) {
+        registry.unregister(ptr_);
+      }
+    },
+    pointer(obj_) {
+      if (obj_[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer;
       }
+      return obj_[pointerLiteralSymbol];
+    },
+    clonePointer(obj_) {
+      const pointer = this.pointer(obj_);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_uuid(pointer, callStatus), FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_uuid(pointer, callStatus), FfiConverterString.lift);
+    },
+    isConcreteType(obj_) {
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Uuid";
     }
-  }
-  return new FFIConverter;
+  };
 })();
+var FfiConverterTypeUuid = new FfiConverterObject(uniffiTypeUuidObjectFactory);
 
-class Welcome extends UniffiAbstractObject {
-  [uniffiTypeNameSymbol] = "Welcome";
+class DeviceId extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "DeviceId";
   [destructorGuardSymbol];
   [pointerLiteralSymbol];
-  constructor(bytes) {
+  constructor(id) {
     super();
-    const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_welcome_new(FfiConverterUint8Array.lower(bytes, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    const pointer = uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_new(FfiConverterUInt64.lower(id, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
     }, FfiConverterString.lift.bind(FfiConverterString));
     this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeWelcomeObjectFactory.bless(pointer);
+    this[destructorGuardSymbol] = uniffiTypeDeviceIdObjectFactory.bless(pointer);
   }
-  serialize() {
+  static fromHexString(hexString) {
+    return FfiConverterTypeDeviceId.lift(uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_constructor_deviceid_from_hex_string(FfiConverterString.lower(hexString, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  toHexString() {
     return ((__rb) => {
       try {
-        return FfiConverterUint8Array.lift(__rb);
+        return FfiConverterString.lift(__rb);
       } finally {
         core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
       }
-    })(uniffiCaller.rustCallWithError(FfiConverterTypeCoreCryptoError.lift.bind(FfiConverterTypeCoreCryptoError), (callStatus) => {
-      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_welcome_serialize(uniffiTypeWelcomeObjectFactory.clonePointer(this), callStatus);
+    })(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_hex_string(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  toU64() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_to_u64(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  equals(other) {
+    return FfiConverterBool.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_eq_eq(uniffiTypeDeviceIdObjectFactory.clonePointer(this), FfiConverterTypeDeviceId.lower(other, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+    }, FfiConverterString.lift.bind(FfiConverterString)));
+  }
+  hashCode() {
+    return FfiConverterUInt64.lift(uniffiCaller.rustCall((callStatus) => {
+      return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deviceid_uniffi_trait_hash(uniffiTypeDeviceIdObjectFactory.clonePointer(this), callStatus);
     }, FfiConverterString.lift.bind(FfiConverterString)));
   }
   uniffiDestroy() {
     const ptr = this[destructorGuardSymbol];
     if (ptr !== undefined) {
-      const pointer = uniffiTypeWelcomeObjectFactory.pointer(this);
-      uniffiTypeWelcomeObjectFactory.freePointer(pointer);
-      uniffiTypeWelcomeObjectFactory.unbless(ptr);
+      const pointer = uniffiTypeDeviceIdObjectFactory.pointer(this);
+      uniffiTypeDeviceIdObjectFactory.freePointer(pointer);
+      uniffiTypeDeviceIdObjectFactory.unbless(ptr);
       delete this[destructorGuardSymbol];
     }
   }
   static instanceOf(obj_) {
-    return uniffiTypeWelcomeObjectFactory.isConcreteType(obj_);
+    return uniffiTypeDeviceIdObjectFactory.isConcreteType(obj_);
   }
 }
-var uniffiTypeWelcomeObjectFactory = (() => {
+var uniffiTypeDeviceIdObjectFactory = (() => {
   const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
-    uniffiTypeWelcomeObjectFactory.freePointer(heldValue);
+    uniffiTypeDeviceIdObjectFactory.freePointer(heldValue);
   }) : null;
   return {
     create(pointer) {
-      const instance = Object.create(Welcome.prototype);
+      const instance = Object.create(DeviceId.prototype);
       instance[pointerLiteralSymbol] = pointer;
       instance[destructorGuardSymbol] = this.bless(pointer);
-      instance[uniffiTypeNameSymbol] = "Welcome";
+      instance[uniffiTypeNameSymbol] = "DeviceId";
       return instance;
     },
     bless(p) {
@@ -4195,89 +3863,63 @@ var uniffiTypeWelcomeObjectFactory = (() => {
     },
     clonePointer(obj_) {
       const pointer = this.pointer(obj_);
-      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_welcome(pointer, callStatus), FfiConverterString.lift);
+      return uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_clone_deviceid(pointer, callStatus), FfiConverterString.lift);
     },
     freePointer(pointer) {
-      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_welcome(pointer, callStatus), FfiConverterString.lift);
+      uniffiCaller.rustCall((callStatus) => core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_free_deviceid(pointer, callStatus), FfiConverterString.lift);
     },
     isConcreteType(obj_) {
-      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "Welcome";
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "DeviceId";
     }
   };
 })();
-var FfiConverterTypeWelcome = new FfiConverterObject(uniffiTypeWelcomeObjectFactory);
-var MlsGroupInfoEncryptionType;
-((MlsGroupInfoEncryptionType2) => {
-  MlsGroupInfoEncryptionType2[MlsGroupInfoEncryptionType2["Plaintext"] = 1] = "Plaintext";
-  MlsGroupInfoEncryptionType2[MlsGroupInfoEncryptionType2["JweEncrypted"] = 2] = "JweEncrypted";
-})(MlsGroupInfoEncryptionType ||= {});
-var FfiConverterTypeMlsGroupInfoEncryptionType = (() => {
-  const ordinalConverter = FfiConverterInt32;
-
-  class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return 1 /* Plaintext */;
-        case 2:
-          return 2 /* JweEncrypted */;
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
-      }
-    }
-    write(value, into) {
-      switch (value) {
-        case 1 /* Plaintext */:
-          return ordinalConverter.write(1, into);
-        case 2 /* JweEncrypted */:
-          return ordinalConverter.write(2, into);
-      }
-    }
-    allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+var FfiConverterTypeDeviceId = new FfiConverterObject(uniffiTypeDeviceIdObjectFactory);
+var DeserializedClientId = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()),
+    toString(self_) {
+      return ((__rb) => {
+        try {
+          return FfiConverterString.lift(__rb);
+        } finally {
+          core_crypto_ffi_ffi_default().rustbuffer_free(__rb);
+        }
+      })(uniffiCaller.rustCall((callStatus) => {
+        return core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_fn_method_deserializedclientid_uniffi_trait_display(FfiConverterTypeDeserializedClientId.lower(self_, core_crypto_ffi_ffi_default().rustbuffer_alloc), callStatus);
+      }, FfiConverterString.lift.bind(FfiConverterString)));
     }
-  }
-  return new FFIConverter;
+  });
 })();
-var MlsRatchetTreeType;
-((MlsRatchetTreeType2) => {
-  MlsRatchetTreeType2[MlsRatchetTreeType2["Full"] = 1] = "Full";
-  MlsRatchetTreeType2[MlsRatchetTreeType2["Delta"] = 2] = "Delta";
-  MlsRatchetTreeType2[MlsRatchetTreeType2["ByRef"] = 3] = "ByRef";
-})(MlsRatchetTreeType ||= {});
-var FfiConverterTypeMlsRatchetTreeType = (() => {
-  const ordinalConverter = FfiConverterInt32;
+var FfiConverterTypeDeserializedClientId = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
-      switch (ordinalConverter.read(from)) {
-        case 1:
-          return 1 /* Full */;
-        case 2:
-          return 2 /* Delta */;
-        case 3:
-          return 3 /* ByRef */;
-        default:
-          throw new UniffiInternalError.UnexpectedEnumCase;
-      }
+      return {
+        clientId: FfiConverterTypeClientId.read(from),
+        userId: FfiConverterTypeUuid.read(from),
+        deviceId: FfiConverterTypeDeviceId.read(from),
+        domain: FfiConverterString.read(from)
+      };
     }
     write(value, into) {
-      switch (value) {
-        case 1 /* Full */:
-          return ordinalConverter.write(1, into);
-        case 2 /* Delta */:
-          return ordinalConverter.write(2, into);
-        case 3 /* ByRef */:
-          return ordinalConverter.write(3, into);
-      }
+      FfiConverterTypeClientId.write(value.clientId, into);
+      FfiConverterTypeUuid.write(value.userId, into);
+      FfiConverterTypeDeviceId.write(value.deviceId, into);
+      FfiConverterString.write(value.domain, into);
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterTypeUuid.allocationSize(value.userId) + FfiConverterTypeDeviceId.allocationSize(value.deviceId) + FfiConverterString.allocationSize(value.domain);
     }
   }
   return new FFIConverter;
 })();
-var GroupInfoBundle = (() => {
+var HistorySecret = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4288,28 +3930,26 @@ var GroupInfoBundle = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeGroupInfoBundle = (() => {
+var FfiConverterTypeHistorySecret = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        encryptionType: FfiConverterTypeMlsGroupInfoEncryptionType.read(from),
-        ratchetTreeType: FfiConverterTypeMlsRatchetTreeType.read(from),
-        payload: FfiConverterUint8Array.read(from)
+        clientId: FfiConverterTypeClientId.read(from),
+        data: FfiConverterUint8Array.read(from)
       };
     }
     write(value, into) {
-      FfiConverterTypeMlsGroupInfoEncryptionType.write(value.encryptionType, into);
-      FfiConverterTypeMlsRatchetTreeType.write(value.ratchetTreeType, into);
-      FfiConverterUint8Array.write(value.payload, into);
+      FfiConverterTypeClientId.write(value.clientId, into);
+      FfiConverterUint8Array.write(value.data, into);
     }
     allocationSize(value) {
-      return FfiConverterTypeMlsGroupInfoEncryptionType.allocationSize(value.encryptionType) + FfiConverterTypeMlsRatchetTreeType.allocationSize(value.ratchetTreeType) + FfiConverterUint8Array.allocationSize(value.payload);
+      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterUint8Array.allocationSize(value.data);
     }
   }
   return new FFIConverter;
 })();
-var CommitBundle = (() => {
+var HttpHeader = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4320,30 +3960,26 @@ var CommitBundle = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeCommitBundle = (() => {
+var FfiConverterTypeHttpHeader = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        welcome: FfiConverterOptionalTypeWelcome.read(from),
-        commit: FfiConverterUint8Array.read(from),
-        groupInfo: FfiConverterTypeGroupInfoBundle.read(from),
-        encryptedMessage: FfiConverterOptionalBytes.read(from)
+        name: FfiConverterString.read(from),
+        value: FfiConverterString.read(from)
       };
     }
     write(value, into) {
-      FfiConverterOptionalTypeWelcome.write(value.welcome, into);
-      FfiConverterUint8Array.write(value.commit, into);
-      FfiConverterTypeGroupInfoBundle.write(value.groupInfo, into);
-      FfiConverterOptionalBytes.write(value.encryptedMessage, into);
+      FfiConverterString.write(value.name, into);
+      FfiConverterString.write(value.value, into);
     }
     allocationSize(value) {
-      return FfiConverterOptionalTypeWelcome.allocationSize(value.welcome) + FfiConverterUint8Array.allocationSize(value.commit) + FfiConverterTypeGroupInfoBundle.allocationSize(value.groupInfo) + FfiConverterOptionalBytes.allocationSize(value.encryptedMessage);
+      return FfiConverterString.allocationSize(value.name) + FfiConverterString.allocationSize(value.value);
     }
   }
   return new FFIConverter;
 })();
-var DecryptedMessage = (() => {
+var HttpResponse = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4354,34 +3990,28 @@ var DecryptedMessage = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeDecryptedMessage = (() => {
+var FfiConverterTypeHttpResponse = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        message: FfiConverterOptionalBytes.read(from),
-        isActive: FfiConverterBool.read(from),
-        commitDelay: FfiConverterOptionalUInt64.read(from),
-        senderClientId: FfiConverterOptionalTypeClientId.read(from),
-        identity: FfiConverterTypeWireIdentity.read(from),
-        bufferedMessages: FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.read(from)
+        status: FfiConverterUInt16.read(from),
+        headers: FfiConverterSequenceTypeHttpHeader.read(from),
+        body: FfiConverterUint8Array.read(from)
       };
     }
     write(value, into) {
-      FfiConverterOptionalBytes.write(value.message, into);
-      FfiConverterBool.write(value.isActive, into);
-      FfiConverterOptionalUInt64.write(value.commitDelay, into);
-      FfiConverterOptionalTypeClientId.write(value.senderClientId, into);
-      FfiConverterTypeWireIdentity.write(value.identity, into);
-      FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.write(value.bufferedMessages, into);
+      FfiConverterUInt16.write(value.status, into);
+      FfiConverterSequenceTypeHttpHeader.write(value.headers, into);
+      FfiConverterUint8Array.write(value.body, into);
     }
     allocationSize(value) {
-      return FfiConverterOptionalBytes.allocationSize(value.message) + FfiConverterBool.allocationSize(value.isActive) + FfiConverterOptionalUInt64.allocationSize(value.commitDelay) + FfiConverterOptionalTypeClientId.allocationSize(value.senderClientId) + FfiConverterTypeWireIdentity.allocationSize(value.identity) + FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.allocationSize(value.bufferedMessages);
+      return FfiConverterUInt16.allocationSize(value.status) + FfiConverterSequenceTypeHttpHeader.allocationSize(value.headers) + FfiConverterUint8Array.allocationSize(value.body);
     }
   }
   return new FFIConverter;
 })();
-var HistorySecret = (() => {
+var ProteusAutoPrekeyBundle = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4392,56 +4022,98 @@ var HistorySecret = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeHistorySecret = (() => {
+var FfiConverterTypeProteusAutoPrekeyBundle = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        clientId: FfiConverterTypeClientId.read(from),
-        data: FfiConverterUint8Array.read(from)
+        id: FfiConverterUInt16.read(from),
+        pkb: FfiConverterUint8Array.read(from)
       };
     }
     write(value, into) {
-      FfiConverterTypeClientId.write(value.clientId, into);
-      FfiConverterUint8Array.write(value.data, into);
+      FfiConverterUInt16.write(value.id, into);
+      FfiConverterUint8Array.write(value.pkb, into);
     }
     allocationSize(value) {
-      return FfiConverterTypeClientId.allocationSize(value.clientId) + FfiConverterUint8Array.allocationSize(value.data);
+      return FfiConverterUInt16.allocationSize(value.id) + FfiConverterUint8Array.allocationSize(value.pkb);
     }
   }
   return new FFIConverter;
 })();
-var HttpHeader = (() => {
-  const defaults = () => ({});
-  const create = (() => {
-    return uniffiCreateRecord(defaults);
-  })();
-  return Object.freeze({
-    create,
-    new: create,
-    defaults: () => Object.freeze(defaults())
-  });
+var DeviceStatus;
+((DeviceStatus2) => {
+  DeviceStatus2[DeviceStatus2["Valid"] = 1] = "Valid";
+  DeviceStatus2[DeviceStatus2["Expired"] = 2] = "Expired";
+  DeviceStatus2[DeviceStatus2["Revoked"] = 3] = "Revoked";
+})(DeviceStatus ||= {});
+var FfiConverterTypeDeviceStatus = (() => {
+  const ordinalConverter = FfiConverterInt32;
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return 1 /* Valid */;
+        case 2:
+          return 2 /* Expired */;
+        case 3:
+          return 3 /* Revoked */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    write(value, into) {
+      switch (value) {
+        case 1 /* Valid */:
+          return ordinalConverter.write(1, into);
+        case 2 /* Expired */:
+          return ordinalConverter.write(2, into);
+        case 3 /* Revoked */:
+          return ordinalConverter.write(3, into);
+      }
+    }
+    allocationSize(value) {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter;
 })();
-var FfiConverterTypeHttpHeader = (() => {
+var CredentialType;
+((CredentialType2) => {
+  CredentialType2[CredentialType2["Basic"] = 1] = "Basic";
+  CredentialType2[CredentialType2["X509"] = 2] = "X509";
+})(CredentialType ||= {});
+var FfiConverterTypeCredentialType = (() => {
+  const ordinalConverter = FfiConverterInt32;
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
-      return {
-        name: FfiConverterString.read(from),
-        value: FfiConverterString.read(from)
-      };
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return 1 /* Basic */;
+        case 2:
+          return 2 /* X509 */;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
     }
     write(value, into) {
-      FfiConverterString.write(value.name, into);
-      FfiConverterString.write(value.value, into);
+      switch (value) {
+        case 1 /* Basic */:
+          return ordinalConverter.write(1, into);
+        case 2 /* X509 */:
+          return ordinalConverter.write(2, into);
+      }
     }
     allocationSize(value) {
-      return FfiConverterString.allocationSize(value.name) + FfiConverterString.allocationSize(value.value);
+      return ordinalConverter.allocationSize(0);
     }
   }
   return new FFIConverter;
 })();
-var HttpResponse = (() => {
+var FfiConverterTypeTimestamp = FfiConverterTimestamp;
+var X509Identity = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4452,28 +4124,36 @@ var HttpResponse = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeHttpResponse = (() => {
+var FfiConverterTypeX509Identity = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        status: FfiConverterUInt16.read(from),
-        headers: FfiConverterSequenceTypeHttpHeader.read(from),
-        body: FfiConverterUint8Array.read(from)
+        handle: FfiConverterString.read(from),
+        displayName: FfiConverterString.read(from),
+        domain: FfiConverterString.read(from),
+        certificate: FfiConverterString.read(from),
+        serialNumber: FfiConverterString.read(from),
+        notBefore: FfiConverterTypeTimestamp.read(from),
+        notAfter: FfiConverterTypeTimestamp.read(from)
       };
     }
     write(value, into) {
-      FfiConverterUInt16.write(value.status, into);
-      FfiConverterSequenceTypeHttpHeader.write(value.headers, into);
-      FfiConverterUint8Array.write(value.body, into);
+      FfiConverterString.write(value.handle, into);
+      FfiConverterString.write(value.displayName, into);
+      FfiConverterString.write(value.domain, into);
+      FfiConverterString.write(value.certificate, into);
+      FfiConverterString.write(value.serialNumber, into);
+      FfiConverterTypeTimestamp.write(value.notBefore, into);
+      FfiConverterTypeTimestamp.write(value.notAfter, into);
     }
     allocationSize(value) {
-      return FfiConverterUInt16.allocationSize(value.status) + FfiConverterSequenceTypeHttpHeader.allocationSize(value.headers) + FfiConverterUint8Array.allocationSize(value.body);
+      return FfiConverterString.allocationSize(value.handle) + FfiConverterString.allocationSize(value.displayName) + FfiConverterString.allocationSize(value.domain) + FfiConverterString.allocationSize(value.certificate) + FfiConverterString.allocationSize(value.serialNumber) + FfiConverterTypeTimestamp.allocationSize(value.notBefore) + FfiConverterTypeTimestamp.allocationSize(value.notAfter);
     }
   }
   return new FFIConverter;
 })();
-var ProteusAutoPrekeyBundle = (() => {
+var WireIdentity = (() => {
   const defaults = () => ({});
   const create = (() => {
     return uniffiCreateRecord(defaults);
@@ -4484,21 +4164,27 @@ var ProteusAutoPrekeyBundle = (() => {
     defaults: () => Object.freeze(defaults())
   });
 })();
-var FfiConverterTypeProteusAutoPrekeyBundle = (() => {
+var FfiConverterTypeWireIdentity = (() => {
 
   class FFIConverter extends AbstractFfiConverterByteArray {
     read(from) {
       return {
-        id: FfiConverterUInt16.read(from),
-        pkb: FfiConverterUint8Array.read(from)
+        clientId: FfiConverterOptionalTypeClientId.read(from),
+        status: FfiConverterTypeDeviceStatus.read(from),
+        thumbprint: FfiConverterString.read(from),
+        credentialType: FfiConverterTypeCredentialType.read(from),
+        x509Identity: FfiConverterOptionalTypeX509Identity.read(from)
       };
     }
     write(value, into) {
-      FfiConverterUInt16.write(value.id, into);
-      FfiConverterUint8Array.write(value.pkb, into);
+      FfiConverterOptionalTypeClientId.write(value.clientId, into);
+      FfiConverterTypeDeviceStatus.write(value.status, into);
+      FfiConverterString.write(value.thumbprint, into);
+      FfiConverterTypeCredentialType.write(value.credentialType, into);
+      FfiConverterOptionalTypeX509Identity.write(value.x509Identity, into);
     }
     allocationSize(value) {
-      return FfiConverterUInt16.allocationSize(value.id) + FfiConverterUint8Array.allocationSize(value.pkb);
+      return FfiConverterOptionalTypeClientId.allocationSize(value.clientId) + FfiConverterTypeDeviceStatus.allocationSize(value.status) + FfiConverterString.allocationSize(value.thumbprint) + FfiConverterTypeCredentialType.allocationSize(value.credentialType) + FfiConverterOptionalTypeX509Identity.allocationSize(value.x509Identity);
     }
   }
   return new FFIConverter;
@@ -4603,6 +4289,139 @@ var FfiConverterTypeX509CredentialAcquisitionConfiguration = (() => {
   }
   return new FFIConverter;
 })();
+var BufferedDecryptedMessage = (() => {
+  class Text_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "BufferedDecryptedMessage";
+    tag = "Text" /* Text */;
+    inner;
+    constructor(inner) {
+      super("BufferedDecryptedMessage", "Text");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Text_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Text" /* Text */;
+    }
+  }
+
+  class Commit_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "BufferedDecryptedMessage";
+    tag = "Commit" /* Commit */;
+    inner;
+    constructor(inner) {
+      super("BufferedDecryptedMessage", "Commit");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Commit_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Commit" /* Commit */;
+    }
+  }
+
+  class Proposal_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "BufferedDecryptedMessage";
+    tag = "Proposal" /* Proposal */;
+    inner;
+    constructor(inner) {
+      super("BufferedDecryptedMessage", "Proposal");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Proposal_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Proposal" /* Proposal */;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "BufferedDecryptedMessage";
+  }
+  return Object.freeze({
+    instanceOf,
+    Text: Text_,
+    Commit: Commit_,
+    Proposal: Proposal_
+  });
+})();
+var FfiConverterTypeBufferedDecryptedMessage = (() => {
+  const ordinalConverter = FfiConverterInt32;
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new BufferedDecryptedMessage.Text({ plaintext: FfiConverterUint8Array.read(from), senderClientId: FfiConverterTypeClientId.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        case 2:
+          return new BufferedDecryptedMessage.Commit({ isActive: FfiConverterBool.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        case 3:
+          return new BufferedDecryptedMessage.Proposal({ delay: FfiConverterOptionalUInt64.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case "Text" /* Text */: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterUint8Array.write(inner.plaintext, into);
+          FfiConverterTypeClientId.write(inner.senderClientId, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        case "Commit" /* Commit */: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterBool.write(inner.isActive, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        case "Proposal" /* Proposal */: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterOptionalUInt64.write(inner.delay, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case "Text" /* Text */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterUint8Array.allocationSize(inner.plaintext);
+          size += FfiConverterTypeClientId.allocationSize(inner.senderClientId);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        case "Commit" /* Commit */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterBool.allocationSize(inner.isActive);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        case "Proposal" /* Proposal */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterOptionalUInt64.allocationSize(inner.delay);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+  }
+  return new FFIConverter;
+})();
 var CoreCryptoLogLevel;
 ((CoreCryptoLogLevel2) => {
   CoreCryptoLogLevel2[CoreCryptoLogLevel2["Off"] = 1] = "Off";
@@ -4656,6 +4475,141 @@ var FfiConverterTypeCoreCryptoLogLevel = (() => {
   }
   return new FFIConverter;
 })();
+var DecryptedMessage = (() => {
+  class Text_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "DecryptedMessage";
+    tag = "Text" /* Text */;
+    inner;
+    constructor(inner) {
+      super("DecryptedMessage", "Text");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Text_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Text" /* Text */;
+    }
+  }
+
+  class Commit_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "DecryptedMessage";
+    tag = "Commit" /* Commit */;
+    inner;
+    constructor(inner) {
+      super("DecryptedMessage", "Commit");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Commit_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Commit" /* Commit */;
+    }
+  }
+
+  class Proposal_ extends UniffiEnum {
+    [uniffiTypeNameSymbol] = "DecryptedMessage";
+    tag = "Proposal" /* Proposal */;
+    inner;
+    constructor(inner) {
+      super("DecryptedMessage", "Proposal");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Proposal_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === "Proposal" /* Proposal */;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "DecryptedMessage";
+  }
+  return Object.freeze({
+    instanceOf,
+    Text: Text_,
+    Commit: Commit_,
+    Proposal: Proposal_
+  });
+})();
+var FfiConverterTypeDecryptedMessage = (() => {
+  const ordinalConverter = FfiConverterInt32;
+
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new DecryptedMessage.Text({ plaintext: FfiConverterUint8Array.read(from), senderClientId: FfiConverterTypeClientId.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        case 2:
+          return new DecryptedMessage.Commit({ isActive: FfiConverterBool.read(from), bufferedMessages: FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        case 3:
+          return new DecryptedMessage.Proposal({ delay: FfiConverterOptionalUInt64.read(from), identity: FfiConverterTypeWireIdentity.read(from) });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case "Text" /* Text */: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterUint8Array.write(inner.plaintext, into);
+          FfiConverterTypeClientId.write(inner.senderClientId, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        case "Commit" /* Commit */: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterBool.write(inner.isActive, into);
+          FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.write(inner.bufferedMessages, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        case "Proposal" /* Proposal */: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterOptionalUInt64.write(inner.delay, into);
+          FfiConverterTypeWireIdentity.write(inner.identity, into);
+          return;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case "Text" /* Text */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterUint8Array.allocationSize(inner.plaintext);
+          size += FfiConverterTypeClientId.allocationSize(inner.senderClientId);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        case "Commit" /* Commit */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterBool.allocationSize(inner.isActive);
+          size += FfiConverterOptionalSequenceTypeBufferedDecryptedMessage.allocationSize(inner.bufferedMessages);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        case "Proposal" /* Proposal */: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterOptionalUInt64.allocationSize(inner.delay);
+          size += FfiConverterTypeWireIdentity.allocationSize(inner.identity);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase;
+      }
+    }
+  }
+  return new FFIConverter;
+})();
 var E2eiConversationState;
 ((E2eiConversationState2) => {
   E2eiConversationState2[E2eiConversationState2["Verified"] = 1] = "Verified";
@@ -4880,9 +4834,7 @@ var FfiConverterTypeMlsTransportError = (() => {
     read(from) {
       switch (ordinalConverter.read(from)) {
         case 1:
-          return new MlsTransportError.MessageRejected({
-            reason: FfiConverterString.read(from)
-          });
+          return new MlsTransportError.MessageRejected({ reason: FfiConverterString.read(from) });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase;
       }
@@ -4994,9 +4946,7 @@ var FfiConverterTypePkiEnvironmentHooksError = (() => {
     read(from) {
       switch (ordinalConverter.read(from)) {
         case 1:
-          return new PkiEnvironmentHooksError.Error({
-            reason: FfiConverterString.read(from)
-          });
+          return new PkiEnvironmentHooksError.Error({ reason: FfiConverterString.read(from) });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase;
       }
@@ -8317,15 +8267,15 @@ var uniffiTypeX509CredentialAcquisitionObjectFactory = (() => {
   };
 })();
 var FfiConverterTypeX509CredentialAcquisition = new FfiConverterObject(uniffiTypeX509CredentialAcquisitionObjectFactory);
+var FfiConverterOptionalTypeWelcome = new FfiConverterOptional(FfiConverterTypeWelcome);
 var FfiConverterOptionalBytes = new FfiConverterOptional(FfiConverterUint8Array);
-var FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+var FfiConverterSequenceTypeHttpHeader = new FfiConverterArray(FfiConverterTypeHttpHeader);
 var FfiConverterOptionalTypeClientId = new FfiConverterOptional(FfiConverterTypeClientId);
 var FfiConverterOptionalTypeX509Identity = new FfiConverterOptional(FfiConverterTypeX509Identity);
-var FfiConverterOptionalTypeWelcome = new FfiConverterOptional(FfiConverterTypeWelcome);
+var FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+var FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
 var FfiConverterSequenceTypeBufferedDecryptedMessage = new FfiConverterArray(FfiConverterTypeBufferedDecryptedMessage);
 var FfiConverterOptionalSequenceTypeBufferedDecryptedMessage = new FfiConverterOptional(FfiConverterSequenceTypeBufferedDecryptedMessage);
-var FfiConverterSequenceTypeHttpHeader = new FfiConverterArray(FfiConverterTypeHttpHeader);
-var FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
 var FfiConverterSequenceTypeKeyPackage = new FfiConverterArray(FfiConverterTypeKeyPackage);
 var FfiConverterOptionalTypeExternalSender = new FfiConverterOptional(FfiConverterTypeExternalSender);
 var FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
@@ -8428,7 +8378,7 @@ function uniffiEnsureInitialized() {
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_create_conversation() !== 63673) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptocontext_create_conversation");
   }
-  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_decrypt_message() !== 47475) {
+  if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_decrypt_message() !== 8493) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_core_crypto_ffi_checksum_method_corecryptocontext_decrypt_message");
   }
   if (core_crypto_ffi_ffi_default().uniffi_core_crypto_ffi_checksum_method_corecryptocontext_disable_history_sharing() !== 27456) {
@@ -8984,6 +8934,7 @@ export {
   DeviceStatus,
   DeviceId,
   DeserializedClientId,
+  DecryptedMessage,
   DatabaseKey,
   Database,
   CredentialType,