ping-openmls-sdk-react-native-macos 0.2.0

package/ios/Generated.swift

@@ -0,0 +1,3239 @@
+// This file was autogenerated by some hot garbage in the `uniffi` crate.
+// Trust me, you don't want to mess with it!
+
+// swiftlint:disable all
+import Foundation
+
+// Depending on the consumer's build setup, the low-level FFI code
+// might be in a separate module, or it might be compiled inline into
+// this module. This is a bit of light hackery to work with both.
+#if canImport(pingFFI)
+    import pingFFI
+#endif
+
+private extension RustBuffer {
+    /// Allocate a new buffer, copying the contents of a `UInt8` array.
+    init(bytes: [UInt8]) {
+        let rbuf = bytes.withUnsafeBufferPointer { ptr in
+            RustBuffer.from(ptr)
+        }
+        self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
+    }
+
+    static func empty() -> RustBuffer {
+        RustBuffer(capacity: 0, len: 0, data: nil)
+    }
+
+    static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
+        try! rustCall { ffi_ping_ffi_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
+    }
+
+    /// Frees the buffer in place.
+    /// The buffer must not be used after this is called.
+    func deallocate() {
+        try! rustCall { ffi_ping_ffi_rustbuffer_free(self, $0) }
+    }
+}
+
+private extension ForeignBytes {
+    init(bufferPointer: UnsafeBufferPointer<UInt8>) {
+        self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
+    }
+}
+
+// For every type used in the interface, we provide helper methods for conveniently
+// lifting and lowering that type from C-compatible data, and for reading and writing
+// values of that type in a buffer.
+
+// Helper classes/extensions that don't change.
+// Someday, this will be in a library of its own.
+
+private extension Data {
+    init(rustBuffer: RustBuffer) {
+        self.init(
+            bytesNoCopy: rustBuffer.data!,
+            count: Int(rustBuffer.len),
+            deallocator: .none
+        )
+    }
+}
+
+// Define reader functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.
+//
+// With external types, one swift source file needs to be able to call the read
+// method on another source file's FfiConverter, but then what visibility
+// should Reader have?
+// - If Reader is fileprivate, then this means the read() must also
+//   be fileprivate, which doesn't work with external types.
+// - If Reader is internal/public, we'll get compile errors since both source
+//   files will try define the same type.
+//
+// Instead, the read() method and these helper functions input a tuple of data
+
+private func createReader(data: Data) -> (data: Data, offset: Data.Index) {
+    (data: data, offset: 0)
+}
+
+/// Reads an integer at the current offset, in big-endian order, and advances
+/// the offset on success. Throws if reading the integer would move the
+/// offset past the end of the buffer.
+private func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
+    let range = reader.offset ..< reader.offset + MemoryLayout<T>.size
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    if T.self == UInt8.self {
+        let value = reader.data[reader.offset]
+        reader.offset += 1
+        return value as! T
+    }
+    var value: T = 0
+    let _ = withUnsafeMutableBytes(of: &value) { reader.data.copyBytes(to: $0, from: range) }
+    reader.offset = range.upperBound
+    return value.bigEndian
+}
+
+/// Reads an arbitrary number of bytes, to be used to read
+/// raw bytes, this is useful when lifting strings
+private func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> [UInt8] {
+    let range = reader.offset ..< (reader.offset + count)
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    var value = [UInt8](repeating: 0, count: count)
+    value.withUnsafeMutableBufferPointer { buffer in
+        reader.data.copyBytes(to: buffer, from: range)
+    }
+    reader.offset = range.upperBound
+    return value
+}
+
+/// Reads a float at the current offset.
+private func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
+    return try Float(bitPattern: readInt(&reader))
+}
+
+/// Reads a float at the current offset.
+private func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
+    return try Double(bitPattern: readInt(&reader))
+}
+
+/// Indicates if the offset has reached the end of the buffer.
+private func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
+    return reader.offset < reader.data.count
+}
+
+// Define writer functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.  See the above discussion on Readers for details.
+
+private func createWriter() -> [UInt8] {
+    return []
+}
+
+private func writeBytes<S: Sequence>(_ writer: inout [UInt8], _ byteArr: S) where S.Element == UInt8 {
+    writer.append(contentsOf: byteArr)
+}
+
+/// Writes an integer in big-endian order.
+///
+/// Warning: make sure what you are trying to write
+/// is in the correct type!
+private func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
+    var value = value.bigEndian
+    withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
+}
+
+private func writeFloat(_ writer: inout [UInt8], _ value: Float) {
+    writeInt(&writer, value.bitPattern)
+}
+
+private func writeDouble(_ writer: inout [UInt8], _ value: Double) {
+    writeInt(&writer, value.bitPattern)
+}
+
+/// Protocol for types that transfer other types across the FFI. This is
+/// analogous to the Rust trait of the same name.
+private protocol FfiConverter {
+    associatedtype FfiType
+    associatedtype SwiftType
+
+    static func lift(_ value: FfiType) throws -> SwiftType
+    static func lower(_ value: SwiftType) -> FfiType
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
+    static func write(_ value: SwiftType, into buf: inout [UInt8])
+}
+
+/// Types conforming to `Primitive` pass themselves directly over the FFI.
+private protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType {}
+
+extension FfiConverterPrimitive {
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public static func lift(_ value: FfiType) throws -> SwiftType {
+        return value
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public static func lower(_ value: SwiftType) -> FfiType {
+        return value
+    }
+}
+
+/// Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
+/// Used for complex types where it's hard to write a custom lift/lower.
+private protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
+
+extension FfiConverterRustBuffer {
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public static func lift(_ buf: RustBuffer) throws -> SwiftType {
+        var reader = createReader(data: Data(rustBuffer: buf))
+        let value = try read(from: &reader)
+        if hasRemaining(reader) {
+            throw UniffiInternalError.incompleteData
+        }
+        buf.deallocate()
+        return value
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public static func lower(_ value: SwiftType) -> RustBuffer {
+        var writer = createWriter()
+        write(value, into: &writer)
+        return RustBuffer(bytes: writer)
+    }
+}
+
+/// An error type for FFI errors. These errors occur at the UniFFI level, not
+/// the library level.
+private enum UniffiInternalError: LocalizedError {
+    case bufferOverflow
+    case incompleteData
+    case unexpectedOptionalTag
+    case unexpectedEnumCase
+    case unexpectedNullPointer
+    case unexpectedRustCallStatusCode
+    case unexpectedRustCallError
+    case unexpectedStaleHandle
+    case rustPanic(_ message: String)
+
+    var errorDescription: String? {
+        switch self {
+        case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
+        case .incompleteData: return "The buffer still has data after lifting its containing value"
+        case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
+        case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
+        case .unexpectedNullPointer: return "Raw pointer value was null"
+        case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
+        case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
+        case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
+        case let .rustPanic(message): return message
+        }
+    }
+}
+
+private extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
+
+private let CALL_SUCCESS: Int8 = 0
+private let CALL_ERROR: Int8 = 1
+private let CALL_UNEXPECTED_ERROR: Int8 = 2
+private let CALL_CANCELLED: Int8 = 3
+
+private extension RustCallStatus {
+    init() {
+        self.init(
+            code: CALL_SUCCESS,
+            errorBuf: RustBuffer(
+                capacity: 0,
+                len: 0,
+                data: nil
+            )
+        )
+    }
+}
+
+private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    let neverThrow: ((RustBuffer) throws -> Never)? = nil
+    return try makeRustCall(callback, errorHandler: neverThrow)
+}
+
+private func rustCallWithError<T, E: Swift.Error>(
+    _ errorHandler: @escaping (RustBuffer) throws -> E,
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T
+) throws -> T {
+    try makeRustCall(callback, errorHandler: errorHandler)
+}
+
+private func makeRustCall<T, E: Swift.Error>(
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws -> T {
+    uniffiEnsureInitialized()
+    var callStatus = RustCallStatus()
+    let returnedVal = callback(&callStatus)
+    try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
+    return returnedVal
+}
+
+private func uniffiCheckCallStatus<E: Swift.Error>(
+    callStatus: RustCallStatus,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws {
+    switch callStatus.code {
+    case CALL_SUCCESS:
+        return
+
+    case CALL_ERROR:
+        if let errorHandler = errorHandler {
+            throw try errorHandler(callStatus.errorBuf)
+        } else {
+            callStatus.errorBuf.deallocate()
+            throw UniffiInternalError.unexpectedRustCallError
+        }
+
+    case CALL_UNEXPECTED_ERROR:
+        // When the rust code sees a panic, it tries to construct a RustBuffer
+        // with the message.  But if that code panics, then it just sends back
+        // an empty buffer.
+        if callStatus.errorBuf.len > 0 {
+            throw try UniffiInternalError.rustPanic(FfiConverterString.lift(callStatus.errorBuf))
+        } else {
+            callStatus.errorBuf.deallocate()
+            throw UniffiInternalError.rustPanic("Rust panic")
+        }
+
+    case CALL_CANCELLED:
+        fatalError("Cancellation not supported yet")
+
+    default:
+        throw UniffiInternalError.unexpectedRustCallStatusCode
+    }
+}
+
+private func uniffiTraitInterfaceCall<T>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> Void
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+
+private func uniffiTraitInterfaceCallWithError<T, E>(
+    callStatus: UnsafeMutablePointer<RustCallStatus>,
+    makeCall: () throws -> T,
+    writeReturn: (T) -> Void,
+    lowerError: (E) -> RustBuffer
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error as E {
+        callStatus.pointee.code = CALL_ERROR
+        callStatus.pointee.errorBuf = lowerError(error)
+    } catch {
+        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
+        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
+    }
+}
+
+private class UniffiHandleMap<T> {
+    private var map: [UInt64: T] = [:]
+    private let lock = NSLock()
+    private var currentHandle: UInt64 = 1
+
+    func insert(obj: T) -> UInt64 {
+        lock.withLock {
+            let handle = currentHandle
+            currentHandle += 1
+            map[handle] = obj
+            return handle
+        }
+    }
+
+    func get(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    @discardableResult
+    func remove(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map.removeValue(forKey: handle) else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    var count: Int {
+        map.count
+    }
+}
+
+// Public interface members begin here.
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterUInt8: FfiConverterPrimitive {
+    typealias FfiType = UInt8
+    typealias SwiftType = UInt8
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 {
+        return try lift(readInt(&buf))
+    }
+
+    static func write(_ value: UInt8, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterUInt32: FfiConverterPrimitive {
+    typealias FfiType = UInt32
+    typealias SwiftType = UInt32
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
+        return try lift(readInt(&buf))
+    }
+
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterUInt64: FfiConverterPrimitive {
+    typealias FfiType = UInt64
+    typealias SwiftType = UInt64
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
+        return try lift(readInt(&buf))
+    }
+
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterBool: FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+        return try lift(readInt(&buf))
+    }
+
+    static func write(_ value: Bool, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterString: FfiConverter {
+    typealias SwiftType = String
+    typealias FfiType = RustBuffer
+
+    static func lift(_ value: RustBuffer) throws -> String {
+        defer {
+            value.deallocate()
+        }
+        if value.data == nil {
+            return String()
+        }
+        let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
+        return String(bytes: bytes, encoding: String.Encoding.utf8)!
+    }
+
+    static func lower(_ value: String) -> RustBuffer {
+        return value.utf8CString.withUnsafeBufferPointer { ptr in
+            // The swift string gives us int8_t, we want uint8_t.
+            ptr.withMemoryRebound(to: UInt8.self) { ptr in
+                // The swift string gives us a trailing null byte, we don't want it.
+                let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
+                return RustBuffer.from(buf)
+            }
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+        let len: Int32 = try readInt(&buf)
+        return try String(bytes: readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
+    }
+
+    static func write(_ value: String, into buf: inout [UInt8]) {
+        let len = Int32(value.utf8.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value.utf8)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterData: FfiConverterRustBuffer {
+    typealias SwiftType = Data
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        let len: Int32 = try readInt(&buf)
+        return try Data(readBytes(&buf, count: Int(len)))
+    }
+
+    static func write(_ value: Data, into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value)
+    }
+}
+
+public protocol MessageObserver: AnyObject {
+    func onApplicationMessage(msg: IncomingMessage)
+
+    func onConversationUpdated(id: ConversationId, newEpoch: UInt64)
+}
+
+open class MessageObserverImpl:
+    MessageObserver
+{
+    fileprivate let pointer: UnsafeMutableRawPointer!
+
+    // Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public struct NoPointer {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        self.pointer = pointer
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public init(noPointer _: NoPointer) {
+        pointer = nil
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
+        return try! rustCall { uniffi_ping_ffi_fn_clone_messageobserver(self.pointer, $0) }
+    }
+
+    // No primary constructor declared for this class.
+
+    deinit {
+        guard let pointer = pointer else {
+            return
+        }
+
+        try! rustCall { uniffi_ping_ffi_fn_free_messageobserver(pointer, $0) }
+    }
+
+    open func onApplicationMessage(msg: IncomingMessage) {
+        try! rustCall {
+            uniffi_ping_ffi_fn_method_messageobserver_on_application_message(self.uniffiClonePointer(),
+                                                                             FfiConverterTypeIncomingMessage.lower(msg), $0)
+        }
+    }
+
+    open func onConversationUpdated(id: ConversationId, newEpoch: UInt64) {
+        try! rustCall {
+            uniffi_ping_ffi_fn_method_messageobserver_on_conversation_updated(self.uniffiClonePointer(),
+                                                                              FfiConverterTypeConversationId.lower(id),
+                                                                              FfiConverterUInt64.lower(newEpoch), $0)
+        }
+    }
+}
+
+/// Magic number for the Rust proxy to call using the same mechanism as every other method,
+/// to free the callback once it's dropped by Rust.
+private let IDX_CALLBACK_FREE: Int32 = 0
+// Callback return codes
+private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
+private let UNIFFI_CALLBACK_ERROR: Int32 = 1
+private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2
+
+/// Put the implementation in a struct so we don't pollute the top-level namespace
+private enum UniffiCallbackInterfaceMessageObserver {
+    /// Create the VTable using a series of closures.
+    /// Swift automatically converts these into C callback functions.
+    static var vtable: UniffiVTableCallbackInterfaceMessageObserver = .init(
+        onApplicationMessage: { (
+            uniffiHandle: UInt64,
+            msg: RustBuffer,
+            _: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws in
+                guard let uniffiObj = try? FfiConverterTypeMessageObserver.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try uniffiObj.onApplicationMessage(
+                    msg: FfiConverterTypeIncomingMessage.lift(msg)
+                )
+            }
+
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        },
+        onConversationUpdated: { (
+            uniffiHandle: UInt64,
+            id: RustBuffer,
+            newEpoch: UInt64,
+            _: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws in
+                guard let uniffiObj = try? FfiConverterTypeMessageObserver.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try uniffiObj.onConversationUpdated(
+                    id: FfiConverterTypeConversationId.lift(id),
+                    newEpoch: FfiConverterUInt64.lift(newEpoch)
+                )
+            }
+
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        },
+        uniffiFree: { (uniffiHandle: UInt64) in
+            let result = try? FfiConverterTypeMessageObserver.handleMap.remove(handle: uniffiHandle)
+            if result == nil {
+                print("Uniffi callback interface MessageObserver: handle missing in uniffiFree")
+            }
+        }
+    )
+}
+
+private func uniffiCallbackInitMessageObserver() {
+    uniffi_ping_ffi_fn_init_callback_vtable_messageobserver(&UniffiCallbackInterfaceMessageObserver.vtable)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessageObserver: FfiConverter {
+    fileprivate static var handleMap = UniffiHandleMap<MessageObserver>()
+
+    typealias FfiType = UnsafeMutableRawPointer
+    typealias SwiftType = MessageObserver
+
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MessageObserver {
+        return MessageObserverImpl(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: MessageObserver) -> UnsafeMutableRawPointer {
+        guard let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: handleMap.insert(obj: value))) else {
+            fatalError("Cast to UnsafeMutableRawPointer failed")
+        }
+        return ptr
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessageObserver {
+        let v: UInt64 = try readInt(&buf)
+        // The Rust code won't compile if a pointer won't fit in a UInt64.
+        // We have to go via `UInt` because that's the thing that's the size of a pointer.
+        let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
+        if ptr == nil {
+            throw UniffiInternalError.unexpectedNullPointer
+        }
+        return try lift(ptr!)
+    }
+
+    public static func write(_ value: MessageObserver, into buf: inout [UInt8]) {
+        // This fiddling is because `Int` is the thing that's the same size as a pointer.
+        // The Rust code won't compile if a pointer won't fit in a `UInt64`.
+        writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageObserver_lift(_ pointer: UnsafeMutableRawPointer) throws -> MessageObserver {
+    return try FfiConverterTypeMessageObserver.lift(pointer)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageObserver_lower(_ value: MessageObserver) -> UnsafeMutableRawPointer {
+    return FfiConverterTypeMessageObserver.lower(value)
+}
+
+public protocol MessagingClientProtocol: AnyObject {
+    func addMembers(conversationId: ConversationId, keyPackages: [Data], nowMs: UInt64) async throws
+
+    func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, nowMs: UInt64) async throws -> LinkingTicket
+
+    func consumeLinkingTicket(ticket: LinkingTicket, nowMs: UInt64) async throws
+
+    func createConversation(name: String?, nowMs: UInt64) async throws -> ConversationId
+
+    func deviceId() -> DeviceId
+
+    func deviceInfo(nowMs: UInt64) -> DeviceInfo
+
+    func freshKeyPackage() throws -> Data
+
+    func joinConversation(welcome: MessageEnvelope, nowMs: UInt64) async throws -> ConversationId
+
+    func listConversations() -> [ConversationMeta]
+
+    func listDevices() -> [DeviceInfo]
+
+    func processEnvelope(envelope: MessageEnvelope, nowMs: UInt64) async throws -> IncomingMessage?
+
+    func removeMembers(conversationId: ConversationId, leafIndexes: [UInt32], nowMs: UInt64) async throws
+
+    func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws
+
+    func send(conversationId: ConversationId, plaintext: Data, nowMs: UInt64) async throws -> MessageEnvelope
+
+    func setObserver(observer: MessageObserver)
+
+    func syncConversations(nowMs: UInt64) async throws -> [IncomingMessage]
+
+    func userId() -> UserId
+}
+
+open class MessagingClient:
+    MessagingClientProtocol
+{
+    fileprivate let pointer: UnsafeMutableRawPointer!
+
+    // Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public struct NoPointer {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        self.pointer = pointer
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public init(noPointer _: NoPointer) {
+        pointer = nil
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
+        return try! rustCall { uniffi_ping_ffi_fn_clone_messagingclient(self.pointer, $0) }
+    }
+
+    // No primary constructor declared for this class.
+
+    deinit {
+        guard let pointer = pointer else {
+            return
+        }
+
+        try! rustCall { uniffi_ping_ffi_fn_free_messagingclient(pointer, $0) }
+    }
+
+    public static func `init`(identityExport: Data, deviceLabel: String, storage: Storage, transport: Transport, nowMs: UInt64) async throws -> MessagingClient {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_constructor_messagingclient_init(FfiConverterData.lower(identityExport), FfiConverterString.lower(deviceLabel), FfiConverterTypeStorage.lower(storage), FfiConverterTypeTransport.lower(transport), FfiConverterUInt64.lower(nowMs))
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_pointer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_pointer,
+                freeFunc: ffi_ping_ffi_rust_future_free_pointer,
+                liftFunc: FfiConverterTypeMessagingClient.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func addMembers(conversationId: ConversationId, keyPackages: [Data], nowMs: UInt64) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_add_members(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterSequenceData.lower(keyPackages), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, nowMs: UInt64) async throws -> LinkingTicket {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_build_linking_ticket(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeDeviceId.lower(newDeviceId), FfiConverterData.lower(newDeviceKp), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterTypeLinkingTicket.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func consumeLinkingTicket(ticket: LinkingTicket, nowMs: UInt64) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_consume_linking_ticket(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeLinkingTicket.lower(ticket), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func createConversation(name: String?, nowMs: UInt64) async throws -> ConversationId {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_create_conversation(
+                        self.uniffiClonePointer(),
+                        FfiConverterOptionString.lower(name), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterTypeConversationId.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func deviceId() -> DeviceId {
+        return try! FfiConverterTypeDeviceId.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_device_id(self.uniffiClonePointer(), $0)
+        })
+    }
+
+    open func deviceInfo(nowMs: UInt64) -> DeviceInfo {
+        return try! FfiConverterTypeDeviceInfo.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_device_info(self.uniffiClonePointer(),
+                                                                  FfiConverterUInt64.lower(nowMs), $0)
+        })
+    }
+
+    open func freshKeyPackage() throws -> Data {
+        return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+            uniffi_ping_ffi_fn_method_messagingclient_fresh_key_package(self.uniffiClonePointer(), $0)
+        })
+    }
+
+    open func joinConversation(welcome: MessageEnvelope, nowMs: UInt64) async throws -> ConversationId {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_join_conversation(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeMessageEnvelope.lower(welcome), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterTypeConversationId.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func listConversations() -> [ConversationMeta] {
+        return try! FfiConverterSequenceTypeConversationMeta.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_list_conversations(self.uniffiClonePointer(), $0)
+        })
+    }
+
+    open func listDevices() -> [DeviceInfo] {
+        return try! FfiConverterSequenceTypeDeviceInfo.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_list_devices(self.uniffiClonePointer(), $0)
+        })
+    }
+
+    open func processEnvelope(envelope: MessageEnvelope, nowMs: UInt64) async throws -> IncomingMessage? {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_process_envelope(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeMessageEnvelope.lower(envelope), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterOptionTypeIncomingMessage.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func removeMembers(conversationId: ConversationId, leafIndexes: [UInt32], nowMs: UInt64) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_remove_members(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterSequenceUInt32.lower(leafIndexes), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_revoke_device(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeDeviceId.lower(deviceId), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func send(conversationId: ConversationId, plaintext: Data, nowMs: UInt64) async throws -> MessageEnvelope {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_send(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterData.lower(plaintext), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterTypeMessageEnvelope.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func setObserver(observer: MessageObserver) {
+        try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_set_observer(self.uniffiClonePointer(),
+                                                                   FfiConverterTypeMessageObserver.lower(observer), $0)
+        }
+    }
+
+    open func syncConversations(nowMs: UInt64) async throws -> [IncomingMessage] {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_sync_conversations(
+                        self.uniffiClonePointer(),
+                        FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterSequenceTypeIncomingMessage.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func userId() -> UserId {
+        return try! FfiConverterTypeUserId.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_user_id(self.uniffiClonePointer(), $0)
+        })
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessagingClient: FfiConverter {
+    typealias FfiType = UnsafeMutableRawPointer
+    typealias SwiftType = MessagingClient
+
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MessagingClient {
+        return MessagingClient(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: MessagingClient) -> UnsafeMutableRawPointer {
+        return value.uniffiClonePointer()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessagingClient {
+        let v: UInt64 = try readInt(&buf)
+        // The Rust code won't compile if a pointer won't fit in a UInt64.
+        // We have to go via `UInt` because that's the thing that's the size of a pointer.
+        let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
+        if ptr == nil {
+            throw UniffiInternalError.unexpectedNullPointer
+        }
+        return try lift(ptr!)
+    }
+
+    public static func write(_ value: MessagingClient, into buf: inout [UInt8]) {
+        // This fiddling is because `Int` is the thing that's the same size as a pointer.
+        // The Rust code won't compile if a pointer won't fit in a `UInt64`.
+        writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessagingClient_lift(_ pointer: UnsafeMutableRawPointer) throws -> MessagingClient {
+    return try FfiConverterTypeMessagingClient.lift(pointer)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessagingClient_lower(_ value: MessagingClient) -> UnsafeMutableRawPointer {
+    return FfiConverterTypeMessagingClient.lower(value)
+}
+
+public protocol Storage: AnyObject {
+    func delete(namespace: String, key: String) async throws
+
+    func get(namespace: String, key: String) async throws -> Data?
+
+    func listKeys(namespace: String, prefix: String) async throws -> [String]
+
+    func put(namespace: String, key: String, value: Data) async throws
+}
+
+open class StorageImpl:
+    Storage
+{
+    fileprivate let pointer: UnsafeMutableRawPointer!
+
+    // Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public struct NoPointer {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        self.pointer = pointer
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public init(noPointer _: NoPointer) {
+        pointer = nil
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
+        return try! rustCall { uniffi_ping_ffi_fn_clone_storage(self.pointer, $0) }
+    }
+
+    // No primary constructor declared for this class.
+
+    deinit {
+        guard let pointer = pointer else {
+            return
+        }
+
+        try! rustCall { uniffi_ping_ffi_fn_free_storage(pointer, $0) }
+    }
+
+    open func delete(namespace: String, key: String) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_storage_delete(
+                        self.uniffiClonePointer(),
+                        FfiConverterString.lower(namespace), FfiConverterString.lower(key)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func get(namespace: String, key: String) async throws -> Data? {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_storage_get(
+                        self.uniffiClonePointer(),
+                        FfiConverterString.lower(namespace), FfiConverterString.lower(key)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterOptionData.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func listKeys(namespace: String, prefix: String) async throws -> [String] {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_storage_list_keys(
+                        self.uniffiClonePointer(),
+                        FfiConverterString.lower(namespace), FfiConverterString.lower(prefix)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterSequenceString.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func put(namespace: String, key: String, value: Data) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_storage_put(
+                        self.uniffiClonePointer(),
+                        FfiConverterString.lower(namespace), FfiConverterString.lower(key), FfiConverterData.lower(value)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+}
+
+/// Put the implementation in a struct so we don't pollute the top-level namespace
+private enum UniffiCallbackInterfaceStorage {
+    /// Create the VTable using a series of closures.
+    /// Swift automatically converts these into C callback functions.
+    static var vtable: UniffiVTableCallbackInterfaceStorage = .init(
+        delete: { (
+            uniffiHandle: UInt64,
+            namespace: RustBuffer,
+            key: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteVoid,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws in
+                guard let uniffiObj = try? FfiConverterTypeStorage.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.delete(
+                    namespace: FfiConverterString.lift(namespace),
+                    key: FfiConverterString.lift(key)
+                )
+            }
+
+            let uniffiHandleSuccess = { (_: ()) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        get: { (
+            uniffiHandle: UInt64,
+            namespace: RustBuffer,
+            key: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteRustBuffer,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws -> Data? in
+                guard let uniffiObj = try? FfiConverterTypeStorage.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.get(
+                    namespace: FfiConverterString.lift(namespace),
+                    key: FfiConverterString.lift(key)
+                )
+            }
+
+            let uniffiHandleSuccess = { (returnValue: Data?) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: FfiConverterOptionData.lower(returnValue),
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: RustBuffer.empty(),
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        listKeys: { (
+            uniffiHandle: UInt64,
+            namespace: RustBuffer,
+            prefix: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteRustBuffer,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws -> [String] in
+                guard let uniffiObj = try? FfiConverterTypeStorage.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.listKeys(
+                    namespace: FfiConverterString.lift(namespace),
+                    prefix: FfiConverterString.lift(prefix)
+                )
+            }
+
+            let uniffiHandleSuccess = { (returnValue: [String]) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: FfiConverterSequenceString.lower(returnValue),
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: RustBuffer.empty(),
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        put: { (
+            uniffiHandle: UInt64,
+            namespace: RustBuffer,
+            key: RustBuffer,
+            value: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteVoid,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws in
+                guard let uniffiObj = try? FfiConverterTypeStorage.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.put(
+                    namespace: FfiConverterString.lift(namespace),
+                    key: FfiConverterString.lift(key),
+                    value: FfiConverterData.lift(value)
+                )
+            }
+
+            let uniffiHandleSuccess = { (_: ()) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        uniffiFree: { (uniffiHandle: UInt64) in
+            let result = try? FfiConverterTypeStorage.handleMap.remove(handle: uniffiHandle)
+            if result == nil {
+                print("Uniffi callback interface Storage: handle missing in uniffiFree")
+            }
+        }
+    )
+}
+
+private func uniffiCallbackInitStorage() {
+    uniffi_ping_ffi_fn_init_callback_vtable_storage(&UniffiCallbackInterfaceStorage.vtable)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeStorage: FfiConverter {
+    fileprivate static var handleMap = UniffiHandleMap<Storage>()
+
+    typealias FfiType = UnsafeMutableRawPointer
+    typealias SwiftType = Storage
+
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Storage {
+        return StorageImpl(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: Storage) -> UnsafeMutableRawPointer {
+        guard let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: handleMap.insert(obj: value))) else {
+            fatalError("Cast to UnsafeMutableRawPointer failed")
+        }
+        return ptr
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Storage {
+        let v: UInt64 = try readInt(&buf)
+        // The Rust code won't compile if a pointer won't fit in a UInt64.
+        // We have to go via `UInt` because that's the thing that's the size of a pointer.
+        let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
+        if ptr == nil {
+            throw UniffiInternalError.unexpectedNullPointer
+        }
+        return try lift(ptr!)
+    }
+
+    public static func write(_ value: Storage, into buf: inout [UInt8]) {
+        // This fiddling is because `Int` is the thing that's the same size as a pointer.
+        // The Rust code won't compile if a pointer won't fit in a `UInt64`.
+        writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeStorage_lift(_ pointer: UnsafeMutableRawPointer) throws -> Storage {
+    return try FfiConverterTypeStorage.lift(pointer)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeStorage_lower(_ value: Storage) -> UnsafeMutableRawPointer {
+    return FfiConverterTypeStorage.lower(value)
+}
+
+public protocol Transport: AnyObject {
+    func discoverDevices(userId: UserId) async throws -> [DiscoveredDevice]
+
+    func fetchSince(conversationId: ConversationId, cursorToken: Data, limit: UInt32) async throws -> [MessageEnvelope]
+
+    func send(envelope: MessageEnvelope) async throws
+}
+
+open class TransportImpl:
+    Transport
+{
+    fileprivate let pointer: UnsafeMutableRawPointer!
+
+    // Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public struct NoPointer {
+        public init() {}
+    }
+
+    // TODO: We'd like this to be `private` but for Swifty reasons,
+    // we can't implement `FfiConverter` without making this `required` and we can't
+    // make it `required` without making it `public`.
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        self.pointer = pointer
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
+    //
+    // - Warning:
+    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public init(noPointer _: NoPointer) {
+        pointer = nil
+    }
+
+    #if swift(>=5.8)
+        @_documentation(visibility: private)
+    #endif
+    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
+        return try! rustCall { uniffi_ping_ffi_fn_clone_transport(self.pointer, $0) }
+    }
+
+    // No primary constructor declared for this class.
+
+    deinit {
+        guard let pointer = pointer else {
+            return
+        }
+
+        try! rustCall { uniffi_ping_ffi_fn_free_transport(pointer, $0) }
+    }
+
+    open func discoverDevices(userId: UserId) async throws -> [DiscoveredDevice] {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_transport_discover_devices(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeUserId.lower(userId)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterSequenceTypeDiscoveredDevice.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func fetchSince(conversationId: ConversationId, cursorToken: Data, limit: UInt32) async throws -> [MessageEnvelope] {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_transport_fetch_since(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterData.lower(cursorToken), FfiConverterUInt32.lower(limit)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterSequenceTypeMessageEnvelope.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
+    open func send(envelope: MessageEnvelope) async throws {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_transport_send(
+                        self.uniffiClonePointer(),
+                        FfiConverterTypeMessageEnvelope.lower(envelope)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_void,
+                completeFunc: ffi_ping_ffi_rust_future_complete_void,
+                freeFunc: ffi_ping_ffi_rust_future_free_void,
+                liftFunc: { $0 },
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+}
+
+/// Put the implementation in a struct so we don't pollute the top-level namespace
+private enum UniffiCallbackInterfaceTransport {
+    /// Create the VTable using a series of closures.
+    /// Swift automatically converts these into C callback functions.
+    static var vtable: UniffiVTableCallbackInterfaceTransport = .init(
+        discoverDevices: { (
+            uniffiHandle: UInt64,
+            userId: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteRustBuffer,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws -> [DiscoveredDevice] in
+                guard let uniffiObj = try? FfiConverterTypeTransport.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.discoverDevices(
+                    userId: FfiConverterTypeUserId.lift(userId)
+                )
+            }
+
+            let uniffiHandleSuccess = { (returnValue: [DiscoveredDevice]) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: FfiConverterSequenceTypeDiscoveredDevice.lower(returnValue),
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: RustBuffer.empty(),
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        fetchSince: { (
+            uniffiHandle: UInt64,
+            conversationId: RustBuffer,
+            cursorToken: RustBuffer,
+            limit: UInt32,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteRustBuffer,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws -> [MessageEnvelope] in
+                guard let uniffiObj = try? FfiConverterTypeTransport.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.fetchSince(
+                    conversationId: FfiConverterTypeConversationId.lift(conversationId),
+                    cursorToken: FfiConverterData.lift(cursorToken),
+                    limit: FfiConverterUInt32.lift(limit)
+                )
+            }
+
+            let uniffiHandleSuccess = { (returnValue: [MessageEnvelope]) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: FfiConverterSequenceTypeMessageEnvelope.lower(returnValue),
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructRustBuffer(
+                        returnValue: RustBuffer.empty(),
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        send: { (
+            uniffiHandle: UInt64,
+            envelope: RustBuffer,
+            uniffiFutureCallback: @escaping UniffiForeignFutureCompleteVoid,
+            uniffiCallbackData: UInt64,
+            uniffiOutReturn: UnsafeMutablePointer<UniffiForeignFuture>
+        ) in
+            let makeCall = {
+                () async throws in
+                guard let uniffiObj = try? FfiConverterTypeTransport.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return try await uniffiObj.send(
+                    envelope: FfiConverterTypeMessageEnvelope.lift(envelope)
+                )
+            }
+
+            let uniffiHandleSuccess = { (_: ()) in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus()
+                    )
+                )
+            }
+            let uniffiHandleError = { statusCode, errorBuf in
+                uniffiFutureCallback(
+                    uniffiCallbackData,
+                    UniffiForeignFutureStructVoid(
+                        callStatus: RustCallStatus(code: statusCode, errorBuf: errorBuf)
+                    )
+                )
+            }
+            let uniffiForeignFuture = uniffiTraitInterfaceCallAsyncWithError(
+                makeCall: makeCall,
+                handleSuccess: uniffiHandleSuccess,
+                handleError: uniffiHandleError,
+                lowerError: FfiConverterTypePingError.lower
+            )
+            uniffiOutReturn.pointee = uniffiForeignFuture
+        },
+        uniffiFree: { (uniffiHandle: UInt64) in
+            let result = try? FfiConverterTypeTransport.handleMap.remove(handle: uniffiHandle)
+            if result == nil {
+                print("Uniffi callback interface Transport: handle missing in uniffiFree")
+            }
+        }
+    )
+}
+
+private func uniffiCallbackInitTransport() {
+    uniffi_ping_ffi_fn_init_callback_vtable_transport(&UniffiCallbackInterfaceTransport.vtable)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransport: FfiConverter {
+    fileprivate static var handleMap = UniffiHandleMap<Transport>()
+
+    typealias FfiType = UnsafeMutableRawPointer
+    typealias SwiftType = Transport
+
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> Transport {
+        return TransportImpl(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: Transport) -> UnsafeMutableRawPointer {
+        guard let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: handleMap.insert(obj: value))) else {
+            fatalError("Cast to UnsafeMutableRawPointer failed")
+        }
+        return ptr
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Transport {
+        let v: UInt64 = try readInt(&buf)
+        // The Rust code won't compile if a pointer won't fit in a UInt64.
+        // We have to go via `UInt` because that's the thing that's the size of a pointer.
+        let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
+        if ptr == nil {
+            throw UniffiInternalError.unexpectedNullPointer
+        }
+        return try lift(ptr!)
+    }
+
+    public static func write(_ value: Transport, into buf: inout [UInt8]) {
+        // This fiddling is because `Int` is the thing that's the same size as a pointer.
+        // The Rust code won't compile if a pointer won't fit in a `UInt64`.
+        writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransport_lift(_ pointer: UnsafeMutableRawPointer) throws -> Transport {
+    return try FfiConverterTypeTransport.lift(pointer)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransport_lower(_ value: Transport) -> UnsafeMutableRawPointer {
+    return FfiConverterTypeTransport.lower(value)
+}
+
+public struct ConversationId {
+    public var value: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(value: Data) {
+        self.value = value
+    }
+}
+
+extension ConversationId: Equatable, Hashable {
+    public static func == (lhs: ConversationId, rhs: ConversationId) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeConversationId: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConversationId {
+        return
+            try ConversationId(
+                value: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: ConversationId, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.value, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeConversationId_lift(_ buf: RustBuffer) throws -> ConversationId {
+    return try FfiConverterTypeConversationId.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeConversationId_lower(_ value: ConversationId) -> RustBuffer {
+    return FfiConverterTypeConversationId.lower(value)
+}
+
+public struct ConversationMeta {
+    public var id: ConversationId
+    public var name: String?
+    public var epoch: UInt64
+    public var memberCount: UInt32
+    public var isDeviceGroup: Bool
+    public var createdAtMs: UInt64
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(id: ConversationId, name: String?, epoch: UInt64, memberCount: UInt32, isDeviceGroup: Bool, createdAtMs: UInt64) {
+        self.id = id
+        self.name = name
+        self.epoch = epoch
+        self.memberCount = memberCount
+        self.isDeviceGroup = isDeviceGroup
+        self.createdAtMs = createdAtMs
+    }
+}
+
+extension ConversationMeta: Equatable, Hashable {
+    public static func == (lhs: ConversationMeta, rhs: ConversationMeta) -> Bool {
+        if lhs.id != rhs.id {
+            return false
+        }
+        if lhs.name != rhs.name {
+            return false
+        }
+        if lhs.epoch != rhs.epoch {
+            return false
+        }
+        if lhs.memberCount != rhs.memberCount {
+            return false
+        }
+        if lhs.isDeviceGroup != rhs.isDeviceGroup {
+            return false
+        }
+        if lhs.createdAtMs != rhs.createdAtMs {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+        hasher.combine(name)
+        hasher.combine(epoch)
+        hasher.combine(memberCount)
+        hasher.combine(isDeviceGroup)
+        hasher.combine(createdAtMs)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeConversationMeta: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ConversationMeta {
+        return
+            try ConversationMeta(
+                id: FfiConverterTypeConversationId.read(from: &buf),
+                name: FfiConverterOptionString.read(from: &buf),
+                epoch: FfiConverterUInt64.read(from: &buf),
+                memberCount: FfiConverterUInt32.read(from: &buf),
+                isDeviceGroup: FfiConverterBool.read(from: &buf),
+                createdAtMs: FfiConverterUInt64.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: ConversationMeta, into buf: inout [UInt8]) {
+        FfiConverterTypeConversationId.write(value.id, into: &buf)
+        FfiConverterOptionString.write(value.name, into: &buf)
+        FfiConverterUInt64.write(value.epoch, into: &buf)
+        FfiConverterUInt32.write(value.memberCount, into: &buf)
+        FfiConverterBool.write(value.isDeviceGroup, into: &buf)
+        FfiConverterUInt64.write(value.createdAtMs, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeConversationMeta_lift(_ buf: RustBuffer) throws -> ConversationMeta {
+    return try FfiConverterTypeConversationMeta.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeConversationMeta_lower(_ value: ConversationMeta) -> RustBuffer {
+    return FfiConverterTypeConversationMeta.lower(value)
+}
+
+public struct DeviceId {
+    public var value: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(value: Data) {
+        self.value = value
+    }
+}
+
+extension DeviceId: Equatable, Hashable {
+    public static func == (lhs: DeviceId, rhs: DeviceId) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDeviceId: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DeviceId {
+        return
+            try DeviceId(
+                value: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: DeviceId, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.value, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDeviceId_lift(_ buf: RustBuffer) throws -> DeviceId {
+    return try FfiConverterTypeDeviceId.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDeviceId_lower(_ value: DeviceId) -> RustBuffer {
+    return FfiConverterTypeDeviceId.lower(value)
+}
+
+public struct DeviceInfo {
+    public var deviceId: DeviceId
+    public var userId: UserId
+    public var label: String
+    public var createdAtMs: UInt64
+    public var lastSeenMs: UInt64
+    public var revoked: Bool
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(deviceId: DeviceId, userId: UserId, label: String, createdAtMs: UInt64, lastSeenMs: UInt64, revoked: Bool) {
+        self.deviceId = deviceId
+        self.userId = userId
+        self.label = label
+        self.createdAtMs = createdAtMs
+        self.lastSeenMs = lastSeenMs
+        self.revoked = revoked
+    }
+}
+
+extension DeviceInfo: Equatable, Hashable {
+    public static func == (lhs: DeviceInfo, rhs: DeviceInfo) -> Bool {
+        if lhs.deviceId != rhs.deviceId {
+            return false
+        }
+        if lhs.userId != rhs.userId {
+            return false
+        }
+        if lhs.label != rhs.label {
+            return false
+        }
+        if lhs.createdAtMs != rhs.createdAtMs {
+            return false
+        }
+        if lhs.lastSeenMs != rhs.lastSeenMs {
+            return false
+        }
+        if lhs.revoked != rhs.revoked {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(deviceId)
+        hasher.combine(userId)
+        hasher.combine(label)
+        hasher.combine(createdAtMs)
+        hasher.combine(lastSeenMs)
+        hasher.combine(revoked)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDeviceInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DeviceInfo {
+        return
+            try DeviceInfo(
+                deviceId: FfiConverterTypeDeviceId.read(from: &buf),
+                userId: FfiConverterTypeUserId.read(from: &buf),
+                label: FfiConverterString.read(from: &buf),
+                createdAtMs: FfiConverterUInt64.read(from: &buf),
+                lastSeenMs: FfiConverterUInt64.read(from: &buf),
+                revoked: FfiConverterBool.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: DeviceInfo, into buf: inout [UInt8]) {
+        FfiConverterTypeDeviceId.write(value.deviceId, into: &buf)
+        FfiConverterTypeUserId.write(value.userId, into: &buf)
+        FfiConverterString.write(value.label, into: &buf)
+        FfiConverterUInt64.write(value.createdAtMs, into: &buf)
+        FfiConverterUInt64.write(value.lastSeenMs, into: &buf)
+        FfiConverterBool.write(value.revoked, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDeviceInfo_lift(_ buf: RustBuffer) throws -> DeviceInfo {
+    return try FfiConverterTypeDeviceInfo.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDeviceInfo_lower(_ value: DeviceInfo) -> RustBuffer {
+    return FfiConverterTypeDeviceInfo.lower(value)
+}
+
+public struct DiscoveredDevice {
+    public var deviceId: DeviceId
+    public var keyPackage: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(deviceId: DeviceId, keyPackage: Data) {
+        self.deviceId = deviceId
+        self.keyPackage = keyPackage
+    }
+}
+
+extension DiscoveredDevice: Equatable, Hashable {
+    public static func == (lhs: DiscoveredDevice, rhs: DiscoveredDevice) -> Bool {
+        if lhs.deviceId != rhs.deviceId {
+            return false
+        }
+        if lhs.keyPackage != rhs.keyPackage {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(deviceId)
+        hasher.combine(keyPackage)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDiscoveredDevice: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DiscoveredDevice {
+        return
+            try DiscoveredDevice(
+                deviceId: FfiConverterTypeDeviceId.read(from: &buf),
+                keyPackage: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: DiscoveredDevice, into buf: inout [UInt8]) {
+        FfiConverterTypeDeviceId.write(value.deviceId, into: &buf)
+        FfiConverterData.write(value.keyPackage, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDiscoveredDevice_lift(_ buf: RustBuffer) throws -> DiscoveredDevice {
+    return try FfiConverterTypeDiscoveredDevice.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDiscoveredDevice_lower(_ value: DiscoveredDevice) -> RustBuffer {
+    return FfiConverterTypeDiscoveredDevice.lower(value)
+}
+
+public struct Hlc {
+    public var wallMs: UInt64
+    public var logical: UInt32
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(wallMs: UInt64, logical: UInt32) {
+        self.wallMs = wallMs
+        self.logical = logical
+    }
+}
+
+extension Hlc: Equatable, Hashable {
+    public static func == (lhs: Hlc, rhs: Hlc) -> Bool {
+        if lhs.wallMs != rhs.wallMs {
+            return false
+        }
+        if lhs.logical != rhs.logical {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(wallMs)
+        hasher.combine(logical)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeHlc: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Hlc {
+        return
+            try Hlc(
+                wallMs: FfiConverterUInt64.read(from: &buf),
+                logical: FfiConverterUInt32.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: Hlc, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.wallMs, into: &buf)
+        FfiConverterUInt32.write(value.logical, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHlc_lift(_ buf: RustBuffer) throws -> Hlc {
+    return try FfiConverterTypeHlc.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeHlc_lower(_ value: Hlc) -> RustBuffer {
+    return FfiConverterTypeHlc.lower(value)
+}
+
+public struct IncomingMessage {
+    public var conversationId: ConversationId
+    public var senderDevice: DeviceId
+    public var epoch: UInt64
+    public var hlc: Hlc
+    public var plaintext: Data
+    public var contentHash: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(conversationId: ConversationId, senderDevice: DeviceId, epoch: UInt64, hlc: Hlc, plaintext: Data, contentHash: Data) {
+        self.conversationId = conversationId
+        self.senderDevice = senderDevice
+        self.epoch = epoch
+        self.hlc = hlc
+        self.plaintext = plaintext
+        self.contentHash = contentHash
+    }
+}
+
+extension IncomingMessage: Equatable, Hashable {
+    public static func == (lhs: IncomingMessage, rhs: IncomingMessage) -> Bool {
+        if lhs.conversationId != rhs.conversationId {
+            return false
+        }
+        if lhs.senderDevice != rhs.senderDevice {
+            return false
+        }
+        if lhs.epoch != rhs.epoch {
+            return false
+        }
+        if lhs.hlc != rhs.hlc {
+            return false
+        }
+        if lhs.plaintext != rhs.plaintext {
+            return false
+        }
+        if lhs.contentHash != rhs.contentHash {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(conversationId)
+        hasher.combine(senderDevice)
+        hasher.combine(epoch)
+        hasher.combine(hlc)
+        hasher.combine(plaintext)
+        hasher.combine(contentHash)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeIncomingMessage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> IncomingMessage {
+        return
+            try IncomingMessage(
+                conversationId: FfiConverterTypeConversationId.read(from: &buf),
+                senderDevice: FfiConverterTypeDeviceId.read(from: &buf),
+                epoch: FfiConverterUInt64.read(from: &buf),
+                hlc: FfiConverterTypeHlc.read(from: &buf),
+                plaintext: FfiConverterData.read(from: &buf),
+                contentHash: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: IncomingMessage, into buf: inout [UInt8]) {
+        FfiConverterTypeConversationId.write(value.conversationId, into: &buf)
+        FfiConverterTypeDeviceId.write(value.senderDevice, into: &buf)
+        FfiConverterUInt64.write(value.epoch, into: &buf)
+        FfiConverterTypeHlc.write(value.hlc, into: &buf)
+        FfiConverterData.write(value.plaintext, into: &buf)
+        FfiConverterData.write(value.contentHash, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeIncomingMessage_lift(_ buf: RustBuffer) throws -> IncomingMessage {
+    return try FfiConverterTypeIncomingMessage.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeIncomingMessage_lower(_ value: IncomingMessage) -> RustBuffer {
+    return FfiConverterTypeIncomingMessage.lower(value)
+}
+
+public struct LinkingTicket {
+    public var v: UInt8
+    public var userId: UserId
+    public var userPubkey: Data
+    public var newDeviceId: DeviceId
+    public var deviceBindingSig: Data
+    public var deviceGroupWelcome: Data
+    public var catchupSnapshot: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(v: UInt8, userId: UserId, userPubkey: Data, newDeviceId: DeviceId, deviceBindingSig: Data, deviceGroupWelcome: Data, catchupSnapshot: Data) {
+        self.v = v
+        self.userId = userId
+        self.userPubkey = userPubkey
+        self.newDeviceId = newDeviceId
+        self.deviceBindingSig = deviceBindingSig
+        self.deviceGroupWelcome = deviceGroupWelcome
+        self.catchupSnapshot = catchupSnapshot
+    }
+}
+
+extension LinkingTicket: Equatable, Hashable {
+    public static func == (lhs: LinkingTicket, rhs: LinkingTicket) -> Bool {
+        if lhs.v != rhs.v {
+            return false
+        }
+        if lhs.userId != rhs.userId {
+            return false
+        }
+        if lhs.userPubkey != rhs.userPubkey {
+            return false
+        }
+        if lhs.newDeviceId != rhs.newDeviceId {
+            return false
+        }
+        if lhs.deviceBindingSig != rhs.deviceBindingSig {
+            return false
+        }
+        if lhs.deviceGroupWelcome != rhs.deviceGroupWelcome {
+            return false
+        }
+        if lhs.catchupSnapshot != rhs.catchupSnapshot {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(v)
+        hasher.combine(userId)
+        hasher.combine(userPubkey)
+        hasher.combine(newDeviceId)
+        hasher.combine(deviceBindingSig)
+        hasher.combine(deviceGroupWelcome)
+        hasher.combine(catchupSnapshot)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeLinkingTicket: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> LinkingTicket {
+        return
+            try LinkingTicket(
+                v: FfiConverterUInt8.read(from: &buf),
+                userId: FfiConverterTypeUserId.read(from: &buf),
+                userPubkey: FfiConverterData.read(from: &buf),
+                newDeviceId: FfiConverterTypeDeviceId.read(from: &buf),
+                deviceBindingSig: FfiConverterData.read(from: &buf),
+                deviceGroupWelcome: FfiConverterData.read(from: &buf),
+                catchupSnapshot: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: LinkingTicket, into buf: inout [UInt8]) {
+        FfiConverterUInt8.write(value.v, into: &buf)
+        FfiConverterTypeUserId.write(value.userId, into: &buf)
+        FfiConverterData.write(value.userPubkey, into: &buf)
+        FfiConverterTypeDeviceId.write(value.newDeviceId, into: &buf)
+        FfiConverterData.write(value.deviceBindingSig, into: &buf)
+        FfiConverterData.write(value.deviceGroupWelcome, into: &buf)
+        FfiConverterData.write(value.catchupSnapshot, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeLinkingTicket_lift(_ buf: RustBuffer) throws -> LinkingTicket {
+    return try FfiConverterTypeLinkingTicket.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeLinkingTicket_lower(_ value: LinkingTicket) -> RustBuffer {
+    return FfiConverterTypeLinkingTicket.lower(value)
+}
+
+public struct MessageEnvelope {
+    public var v: UInt8
+    public var conversationId: ConversationId
+    public var epoch: UInt64
+    public var kind: MessageKind
+    public var senderDevice: DeviceId
+    public var seq: UInt64
+    public var hlc: Hlc
+    public var payload: Data
+    public var contentHash: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(v: UInt8, conversationId: ConversationId, epoch: UInt64, kind: MessageKind, senderDevice: DeviceId, seq: UInt64, hlc: Hlc, payload: Data, contentHash: Data) {
+        self.v = v
+        self.conversationId = conversationId
+        self.epoch = epoch
+        self.kind = kind
+        self.senderDevice = senderDevice
+        self.seq = seq
+        self.hlc = hlc
+        self.payload = payload
+        self.contentHash = contentHash
+    }
+}
+
+extension MessageEnvelope: Equatable, Hashable {
+    public static func == (lhs: MessageEnvelope, rhs: MessageEnvelope) -> Bool {
+        if lhs.v != rhs.v {
+            return false
+        }
+        if lhs.conversationId != rhs.conversationId {
+            return false
+        }
+        if lhs.epoch != rhs.epoch {
+            return false
+        }
+        if lhs.kind != rhs.kind {
+            return false
+        }
+        if lhs.senderDevice != rhs.senderDevice {
+            return false
+        }
+        if lhs.seq != rhs.seq {
+            return false
+        }
+        if lhs.hlc != rhs.hlc {
+            return false
+        }
+        if lhs.payload != rhs.payload {
+            return false
+        }
+        if lhs.contentHash != rhs.contentHash {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(v)
+        hasher.combine(conversationId)
+        hasher.combine(epoch)
+        hasher.combine(kind)
+        hasher.combine(senderDevice)
+        hasher.combine(seq)
+        hasher.combine(hlc)
+        hasher.combine(payload)
+        hasher.combine(contentHash)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessageEnvelope: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessageEnvelope {
+        return
+            try MessageEnvelope(
+                v: FfiConverterUInt8.read(from: &buf),
+                conversationId: FfiConverterTypeConversationId.read(from: &buf),
+                epoch: FfiConverterUInt64.read(from: &buf),
+                kind: FfiConverterTypeMessageKind.read(from: &buf),
+                senderDevice: FfiConverterTypeDeviceId.read(from: &buf),
+                seq: FfiConverterUInt64.read(from: &buf),
+                hlc: FfiConverterTypeHlc.read(from: &buf),
+                payload: FfiConverterData.read(from: &buf),
+                contentHash: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: MessageEnvelope, into buf: inout [UInt8]) {
+        FfiConverterUInt8.write(value.v, into: &buf)
+        FfiConverterTypeConversationId.write(value.conversationId, into: &buf)
+        FfiConverterUInt64.write(value.epoch, into: &buf)
+        FfiConverterTypeMessageKind.write(value.kind, into: &buf)
+        FfiConverterTypeDeviceId.write(value.senderDevice, into: &buf)
+        FfiConverterUInt64.write(value.seq, into: &buf)
+        FfiConverterTypeHlc.write(value.hlc, into: &buf)
+        FfiConverterData.write(value.payload, into: &buf)
+        FfiConverterData.write(value.contentHash, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageEnvelope_lift(_ buf: RustBuffer) throws -> MessageEnvelope {
+    return try FfiConverterTypeMessageEnvelope.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageEnvelope_lower(_ value: MessageEnvelope) -> RustBuffer {
+    return FfiConverterTypeMessageEnvelope.lower(value)
+}
+
+public struct UserId {
+    public var value: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(value: Data) {
+        self.value = value
+    }
+}
+
+extension UserId: Equatable, Hashable {
+    public static func == (lhs: UserId, rhs: UserId) -> Bool {
+        if lhs.value != rhs.value {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeUserId: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UserId {
+        return
+            try UserId(
+                value: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: UserId, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.value, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserId_lift(_ buf: RustBuffer) throws -> UserId {
+    return try FfiConverterTypeUserId.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeUserId_lower(_ value: UserId) -> RustBuffer {
+    return FfiConverterTypeUserId.lower(value)
+}
+
+// Note that we don't yet support `indirect` for enums.
+// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
+
+public enum MessageKind {
+    case application
+    case commit
+    case welcome
+    case proposal
+    case keyPackage
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessageKind: FfiConverterRustBuffer {
+    typealias SwiftType = MessageKind
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessageKind {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        case 1: return .application
+
+        case 2: return .commit
+
+        case 3: return .welcome
+
+        case 4: return .proposal
+
+        case 5: return .keyPackage
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: MessageKind, into buf: inout [UInt8]) {
+        switch value {
+        case .application:
+            writeInt(&buf, Int32(1))
+
+        case .commit:
+            writeInt(&buf, Int32(2))
+
+        case .welcome:
+            writeInt(&buf, Int32(3))
+
+        case .proposal:
+            writeInt(&buf, Int32(4))
+
+        case .keyPackage:
+            writeInt(&buf, Int32(5))
+        }
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageKind_lift(_ buf: RustBuffer) throws -> MessageKind {
+    return try FfiConverterTypeMessageKind.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageKind_lower(_ value: MessageKind) -> RustBuffer {
+    return FfiConverterTypeMessageKind.lower(value)
+}
+
+extension MessageKind: Equatable, Hashable {}
+
+public enum PingError {
+    case Storage(message: String)
+
+    case Transport(message: String)
+
+    case Mls(message: String)
+
+    case Identity(message: String)
+
+    case UnknownConversation(message: String)
+
+    case UnknownDevice(message: String)
+
+    case EpochOccupied(message: String)
+
+    case Codec(message: String)
+
+    case Invalid(message: String)
+
+    case NotInitialised(message: String)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypePingError: FfiConverterRustBuffer {
+    typealias SwiftType = PingError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PingError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        case 1: return try .Storage(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 2: return try .Transport(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 3: return try .Mls(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 4: return try .Identity(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 5: return try .UnknownConversation(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 6: return try .UnknownDevice(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 7: return try .EpochOccupied(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 8: return try .Codec(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 9: return try .Invalid(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        case 10: return try .NotInitialised(
+                message: FfiConverterString.read(from: &buf)
+            )
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: PingError, into buf: inout [UInt8]) {
+        switch value {
+        case .Storage(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(1))
+        case .Transport(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(2))
+        case .Mls(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(3))
+        case .Identity(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(4))
+        case .UnknownConversation(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(5))
+        case .UnknownDevice(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(6))
+        case .EpochOccupied(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(7))
+        case .Codec(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(8))
+        case .Invalid(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(9))
+        case .NotInitialised(_ /* message is ignored*/ ):
+            writeInt(&buf, Int32(10))
+        }
+    }
+}
+
+extension PingError: Equatable, Hashable {}
+
+extension PingError: Foundation.LocalizedError {
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterOptionString: FfiConverterRustBuffer {
+    typealias SwiftType = String?
+
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterString.write(value, into: &buf)
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterString.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterOptionData: FfiConverterRustBuffer {
+    typealias SwiftType = Data?
+
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterData.write(value, into: &buf)
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterData.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterOptionTypeIncomingMessage: FfiConverterRustBuffer {
+    typealias SwiftType = IncomingMessage?
+
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeIncomingMessage.write(value, into: &buf)
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        switch try readInt(&buf) as Int8 {
+        case 0: return nil
+        case 1: return try FfiConverterTypeIncomingMessage.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceUInt32: FfiConverterRustBuffer {
+    typealias SwiftType = [UInt32]
+
+    static func write(_ value: [UInt32], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterUInt32.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt32] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [UInt32]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterUInt32.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceString: FfiConverterRustBuffer {
+    typealias SwiftType = [String]
+
+    static func write(_ value: [String], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterString.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [String]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterString.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceData: FfiConverterRustBuffer {
+    typealias SwiftType = [Data]
+
+    static func write(_ value: [Data], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterData.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [Data]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterData.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeConversationMeta: FfiConverterRustBuffer {
+    typealias SwiftType = [ConversationMeta]
+
+    static func write(_ value: [ConversationMeta], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeConversationMeta.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ConversationMeta] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [ConversationMeta]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeConversationMeta.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeDeviceInfo: FfiConverterRustBuffer {
+    typealias SwiftType = [DeviceInfo]
+
+    static func write(_ value: [DeviceInfo], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeDeviceInfo.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [DeviceInfo] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [DeviceInfo]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeDeviceInfo.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeDiscoveredDevice: FfiConverterRustBuffer {
+    typealias SwiftType = [DiscoveredDevice]
+
+    static func write(_ value: [DiscoveredDevice], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeDiscoveredDevice.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [DiscoveredDevice] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [DiscoveredDevice]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeDiscoveredDevice.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeIncomingMessage: FfiConverterRustBuffer {
+    typealias SwiftType = [IncomingMessage]
+
+    static func write(_ value: [IncomingMessage], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeIncomingMessage.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [IncomingMessage] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [IncomingMessage]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeIncomingMessage.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeMessageEnvelope: FfiConverterRustBuffer {
+    typealias SwiftType = [MessageEnvelope]
+
+    static func write(_ value: [MessageEnvelope], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeMessageEnvelope.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MessageEnvelope] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [MessageEnvelope]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeMessageEnvelope.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+private let UNIFFI_RUST_FUTURE_POLL_READY: Int8 = 0
+private let UNIFFI_RUST_FUTURE_POLL_MAYBE_READY: Int8 = 1
+
+private let uniffiContinuationHandleMap = UniffiHandleMap<UnsafeContinuation<Int8, Never>>()
+
+private func uniffiRustCallAsync<F, T>(
+    rustFutureFunc: () -> UInt64,
+    pollFunc: (UInt64, @escaping UniffiRustFutureContinuationCallback, UInt64) -> Void,
+    completeFunc: (UInt64, UnsafeMutablePointer<RustCallStatus>) -> F,
+    freeFunc: (UInt64) -> Void,
+    liftFunc: (F) throws -> T,
+    errorHandler: ((RustBuffer) throws -> Swift.Error)?
+) async throws -> T {
+    // Make sure to call uniffiEnsureInitialized() since future creation doesn't have a
+    // RustCallStatus param, so doesn't use makeRustCall()
+    uniffiEnsureInitialized()
+    let rustFuture = rustFutureFunc()
+    defer {
+        freeFunc(rustFuture)
+    }
+    var pollResult: Int8
+    repeat {
+        pollResult = await withUnsafeContinuation {
+            pollFunc(
+                rustFuture,
+                uniffiFutureContinuationCallback,
+                uniffiContinuationHandleMap.insert(obj: $0)
+            )
+        }
+    } while pollResult != UNIFFI_RUST_FUTURE_POLL_READY
+
+    return try liftFunc(makeRustCall(
+        { completeFunc(rustFuture, $0) },
+        errorHandler: errorHandler
+    ))
+}
+
+/// Callback handlers for an async calls.  These are invoked by Rust when the future is ready.  They
+/// lift the return value or error and resume the suspended function.
+private func uniffiFutureContinuationCallback(handle: UInt64, pollResult: Int8) {
+    if let continuation = try? uniffiContinuationHandleMap.remove(handle: handle) {
+        continuation.resume(returning: pollResult)
+    } else {
+        print("uniffiFutureContinuationCallback invalid handle")
+    }
+}
+
+private func uniffiTraitInterfaceCallAsync<T>(
+    makeCall: @escaping () async throws -> T,
+    handleSuccess: @escaping (T) -> Void,
+    handleError: @escaping (Int8, RustBuffer) -> Void
+) -> UniffiForeignFuture {
+    let task = Task {
+        do {
+            try handleSuccess(await makeCall())
+        } catch {
+            handleError(CALL_UNEXPECTED_ERROR, FfiConverterString.lower(String(describing: error)))
+        }
+    }
+    let handle = UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.insert(obj: task)
+    return UniffiForeignFuture(handle: handle, free: uniffiForeignFutureFree)
+}
+
+private func uniffiTraitInterfaceCallAsyncWithError<T, E>(
+    makeCall: @escaping () async throws -> T,
+    handleSuccess: @escaping (T) -> Void,
+    handleError: @escaping (Int8, RustBuffer) -> Void,
+    lowerError: @escaping (E) -> RustBuffer
+) -> UniffiForeignFuture {
+    let task = Task {
+        do {
+            try handleSuccess(await makeCall())
+        } catch let error as E {
+            handleError(CALL_ERROR, lowerError(error))
+        } catch {
+            handleError(CALL_UNEXPECTED_ERROR, FfiConverterString.lower(String(describing: error)))
+        }
+    }
+    let handle = UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.insert(obj: task)
+    return UniffiForeignFuture(handle: handle, free: uniffiForeignFutureFree)
+}
+
+// Borrow the callback handle map implementation to store foreign future handles
+// TODO: consolidate the handle-map code (https://github.com/mozilla/uniffi-rs/pull/1823)
+private var UNIFFI_FOREIGN_FUTURE_HANDLE_MAP = UniffiHandleMap<UniffiForeignFutureTask>()
+
+/// Protocol for tasks that handle foreign futures.
+///
+/// Defining a protocol allows all tasks to be stored in the same handle map.  This can't be done
+/// with the task object itself, since has generic parameters.
+protocol UniffiForeignFutureTask {
+    func cancel()
+}
+
+extension Task: UniffiForeignFutureTask {}
+
+private func uniffiForeignFutureFree(handle: UInt64) {
+    do {
+        let task = try UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.remove(handle: handle)
+        // Set the cancellation flag on the task.  If it's still running, the code can check the
+        // cancellation flag or call `Task.checkCancellation()`.  If the task has completed, this is
+        // a no-op.
+        task.cancel()
+    } catch {
+        print("uniffiForeignFutureFree: handle missing from handlemap")
+    }
+}
+
+/// For testing
+public func uniffiForeignFutureHandleCountPing() -> Int {
+    UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.count
+}
+
+public func generateIdentityExport() -> Data {
+    return try! FfiConverterData.lift(try! rustCall {
+        uniffi_ping_ffi_fn_func_generate_identity_export($0)
+    })
+}
+
+private enum InitializationResult {
+    case ok
+    case contractVersionMismatch
+    case apiChecksumMismatch
+}
+
+/// Use a global variable to perform the versioning checks. Swift ensures that
+/// the code inside is only computed once.
+private var initializationResult: InitializationResult = {
+    // Get the bindings contract version from our ComponentInterface
+    let bindings_contract_version = 26
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_ping_ffi_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if uniffi_ping_ffi_checksum_func_generate_identity_export() != 15026 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messageobserver_on_application_message() != 7190 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messageobserver_on_conversation_updated() != 50154 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_add_members() != 59894 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_build_linking_ticket() != 54304 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_consume_linking_ticket() != 11953 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_create_conversation() != 49429 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_device_id() != 45433 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_device_info() != 51623 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_fresh_key_package() != 54233 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_join_conversation() != 48291 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_list_conversations() != 15788 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_list_devices() != 10141 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_process_envelope() != 11247 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_remove_members() != 62054 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_revoke_device() != 63664 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_send() != 11574 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_set_observer() != 43381 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_sync_conversations() != 21737 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_user_id() != 53867 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_storage_delete() != 26596 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_storage_get() != 24556 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_storage_list_keys() != 3905 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_storage_put() != 24542 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_transport_discover_devices() != 6136 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_transport_fetch_since() != 1677 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_transport_send() != 46493 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_constructor_messagingclient_init() != 38981 {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    uniffiCallbackInitMessageObserver()
+    uniffiCallbackInitStorage()
+    uniffiCallbackInitTransport()
+    return InitializationResult.ok
+}()
+
+private func uniffiEnsureInitialized() {
+    switch initializationResult {
+    case .ok:
+        break
+    case .contractVersionMismatch:
+        fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+    case .apiChecksumMismatch:
+        fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+}
+
+// swiftlint:enable all