matrix-sdk-python 0.18.0a1__cp314-cp314-win_amd64.whl

matrix_sdk_python/_generated/matrix_sdk_crypto.py

@@ -0,0 +1,1876 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .py file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Python
+# helpers directly inline like we're doing here.
+
+from __future__ import annotations
+import os
+import sys
+import ctypes
+from dataclasses import dataclass
+import enum
+import struct
+import contextlib
+import datetime
+import threading
+import itertools
+import traceback
+import typing
+import platform
+
+
+# Used for default argument values
+_DEFAULT = object() # type: typing.Any
+
+
+class _UniffiRustBuffer(ctypes.Structure):
+    _fields_ = [
+        ("capacity", ctypes.c_uint64),
+        ("len", ctypes.c_uint64),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    @staticmethod
+    def default():
+        return _UniffiRustBuffer(0, 0, None)
+
+    @staticmethod
+    def alloc(size):
+        return _uniffi_rust_call(_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_alloc, size)
+
+    @staticmethod
+    def reserve(rbuf, additional):
+        return _uniffi_rust_call(_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_reserve, rbuf, additional)
+
+    def free(self):
+        return _uniffi_rust_call(_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_free, self)
+
+    def __str__(self):
+        return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
+            self.capacity,
+            self.len,
+            self.data[0:self.len]
+        )
+
+    @contextlib.contextmanager
+    def alloc_with_builder(*args):
+        """Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
+
+        The allocated buffer will be automatically freed if an error occurs, ensuring that
+        we don't accidentally leak it.
+        """
+        builder = _UniffiRustBufferBuilder()
+        try:
+            yield builder
+        except:
+            builder.discard()
+            raise
+
+    @contextlib.contextmanager
+    def consume_with_stream(self):
+        """Context-manager to consume a buffer using a _UniffiRustBufferStream.
+
+        The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
+        leak it even if an error occurs.
+        """
+        try:
+            s = _UniffiRustBufferStream.from_rust_buffer(self)
+            yield s
+            if s.remaining() != 0:
+                raise RuntimeError(f"junk data left in buffer at end of consume_with_stream {s.remaining()}")
+        finally:
+            self.free()
+
+    @contextlib.contextmanager
+    def read_with_stream(self):
+        """Context-manager to read a buffer using a _UniffiRustBufferStream.
+
+        This is like consume_with_stream, but doesn't free the buffer afterwards.
+        It should only be used with borrowed `_UniffiRustBuffer` data.
+        """
+        s = _UniffiRustBufferStream.from_rust_buffer(self)
+        yield s
+        if s.remaining() != 0:
+            raise RuntimeError(f"junk data left in buffer at end of read_with_stream {s.remaining()}")
+
+class _UniffiForeignBytes(ctypes.Structure):
+    _fields_ = [
+        ("len", ctypes.c_int32),
+        ("data", ctypes.POINTER(ctypes.c_char)),
+    ]
+
+    def __str__(self):
+        return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
+
+
+class _UniffiRustBufferStream:
+    """
+    Helper for structured reading of bytes from a _UniffiRustBuffer
+    """
+
+    def __init__(self, data, len):
+        self.data = data
+        self.len = len
+        self.offset = 0
+
+    @classmethod
+    def from_rust_buffer(cls, buf):
+        return cls(buf.data, buf.len)
+
+    def remaining(self):
+        return self.len - self.offset
+
+    def _unpack_from(self, size, format):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
+        self.offset += size
+        return value
+
+    def read(self, size):
+        if self.offset + size > self.len:
+            raise InternalError("read past end of rust buffer")
+        data = self.data[self.offset:self.offset+size]
+        self.offset += size
+        return data
+
+    def read_i8(self):
+        return self._unpack_from(1, ">b")
+
+    def read_u8(self):
+        return self._unpack_from(1, ">B")
+
+    def read_i16(self):
+        return self._unpack_from(2, ">h")
+
+    def read_u16(self):
+        return self._unpack_from(2, ">H")
+
+    def read_i32(self):
+        return self._unpack_from(4, ">i")
+
+    def read_u32(self):
+        return self._unpack_from(4, ">I")
+
+    def read_i64(self):
+        return self._unpack_from(8, ">q")
+
+    def read_u64(self):
+        return self._unpack_from(8, ">Q")
+
+    def read_float(self):
+        v = self._unpack_from(4, ">f")
+        return v
+
+    def read_double(self):
+        return self._unpack_from(8, ">d")
+
+class _UniffiRustBufferBuilder:
+    """
+    Helper for structured writing of bytes into a _UniffiRustBuffer.
+    """
+
+    def __init__(self):
+        self.rbuf = _UniffiRustBuffer.alloc(16)
+        self.rbuf.len = 0
+
+    def finalize(self):
+        rbuf = self.rbuf
+        self.rbuf = None
+        return rbuf
+
+    def discard(self):
+        if self.rbuf is not None:
+            rbuf = self.finalize()
+            rbuf.free()
+
+    @contextlib.contextmanager
+    def _reserve(self, num_bytes):
+        if self.rbuf.len + num_bytes > self.rbuf.capacity:
+            self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
+        yield None
+        self.rbuf.len += num_bytes
+
+    def _pack_into(self, size, format, value):
+        with self._reserve(size):
+            # XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
+            for i, byte in enumerate(struct.pack(format, value)):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write(self, value):
+        with self._reserve(len(value)):
+            for i, byte in enumerate(value):
+                self.rbuf.data[self.rbuf.len + i] = byte
+
+    def write_i8(self, v):
+        self._pack_into(1, ">b", v)
+
+    def write_u8(self, v):
+        self._pack_into(1, ">B", v)
+
+    def write_i16(self, v):
+        self._pack_into(2, ">h", v)
+
+    def write_u16(self, v):
+        self._pack_into(2, ">H", v)
+
+    def write_i32(self, v):
+        self._pack_into(4, ">i", v)
+
+    def write_u32(self, v):
+        self._pack_into(4, ">I", v)
+
+    def write_i64(self, v):
+        self._pack_into(8, ">q", v)
+
+    def write_u64(self, v):
+        self._pack_into(8, ">Q", v)
+
+    def write_float(self, v):
+        self._pack_into(4, ">f", v)
+
+    def write_double(self, v):
+        self._pack_into(8, ">d", v)
+
+    def write_c_size_t(self, v):
+        self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
+# A handful of classes and functions to support the generated data structures.
+# This would be a good candidate for isolating in its own ffi-support lib.
+
+class InternalError(Exception):
+    pass
+
+class _UniffiRustCallStatus(ctypes.Structure):
+    """
+    Error runtime.
+    """
+    _fields_ = [
+        ("code", ctypes.c_int8),
+        ("error_buf", _UniffiRustBuffer),
+    ]
+
+    # These match the values from the uniffi::rustcalls module
+    CALL_SUCCESS = 0
+    CALL_ERROR = 1
+    CALL_UNEXPECTED_ERROR = 2
+
+    @staticmethod
+    def default():
+        return _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer.default())
+
+    def __str__(self):
+        if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
+            return "_UniffiRustCallStatus(CALL_SUCCESS)"
+        elif self.code == _UniffiRustCallStatus.CALL_ERROR:
+            return "_UniffiRustCallStatus(CALL_ERROR)"
+        elif self.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+            return "_UniffiRustCallStatus(CALL_UNEXPECTED_ERROR)"
+        else:
+            return "_UniffiRustCallStatus(<invalid code>)"
+
+def _uniffi_rust_call(fn, *args):
+    # Call a rust function
+    return _uniffi_rust_call_with_error(None, fn, *args)
+
+def _uniffi_rust_call_with_error(error_ffi_converter, fn, *args):
+    # Call a rust function and handle any errors
+    #
+    # This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code.
+    # error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result.
+    call_status = _UniffiRustCallStatus.default()
+
+    args_with_error = args + (ctypes.byref(call_status),)
+    result = fn(*args_with_error)
+    _uniffi_check_call_status(error_ffi_converter, call_status)
+    return result
+
+def _uniffi_check_call_status(error_ffi_converter, call_status):
+    if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS:
+        pass
+    elif call_status.code == _UniffiRustCallStatus.CALL_ERROR:
+        if error_ffi_converter is None:
+            call_status.error_buf.free()
+            raise InternalError("_uniffi_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None")
+        else:
+            raise error_ffi_converter.lift(call_status.error_buf)
+    elif call_status.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
+        # When the rust code sees a panic, it tries to construct a _UniffiRustBuffer
+        # with the message.  But if that code panics, then it just sends back
+        # an empty buffer.
+        if call_status.error_buf.len > 0:
+            msg = _UniffiFfiConverterString.lift(call_status.error_buf)
+        else:
+            msg = "Unknown rust panic"
+        raise InternalError(msg)
+    else:
+        raise InternalError("Invalid _UniffiRustCallStatus code: {}".format(
+            call_status.code))
+
+def _uniffi_trait_interface_call(call_status, make_call, write_return_value):
+    try:
+        return write_return_value(make_call())
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+
+def _uniffi_trait_interface_call_with_error(call_status, make_call, write_return_value, error_type, lower_error):
+    try:
+        try:
+            return write_return_value(make_call())
+        except error_type as e:
+            call_status.code = _UniffiRustCallStatus.CALL_ERROR
+            call_status.error_buf = lower_error(e)
+    except Exception as e:
+        call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
+        call_status.error_buf = _UniffiFfiConverterString.lower(repr(e))
+# Initial value and increment amount for handles. 
+# These ensure that Python-generated handles always have the lowest bit set
+_UNIFFI_HANDLEMAP_INITIAL = 1
+_UNIFFI_HANDLEMAP_DELTA = 2
+
+class _UniffiHandleMap:
+    """
+    A map where inserting, getting and removing data is synchronized with a lock.
+    """
+
+    def __init__(self):
+        # type Handle = int
+        self._map = {}  # type: Dict[Handle, Any]
+        self._lock = threading.Lock()
+        self._counter = _UNIFFI_HANDLEMAP_INITIAL
+
+    def insert(self, obj):
+        with self._lock:
+            return self._insert(obj)
+
+    """Low-level insert, this assumes `self._lock` is held."""
+    def _insert(self, obj):
+        handle = self._counter
+        self._counter += _UNIFFI_HANDLEMAP_DELTA
+        self._map[handle] = obj
+        return handle
+
+    def get(self, handle):
+        try:
+            with self._lock:
+                return self._map[handle]
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.get: Invalid handle {handle}")
+
+    def clone(self, handle):
+        try:
+            with self._lock:
+                obj = self._map[handle]
+                return self._insert(obj)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.clone: Invalid handle {handle}")
+
+    def remove(self, handle):
+        try:
+            with self._lock:
+                return self._map.pop(handle)
+        except KeyError:
+            raise InternalError(f"_UniffiHandleMap.remove: Invalid handle: {handle}")
+
+    def __len__(self):
+        return len(self._map)
+# Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI.
+class _UniffiConverterPrimitive:
+    @classmethod
+    def lift(cls, value):
+        return value
+
+    @classmethod
+    def lower(cls, value):
+        return value
+
+class _UniffiConverterPrimitiveInt(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__index__()
+        except Exception:
+            raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__))
+        if not isinstance(value, int):
+            raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__))
+        if not cls.VALUE_MIN <= value < cls.VALUE_MAX:
+            raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX))
+
+class _UniffiConverterPrimitiveFloat(_UniffiConverterPrimitive):
+    @classmethod
+    def check_lower(cls, value):
+        try:
+            value = value.__float__()
+        except Exception:
+            raise TypeError("must be real number, not {}".format(type(value).__name__))
+        if not isinstance(value, float):
+            raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__))
+
+# Helper class for wrapper types that will always go through a _UniffiRustBuffer.
+# Classes should inherit from this and implement the `read` and `write` static methods.
+class _UniffiConverterRustBuffer:
+    @classmethod
+    def lift(cls, rbuf):
+        with rbuf.consume_with_stream() as stream:
+            return cls.read(stream)
+
+    @classmethod
+    def lower(cls, value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            cls.write(value, builder)
+            return builder.finalize()
+
+# Contains loading, initialization code, and the FFI Function declarations.
+# Define some ctypes FFI types that we use in the library
+
+"""
+Function pointer for a Rust task, which a callback function that takes a opaque pointer
+"""
+_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8)
+
+def _uniffi_future_callback_t(return_type):
+    """
+    Factory function to create callback function types for async functions
+    """
+    return ctypes.CFUNCTYPE(None, ctypes.c_uint64, return_type, _UniffiRustCallStatus)
+
+def _uniffi_load_indirect():
+    """
+    This is how we find and load the dynamic library provided by the component.
+    For now we just look it up by name.
+    """
+    if sys.platform == "darwin":
+        libname = "lib{}.dylib"
+    elif sys.platform.startswith("win"):
+        # As of python3.8, ctypes does not seem to search $PATH when loading DLLs.
+        # We could use `os.add_dll_directory` to configure the search path, but
+        # it doesn't feel right to mess with application-wide settings. Let's
+        # assume that the `.dll` is next to the `.py` file and load by full path.
+        libname = os.path.join(
+            os.path.dirname(__file__),
+            "{}.dll",
+        )
+    else:
+        # Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos
+        libname = "lib{}.so"
+
+    libname = libname.format("matrix_sdk_ffi")
+    path = os.path.join(os.path.dirname(__file__), libname)
+    lib = ctypes.cdll.LoadLibrary(path)
+    return lib
+
+def _uniffi_check_contract_api_version(lib):
+    # Get the bindings contract version from our ComponentInterface
+    bindings_contract_version = 30
+    # Get the scaffolding contract version by calling the into the dylib
+    scaffolding_contract_version = lib.ffi_matrix_sdk_crypto_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version:
+        raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+
+def _uniffi_check_api_checksums(lib):
+    pass
+
+# A ctypes library to expose the extern-C FFI definitions.
+# This is an implementation detail which will be called internally by the public API.
+
+_UniffiLib = _uniffi_load_indirect()
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_alloc.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_alloc.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_from_bytes.argtypes = (
+    _UniffiForeignBytes,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_from_bytes.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_free.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_free.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_reserve.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rustbuffer_reserve.restype = _UniffiRustBuffer
+_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_int8,
+)
+_UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
+)
+class _UniffiForeignFutureDroppedCallbackStruct(ctypes.Structure):
+    _fields_ = [
+        ("handle", ctypes.c_uint64),
+        ("free", _UNIFFI_FOREIGN_FUTURE_DROPPED_CALLBACK),
+    ]
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u8.restype = ctypes.c_uint8
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i8.restype = ctypes.c_int8
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u16.restype = ctypes.c_uint16
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i16.restype = ctypes.c_int16
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u32.restype = ctypes.c_uint32
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i32.restype = ctypes.c_int32
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_u64.restype = ctypes.c_uint64
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_i64.restype = ctypes.c_int64
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_f32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_f32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_f32.restype = ctypes.c_float
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_f64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_f64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_f64.restype = ctypes.c_double
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_void.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_poll_void.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_cancel_void.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_void.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_complete_void.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_crypto_rust_future_free_void.restype = None
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_backupsecrets.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_backupsecrets.restype = ctypes.c_uint64
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_backupsecrets.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_backupsecrets.restype = None
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_crosssigningsecrets.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_crosssigningsecrets.restype = ctypes.c_uint64
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_crosssigningsecrets.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_crosssigningsecrets.restype = None
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_secretsbundle.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_secretsbundle.restype = ctypes.c_uint64
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_secretsbundle.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_secretsbundle.restype = None
+_UniffiLib.ffi_matrix_sdk_crypto_uniffi_contract_version.argtypes = (
+)
+_UniffiLib.ffi_matrix_sdk_crypto_uniffi_contract_version.restype = ctypes.c_uint32
+
+_uniffi_check_contract_api_version(_UniffiLib)
+# _uniffi_check_api_checksums(_UniffiLib)
+
+
+
+# Public interface members begin here.
+
+
+
+
+
+
+
+class TrustRequirement(enum.Enum):
+    """
+    The trust level in the sender's device that is required to decrypt an
+    event.
+"""
+    
+    UNTRUSTED = 0
+    """
+    Decrypt events from everyone regardless of trust.
+
+    Not recommended, per the guidance of [MSC4153].
+
+    [MSC4153]: https://github.com/matrix-org/matrix-doc/pull/4153
+"""
+    
+    CROSS_SIGNED_OR_LEGACY = 1
+    """
+    Only decrypt events from cross-signed devices or legacy sessions (Megolm
+    sessions created before we started collecting trust information).
+"""
+    
+    CROSS_SIGNED = 2
+    """
+    Only decrypt events from cross-signed devices.
+"""
+    
+
+
+class _UniffiFfiConverterTypeTrustRequirement(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return TrustRequirement.UNTRUSTED
+        if variant == 2:
+            return TrustRequirement.CROSS_SIGNED_OR_LEGACY
+        if variant == 3:
+            return TrustRequirement.CROSS_SIGNED
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == TrustRequirement.UNTRUSTED:
+            return
+        if value == TrustRequirement.CROSS_SIGNED_OR_LEGACY:
+            return
+        if value == TrustRequirement.CROSS_SIGNED:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == TrustRequirement.UNTRUSTED:
+            buf.write_i32(1)
+        if value == TrustRequirement.CROSS_SIGNED_OR_LEGACY:
+            buf.write_i32(2)
+        if value == TrustRequirement.CROSS_SIGNED:
+            buf.write_i32(3)
+
+
+
+@dataclass
+class DecryptionSettings:
+    """
+    Settings for decrypting messages
+"""
+    def __init__(self, *, sender_device_trust_requirement:TrustRequirement):
+        self.sender_device_trust_requirement = sender_device_trust_requirement
+        
+        
+
+    
+    def __str__(self):
+        return "DecryptionSettings(sender_device_trust_requirement={})".format(self.sender_device_trust_requirement)
+    def __eq__(self, other):
+        if self.sender_device_trust_requirement != other.sender_device_trust_requirement:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeDecryptionSettings(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return DecryptionSettings(
+            sender_device_trust_requirement=_UniffiFfiConverterTypeTrustRequirement.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterTypeTrustRequirement.check_lower(value.sender_device_trust_requirement)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterTypeTrustRequirement.write(value.sender_device_trust_requirement, buf)
+
+
+
+
+
+
+class CollectStrategy(enum.Enum):
+    """
+    Strategy to collect the devices that should receive room keys for the
+    current discussion.
+"""
+    
+    ALL_DEVICES = 0
+    """
+    Share with all (unblacklisted) devices.
+
+    Not recommended, per the guidance of [MSC4153].
+
+    (Used by Element X and Element Web in the legacy, non-"exclude insecure
+    devices" mode.)
+
+    [MSC4153]: https://github.com/matrix-org/matrix-doc/pull/4153
+"""
+    
+    ERROR_ON_VERIFIED_USER_PROBLEM = 1
+    """
+    Share with all devices, except errors for *verified* users cause sharing
+    to fail with an error.
+
+    In this strategy, if a verified user has an unsigned device,
+    key sharing will fail with a
+    [`SessionRecipientCollectionError::VerifiedUserHasUnsignedDevice`].
+    If a verified user has replaced their identity, key
+    sharing will fail with a
+    [`SessionRecipientCollectionError::VerifiedUserChangedIdentity`].
+
+    Otherwise, keys are shared with unsigned devices as normal.
+
+    Once the problematic devices are blacklisted or whitelisted the
+    caller can retry to share a second time.
+
+    Not recommended, per the guidance of [MSC4153].
+
+    [MSC4153]: https://github.com/matrix-org/matrix-doc/pull/4153
+"""
+    
+    IDENTITY_BASED_STRATEGY = 2
+    """
+    Share based on identity. Only distribute to devices signed by their
+    owner. If a user has no published identity he will not receive
+    any room keys.
+
+    This is the recommended strategy: it is compliant with the guidance of
+    [MSC4153].
+
+    (Used by Element Web and Element X in the "exclude insecure devices"
+    mode.)
+
+    [MSC4153]: https://github.com/matrix-org/matrix-doc/pull/4153
+"""
+    
+    ONLY_TRUSTED_DEVICES = 3
+    """
+    Only share keys with devices that we "trust". A device is trusted if any
+    of the following is true:
+    - It was manually marked as trusted.
+    - It was marked as verified via interactive verification.
+    - It is signed by its owner identity, and this identity has been
+    trusted via interactive verification.
+    - It is the current own device of the user.
+
+    This strategy is compliant with [MSC4153], but is probably too strict
+    for normal use.
+
+    (Used by Element Web when "only send messages to verified users" is
+    enabled.)
+
+    [MSC4153]: https://github.com/matrix-org/matrix-doc/pull/4153
+"""
+    
+
+
+class _UniffiFfiConverterTypeCollectStrategy(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return CollectStrategy.ALL_DEVICES
+        if variant == 2:
+            return CollectStrategy.ERROR_ON_VERIFIED_USER_PROBLEM
+        if variant == 3:
+            return CollectStrategy.IDENTITY_BASED_STRATEGY
+        if variant == 4:
+            return CollectStrategy.ONLY_TRUSTED_DEVICES
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == CollectStrategy.ALL_DEVICES:
+            return
+        if value == CollectStrategy.ERROR_ON_VERIFIED_USER_PROBLEM:
+            return
+        if value == CollectStrategy.IDENTITY_BASED_STRATEGY:
+            return
+        if value == CollectStrategy.ONLY_TRUSTED_DEVICES:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == CollectStrategy.ALL_DEVICES:
+            buf.write_i32(1)
+        if value == CollectStrategy.ERROR_ON_VERIFIED_USER_PROBLEM:
+            buf.write_i32(2)
+        if value == CollectStrategy.IDENTITY_BASED_STRATEGY:
+            buf.write_i32(3)
+        if value == CollectStrategy.ONLY_TRUSTED_DEVICES:
+            buf.write_i32(4)
+
+
+
+
+
+
+
+
+class IdentityState(enum.Enum):
+    """
+    The state of an identity - verified, pinned etc.
+"""
+    
+    VERIFIED = 0
+    """
+    The user is verified with us
+"""
+    
+    PINNED = 1
+    """
+    Either this is the first identity we have seen for this user, or the
+    user has acknowledged a change of identity explicitly e.g. by
+    clicking OK on a notification.
+"""
+    
+    PIN_VIOLATION = 2
+    """
+    The user's identity has changed since it was pinned. The user should be
+    notified about this and given the opportunity to acknowledge the
+    change, which will make the new identity pinned.
+    When the user acknowledges the change, the app should call
+    [`crate::OtherUserIdentity::pin_current_master_key`].
+"""
+    
+    VERIFICATION_VIOLATION = 3
+    """
+    The user's identity has changed, and before that it was verified. This
+    is a serious problem. The user can either verify again to make this
+    identity verified, or withdraw verification
+    [`UserIdentity::withdraw_verification`] to make it pinned.
+"""
+    
+
+
+class _UniffiFfiConverterTypeIdentityState(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return IdentityState.VERIFIED
+        if variant == 2:
+            return IdentityState.PINNED
+        if variant == 3:
+            return IdentityState.PIN_VIOLATION
+        if variant == 4:
+            return IdentityState.VERIFICATION_VIOLATION
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == IdentityState.VERIFIED:
+            return
+        if value == IdentityState.PINNED:
+            return
+        if value == IdentityState.PIN_VIOLATION:
+            return
+        if value == IdentityState.VERIFICATION_VIOLATION:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == IdentityState.VERIFIED:
+            buf.write_i32(1)
+        if value == IdentityState.PINNED:
+            buf.write_i32(2)
+        if value == IdentityState.PIN_VIOLATION:
+            buf.write_i32(3)
+        if value == IdentityState.VERIFICATION_VIOLATION:
+            buf.write_i32(4)
+
+
+
+
+
+
+
+
+class LocalTrust(enum.Enum):
+    """
+    The local trust state of a device.
+"""
+    
+    VERIFIED = 0
+    """
+    The device has been verified and is trusted.
+"""
+    
+    BLACK_LISTED = 1
+    """
+    The device been blacklisted from communicating.
+"""
+    
+    IGNORED = 2
+    """
+    The trust state of the device is being ignored.
+"""
+    
+    UNSET = 3
+    """
+    The trust state is unset.
+"""
+    
+
+
+class _UniffiFfiConverterTypeLocalTrust(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return LocalTrust.VERIFIED
+        if variant == 2:
+            return LocalTrust.BLACK_LISTED
+        if variant == 3:
+            return LocalTrust.IGNORED
+        if variant == 4:
+            return LocalTrust.UNSET
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == LocalTrust.VERIFIED:
+            return
+        if value == LocalTrust.BLACK_LISTED:
+            return
+        if value == LocalTrust.IGNORED:
+            return
+        if value == LocalTrust.UNSET:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == LocalTrust.VERIFIED:
+            buf.write_i32(1)
+        if value == LocalTrust.BLACK_LISTED:
+            buf.write_i32(2)
+        if value == LocalTrust.IGNORED:
+            buf.write_i32(3)
+        if value == LocalTrust.UNSET:
+            buf.write_i32(4)
+
+
+
+
+
+# LoginQrCodeDecodeError
+# We want to define each variant as a nested class that's also a subclass,
+# which is tricky in Python.  To accomplish this we're going to create each
+# class separately, then manually add the child classes to the base class's
+# __dict__.  All of this happens in dummy class to avoid polluting the module
+# namespace.
+class LoginQrCodeDecodeError(Exception):
+    """
+    Error type for the decoding of the [`QrCodeData`].
+"""
+    pass
+
+_UniffiTempLoginQrCodeDecodeError = LoginQrCodeDecodeError
+
+class LoginQrCodeDecodeError:  # type: ignore
+    """
+    Error type for the decoding of the [`QrCodeData`].
+"""
+    
+    class NotEnoughData(_UniffiTempLoginQrCodeDecodeError):
+        """
+        The QR code data is no long enough, it's missing some fields.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.NotEnoughData({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.NotEnoughData = NotEnoughData # type: ignore
+    class NotUtf8(_UniffiTempLoginQrCodeDecodeError):
+        """
+        One of the URLs in the QR code data is not a valid UTF-8 encoded string.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.NotUtf8({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.NotUtf8 = NotUtf8 # type: ignore
+    class UrlParse(_UniffiTempLoginQrCodeDecodeError):
+        """
+        One of the URLs in the QR code data could not be parsed.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.UrlParse({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.UrlParse = UrlParse # type: ignore
+    class InvalidIntent(_UniffiTempLoginQrCodeDecodeError):
+        """
+        The QR code data contains an invalid intent, we expect the login
+        intent or the reciprocate intent.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.InvalidIntent({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.InvalidIntent = InvalidIntent # type: ignore
+    class InvalidType(_UniffiTempLoginQrCodeDecodeError):
+        """
+        The QR code data contains an unsupported type.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.InvalidType({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.InvalidType = InvalidType # type: ignore
+    class Base64(_UniffiTempLoginQrCodeDecodeError):
+        """
+        The base64 encoded variant of the QR code data is not a valid base64
+        string.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.Base64({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.Base64 = Base64 # type: ignore
+    class InvalidPrefix(_UniffiTempLoginQrCodeDecodeError):
+        """
+        The QR code data doesn't contain the expected `MATRIX` prefix.
+"""
+        def __repr__(self):
+            return "LoginQrCodeDecodeError.InvalidPrefix({})".format(repr(str(self)))
+    _UniffiTempLoginQrCodeDecodeError.InvalidPrefix = InvalidPrefix # type: ignore
+
+LoginQrCodeDecodeError = _UniffiTempLoginQrCodeDecodeError # type: ignore
+del _UniffiTempLoginQrCodeDecodeError
+
+
+class _UniffiFfiConverterTypeLoginQrCodeDecodeError(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return LoginQrCodeDecodeError.NotEnoughData(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 2:
+            return LoginQrCodeDecodeError.NotUtf8(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 3:
+            return LoginQrCodeDecodeError.UrlParse(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 4:
+            return LoginQrCodeDecodeError.InvalidIntent(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 5:
+            return LoginQrCodeDecodeError.InvalidType(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 6:
+            return LoginQrCodeDecodeError.Base64(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 7:
+            return LoginQrCodeDecodeError.InvalidPrefix(
+                _UniffiFfiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if isinstance(value, LoginQrCodeDecodeError.NotEnoughData):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.NotUtf8):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.UrlParse):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.InvalidIntent):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.InvalidType):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.Base64):
+            return
+        if isinstance(value, LoginQrCodeDecodeError.InvalidPrefix):
+            return
+
+    @staticmethod
+    def write(value, buf):
+        if isinstance(value, LoginQrCodeDecodeError.NotEnoughData):
+            buf.write_i32(1)
+        if isinstance(value, LoginQrCodeDecodeError.NotUtf8):
+            buf.write_i32(2)
+        if isinstance(value, LoginQrCodeDecodeError.UrlParse):
+            buf.write_i32(3)
+        if isinstance(value, LoginQrCodeDecodeError.InvalidIntent):
+            buf.write_i32(4)
+        if isinstance(value, LoginQrCodeDecodeError.InvalidType):
+            buf.write_i32(5)
+        if isinstance(value, LoginQrCodeDecodeError.Base64):
+            buf.write_i32(6)
+        if isinstance(value, LoginQrCodeDecodeError.InvalidPrefix):
+            buf.write_i32(7)
+
+
+
+
+
+
+class QrCodeIntent(enum.Enum):
+    """
+    The intent of the device that generated/displayed the QR code.
+
+    The QR code login mechanism supports both, the new device, as well as the
+    existing device to display the QR code.
+
+    The different intents have an explicit one-byte identifier which gets added
+    to the QR code data.
+"""
+    
+    LOGIN = 0
+    """
+    Enum variant for the case where the new device is displaying the QR
+    code.
+"""
+    
+    RECIPROCATE = 1
+    """
+    Enum variant for the case where the existing device is displaying the QR
+    code.
+"""
+    
+
+
+class _UniffiFfiConverterTypeQrCodeIntent(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return QrCodeIntent.LOGIN
+        if variant == 2:
+            return QrCodeIntent.RECIPROCATE
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == QrCodeIntent.LOGIN:
+            return
+        if value == QrCodeIntent.RECIPROCATE:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == QrCodeIntent.LOGIN:
+            buf.write_i32(1)
+        if value == QrCodeIntent.RECIPROCATE:
+            buf.write_i32(2)
+
+
+
+
+
+
+
+
+class SignatureState(enum.Enum):
+    """
+    The result of a signature check.
+"""
+    
+    MISSING = 0
+    """
+    The signature is missing.
+"""
+    
+    INVALID = 1
+    """
+    The signature is invalid.
+"""
+    
+    VALID_BUT_NOT_TRUSTED = 2
+    """
+    The signature is valid but the device or user identity that created the
+    signature is not trusted.
+"""
+    
+    VALID_AND_TRUSTED = 3
+    """
+    The signature is valid and the device or user identity that created the
+    signature is trusted.
+"""
+    
+
+
+class _UniffiFfiConverterTypeSignatureState(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return SignatureState.MISSING
+        if variant == 2:
+            return SignatureState.INVALID
+        if variant == 3:
+            return SignatureState.VALID_BUT_NOT_TRUSTED
+        if variant == 4:
+            return SignatureState.VALID_AND_TRUSTED
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == SignatureState.MISSING:
+            return
+        if value == SignatureState.INVALID:
+            return
+        if value == SignatureState.VALID_BUT_NOT_TRUSTED:
+            return
+        if value == SignatureState.VALID_AND_TRUSTED:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == SignatureState.MISSING:
+            buf.write_i32(1)
+        if value == SignatureState.INVALID:
+            buf.write_i32(2)
+        if value == SignatureState.VALID_BUT_NOT_TRUSTED:
+            buf.write_i32(3)
+        if value == SignatureState.VALID_AND_TRUSTED:
+            buf.write_i32(4)
+
+
+
+
+
+
+
+
+class UtdCause(enum.Enum):
+    """
+    Our best guess at the reason why an event can't be decrypted.
+"""
+    
+    UNKNOWN = 0
+    """
+    We don't have an explanation for why this UTD happened - it is probably
+    a bug, or a network split between the two homeservers.
+
+    For example:
+
+    - the keys for this event are missing, but a key storage backup exists
+    and is working, so we should be able to find the keys in the backup.
+
+    - the keys for this event are missing, and a key storage backup exists
+    on the server, but that backup is not working on this client even
+    though this device is verified.
+"""
+    
+    SENT_BEFORE_WE_JOINED = 1
+    """
+    We are missing the keys for this event, and the event was sent when we
+    were not a member of the room (or invited).
+"""
+    
+    VERIFICATION_VIOLATION = 2
+    """
+    The message was sent by a user identity we have not verified, but the
+    user was previously verified.
+"""
+    
+    UNSIGNED_DEVICE = 3
+    """
+    The [`crate::TrustRequirement`] requires that the sending device be
+    signed by its owner, and it was not.
+"""
+    
+    UNKNOWN_DEVICE = 4
+    """
+    The [`crate::TrustRequirement`] requires that the sending device be
+    signed by its owner, and we were unable to securely find the device.
+
+    This could be because the device has since been deleted, because we
+    haven't yet downloaded it from the server, or because the session
+    data was obtained from an insecure source (imported from a file,
+    obtained from a legacy (asymmetric) backup, unsafe key forward, etc.)
+"""
+    
+    HISTORICAL_MESSAGE_AND_BACKUP_IS_DISABLED = 5
+    """
+    We are missing the keys for this event, but it is a "device-historical"
+    message and there is no key storage backup on the server, presumably
+    because the user has turned it off.
+
+    Device-historical means that the message was sent before the current
+    device existed (but the current user was probably a member of the room
+    at the time the message was sent). Not to
+    be confused with pre-join or pre-invite messages (see
+    [`UtdCause::SentBeforeWeJoined`] for that).
+
+    Expected message to user: "History is not available on this device".
+"""
+    
+    WITHHELD_FOR_UNVERIFIED_OR_INSECURE_DEVICE = 6
+    """
+    The keys for this event are intentionally withheld.
+
+    The sender has refused to share the key because our device does not meet
+    the sender's security requirements.
+"""
+    
+    WITHHELD_BY_SENDER = 7
+    """
+    The keys for this event are missing, likely because the sender was
+    unable to share them (e.g., failure to establish an Olm 1:1
+    channel). Alternatively, the sender may have deliberately excluded
+    this device by cherry-picking and blocking it, in which case, no action
+    can be taken on our side.
+"""
+    
+    HISTORICAL_MESSAGE_AND_DEVICE_IS_UNVERIFIED = 8
+    """
+    We are missing the keys for this event, but it is a "device-historical"
+    message, and even though a key storage backup does exist, we can't use
+    it because our device is unverified.
+
+    Device-historical means that the message was sent before the current
+    device existed (but the current user was probably a member of the room
+    at the time the message was sent). Not to
+    be confused with pre-join or pre-invite messages (see
+    [`UtdCause::SentBeforeWeJoined`] for that).
+
+    Expected message to user: "You need to verify this device".
+"""
+    
+
+
+class _UniffiFfiConverterTypeUtdCause(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return UtdCause.UNKNOWN
+        if variant == 2:
+            return UtdCause.SENT_BEFORE_WE_JOINED
+        if variant == 3:
+            return UtdCause.VERIFICATION_VIOLATION
+        if variant == 4:
+            return UtdCause.UNSIGNED_DEVICE
+        if variant == 5:
+            return UtdCause.UNKNOWN_DEVICE
+        if variant == 6:
+            return UtdCause.HISTORICAL_MESSAGE_AND_BACKUP_IS_DISABLED
+        if variant == 7:
+            return UtdCause.WITHHELD_FOR_UNVERIFIED_OR_INSECURE_DEVICE
+        if variant == 8:
+            return UtdCause.WITHHELD_BY_SENDER
+        if variant == 9:
+            return UtdCause.HISTORICAL_MESSAGE_AND_DEVICE_IS_UNVERIFIED
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == UtdCause.UNKNOWN:
+            return
+        if value == UtdCause.SENT_BEFORE_WE_JOINED:
+            return
+        if value == UtdCause.VERIFICATION_VIOLATION:
+            return
+        if value == UtdCause.UNSIGNED_DEVICE:
+            return
+        if value == UtdCause.UNKNOWN_DEVICE:
+            return
+        if value == UtdCause.HISTORICAL_MESSAGE_AND_BACKUP_IS_DISABLED:
+            return
+        if value == UtdCause.WITHHELD_FOR_UNVERIFIED_OR_INSECURE_DEVICE:
+            return
+        if value == UtdCause.WITHHELD_BY_SENDER:
+            return
+        if value == UtdCause.HISTORICAL_MESSAGE_AND_DEVICE_IS_UNVERIFIED:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == UtdCause.UNKNOWN:
+            buf.write_i32(1)
+        if value == UtdCause.SENT_BEFORE_WE_JOINED:
+            buf.write_i32(2)
+        if value == UtdCause.VERIFICATION_VIOLATION:
+            buf.write_i32(3)
+        if value == UtdCause.UNSIGNED_DEVICE:
+            buf.write_i32(4)
+        if value == UtdCause.UNKNOWN_DEVICE:
+            buf.write_i32(5)
+        if value == UtdCause.HISTORICAL_MESSAGE_AND_BACKUP_IS_DISABLED:
+            buf.write_i32(6)
+        if value == UtdCause.WITHHELD_FOR_UNVERIFIED_OR_INSECURE_DEVICE:
+            buf.write_i32(7)
+        if value == UtdCause.WITHHELD_BY_SENDER:
+            buf.write_i32(8)
+        if value == UtdCause.HISTORICAL_MESSAGE_AND_DEVICE_IS_UNVERIFIED:
+            buf.write_i32(9)
+
+
+
+
+class BackupSecretsProtocol(typing.Protocol):
+    """
+    Enum for the algorithm-specific secrets for the room key backup.
+"""
+    
+    pass
+
+class BackupSecrets(BackupSecretsProtocol):
+    """
+    Enum for the algorithm-specific secrets for the room key backup.
+"""
+    
+    _handle: ctypes.c_uint64
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_backupsecrets, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_backupsecrets, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+
+
+
+
+
+class _UniffiFfiConverterTypeBackupSecrets:
+    @staticmethod
+    def lift(value: int) -> BackupSecrets:
+        return BackupSecrets._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: BackupSecrets):
+        if not isinstance(value, BackupSecrets):
+            raise TypeError("Expected BackupSecrets instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: BackupSecrets) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> BackupSecrets:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: BackupSecrets, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class CrossSigningSecretsProtocol(typing.Protocol):
+    """
+    Data for the secrets bundle containing the cross-signing keys.
+"""
+    
+    pass
+
+class CrossSigningSecrets(CrossSigningSecretsProtocol):
+    """
+    Data for the secrets bundle containing the cross-signing keys.
+"""
+    
+    _handle: ctypes.c_uint64
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_crosssigningsecrets, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_crosssigningsecrets, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+
+
+
+
+
+class _UniffiFfiConverterTypeCrossSigningSecrets:
+    @staticmethod
+    def lift(value: int) -> CrossSigningSecrets:
+        return CrossSigningSecrets._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: CrossSigningSecrets):
+        if not isinstance(value, CrossSigningSecrets):
+            raise TypeError("Expected CrossSigningSecrets instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: CrossSigningSecrets) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> CrossSigningSecrets:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: CrossSigningSecrets, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+
+class SecretsBundleProtocol(typing.Protocol):
+    """
+    Struct containing the bundle of secrets to fully activate a new device for
+    end-to-end encryption.
+"""
+    
+    pass
+
+class SecretsBundle(SecretsBundleProtocol):
+    """
+    Struct containing the bundle of secrets to fully activate a new device for
+    end-to-end encryption.
+"""
+    
+    _handle: ctypes.c_uint64
+    
+    def __init__(self, *args, **kwargs):
+        raise ValueError("This class has no default constructor")
+
+    def __del__(self):
+        # In case of partial initialization of instances.
+        handle = getattr(self, "_handle", None)
+        if handle is not None:
+            _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_free_secretsbundle, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_crypto_fn_clone_secretsbundle, self._handle)
+
+    # Used by alternative constructors or any methods which return this type.
+    @classmethod
+    def _uniffi_make_instance(cls, handle):
+        # Lightly yucky way to bypass the usual __init__ logic
+        # and just create a new instance with the required handle.
+        inst = cls.__new__(cls)
+        inst._handle = handle
+        return inst
+
+
+
+
+
+class _UniffiFfiConverterTypeSecretsBundle:
+    @staticmethod
+    def lift(value: int) -> SecretsBundle:
+        return SecretsBundle._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: SecretsBundle):
+        if not isinstance(value, SecretsBundle):
+            raise TypeError("Expected SecretsBundle instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: SecretsBundle) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> SecretsBundle:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: SecretsBundle, buf: _UniffiRustBuffer):
+        buf.write_u64(cls.lower(value))
+
+class _UniffiFfiConverterUInt8(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u8"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**8
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u8()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u8(value)
+
+class _UniffiFfiConverterUInt64(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "u64"
+    VALUE_MIN = 0
+    VALUE_MAX = 2**64
+
+    @staticmethod
+    def read(buf):
+        return buf.read_u64()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_u64(value)
+
+class _UniffiFfiConverterString:
+    @staticmethod
+    def check_lower(value):
+        if not isinstance(value, str):
+            raise TypeError("argument must be str, not {}".format(type(value).__name__))
+        return value
+
+    @staticmethod
+    def read(buf):
+        size = buf.read_i32()
+        if size < 0:
+            raise InternalError("Unexpected negative string length")
+        utf8_bytes = buf.read(size)
+        return utf8_bytes.decode("utf-8")
+
+    @staticmethod
+    def write(value, buf):
+        utf8_bytes = value.encode("utf-8")
+        buf.write_i32(len(utf8_bytes))
+        buf.write(utf8_bytes)
+
+    @staticmethod
+    def lift(buf):
+        with buf.consume_with_stream() as stream:
+            return stream.read(stream.remaining()).decode("utf-8")
+
+    @staticmethod
+    def lower(value):
+        with _UniffiRustBuffer.alloc_with_builder() as builder:
+            builder.write(value.encode("utf-8"))
+            return builder.finalize()
+
+__all__ = [
+    "InternalError",
+    "TrustRequirement",
+    "CollectStrategy",
+    "IdentityState",
+    "LocalTrust",
+    "LoginQrCodeDecodeError",
+    "QrCodeIntent",
+    "SignatureState",
+    "UtdCause",
+    "DecryptionSettings",
+    "BackupSecrets",
+    "BackupSecretsProtocol",
+    "CrossSigningSecrets",
+    "CrossSigningSecretsProtocol",
+    "SecretsBundle",
+    "SecretsBundleProtocol",
+]