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

matrix_sdk_python/_generated/matrix_sdk.py

@@ -0,0 +1,2533 @@
+# 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_rustbuffer_alloc, size)
+
+    @staticmethod
+    def reserve(rbuf, additional):
+        return _uniffi_rust_call(_UniffiLib.ffi_matrix_sdk_rustbuffer_reserve, rbuf, additional)
+
+    def free(self):
+        return _uniffi_rust_call(_UniffiLib.ffi_matrix_sdk_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_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):
+    if lib.uniffi_matrix_sdk_checksum_method_oauthauthorizationdata_login_url() != 47865:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+
+# 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_rustbuffer_alloc.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rustbuffer_alloc.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_rustbuffer_from_bytes.argtypes = (
+    _UniffiForeignBytes,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rustbuffer_from_bytes.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_rustbuffer_free.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rustbuffer_free.restype = None
+_UniffiLib.ffi_matrix_sdk_rustbuffer_reserve.argtypes = (
+    _UniffiRustBuffer,
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_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_rust_future_poll_u8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u8.restype = ctypes.c_uint8
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i8.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i8.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i8.restype = ctypes.c_int8
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i8.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i8.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u16.restype = ctypes.c_uint16
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i16.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i16.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i16.restype = ctypes.c_int16
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i16.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i16.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u32.restype = ctypes.c_uint32
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i32.restype = ctypes.c_int32
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_u64.restype = ctypes.c_uint64
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_u64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_i64.restype = ctypes.c_int64
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_i64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_f32.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_f32.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_f32.restype = ctypes.c_float
+_UniffiLib.ffi_matrix_sdk_rust_future_free_f32.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_f32.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_f64.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_f64.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_f64.restype = ctypes.c_double
+_UniffiLib.ffi_matrix_sdk_rust_future_free_f64.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_f64.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_rust_future_free_rust_buffer.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_rust_buffer.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_void.argtypes = (
+    ctypes.c_uint64,
+    _UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_poll_void.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_cancel_void.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_void.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_complete_void.restype = None
+_UniffiLib.ffi_matrix_sdk_rust_future_free_void.argtypes = (
+    ctypes.c_uint64,
+)
+_UniffiLib.ffi_matrix_sdk_rust_future_free_void.restype = None
+_UniffiLib.uniffi_matrix_sdk_fn_clone_oauthauthorizationdata.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_fn_clone_oauthauthorizationdata.restype = ctypes.c_uint64
+_UniffiLib.uniffi_matrix_sdk_fn_free_oauthauthorizationdata.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_fn_free_oauthauthorizationdata.restype = None
+_UniffiLib.uniffi_matrix_sdk_fn_method_oauthauthorizationdata_login_url.argtypes = (
+    ctypes.c_uint64,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_matrix_sdk_fn_method_oauthauthorizationdata_login_url.restype = _UniffiRustBuffer
+_UniffiLib.ffi_matrix_sdk_uniffi_contract_version.argtypes = (
+)
+_UniffiLib.ffi_matrix_sdk_uniffi_contract_version.restype = ctypes.c_uint32
+_UniffiLib.uniffi_matrix_sdk_checksum_method_oauthauthorizationdata_login_url.argtypes = (
+)
+_UniffiLib.uniffi_matrix_sdk_checksum_method_oauthauthorizationdata_login_url.restype = ctypes.c_uint16
+
+_uniffi_check_contract_api_version(_UniffiLib)
+# _uniffi_check_api_checksums(_UniffiLib)
+
+
+
+# Public interface members begin here.
+
+
+class _UniffiFfiConverterInt64(_UniffiConverterPrimitiveInt):
+    CLASS_NAME = "i64"
+    VALUE_MIN = -2**63
+    VALUE_MAX = 2**63
+
+    @staticmethod
+    def read(buf):
+        return buf.read_i64()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_i64(value)
+
+class _UniffiFfiConverterOptionalInt64(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterInt64.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterInt64.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterInt64.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class RoomPowerLevelChanges:
+    """
+    A set of common power levels required for various operations within a room,
+    that can be applied as a single operation. When updating these
+    settings, any levels that are `None` will remain unchanged.
+"""
+    def __init__(self, *, ban:typing.Optional[int] = _DEFAULT, invite:typing.Optional[int] = _DEFAULT, kick:typing.Optional[int] = _DEFAULT, redact:typing.Optional[int] = _DEFAULT, events_default:typing.Optional[int] = _DEFAULT, state_default:typing.Optional[int] = _DEFAULT, users_default:typing.Optional[int] = _DEFAULT, room_name:typing.Optional[int] = _DEFAULT, room_avatar:typing.Optional[int] = _DEFAULT, room_topic:typing.Optional[int] = _DEFAULT, space_child:typing.Optional[int] = _DEFAULT, beacon:typing.Optional[int] = _DEFAULT, beacon_info:typing.Optional[int] = _DEFAULT):
+        if ban is _DEFAULT:
+            self.ban = None
+        else:
+            self.ban = ban
+        if invite is _DEFAULT:
+            self.invite = None
+        else:
+            self.invite = invite
+        if kick is _DEFAULT:
+            self.kick = None
+        else:
+            self.kick = kick
+        if redact is _DEFAULT:
+            self.redact = None
+        else:
+            self.redact = redact
+        if events_default is _DEFAULT:
+            self.events_default = None
+        else:
+            self.events_default = events_default
+        if state_default is _DEFAULT:
+            self.state_default = None
+        else:
+            self.state_default = state_default
+        if users_default is _DEFAULT:
+            self.users_default = None
+        else:
+            self.users_default = users_default
+        if room_name is _DEFAULT:
+            self.room_name = None
+        else:
+            self.room_name = room_name
+        if room_avatar is _DEFAULT:
+            self.room_avatar = None
+        else:
+            self.room_avatar = room_avatar
+        if room_topic is _DEFAULT:
+            self.room_topic = None
+        else:
+            self.room_topic = room_topic
+        if space_child is _DEFAULT:
+            self.space_child = None
+        else:
+            self.space_child = space_child
+        if beacon is _DEFAULT:
+            self.beacon = None
+        else:
+            self.beacon = beacon
+        if beacon_info is _DEFAULT:
+            self.beacon_info = None
+        else:
+            self.beacon_info = beacon_info
+        
+        
+
+    
+    def __str__(self):
+        return "RoomPowerLevelChanges(ban={}, invite={}, kick={}, redact={}, events_default={}, state_default={}, users_default={}, room_name={}, room_avatar={}, room_topic={}, space_child={}, beacon={}, beacon_info={})".format(self.ban, self.invite, self.kick, self.redact, self.events_default, self.state_default, self.users_default, self.room_name, self.room_avatar, self.room_topic, self.space_child, self.beacon, self.beacon_info)
+    def __eq__(self, other):
+        if self.ban != other.ban:
+            return False
+        if self.invite != other.invite:
+            return False
+        if self.kick != other.kick:
+            return False
+        if self.redact != other.redact:
+            return False
+        if self.events_default != other.events_default:
+            return False
+        if self.state_default != other.state_default:
+            return False
+        if self.users_default != other.users_default:
+            return False
+        if self.room_name != other.room_name:
+            return False
+        if self.room_avatar != other.room_avatar:
+            return False
+        if self.room_topic != other.room_topic:
+            return False
+        if self.space_child != other.space_child:
+            return False
+        if self.beacon != other.beacon:
+            return False
+        if self.beacon_info != other.beacon_info:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeRoomPowerLevelChanges(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return RoomPowerLevelChanges(
+            ban=_UniffiFfiConverterOptionalInt64.read(buf),
+            invite=_UniffiFfiConverterOptionalInt64.read(buf),
+            kick=_UniffiFfiConverterOptionalInt64.read(buf),
+            redact=_UniffiFfiConverterOptionalInt64.read(buf),
+            events_default=_UniffiFfiConverterOptionalInt64.read(buf),
+            state_default=_UniffiFfiConverterOptionalInt64.read(buf),
+            users_default=_UniffiFfiConverterOptionalInt64.read(buf),
+            room_name=_UniffiFfiConverterOptionalInt64.read(buf),
+            room_avatar=_UniffiFfiConverterOptionalInt64.read(buf),
+            room_topic=_UniffiFfiConverterOptionalInt64.read(buf),
+            space_child=_UniffiFfiConverterOptionalInt64.read(buf),
+            beacon=_UniffiFfiConverterOptionalInt64.read(buf),
+            beacon_info=_UniffiFfiConverterOptionalInt64.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalInt64.check_lower(value.ban)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.invite)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.kick)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.redact)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.events_default)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.state_default)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.users_default)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.room_name)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.room_avatar)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.room_topic)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.space_child)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.beacon)
+        _UniffiFfiConverterOptionalInt64.check_lower(value.beacon_info)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalInt64.write(value.ban, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.invite, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.kick, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.redact, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.events_default, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.state_default, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.users_default, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.room_name, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.room_avatar, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.room_topic, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.space_child, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.beacon, buf)
+        _UniffiFfiConverterOptionalInt64.write(value.beacon_info, buf)
+
+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()
+
+@dataclass
+class ServerVendorInfo:
+    """
+    Information about the server vendor obtained from the federation API.
+"""
+    def __init__(self, *, server_name:str, version:str):
+        self.server_name = server_name
+        self.version = version
+        
+        
+
+    
+    def __str__(self):
+        return "ServerVendorInfo(server_name={}, version={})".format(self.server_name, self.version)
+    def __eq__(self, other):
+        if self.server_name != other.server_name:
+            return False
+        if self.version != other.version:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeServerVendorInfo(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return ServerVendorInfo(
+            server_name=_UniffiFfiConverterString.read(buf),
+            version=_UniffiFfiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterString.check_lower(value.server_name)
+        _UniffiFfiConverterString.check_lower(value.version)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterString.write(value.server_name, buf)
+        _UniffiFfiConverterString.write(value.version, buf)
+
+@dataclass
+class TileServerInfo:
+    """
+    Information about a map tile server advertised by the homeserver through the
+    `tile_server` field of the matrix client well-known (MSC3488).
+"""
+    def __init__(self, *, map_style_url:str):
+        self.map_style_url = map_style_url
+        
+        
+
+    
+    def __str__(self):
+        return "TileServerInfo(map_style_url={})".format(self.map_style_url)
+    def __eq__(self, other):
+        if self.map_style_url != other.map_style_url:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeTileServerInfo(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return TileServerInfo(
+            map_style_url=_UniffiFfiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterString.check_lower(value.map_style_url)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterString.write(value.map_style_url, buf)
+
+
+
+
+
+
+class Intent(enum.Enum):
+    """
+    Defines the intent of showing the call.
+
+    This controls whether to show or skip the lobby.
+"""
+    
+    START_CALL = 0
+    """
+    The user wants to start a call.
+"""
+    
+    JOIN_EXISTING = 1
+    """
+    The user wants to join an existing call.
+"""
+    
+    JOIN_EXISTING_DM = 2
+    """
+    The user wants to join an existing call that is a "Direct Message" (DM)
+    room.
+"""
+    
+    START_CALL_DM = 3
+    """
+    The user wants to start a call in a "Direct Message" (DM) room.
+"""
+    
+    START_CALL_DM_VOICE = 4
+    """
+    The user wants to start a voice call in a "Direct Message" (DM) room.
+"""
+    
+    JOIN_EXISTING_DM_VOICE = 5
+    """
+    The user wants to join an existing  voice call that is a "Direct
+    Message" (DM) room.
+"""
+    
+
+
+class _UniffiFfiConverterTypeIntent(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return Intent.START_CALL
+        if variant == 2:
+            return Intent.JOIN_EXISTING
+        if variant == 3:
+            return Intent.JOIN_EXISTING_DM
+        if variant == 4:
+            return Intent.START_CALL_DM
+        if variant == 5:
+            return Intent.START_CALL_DM_VOICE
+        if variant == 6:
+            return Intent.JOIN_EXISTING_DM_VOICE
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == Intent.START_CALL:
+            return
+        if value == Intent.JOIN_EXISTING:
+            return
+        if value == Intent.JOIN_EXISTING_DM:
+            return
+        if value == Intent.START_CALL_DM:
+            return
+        if value == Intent.START_CALL_DM_VOICE:
+            return
+        if value == Intent.JOIN_EXISTING_DM_VOICE:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == Intent.START_CALL:
+            buf.write_i32(1)
+        if value == Intent.JOIN_EXISTING:
+            buf.write_i32(2)
+        if value == Intent.JOIN_EXISTING_DM:
+            buf.write_i32(3)
+        if value == Intent.START_CALL_DM:
+            buf.write_i32(4)
+        if value == Intent.START_CALL_DM_VOICE:
+            buf.write_i32(5)
+        if value == Intent.JOIN_EXISTING_DM_VOICE:
+            buf.write_i32(6)
+
+
+
+class _UniffiFfiConverterOptionalTypeIntent(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeIntent.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeIntent.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeIntent.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+class _UniffiFfiConverterBoolean:
+    @classmethod
+    def check_lower(cls, value):
+        return not not value
+
+    @classmethod
+    def lower(cls, value):
+        return 1 if value else 0
+
+    @staticmethod
+    def lift(value):
+        return value != 0
+
+    @classmethod
+    def read(cls, buf):
+        return cls.lift(buf.read_u8())
+
+    @classmethod
+    def write(cls, value, buf):
+        buf.write_u8(value)
+
+class _UniffiFfiConverterOptionalBoolean(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterBoolean.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterBoolean.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterBoolean.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+
+
+
+class HeaderStyle(enum.Enum):
+    """
+    Defines how (if) element-call renders a header.
+"""
+    
+    STANDARD = 0
+    """
+    The normal header with branding.
+"""
+    
+    APP_BAR = 1
+    """
+    Render a header with a back button (useful on mobile platforms).
+"""
+    
+    NONE = 2
+    """
+    No Header (useful for webapps).
+"""
+    
+
+
+class _UniffiFfiConverterTypeHeaderStyle(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return HeaderStyle.STANDARD
+        if variant == 2:
+            return HeaderStyle.APP_BAR
+        if variant == 3:
+            return HeaderStyle.NONE
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == HeaderStyle.STANDARD:
+            return
+        if value == HeaderStyle.APP_BAR:
+            return
+        if value == HeaderStyle.NONE:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == HeaderStyle.STANDARD:
+            buf.write_i32(1)
+        if value == HeaderStyle.APP_BAR:
+            buf.write_i32(2)
+        if value == HeaderStyle.NONE:
+            buf.write_i32(3)
+
+
+
+class _UniffiFfiConverterOptionalTypeHeaderStyle(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeHeaderStyle.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeHeaderStyle.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeHeaderStyle.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+
+
+
+class NotificationType(enum.Enum):
+    """
+    Types of call notifications.
+"""
+    
+    NOTIFICATION = 0
+    """
+    The receiving client should display a visual notification.
+"""
+    
+    RING = 1
+    """
+    The receiving client should ring with an audible sound.
+"""
+    
+
+
+class _UniffiFfiConverterTypeNotificationType(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return NotificationType.NOTIFICATION
+        if variant == 2:
+            return NotificationType.RING
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == NotificationType.NOTIFICATION:
+            return
+        if value == NotificationType.RING:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == NotificationType.NOTIFICATION:
+            buf.write_i32(1)
+        if value == NotificationType.RING:
+            buf.write_i32(2)
+
+
+
+class _UniffiFfiConverterOptionalTypeNotificationType(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterTypeNotificationType.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterTypeNotificationType.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterTypeNotificationType.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+@dataclass
+class VirtualElementCallWidgetConfig:
+    """
+    Configuration parameters, to create a new virtual Element Call widget.
+
+    If `intent` is provided the appropriate default values for all other
+    parameters will be used by element call.
+    In most cases its enough to only set the intent. Use the other properties
+    only if you want to deviate from the `intent` defaults.
+
+    Set [`docs/url-params.md`](https://github.com/element-hq/element-call/blob/livekit/docs/url-params.md)
+    to find out more about the parameters and their defaults.
+"""
+    def __init__(self, *, intent:typing.Optional[Intent], skip_lobby:typing.Optional[bool] = _DEFAULT, header:typing.Optional[HeaderStyle] = _DEFAULT, hide_header:typing.Optional[bool] = _DEFAULT, preload:typing.Optional[bool] = _DEFAULT, app_prompt:typing.Optional[bool] = _DEFAULT, confine_to_room:typing.Optional[bool] = _DEFAULT, hide_screensharing:typing.Optional[bool] = _DEFAULT, controlled_audio_devices:typing.Optional[bool] = _DEFAULT, send_notification_type:typing.Optional[NotificationType] = _DEFAULT):
+        self.intent = intent
+        if skip_lobby is _DEFAULT:
+            self.skip_lobby = None
+        else:
+            self.skip_lobby = skip_lobby
+        if header is _DEFAULT:
+            self.header = None
+        else:
+            self.header = header
+        if hide_header is _DEFAULT:
+            self.hide_header = None
+        else:
+            self.hide_header = hide_header
+        if preload is _DEFAULT:
+            self.preload = None
+        else:
+            self.preload = preload
+        if app_prompt is _DEFAULT:
+            self.app_prompt = None
+        else:
+            self.app_prompt = app_prompt
+        if confine_to_room is _DEFAULT:
+            self.confine_to_room = None
+        else:
+            self.confine_to_room = confine_to_room
+        if hide_screensharing is _DEFAULT:
+            self.hide_screensharing = None
+        else:
+            self.hide_screensharing = hide_screensharing
+        if controlled_audio_devices is _DEFAULT:
+            self.controlled_audio_devices = None
+        else:
+            self.controlled_audio_devices = controlled_audio_devices
+        if send_notification_type is _DEFAULT:
+            self.send_notification_type = None
+        else:
+            self.send_notification_type = send_notification_type
+        
+        
+
+    
+    def __str__(self):
+        return "VirtualElementCallWidgetConfig(intent={}, skip_lobby={}, header={}, hide_header={}, preload={}, app_prompt={}, confine_to_room={}, hide_screensharing={}, controlled_audio_devices={}, send_notification_type={})".format(self.intent, self.skip_lobby, self.header, self.hide_header, self.preload, self.app_prompt, self.confine_to_room, self.hide_screensharing, self.controlled_audio_devices, self.send_notification_type)
+    def __eq__(self, other):
+        if self.intent != other.intent:
+            return False
+        if self.skip_lobby != other.skip_lobby:
+            return False
+        if self.header != other.header:
+            return False
+        if self.hide_header != other.hide_header:
+            return False
+        if self.preload != other.preload:
+            return False
+        if self.app_prompt != other.app_prompt:
+            return False
+        if self.confine_to_room != other.confine_to_room:
+            return False
+        if self.hide_screensharing != other.hide_screensharing:
+            return False
+        if self.controlled_audio_devices != other.controlled_audio_devices:
+            return False
+        if self.send_notification_type != other.send_notification_type:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeVirtualElementCallWidgetConfig(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return VirtualElementCallWidgetConfig(
+            intent=_UniffiFfiConverterOptionalTypeIntent.read(buf),
+            skip_lobby=_UniffiFfiConverterOptionalBoolean.read(buf),
+            header=_UniffiFfiConverterOptionalTypeHeaderStyle.read(buf),
+            hide_header=_UniffiFfiConverterOptionalBoolean.read(buf),
+            preload=_UniffiFfiConverterOptionalBoolean.read(buf),
+            app_prompt=_UniffiFfiConverterOptionalBoolean.read(buf),
+            confine_to_room=_UniffiFfiConverterOptionalBoolean.read(buf),
+            hide_screensharing=_UniffiFfiConverterOptionalBoolean.read(buf),
+            controlled_audio_devices=_UniffiFfiConverterOptionalBoolean.read(buf),
+            send_notification_type=_UniffiFfiConverterOptionalTypeNotificationType.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterOptionalTypeIntent.check_lower(value.intent)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.skip_lobby)
+        _UniffiFfiConverterOptionalTypeHeaderStyle.check_lower(value.header)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.hide_header)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.preload)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.app_prompt)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.confine_to_room)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.hide_screensharing)
+        _UniffiFfiConverterOptionalBoolean.check_lower(value.controlled_audio_devices)
+        _UniffiFfiConverterOptionalTypeNotificationType.check_lower(value.send_notification_type)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterOptionalTypeIntent.write(value.intent, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.skip_lobby, buf)
+        _UniffiFfiConverterOptionalTypeHeaderStyle.write(value.header, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.hide_header, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.preload, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.app_prompt, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.confine_to_room, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.hide_screensharing, buf)
+        _UniffiFfiConverterOptionalBoolean.write(value.controlled_audio_devices, buf)
+        _UniffiFfiConverterOptionalTypeNotificationType.write(value.send_notification_type, buf)
+
+class _UniffiFfiConverterOptionalString(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterString.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterString.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterString.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+class _UniffiFfiConverterFloat64(_UniffiConverterPrimitiveFloat):
+    @staticmethod
+    def read(buf):
+        return buf.read_double()
+
+    @staticmethod
+    def write(value, buf):
+        buf.write_double(value)
+
+class _UniffiFfiConverterOptionalFloat64(_UniffiConverterRustBuffer):
+    @classmethod
+    def check_lower(cls, value):
+        if value is not None:
+            _UniffiFfiConverterFloat64.check_lower(value)
+
+    @classmethod
+    def write(cls, value, buf):
+        if value is None:
+            buf.write_u8(0)
+            return
+
+        buf.write_u8(1)
+        _UniffiFfiConverterFloat64.write(value, buf)
+
+    @classmethod
+    def read(cls, buf):
+        flag = buf.read_u8()
+        if flag == 0:
+            return None
+        elif flag == 1:
+            return _UniffiFfiConverterFloat64.read(buf)
+        else:
+            raise InternalError("Unexpected flag byte for optional type")
+
+
+
+
+
+
+class EncryptionSystem:
+    """
+    Defines if a call is encrypted and which encryption system should be used.
+
+    This controls the url parameters: `perParticipantE2EE`, `password`.
+"""
+    def __init__(self):
+        raise RuntimeError("EncryptionSystem cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    @dataclass
+    class UNENCRYPTED:
+        """
+        Equivalent to the element call url parameter: `perParticipantE2EE=false`
+        and no password.
+"""
+        
+        def __init__(self, ):
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "EncryptionSystem.UNENCRYPTED()".format()
+        def __eq__(self, other):
+            if not isinstance(other, EncryptionSystem):
+                return NotImplemented
+            if not other.is_UNENCRYPTED():
+                return False
+            return True
+
+    @dataclass
+    class PER_PARTICIPANT_KEYS:
+        """
+        Equivalent to the element call url parameters:
+        `perParticipantE2EE=true`
+"""
+        
+        def __init__(self, ):
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "EncryptionSystem.PER_PARTICIPANT_KEYS()".format()
+        def __eq__(self, other):
+            if not isinstance(other, EncryptionSystem):
+                return NotImplemented
+            if not other.is_PER_PARTICIPANT_KEYS():
+                return False
+            return True
+
+    @dataclass
+    class SHARED_SECRET:
+        """
+        Equivalent to the element call url parameters:
+        `password={secret}`
+"""
+        
+        def __init__(self, secret:str):
+            self.secret = secret
+            
+            """
+        The secret/password which is used in the url.
+"""
+        
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "EncryptionSystem.SHARED_SECRET(secret={})".format(self.secret)
+        def __eq__(self, other):
+            if not isinstance(other, EncryptionSystem):
+                return NotImplemented
+            if not other.is_SHARED_SECRET():
+                return False
+            if self.secret != other.secret:
+                return False
+            return True
+
+    
+
+    # For each variant, we have `is_NAME` and `is_name` methods for easily checking
+    # whether an instance is that variant.
+    def is_UNENCRYPTED(self) -> bool:
+        return isinstance(self, EncryptionSystem.UNENCRYPTED)
+    def is_unencrypted(self) -> bool:
+        return isinstance(self, EncryptionSystem.UNENCRYPTED)
+    def is_PER_PARTICIPANT_KEYS(self) -> bool:
+        return isinstance(self, EncryptionSystem.PER_PARTICIPANT_KEYS)
+    def is_per_participant_keys(self) -> bool:
+        return isinstance(self, EncryptionSystem.PER_PARTICIPANT_KEYS)
+    def is_SHARED_SECRET(self) -> bool:
+        return isinstance(self, EncryptionSystem.SHARED_SECRET)
+    def is_shared_secret(self) -> bool:
+        return isinstance(self, EncryptionSystem.SHARED_SECRET)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+EncryptionSystem.UNENCRYPTED = type("EncryptionSystem.UNENCRYPTED", (EncryptionSystem.UNENCRYPTED, EncryptionSystem,), {})  # type: ignore
+EncryptionSystem.PER_PARTICIPANT_KEYS = type("EncryptionSystem.PER_PARTICIPANT_KEYS", (EncryptionSystem.PER_PARTICIPANT_KEYS, EncryptionSystem,), {})  # type: ignore
+EncryptionSystem.SHARED_SECRET = type("EncryptionSystem.SHARED_SECRET", (EncryptionSystem.SHARED_SECRET, EncryptionSystem,), {})  # type: ignore
+
+
+
+
+class _UniffiFfiConverterTypeEncryptionSystem(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return EncryptionSystem.UNENCRYPTED(
+            )
+        if variant == 2:
+            return EncryptionSystem.PER_PARTICIPANT_KEYS(
+            )
+        if variant == 3:
+            return EncryptionSystem.SHARED_SECRET(
+                _UniffiFfiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_UNENCRYPTED():
+            return
+        if value.is_PER_PARTICIPANT_KEYS():
+            return
+        if value.is_SHARED_SECRET():
+            _UniffiFfiConverterString.check_lower(value.secret)
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_UNENCRYPTED():
+            buf.write_i32(1)
+        if value.is_PER_PARTICIPANT_KEYS():
+            buf.write_i32(2)
+        if value.is_SHARED_SECRET():
+            buf.write_i32(3)
+            _UniffiFfiConverterString.write(value.secret, buf)
+
+
+
+@dataclass
+class VirtualElementCallWidgetProperties:
+    """
+    Properties to create a new virtual Element Call widget.
+
+    All these are required to start the widget in the first place.
+    This is different from the `VirtualElementCallWidgetConfiguration` which
+    configures the widgets behavior.
+"""
+    def __init__(self, *, element_call_url:str, widget_id:str, parent_url:typing.Optional[str] = _DEFAULT, font_scale:typing.Optional[float] = _DEFAULT, font:typing.Optional[str] = _DEFAULT, encryption:EncryptionSystem, posthog_user_id:typing.Optional[str] = _DEFAULT, posthog_api_host:typing.Optional[str] = _DEFAULT, posthog_api_key:typing.Optional[str] = _DEFAULT, rageshake_submit_url:typing.Optional[str] = _DEFAULT, sentry_dsn:typing.Optional[str] = _DEFAULT, sentry_environment:typing.Optional[str] = _DEFAULT):
+        self.element_call_url = element_call_url
+        self.widget_id = widget_id
+        if parent_url is _DEFAULT:
+            self.parent_url = None
+        else:
+            self.parent_url = parent_url
+        if font_scale is _DEFAULT:
+            self.font_scale = None
+        else:
+            self.font_scale = font_scale
+        if font is _DEFAULT:
+            self.font = None
+        else:
+            self.font = font
+        self.encryption = encryption
+        if posthog_user_id is _DEFAULT:
+            self.posthog_user_id = None
+        else:
+            self.posthog_user_id = posthog_user_id
+        if posthog_api_host is _DEFAULT:
+            self.posthog_api_host = None
+        else:
+            self.posthog_api_host = posthog_api_host
+        if posthog_api_key is _DEFAULT:
+            self.posthog_api_key = None
+        else:
+            self.posthog_api_key = posthog_api_key
+        if rageshake_submit_url is _DEFAULT:
+            self.rageshake_submit_url = None
+        else:
+            self.rageshake_submit_url = rageshake_submit_url
+        if sentry_dsn is _DEFAULT:
+            self.sentry_dsn = None
+        else:
+            self.sentry_dsn = sentry_dsn
+        if sentry_environment is _DEFAULT:
+            self.sentry_environment = None
+        else:
+            self.sentry_environment = sentry_environment
+        
+        
+
+    
+    def __str__(self):
+        return "VirtualElementCallWidgetProperties(element_call_url={}, widget_id={}, parent_url={}, font_scale={}, font={}, encryption={}, posthog_user_id={}, posthog_api_host={}, posthog_api_key={}, rageshake_submit_url={}, sentry_dsn={}, sentry_environment={})".format(self.element_call_url, self.widget_id, self.parent_url, self.font_scale, self.font, self.encryption, self.posthog_user_id, self.posthog_api_host, self.posthog_api_key, self.rageshake_submit_url, self.sentry_dsn, self.sentry_environment)
+    def __eq__(self, other):
+        if self.element_call_url != other.element_call_url:
+            return False
+        if self.widget_id != other.widget_id:
+            return False
+        if self.parent_url != other.parent_url:
+            return False
+        if self.font_scale != other.font_scale:
+            return False
+        if self.font != other.font:
+            return False
+        if self.encryption != other.encryption:
+            return False
+        if self.posthog_user_id != other.posthog_user_id:
+            return False
+        if self.posthog_api_host != other.posthog_api_host:
+            return False
+        if self.posthog_api_key != other.posthog_api_key:
+            return False
+        if self.rageshake_submit_url != other.rageshake_submit_url:
+            return False
+        if self.sentry_dsn != other.sentry_dsn:
+            return False
+        if self.sentry_environment != other.sentry_environment:
+            return False
+        return True
+
+class _UniffiFfiConverterTypeVirtualElementCallWidgetProperties(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return VirtualElementCallWidgetProperties(
+            element_call_url=_UniffiFfiConverterString.read(buf),
+            widget_id=_UniffiFfiConverterString.read(buf),
+            parent_url=_UniffiFfiConverterOptionalString.read(buf),
+            font_scale=_UniffiFfiConverterOptionalFloat64.read(buf),
+            font=_UniffiFfiConverterOptionalString.read(buf),
+            encryption=_UniffiFfiConverterTypeEncryptionSystem.read(buf),
+            posthog_user_id=_UniffiFfiConverterOptionalString.read(buf),
+            posthog_api_host=_UniffiFfiConverterOptionalString.read(buf),
+            posthog_api_key=_UniffiFfiConverterOptionalString.read(buf),
+            rageshake_submit_url=_UniffiFfiConverterOptionalString.read(buf),
+            sentry_dsn=_UniffiFfiConverterOptionalString.read(buf),
+            sentry_environment=_UniffiFfiConverterOptionalString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiFfiConverterString.check_lower(value.element_call_url)
+        _UniffiFfiConverterString.check_lower(value.widget_id)
+        _UniffiFfiConverterOptionalString.check_lower(value.parent_url)
+        _UniffiFfiConverterOptionalFloat64.check_lower(value.font_scale)
+        _UniffiFfiConverterOptionalString.check_lower(value.font)
+        _UniffiFfiConverterTypeEncryptionSystem.check_lower(value.encryption)
+        _UniffiFfiConverterOptionalString.check_lower(value.posthog_user_id)
+        _UniffiFfiConverterOptionalString.check_lower(value.posthog_api_host)
+        _UniffiFfiConverterOptionalString.check_lower(value.posthog_api_key)
+        _UniffiFfiConverterOptionalString.check_lower(value.rageshake_submit_url)
+        _UniffiFfiConverterOptionalString.check_lower(value.sentry_dsn)
+        _UniffiFfiConverterOptionalString.check_lower(value.sentry_environment)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiFfiConverterString.write(value.element_call_url, buf)
+        _UniffiFfiConverterString.write(value.widget_id, buf)
+        _UniffiFfiConverterOptionalString.write(value.parent_url, buf)
+        _UniffiFfiConverterOptionalFloat64.write(value.font_scale, buf)
+        _UniffiFfiConverterOptionalString.write(value.font, buf)
+        _UniffiFfiConverterTypeEncryptionSystem.write(value.encryption, buf)
+        _UniffiFfiConverterOptionalString.write(value.posthog_user_id, buf)
+        _UniffiFfiConverterOptionalString.write(value.posthog_api_host, buf)
+        _UniffiFfiConverterOptionalString.write(value.posthog_api_key, buf)
+        _UniffiFfiConverterOptionalString.write(value.rageshake_submit_url, buf)
+        _UniffiFfiConverterOptionalString.write(value.sentry_dsn, buf)
+        _UniffiFfiConverterOptionalString.write(value.sentry_environment, buf)
+
+
+
+
+
+
+class BackupDownloadStrategy(enum.Enum):
+    """
+    Settings for end-to-end encryption features.
+"""
+    
+    ONE_SHOT = 0
+    """
+    Automatically download all room keys from the backup when the backup
+    recovery key has been received. The backup recovery key can be received
+    in two ways:
+
+    1. Received as a `m.secret.send` to-device event, after a successful
+    interactive verification.
+    2. Imported from secret storage (4S) using the
+    [`SecretStore::import_secrets()`] method.
+
+    [`SecretStore::import_secrets()`]: crate::encryption::secret_storage::SecretStore::import_secrets
+"""
+    
+    AFTER_DECRYPTION_FAILURE = 1
+    """
+    Attempt to download a single room key if an event fails to be decrypted.
+"""
+    
+    MANUAL = 2
+    """
+    Don't download any room keys automatically. The user can manually
+    download room keys using the [`Backups::download_room_key()`] methods.
+
+    This is the default option.
+"""
+    
+
+
+class _UniffiFfiConverterTypeBackupDownloadStrategy(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return BackupDownloadStrategy.ONE_SHOT
+        if variant == 2:
+            return BackupDownloadStrategy.AFTER_DECRYPTION_FAILURE
+        if variant == 3:
+            return BackupDownloadStrategy.MANUAL
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == BackupDownloadStrategy.ONE_SHOT:
+            return
+        if value == BackupDownloadStrategy.AFTER_DECRYPTION_FAILURE:
+            return
+        if value == BackupDownloadStrategy.MANUAL:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == BackupDownloadStrategy.ONE_SHOT:
+            buf.write_i32(1)
+        if value == BackupDownloadStrategy.AFTER_DECRYPTION_FAILURE:
+            buf.write_i32(2)
+        if value == BackupDownloadStrategy.MANUAL:
+            buf.write_i32(3)
+
+
+
+
+
+
+
+
+class PaginationStatus:
+    """
+    Status for the pagination on a cache.
+"""
+    def __init__(self):
+        raise RuntimeError("PaginationStatus cannot be instantiated directly")
+
+    # Each enum variant is a nested class of the enum itself.
+    @dataclass
+    class IDLE:
+        """
+        No pagination is happening right now.
+"""
+        
+        def __init__(self, hit_timeline_start:bool):
+            self.hit_timeline_start = hit_timeline_start
+            
+            """
+        Have we hit the start of the timeline, i.e. paginating wouldn't
+        have any effect?
+"""
+        
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "PaginationStatus.IDLE(hit_timeline_start={})".format(self.hit_timeline_start)
+        def __eq__(self, other):
+            if not isinstance(other, PaginationStatus):
+                return NotImplemented
+            if not other.is_IDLE():
+                return False
+            if self.hit_timeline_start != other.hit_timeline_start:
+                return False
+            return True
+
+    @dataclass
+    class PAGINATING:
+        """
+        Pagination is already running in the background.
+"""
+        
+        def __init__(self, ):
+            pass
+
+    
+            
+            
+    
+        def __str__(self):
+            return "PaginationStatus.PAGINATING()".format()
+        def __eq__(self, other):
+            if not isinstance(other, PaginationStatus):
+                return NotImplemented
+            if not other.is_PAGINATING():
+                return False
+            return True
+
+    
+
+    # For each variant, we have `is_NAME` and `is_name` methods for easily checking
+    # whether an instance is that variant.
+    def is_IDLE(self) -> bool:
+        return isinstance(self, PaginationStatus.IDLE)
+    def is_idle(self) -> bool:
+        return isinstance(self, PaginationStatus.IDLE)
+    def is_PAGINATING(self) -> bool:
+        return isinstance(self, PaginationStatus.PAGINATING)
+    def is_paginating(self) -> bool:
+        return isinstance(self, PaginationStatus.PAGINATING)
+    
+
+# Now, a little trick - we make each nested variant class be a subclass of the main
+# enum class, so that method calls and instance checks etc will work intuitively.
+# We might be able to do this a little more neatly with a metaclass, but this'll do.
+PaginationStatus.IDLE = type("PaginationStatus.IDLE", (PaginationStatus.IDLE, PaginationStatus,), {})  # type: ignore
+PaginationStatus.PAGINATING = type("PaginationStatus.PAGINATING", (PaginationStatus.PAGINATING, PaginationStatus,), {})  # type: ignore
+
+
+
+
+class _UniffiFfiConverterTypePaginationStatus(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return PaginationStatus.IDLE(
+                _UniffiFfiConverterBoolean.read(buf),
+            )
+        if variant == 2:
+            return PaginationStatus.PAGINATING(
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value.is_IDLE():
+            _UniffiFfiConverterBoolean.check_lower(value.hit_timeline_start)
+            return
+        if value.is_PAGINATING():
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value.is_IDLE():
+            buf.write_i32(1)
+            _UniffiFfiConverterBoolean.write(value.hit_timeline_start, buf)
+        if value.is_PAGINATING():
+            buf.write_i32(2)
+
+
+
+
+
+
+
+
+class PaginatorState(enum.Enum):
+    """
+    Current state of a [`Paginator`].
+"""
+    
+    INITIAL = 0
+    """
+    The initial state of the paginator.
+"""
+    
+    FETCHING_TARGET_EVENT = 1
+    """
+    The paginator is fetching the target initial event.
+"""
+    
+    IDLE = 2
+    """
+    The target initial event could be found, zero or more paginations have
+    happened since then, and the paginator is at rest now.
+"""
+    
+    PAGINATING = 3
+    """
+    The paginator is… paginating one direction or another.
+"""
+    
+
+
+class _UniffiFfiConverterTypePaginatorState(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return PaginatorState.INITIAL
+        if variant == 2:
+            return PaginatorState.FETCHING_TARGET_EVENT
+        if variant == 3:
+            return PaginatorState.IDLE
+        if variant == 4:
+            return PaginatorState.PAGINATING
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == PaginatorState.INITIAL:
+            return
+        if value == PaginatorState.FETCHING_TARGET_EVENT:
+            return
+        if value == PaginatorState.IDLE:
+            return
+        if value == PaginatorState.PAGINATING:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == PaginatorState.INITIAL:
+            buf.write_i32(1)
+        if value == PaginatorState.FETCHING_TARGET_EVENT:
+            buf.write_i32(2)
+        if value == PaginatorState.IDLE:
+            buf.write_i32(3)
+        if value == PaginatorState.PAGINATING:
+            buf.write_i32(4)
+
+
+
+
+
+# QrCodeLoginError
+# 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 QrCodeLoginError(Exception):
+    """
+    The error type for failures while trying to log in a new device using a QR
+    code.
+"""
+    pass
+
+_UniffiTempQrCodeLoginError = QrCodeLoginError
+
+class QrCodeLoginError:  # type: ignore
+    """
+    The error type for failures while trying to log in a new device using a QR
+    code.
+"""
+    
+    class OAuth(_UniffiTempQrCodeLoginError):
+        """
+        An error happened while we were communicating with the OAuth 2.0
+        authorization server.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.OAuth({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.OAuth = OAuth # type: ignore
+    class LoginFailure(_UniffiTempQrCodeLoginError):
+        """
+        The other device has signaled to us that the login has failed.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.LoginFailure({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.LoginFailure = LoginFailure # type: ignore
+    class UnexpectedMessage(_UniffiTempQrCodeLoginError):
+        """
+        An unexpected message was received from the other device.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.UnexpectedMessage({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.UnexpectedMessage = UnexpectedMessage # type: ignore
+    class SecureChannel(_UniffiTempQrCodeLoginError):
+        """
+        An error happened while exchanging messages with the other device.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.SecureChannel({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.SecureChannel = SecureChannel # type: ignore
+    class NotFound(_UniffiTempQrCodeLoginError):
+        """
+        The rendezvous session was not found and might have expired.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.NotFound({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.NotFound = NotFound # type: ignore
+    class CrossProcessRefreshLock(_UniffiTempQrCodeLoginError):
+        """
+        The cross-process refresh lock failed to be initialized.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.CrossProcessRefreshLock({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.CrossProcessRefreshLock = CrossProcessRefreshLock # type: ignore
+    class UserIdDiscovery(_UniffiTempQrCodeLoginError):
+        """
+        An error happened while we were trying to discover our user and device
+        ID, after we have acquired an access token from the OAuth 2.0
+        authorization server.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.UserIdDiscovery({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.UserIdDiscovery = UserIdDiscovery # type: ignore
+    class SessionTokens(_UniffiTempQrCodeLoginError):
+        """
+        We failed to set the session tokens after we figured out our device and
+        user IDs.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.SessionTokens({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.SessionTokens = SessionTokens # type: ignore
+    class DeviceKeyUpload(_UniffiTempQrCodeLoginError):
+        """
+        The device keys failed to be uploaded after we successfully logged in.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.DeviceKeyUpload({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.DeviceKeyUpload = DeviceKeyUpload # type: ignore
+    class SecretImport(_UniffiTempQrCodeLoginError):
+        """
+        The secrets bundle we received from the existing device failed to be
+        imported.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.SecretImport({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.SecretImport = SecretImport # type: ignore
+    class ServerReset(_UniffiTempQrCodeLoginError):
+        """
+        The other party told us to use a different homeserver but we failed to
+        reset the server URL.
+"""
+        def __repr__(self):
+            return "QrCodeLoginError.ServerReset({})".format(repr(str(self)))
+    _UniffiTempQrCodeLoginError.ServerReset = ServerReset # type: ignore
+
+QrCodeLoginError = _UniffiTempQrCodeLoginError # type: ignore
+del _UniffiTempQrCodeLoginError
+
+
+class _UniffiFfiConverterTypeQRCodeLoginError(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return QrCodeLoginError.OAuth(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 2:
+            return QrCodeLoginError.LoginFailure(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 3:
+            return QrCodeLoginError.UnexpectedMessage(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 4:
+            return QrCodeLoginError.SecureChannel(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 5:
+            return QrCodeLoginError.NotFound(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 6:
+            return QrCodeLoginError.CrossProcessRefreshLock(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 7:
+            return QrCodeLoginError.UserIdDiscovery(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 8:
+            return QrCodeLoginError.SessionTokens(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 9:
+            return QrCodeLoginError.DeviceKeyUpload(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 10:
+            return QrCodeLoginError.SecretImport(
+                _UniffiFfiConverterString.read(buf),
+            )
+        if variant == 11:
+            return QrCodeLoginError.ServerReset(
+                _UniffiFfiConverterString.read(buf),
+            )
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if isinstance(value, QrCodeLoginError.OAuth):
+            return
+        if isinstance(value, QrCodeLoginError.LoginFailure):
+            return
+        if isinstance(value, QrCodeLoginError.UnexpectedMessage):
+            return
+        if isinstance(value, QrCodeLoginError.SecureChannel):
+            return
+        if isinstance(value, QrCodeLoginError.NotFound):
+            return
+        if isinstance(value, QrCodeLoginError.CrossProcessRefreshLock):
+            return
+        if isinstance(value, QrCodeLoginError.UserIdDiscovery):
+            return
+        if isinstance(value, QrCodeLoginError.SessionTokens):
+            return
+        if isinstance(value, QrCodeLoginError.DeviceKeyUpload):
+            return
+        if isinstance(value, QrCodeLoginError.SecretImport):
+            return
+        if isinstance(value, QrCodeLoginError.ServerReset):
+            return
+
+    @staticmethod
+    def write(value, buf):
+        if isinstance(value, QrCodeLoginError.OAuth):
+            buf.write_i32(1)
+        if isinstance(value, QrCodeLoginError.LoginFailure):
+            buf.write_i32(2)
+        if isinstance(value, QrCodeLoginError.UnexpectedMessage):
+            buf.write_i32(3)
+        if isinstance(value, QrCodeLoginError.SecureChannel):
+            buf.write_i32(4)
+        if isinstance(value, QrCodeLoginError.NotFound):
+            buf.write_i32(5)
+        if isinstance(value, QrCodeLoginError.CrossProcessRefreshLock):
+            buf.write_i32(6)
+        if isinstance(value, QrCodeLoginError.UserIdDiscovery):
+            buf.write_i32(7)
+        if isinstance(value, QrCodeLoginError.SessionTokens):
+            buf.write_i32(8)
+        if isinstance(value, QrCodeLoginError.DeviceKeyUpload):
+            buf.write_i32(9)
+        if isinstance(value, QrCodeLoginError.SecretImport):
+            buf.write_i32(10)
+        if isinstance(value, QrCodeLoginError.ServerReset):
+            buf.write_i32(11)
+
+
+
+
+
+
+class RoomMemberRole(enum.Enum):
+    """
+    The role of a member in a room.
+"""
+    
+    CREATOR = 0
+    """
+    The member is a creator.
+
+    A creator has an infinite power level and cannot be demoted, so this
+    role is immutable. A room can have several creators.
+
+    It is available in room versions where
+    `explicitly_privilege_room_creators` in [`AuthorizationRules`] is set to
+    `true`.
+
+    [`AuthorizationRules`]: ruma::room_version_rules::AuthorizationRules
+"""
+    
+    ADMINISTRATOR = 1
+    """
+    The member is an administrator.
+"""
+    
+    MODERATOR = 2
+    """
+    The member is a moderator.
+"""
+    
+    USER = 3
+    """
+    The member is a regular user.
+"""
+    
+
+
+class _UniffiFfiConverterTypeRoomMemberRole(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        variant = buf.read_i32()
+        if variant == 1:
+            return RoomMemberRole.CREATOR
+        if variant == 2:
+            return RoomMemberRole.ADMINISTRATOR
+        if variant == 3:
+            return RoomMemberRole.MODERATOR
+        if variant == 4:
+            return RoomMemberRole.USER
+        raise InternalError("Raw enum value doesn't match any cases")
+
+    @staticmethod
+    def check_lower(value):
+        if value == RoomMemberRole.CREATOR:
+            return
+        if value == RoomMemberRole.ADMINISTRATOR:
+            return
+        if value == RoomMemberRole.MODERATOR:
+            return
+        if value == RoomMemberRole.USER:
+            return
+        raise ValueError(value)
+
+    @staticmethod
+    def write(value, buf):
+        if value == RoomMemberRole.CREATOR:
+            buf.write_i32(1)
+        if value == RoomMemberRole.ADMINISTRATOR:
+            buf.write_i32(2)
+        if value == RoomMemberRole.MODERATOR:
+            buf.write_i32(3)
+        if value == RoomMemberRole.USER:
+            buf.write_i32(4)
+
+
+
+
+class OAuthAuthorizationDataProtocol(typing.Protocol):
+    """
+    The data needed to perform authorization using OAuth 2.0.
+"""
+    
+    def login_url(self, ) -> str:
+        """
+        The login URL to use for authorization.
+"""
+        raise NotImplementedError
+
+class OAuthAuthorizationData(OAuthAuthorizationDataProtocol):
+    """
+    The data needed to perform authorization using OAuth 2.0.
+"""
+    
+    _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_fn_free_oauthauthorizationdata, handle)
+
+    def _uniffi_clone_handle(self):
+        return _uniffi_rust_call(_UniffiLib.uniffi_matrix_sdk_fn_clone_oauthauthorizationdata, 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
+    def login_url(self, ) -> str:
+        """
+        The login URL to use for authorization.
+"""
+        _uniffi_lowered_args = (
+            self._uniffi_clone_handle(),
+        )
+        _uniffi_lift_return = _UniffiFfiConverterString.lift
+        _uniffi_error_converter = None
+        _uniffi_ffi_result = _uniffi_rust_call_with_error(
+            _uniffi_error_converter,
+            _UniffiLib.uniffi_matrix_sdk_fn_method_oauthauthorizationdata_login_url,
+            *_uniffi_lowered_args,
+        )
+        return _uniffi_lift_return(_uniffi_ffi_result)
+
+
+
+
+
+class _UniffiFfiConverterTypeOAuthAuthorizationData:
+    @staticmethod
+    def lift(value: int) -> OAuthAuthorizationData:
+        return OAuthAuthorizationData._uniffi_make_instance(value)
+
+    @staticmethod
+    def check_lower(value: OAuthAuthorizationData):
+        if not isinstance(value, OAuthAuthorizationData):
+            raise TypeError("Expected OAuthAuthorizationData instance, {} found".format(type(value).__name__))
+
+    @staticmethod
+    def lower(value: OAuthAuthorizationData) -> ctypes.c_uint64:
+        return value._uniffi_clone_handle()
+
+    @classmethod
+    def read(cls, buf: _UniffiRustBuffer) -> OAuthAuthorizationData:
+        ptr = buf.read_u64()
+        if ptr == 0:
+            raise InternalError("Raw handle value was null")
+        return cls.lift(ptr)
+
+    @classmethod
+    def write(cls, value: OAuthAuthorizationData, 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)
+
+__all__ = [
+    "InternalError",
+    "Intent",
+    "HeaderStyle",
+    "NotificationType",
+    "EncryptionSystem",
+    "BackupDownloadStrategy",
+    "PaginationStatus",
+    "PaginatorState",
+    "QrCodeLoginError",
+    "RoomMemberRole",
+    "RoomPowerLevelChanges",
+    "ServerVendorInfo",
+    "TileServerInfo",
+    "VirtualElementCallWidgetConfig",
+    "VirtualElementCallWidgetProperties",
+    "OAuthAuthorizationData",
+    "OAuthAuthorizationDataProtocol",
+]