@offline-protocol/mesh-sdk 0.2.0

package/ios/Generated/offline_protocol.swift

@@ -0,0 +1,3995 @@
+// 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(offline_protocolFFI)
+import offline_protocolFFI
+#endif
+
+fileprivate 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_offline_protocol_uniffi_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_offline_protocol_uniffi_rustbuffer_free(self, $0) }
+    }
+}
+
+fileprivate 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.
+
+fileprivate 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
+
+fileprivate 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.
+fileprivate 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
+fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<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.
+fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
+    return Float(bitPattern: try readInt(&reader))
+}
+
+// Reads a float at the current offset.
+fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
+    return Double(bitPattern: try readInt(&reader))
+}
+
+// Indicates if the offset has reached the end of the buffer.
+fileprivate 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.
+
+fileprivate func createWriter() -> [UInt8] {
+    return []
+}
+
+fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, 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!
+fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
+    var value = value.bigEndian
+    withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
+}
+
+fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
+    writeInt(&writer, value.bitPattern)
+}
+
+fileprivate 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.
+fileprivate 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.
+fileprivate 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.
+fileprivate 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.
+fileprivate enum UniffiInternalError: LocalizedError {
+    case bufferOverflow
+    case incompleteData
+    case unexpectedOptionalTag
+    case unexpectedEnumCase
+    case unexpectedNullPointer
+    case unexpectedRustCallStatusCode
+    case unexpectedRustCallError
+    case unexpectedStaleHandle
+    case rustPanic(_ message: String)
+
+    public 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
+        }
+    }
+}
+
+fileprivate extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        self.lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
+
+fileprivate let CALL_SUCCESS: Int8 = 0
+fileprivate let CALL_ERROR: Int8 = 1
+fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
+fileprivate let CALL_CANCELLED: Int8 = 3
+
+fileprivate extension RustCallStatus {
+    init() {
+        self.init(
+            code: CALL_SUCCESS,
+            errorBuf: RustBuffer.init(
+                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 {
+    uniffiEnsureOfflineProtocolUniffiInitialized()
+    var callStatus = RustCallStatus.init()
+    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 UniffiInternalError.rustPanic(try 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) -> ()
+) {
+    do {
+        try writeReturn(makeCall())
+    } catch let error {
+        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) -> (),
+    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))
+    }
+}
+// Initial value and increment amount for handles. 
+// These ensure that SWIFT handles always have the lowest bit set
+fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1
+fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2
+
+fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
+    // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
+    private let lock = NSLock()
+    private var map: [UInt64: T] = [:]
+    private var currentHandle: UInt64 = UNIFFI_HANDLEMAP_INITIAL
+
+    func insert(obj: T) -> UInt64 {
+        lock.withLock {
+            return doInsert(obj)
+        }
+    }
+
+    // Low-level insert function, this assumes `lock` is held.
+    private func doInsert(_ obj: T) -> UInt64 {
+        let handle = currentHandle
+        currentHandle += UNIFFI_HANDLEMAP_DELTA
+        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
+        }
+    }
+
+     func clone(handle: UInt64) throws -> UInt64 {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return doInsert(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 {
+        get {
+            map.count
+        }
+    }
+}
+
+
+// Public interface members begin here.
+// 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
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt8: FfiConverterPrimitive {
+    typealias FfiType = UInt8
+    typealias SwiftType = UInt8
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: UInt8, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt16: FfiConverterPrimitive {
+    typealias FfiType = UInt16
+    typealias SwiftType = UInt16
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt16 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterInt16: FfiConverterPrimitive {
+    typealias FfiType = Int16
+    typealias SwiftType = Int16
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int16 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Int16, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
+    typealias FfiType = UInt32
+    typealias SwiftType = UInt32
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
+    typealias FfiType = UInt64
+    typealias SwiftType = UInt64
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterFloat: FfiConverterPrimitive {
+    typealias FfiType = Float
+    typealias SwiftType = Float
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Float {
+        return try lift(readFloat(&buf))
+    }
+
+    public static func write(_ value: Float, into buf: inout [UInt8]) {
+        writeFloat(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterBool : FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    public static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    public static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: Bool, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterString: FfiConverter {
+    typealias SwiftType = String
+    typealias FfiType = RustBuffer
+
+    public 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)!
+    }
+
+    public 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)
+            }
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+        let len: Int32 = try readInt(&buf)
+        return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
+    }
+
+    public static func write(_ value: String, into buf: inout [UInt8]) {
+        let len = Int32(value.utf8.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value.utf8)
+    }
+}
+
+
+
+
+public protocol OfflineProtocolProtocol: AnyObject, Sendable {
+    
+    func addInternetTransport(serverUrl: String, port: UInt16) throws 
+    
+    func addWifiDirectTransport() throws 
+    
+    func bleFragmentReceived(senderId: String, fragment: [UInt8]) throws 
+    
+    func bleGetNextFragment()  -> BleFragment?
+    
+    func bleGetPeerCount()  -> UInt32
+    
+    func blePeerDiscovered(peerId: String, rssi: Int16) throws 
+    
+    func blePeerLost(peerId: String) throws 
+    
+    func bleReturnFragment() 
+    
+    func bleStatusChanged(isAvailable: Bool) throws 
+    
+    func cancelFileTransfer(fileId: String) throws 
+    
+    func cleanupExpiredRoutes() 
+    
+    func emitTestEvent() 
+    
+    func finalizeFile(fileId: String) throws 
+    
+    func forceTransport(transportType: TransportType) throws 
+    
+    func getActiveTransports()  -> [String]
+    
+    func getAllRoutes(destination: String)  -> [RouteEntry]
+    
+    func getBatteryLevel()  -> UInt8?
+    
+    func getBestRoute(destination: String)  -> RouteEntry?
+    
+    func getDedupStats()  -> DedupStats
+    
+    func getDeliverySuccessRate()  -> Float
+    
+    func getDorsConfig()  -> DorsConfig
+    
+    func getFileProgress(fileId: String)  -> FileProgress?
+    
+    func getMedianHops()  -> UInt8
+    
+    func getMedianLatency()  -> UInt64
+    
+    func getMessageStats()  -> [MessageStats]
+    
+    func getPendingAckCount()  -> UInt64
+    
+    func getRelayPriority()  -> RelayPriority
+    
+    func getRetryQueueSize()  -> UInt64
+    
+    func getRoutingStats()  -> RoutingStats
+    
+    func getState()  -> ProtocolState
+    
+    func getTopology() throws  -> NetworkTopology
+    
+    func getTransportMetrics(transportType: TransportType)  -> TransportMetrics?
+    
+    func hasRoute(destination: String)  -> Bool
+    
+    func internetGetNextMessage()  -> InternetMessage?
+    
+    func internetMessageReceived(senderId: String, data: [UInt8]) throws 
+    
+    func internetReturnMessage() 
+    
+    func internetStatusChanged(isConnected: Bool) throws 
+    
+    func isRelay()  -> Bool
+    
+    func learnRoute(destination: String, nextHop: String, hopCount: UInt8, quality: Float) 
+    
+    func pause() throws 
+    
+    func pollEvent()  -> String?
+    
+    func process() throws 
+    
+    func processFileChunk(fileId: String, chunkIndex: UInt32, data: [UInt8]) throws 
+    
+    func receiveMessage()  -> String?
+    
+    func releaseTransportLock() 
+    
+    func removeNeighborRoutes(neighborId: String) 
+    
+    func removeTransport(transportType: TransportType) throws 
+    
+    func resume() throws 
+    
+    func sendFile(recipient: String, filePath: String, fileName: String) throws  -> String
+    
+    func sendMessage(recipient: String, content: String, priority: MessagePriority) throws  -> String
+    
+    func setBatteryLevel(level: UInt8) 
+    
+    func setEventCallback(callback: EventCallback) 
+    
+    func setRelayPriority(priority: RelayPriority) throws 
+    
+    func shouldEscalateToWifi()  -> Bool
+    
+    func start() throws 
+    
+    func stop() throws 
+    
+    func updateAckConfig(config: AckConfig) 
+    
+    func updateDedupConfig(config: DedupConfig) 
+    
+    func updateDorsConfig(config: DorsConfig) throws 
+    
+    func updateRetryConfig(config: RetryConfig) 
+    
+    func updateRoutingConfig(config: GradientRoutingConfig) 
+    
+    func updateTransportMetrics(transportType: TransportType, metrics: TransportMetrics) throws 
+    
+    func wifiDirectGetNextMessage()  -> WifiDirectMessage?
+    
+    func wifiDirectMessageReceived(senderId: String, data: [UInt8]) throws 
+    
+    func wifiDirectPeerConnected(peerId: String) throws 
+    
+    func wifiDirectPeerDisconnected(peerId: String) throws 
+    
+    func wifiDirectStatusChanged(isConnected: Bool) throws 
+    
+}
+open class OfflineProtocol: OfflineProtocolProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        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`.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    required public init(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: 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 handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_offline_protocol_uniffi_fn_clone_offlineprotocol(self.handle, $0) }
+    }
+public convenience init(config: ProtocolConfig)throws  {
+    let handle =
+        try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_constructor_offlineprotocol_new(
+        FfiConverterTypeProtocolConfig_lower(config),$0
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        try! rustCall { uniffi_offline_protocol_uniffi_fn_free_offlineprotocol(handle, $0) }
+    }
+
+    
+
+    
+open func addInternetTransport(serverUrl: String, port: UInt16)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_internet_transport(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(serverUrl),
+        FfiConverterUInt16.lower(port),$0
+    )
+}
+}
+    
+open func addWifiDirectTransport()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_wifi_direct_transport(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func bleFragmentReceived(senderId: String, fragment: [UInt8])throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_fragment_received(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(senderId),
+        FfiConverterSequenceUInt8.lower(fragment),$0
+    )
+}
+}
+    
+open func bleGetNextFragment() -> BleFragment?  {
+    return try!  FfiConverterOptionTypeBleFragment.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_next_fragment(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func bleGetPeerCount() -> UInt32  {
+    return try!  FfiConverterUInt32.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_peer_count(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func blePeerDiscovered(peerId: String, rssi: Int16)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_discovered(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(peerId),
+        FfiConverterInt16.lower(rssi),$0
+    )
+}
+}
+    
+open func blePeerLost(peerId: String)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_lost(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(peerId),$0
+    )
+}
+}
+    
+open func bleReturnFragment()  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_return_fragment(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func bleStatusChanged(isAvailable: Bool)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_status_changed(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(isAvailable),$0
+    )
+}
+}
+    
+open func cancelFileTransfer(fileId: String)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cancel_file_transfer(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(fileId),$0
+    )
+}
+}
+    
+open func cleanupExpiredRoutes()  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cleanup_expired_routes(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func emitTestEvent()  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_emit_test_event(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func finalizeFile(fileId: String)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_finalize_file(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(fileId),$0
+    )
+}
+}
+    
+open func forceTransport(transportType: TransportType)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_force_transport(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeTransportType_lower(transportType),$0
+    )
+}
+}
+    
+open func getActiveTransports() -> [String]  {
+    return try!  FfiConverterSequenceString.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_active_transports(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getAllRoutes(destination: String) -> [RouteEntry]  {
+    return try!  FfiConverterSequenceTypeRouteEntry.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_all_routes(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(destination),$0
+    )
+})
+}
+    
+open func getBatteryLevel() -> UInt8?  {
+    return try!  FfiConverterOptionUInt8.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_battery_level(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getBestRoute(destination: String) -> RouteEntry?  {
+    return try!  FfiConverterOptionTypeRouteEntry.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_best_route(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(destination),$0
+    )
+})
+}
+    
+open func getDedupStats() -> DedupStats  {
+    return try!  FfiConverterTypeDedupStats_lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dedup_stats(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getDeliverySuccessRate() -> Float  {
+    return try!  FfiConverterFloat.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_delivery_success_rate(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getDorsConfig() -> DorsConfig  {
+    return try!  FfiConverterTypeDorsConfig_lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dors_config(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getFileProgress(fileId: String) -> FileProgress?  {
+    return try!  FfiConverterOptionTypeFileProgress.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_file_progress(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(fileId),$0
+    )
+})
+}
+    
+open func getMedianHops() -> UInt8  {
+    return try!  FfiConverterUInt8.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_hops(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getMedianLatency() -> UInt64  {
+    return try!  FfiConverterUInt64.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_latency(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getMessageStats() -> [MessageStats]  {
+    return try!  FfiConverterSequenceTypeMessageStats.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_message_stats(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getPendingAckCount() -> UInt64  {
+    return try!  FfiConverterUInt64.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_pending_ack_count(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getRelayPriority() -> RelayPriority  {
+    return try!  FfiConverterTypeRelayPriority_lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_relay_priority(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getRetryQueueSize() -> UInt64  {
+    return try!  FfiConverterUInt64.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_retry_queue_size(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getRoutingStats() -> RoutingStats  {
+    return try!  FfiConverterTypeRoutingStats_lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_routing_stats(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getState() -> ProtocolState  {
+    return try!  FfiConverterTypeProtocolState_lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_state(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getTopology()throws  -> NetworkTopology  {
+    return try  FfiConverterTypeNetworkTopology_lift(try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_topology(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func getTransportMetrics(transportType: TransportType) -> TransportMetrics?  {
+    return try!  FfiConverterOptionTypeTransportMetrics.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_transport_metrics(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeTransportType_lower(transportType),$0
+    )
+})
+}
+    
+open func hasRoute(destination: String) -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_has_route(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(destination),$0
+    )
+})
+}
+    
+open func internetGetNextMessage() -> InternetMessage?  {
+    return try!  FfiConverterOptionTypeInternetMessage.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_get_next_message(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func internetMessageReceived(senderId: String, data: [UInt8])throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_message_received(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(senderId),
+        FfiConverterSequenceUInt8.lower(data),$0
+    )
+}
+}
+    
+open func internetReturnMessage()  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_return_message(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func internetStatusChanged(isConnected: Bool)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_status_changed(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(isConnected),$0
+    )
+}
+}
+    
+open func isRelay() -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_is_relay(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func learnRoute(destination: String, nextHop: String, hopCount: UInt8, quality: Float)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_learn_route(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(destination),
+        FfiConverterString.lower(nextHop),
+        FfiConverterUInt8.lower(hopCount),
+        FfiConverterFloat.lower(quality),$0
+    )
+}
+}
+    
+open func pause()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_pause(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func pollEvent() -> String?  {
+    return try!  FfiConverterOptionString.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_poll_event(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func process()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func processFileChunk(fileId: String, chunkIndex: UInt32, data: [UInt8])throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process_file_chunk(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(fileId),
+        FfiConverterUInt32.lower(chunkIndex),
+        FfiConverterSequenceUInt8.lower(data),$0
+    )
+}
+}
+    
+open func receiveMessage() -> String?  {
+    return try!  FfiConverterOptionString.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_receive_message(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func releaseTransportLock()  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_release_transport_lock(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func removeNeighborRoutes(neighborId: String)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_neighbor_routes(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(neighborId),$0
+    )
+}
+}
+    
+open func removeTransport(transportType: TransportType)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_transport(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeTransportType_lower(transportType),$0
+    )
+}
+}
+    
+open func resume()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_resume(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func sendFile(recipient: String, filePath: String, fileName: String)throws  -> String  {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_file(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(recipient),
+        FfiConverterString.lower(filePath),
+        FfiConverterString.lower(fileName),$0
+    )
+})
+}
+    
+open func sendMessage(recipient: String, content: String, priority: MessagePriority)throws  -> String  {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_message(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(recipient),
+        FfiConverterString.lower(content),
+        FfiConverterTypeMessagePriority_lower(priority),$0
+    )
+})
+}
+    
+open func setBatteryLevel(level: UInt8)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_battery_level(
+            self.uniffiCloneHandle(),
+        FfiConverterUInt8.lower(level),$0
+    )
+}
+}
+    
+open func setEventCallback(callback: EventCallback)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_event_callback(
+            self.uniffiCloneHandle(),
+        FfiConverterCallbackInterfaceEventCallback_lower(callback),$0
+    )
+}
+}
+    
+open func setRelayPriority(priority: RelayPriority)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_relay_priority(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeRelayPriority_lower(priority),$0
+    )
+}
+}
+    
+open func shouldEscalateToWifi() -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_should_escalate_to_wifi(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func start()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_start(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func stop()throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_stop(
+            self.uniffiCloneHandle(),$0
+    )
+}
+}
+    
+open func updateAckConfig(config: AckConfig)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_ack_config(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeAckConfig_lower(config),$0
+    )
+}
+}
+    
+open func updateDedupConfig(config: DedupConfig)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dedup_config(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeDedupConfig_lower(config),$0
+    )
+}
+}
+    
+open func updateDorsConfig(config: DorsConfig)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dors_config(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeDorsConfig_lower(config),$0
+    )
+}
+}
+    
+open func updateRetryConfig(config: RetryConfig)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_retry_config(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeRetryConfig_lower(config),$0
+    )
+}
+}
+    
+open func updateRoutingConfig(config: GradientRoutingConfig)  {try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_routing_config(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeGradientRoutingConfig_lower(config),$0
+    )
+}
+}
+    
+open func updateTransportMetrics(transportType: TransportType, metrics: TransportMetrics)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_transport_metrics(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeTransportType_lower(transportType),
+        FfiConverterTypeTransportMetrics_lower(metrics),$0
+    )
+}
+}
+    
+open func wifiDirectGetNextMessage() -> WifiDirectMessage?  {
+    return try!  FfiConverterOptionTypeWifiDirectMessage.lift(try! rustCall() {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_get_next_message(
+            self.uniffiCloneHandle(),$0
+    )
+})
+}
+    
+open func wifiDirectMessageReceived(senderId: String, data: [UInt8])throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_message_received(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(senderId),
+        FfiConverterSequenceUInt8.lower(data),$0
+    )
+}
+}
+    
+open func wifiDirectPeerConnected(peerId: String)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_connected(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(peerId),$0
+    )
+}
+}
+    
+open func wifiDirectPeerDisconnected(peerId: String)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_disconnected(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(peerId),$0
+    )
+}
+}
+    
+open func wifiDirectStatusChanged(isConnected: Bool)throws   {try rustCallWithError(FfiConverterTypeProtocolError_lift) {
+    uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_status_changed(
+            self.uniffiCloneHandle(),
+        FfiConverterBool.lower(isConnected),$0
+    )
+}
+}
+    
+
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeOfflineProtocol: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = OfflineProtocol
+
+    public static func lift(_ handle: UInt64) throws -> OfflineProtocol {
+        return OfflineProtocol(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: OfflineProtocol) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> OfflineProtocol {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: OfflineProtocol, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOfflineProtocol_lift(_ handle: UInt64) throws -> OfflineProtocol {
+    return try FfiConverterTypeOfflineProtocol.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOfflineProtocol_lower(_ value: OfflineProtocol) -> UInt64 {
+    return FfiConverterTypeOfflineProtocol.lower(value)
+}
+
+
+
+
+public struct AckConfig: Equatable, Hashable {
+    public var defaultTimeoutMs: UInt64
+    public var maxPendingAcks: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(defaultTimeoutMs: UInt64, maxPendingAcks: UInt64) {
+        self.defaultTimeoutMs = defaultTimeoutMs
+        self.maxPendingAcks = maxPendingAcks
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension AckConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeAckConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AckConfig {
+        return
+            try AckConfig(
+                defaultTimeoutMs: FfiConverterUInt64.read(from: &buf), 
+                maxPendingAcks: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: AckConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.defaultTimeoutMs, into: &buf)
+        FfiConverterUInt64.write(value.maxPendingAcks, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAckConfig_lift(_ buf: RustBuffer) throws -> AckConfig {
+    return try FfiConverterTypeAckConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeAckConfig_lower(_ value: AckConfig) -> RustBuffer {
+    return FfiConverterTypeAckConfig.lower(value)
+}
+
+
+public struct BleFragment: Equatable, Hashable {
+    public var recipientId: String
+    public var data: [UInt8]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(recipientId: String, data: [UInt8]) {
+        self.recipientId = recipientId
+        self.data = data
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension BleFragment: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeBleFragment: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> BleFragment {
+        return
+            try BleFragment(
+                recipientId: FfiConverterString.read(from: &buf), 
+                data: FfiConverterSequenceUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: BleFragment, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.recipientId, into: &buf)
+        FfiConverterSequenceUInt8.write(value.data, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBleFragment_lift(_ buf: RustBuffer) throws -> BleFragment {
+    return try FfiConverterTypeBleFragment.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeBleFragment_lower(_ value: BleFragment) -> RustBuffer {
+    return FfiConverterTypeBleFragment.lower(value)
+}
+
+
+public struct DedupConfig: Equatable, Hashable {
+    public var maxTrackedMessages: UInt64
+    public var retentionTimeSecs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(maxTrackedMessages: UInt64, retentionTimeSecs: UInt64) {
+        self.maxTrackedMessages = maxTrackedMessages
+        self.retentionTimeSecs = retentionTimeSecs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension DedupConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDedupConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DedupConfig {
+        return
+            try DedupConfig(
+                maxTrackedMessages: FfiConverterUInt64.read(from: &buf), 
+                retentionTimeSecs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: DedupConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.maxTrackedMessages, into: &buf)
+        FfiConverterUInt64.write(value.retentionTimeSecs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDedupConfig_lift(_ buf: RustBuffer) throws -> DedupConfig {
+    return try FfiConverterTypeDedupConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDedupConfig_lower(_ value: DedupConfig) -> RustBuffer {
+    return FfiConverterTypeDedupConfig.lower(value)
+}
+
+
+public struct DedupStats: Equatable, Hashable {
+    public var totalTracked: UInt64
+    public var recentTracked: UInt64
+    public var capacityUsedPercent: UInt8
+    public var mode: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(totalTracked: UInt64, recentTracked: UInt64, capacityUsedPercent: UInt8, mode: String) {
+        self.totalTracked = totalTracked
+        self.recentTracked = recentTracked
+        self.capacityUsedPercent = capacityUsedPercent
+        self.mode = mode
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension DedupStats: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDedupStats: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DedupStats {
+        return
+            try DedupStats(
+                totalTracked: FfiConverterUInt64.read(from: &buf), 
+                recentTracked: FfiConverterUInt64.read(from: &buf), 
+                capacityUsedPercent: FfiConverterUInt8.read(from: &buf), 
+                mode: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: DedupStats, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.totalTracked, into: &buf)
+        FfiConverterUInt64.write(value.recentTracked, into: &buf)
+        FfiConverterUInt8.write(value.capacityUsedPercent, into: &buf)
+        FfiConverterString.write(value.mode, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDedupStats_lift(_ buf: RustBuffer) throws -> DedupStats {
+    return try FfiConverterTypeDedupStats.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDedupStats_lower(_ value: DedupStats) -> RustBuffer {
+    return FfiConverterTypeDedupStats.lower(value)
+}
+
+
+public struct DorsConfig: Equatable, Hashable {
+    public var preferOnline: Bool
+    public var switchHysteresis: Float
+    public var switchCooldownSecs: UInt64
+    public var bleToWifiRetryThreshold: UInt32
+    public var rssiSwitchThreshold: Int16
+    public var congestionQueueThreshold: UInt64
+    public var stabilityWindowSecs: UInt64
+    public var poorSignalDurationSecs: UInt64
+    public var ttlEscalationThreshold: UInt8
+    public var congestionDurationSecs: UInt64
+    public var ttlEscalationHoldSecs: UInt64
+    public var historyWindowSize: UInt64
+    public var queueRecoveryRatio: Float
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(preferOnline: Bool, switchHysteresis: Float, switchCooldownSecs: UInt64, bleToWifiRetryThreshold: UInt32, rssiSwitchThreshold: Int16, congestionQueueThreshold: UInt64, stabilityWindowSecs: UInt64, poorSignalDurationSecs: UInt64, ttlEscalationThreshold: UInt8, congestionDurationSecs: UInt64, ttlEscalationHoldSecs: UInt64, historyWindowSize: UInt64, queueRecoveryRatio: Float) {
+        self.preferOnline = preferOnline
+        self.switchHysteresis = switchHysteresis
+        self.switchCooldownSecs = switchCooldownSecs
+        self.bleToWifiRetryThreshold = bleToWifiRetryThreshold
+        self.rssiSwitchThreshold = rssiSwitchThreshold
+        self.congestionQueueThreshold = congestionQueueThreshold
+        self.stabilityWindowSecs = stabilityWindowSecs
+        self.poorSignalDurationSecs = poorSignalDurationSecs
+        self.ttlEscalationThreshold = ttlEscalationThreshold
+        self.congestionDurationSecs = congestionDurationSecs
+        self.ttlEscalationHoldSecs = ttlEscalationHoldSecs
+        self.historyWindowSize = historyWindowSize
+        self.queueRecoveryRatio = queueRecoveryRatio
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension DorsConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeDorsConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> DorsConfig {
+        return
+            try DorsConfig(
+                preferOnline: FfiConverterBool.read(from: &buf), 
+                switchHysteresis: FfiConverterFloat.read(from: &buf), 
+                switchCooldownSecs: FfiConverterUInt64.read(from: &buf), 
+                bleToWifiRetryThreshold: FfiConverterUInt32.read(from: &buf), 
+                rssiSwitchThreshold: FfiConverterInt16.read(from: &buf), 
+                congestionQueueThreshold: FfiConverterUInt64.read(from: &buf), 
+                stabilityWindowSecs: FfiConverterUInt64.read(from: &buf), 
+                poorSignalDurationSecs: FfiConverterUInt64.read(from: &buf), 
+                ttlEscalationThreshold: FfiConverterUInt8.read(from: &buf), 
+                congestionDurationSecs: FfiConverterUInt64.read(from: &buf), 
+                ttlEscalationHoldSecs: FfiConverterUInt64.read(from: &buf), 
+                historyWindowSize: FfiConverterUInt64.read(from: &buf), 
+                queueRecoveryRatio: FfiConverterFloat.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: DorsConfig, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.preferOnline, into: &buf)
+        FfiConverterFloat.write(value.switchHysteresis, into: &buf)
+        FfiConverterUInt64.write(value.switchCooldownSecs, into: &buf)
+        FfiConverterUInt32.write(value.bleToWifiRetryThreshold, into: &buf)
+        FfiConverterInt16.write(value.rssiSwitchThreshold, into: &buf)
+        FfiConverterUInt64.write(value.congestionQueueThreshold, into: &buf)
+        FfiConverterUInt64.write(value.stabilityWindowSecs, into: &buf)
+        FfiConverterUInt64.write(value.poorSignalDurationSecs, into: &buf)
+        FfiConverterUInt8.write(value.ttlEscalationThreshold, into: &buf)
+        FfiConverterUInt64.write(value.congestionDurationSecs, into: &buf)
+        FfiConverterUInt64.write(value.ttlEscalationHoldSecs, into: &buf)
+        FfiConverterUInt64.write(value.historyWindowSize, into: &buf)
+        FfiConverterFloat.write(value.queueRecoveryRatio, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDorsConfig_lift(_ buf: RustBuffer) throws -> DorsConfig {
+    return try FfiConverterTypeDorsConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeDorsConfig_lower(_ value: DorsConfig) -> RustBuffer {
+    return FfiConverterTypeDorsConfig.lower(value)
+}
+
+
+public struct FileProgress: Equatable, Hashable {
+    public var fileId: String
+    public var chunksSent: UInt32
+    public var totalChunks: UInt32
+    public var percentage: UInt8
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(fileId: String, chunksSent: UInt32, totalChunks: UInt32, percentage: UInt8) {
+        self.fileId = fileId
+        self.chunksSent = chunksSent
+        self.totalChunks = totalChunks
+        self.percentage = percentage
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension FileProgress: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFileProgress: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FileProgress {
+        return
+            try FileProgress(
+                fileId: FfiConverterString.read(from: &buf), 
+                chunksSent: FfiConverterUInt32.read(from: &buf), 
+                totalChunks: FfiConverterUInt32.read(from: &buf), 
+                percentage: FfiConverterUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: FileProgress, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.fileId, into: &buf)
+        FfiConverterUInt32.write(value.chunksSent, into: &buf)
+        FfiConverterUInt32.write(value.totalChunks, into: &buf)
+        FfiConverterUInt8.write(value.percentage, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFileProgress_lift(_ buf: RustBuffer) throws -> FileProgress {
+    return try FfiConverterTypeFileProgress.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFileProgress_lower(_ value: FileProgress) -> RustBuffer {
+    return FfiConverterTypeFileProgress.lower(value)
+}
+
+
+public struct GradientRoutingConfig: Equatable, Hashable {
+    public var maxRoutesPerDestination: UInt32
+    public var routeTtlSecs: UInt64
+    public var maxRoutingTableSize: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(maxRoutesPerDestination: UInt32, routeTtlSecs: UInt64, maxRoutingTableSize: UInt32) {
+        self.maxRoutesPerDestination = maxRoutesPerDestination
+        self.routeTtlSecs = routeTtlSecs
+        self.maxRoutingTableSize = maxRoutingTableSize
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension GradientRoutingConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeGradientRoutingConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> GradientRoutingConfig {
+        return
+            try GradientRoutingConfig(
+                maxRoutesPerDestination: FfiConverterUInt32.read(from: &buf), 
+                routeTtlSecs: FfiConverterUInt64.read(from: &buf), 
+                maxRoutingTableSize: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: GradientRoutingConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.maxRoutesPerDestination, into: &buf)
+        FfiConverterUInt64.write(value.routeTtlSecs, into: &buf)
+        FfiConverterUInt32.write(value.maxRoutingTableSize, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeGradientRoutingConfig_lift(_ buf: RustBuffer) throws -> GradientRoutingConfig {
+    return try FfiConverterTypeGradientRoutingConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeGradientRoutingConfig_lower(_ value: GradientRoutingConfig) -> RustBuffer {
+    return FfiConverterTypeGradientRoutingConfig.lower(value)
+}
+
+
+public struct InternetMessage: Equatable, Hashable {
+    public var recipientId: String
+    public var data: [UInt8]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(recipientId: String, data: [UInt8]) {
+        self.recipientId = recipientId
+        self.data = data
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension InternetMessage: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeInternetMessage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> InternetMessage {
+        return
+            try InternetMessage(
+                recipientId: FfiConverterString.read(from: &buf), 
+                data: FfiConverterSequenceUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: InternetMessage, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.recipientId, into: &buf)
+        FfiConverterSequenceUInt8.write(value.data, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeInternetMessage_lift(_ buf: RustBuffer) throws -> InternetMessage {
+    return try FfiConverterTypeInternetMessage.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeInternetMessage_lower(_ value: InternetMessage) -> RustBuffer {
+    return FfiConverterTypeInternetMessage.lower(value)
+}
+
+
+public struct MessageStats: Equatable, Hashable {
+    public var messageId: String
+    public var sentAtMs: UInt64
+    public var deliveredAtMs: UInt64?
+    public var hopCount: UInt8
+    public var status: String
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(messageId: String, sentAtMs: UInt64, deliveredAtMs: UInt64?, hopCount: UInt8, status: String) {
+        self.messageId = messageId
+        self.sentAtMs = sentAtMs
+        self.deliveredAtMs = deliveredAtMs
+        self.hopCount = hopCount
+        self.status = status
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension MessageStats: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessageStats: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessageStats {
+        return
+            try MessageStats(
+                messageId: FfiConverterString.read(from: &buf), 
+                sentAtMs: FfiConverterUInt64.read(from: &buf), 
+                deliveredAtMs: FfiConverterOptionUInt64.read(from: &buf), 
+                hopCount: FfiConverterUInt8.read(from: &buf), 
+                status: FfiConverterString.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: MessageStats, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.messageId, into: &buf)
+        FfiConverterUInt64.write(value.sentAtMs, into: &buf)
+        FfiConverterOptionUInt64.write(value.deliveredAtMs, into: &buf)
+        FfiConverterUInt8.write(value.hopCount, into: &buf)
+        FfiConverterString.write(value.status, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageStats_lift(_ buf: RustBuffer) throws -> MessageStats {
+    return try FfiConverterTypeMessageStats.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessageStats_lower(_ value: MessageStats) -> RustBuffer {
+    return FfiConverterTypeMessageStats.lower(value)
+}
+
+
+public struct NetworkLink: Equatable, Hashable {
+    public var sourceId: String
+    public var targetId: String
+    public var transport: String
+    public var quality: Float
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(sourceId: String, targetId: String, transport: String, quality: Float) {
+        self.sourceId = sourceId
+        self.targetId = targetId
+        self.transport = transport
+        self.quality = quality
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension NetworkLink: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNetworkLink: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NetworkLink {
+        return
+            try NetworkLink(
+                sourceId: FfiConverterString.read(from: &buf), 
+                targetId: FfiConverterString.read(from: &buf), 
+                transport: FfiConverterString.read(from: &buf), 
+                quality: FfiConverterFloat.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NetworkLink, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.sourceId, into: &buf)
+        FfiConverterString.write(value.targetId, into: &buf)
+        FfiConverterString.write(value.transport, into: &buf)
+        FfiConverterFloat.write(value.quality, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkLink_lift(_ buf: RustBuffer) throws -> NetworkLink {
+    return try FfiConverterTypeNetworkLink.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkLink_lower(_ value: NetworkLink) -> RustBuffer {
+    return FfiConverterTypeNetworkLink.lower(value)
+}
+
+
+public struct NetworkNode: Equatable, Hashable {
+    public var nodeId: String
+    public var role: String
+    public var rssi: Int16?
+    public var lastSeenMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(nodeId: String, role: String, rssi: Int16?, lastSeenMs: UInt64) {
+        self.nodeId = nodeId
+        self.role = role
+        self.rssi = rssi
+        self.lastSeenMs = lastSeenMs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension NetworkNode: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNetworkNode: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NetworkNode {
+        return
+            try NetworkNode(
+                nodeId: FfiConverterString.read(from: &buf), 
+                role: FfiConverterString.read(from: &buf), 
+                rssi: FfiConverterOptionInt16.read(from: &buf), 
+                lastSeenMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NetworkNode, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.nodeId, into: &buf)
+        FfiConverterString.write(value.role, into: &buf)
+        FfiConverterOptionInt16.write(value.rssi, into: &buf)
+        FfiConverterUInt64.write(value.lastSeenMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkNode_lift(_ buf: RustBuffer) throws -> NetworkNode {
+    return try FfiConverterTypeNetworkNode.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkNode_lower(_ value: NetworkNode) -> RustBuffer {
+    return FfiConverterTypeNetworkNode.lower(value)
+}
+
+
+public struct NetworkTopology: Equatable, Hashable {
+    public var nodes: [NetworkNode]
+    public var links: [NetworkLink]
+    public var messageStats: [MessageStats]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(nodes: [NetworkNode], links: [NetworkLink], messageStats: [MessageStats]) {
+        self.nodes = nodes
+        self.links = links
+        self.messageStats = messageStats
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension NetworkTopology: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNetworkTopology: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NetworkTopology {
+        return
+            try NetworkTopology(
+                nodes: FfiConverterSequenceTypeNetworkNode.read(from: &buf), 
+                links: FfiConverterSequenceTypeNetworkLink.read(from: &buf), 
+                messageStats: FfiConverterSequenceTypeMessageStats.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: NetworkTopology, into buf: inout [UInt8]) {
+        FfiConverterSequenceTypeNetworkNode.write(value.nodes, into: &buf)
+        FfiConverterSequenceTypeNetworkLink.write(value.links, into: &buf)
+        FfiConverterSequenceTypeMessageStats.write(value.messageStats, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkTopology_lift(_ buf: RustBuffer) throws -> NetworkTopology {
+    return try FfiConverterTypeNetworkTopology.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetworkTopology_lower(_ value: NetworkTopology) -> RustBuffer {
+    return FfiConverterTypeNetworkTopology.lower(value)
+}
+
+
+public struct PathConfig: Equatable, Hashable {
+    public var forwardToTopK: UInt32
+    public var maxCongestionLevel: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(forwardToTopK: UInt32, maxCongestionLevel: UInt32) {
+        self.forwardToTopK = forwardToTopK
+        self.maxCongestionLevel = maxCongestionLevel
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension PathConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypePathConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PathConfig {
+        return
+            try PathConfig(
+                forwardToTopK: FfiConverterUInt32.read(from: &buf), 
+                maxCongestionLevel: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: PathConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.forwardToTopK, into: &buf)
+        FfiConverterUInt32.write(value.maxCongestionLevel, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePathConfig_lift(_ buf: RustBuffer) throws -> PathConfig {
+    return try FfiConverterTypePathConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePathConfig_lower(_ value: PathConfig) -> RustBuffer {
+    return FfiConverterTypePathConfig.lower(value)
+}
+
+
+public struct PeerDevice: Equatable, Hashable {
+    public var peerId: String
+    public var rssi: Int16
+    public var lastSeenMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(peerId: String, rssi: Int16, lastSeenMs: UInt64) {
+        self.peerId = peerId
+        self.rssi = rssi
+        self.lastSeenMs = lastSeenMs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension PeerDevice: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypePeerDevice: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> PeerDevice {
+        return
+            try PeerDevice(
+                peerId: FfiConverterString.read(from: &buf), 
+                rssi: FfiConverterInt16.read(from: &buf), 
+                lastSeenMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: PeerDevice, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.peerId, into: &buf)
+        FfiConverterInt16.write(value.rssi, into: &buf)
+        FfiConverterUInt64.write(value.lastSeenMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePeerDevice_lift(_ buf: RustBuffer) throws -> PeerDevice {
+    return try FfiConverterTypePeerDevice.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypePeerDevice_lower(_ value: PeerDevice) -> RustBuffer {
+    return FfiConverterTypePeerDevice.lower(value)
+}
+
+
+public struct ProtocolConfig: Equatable, Hashable {
+    public var appId: String
+    public var userId: String
+    public var bleEnabled: Bool
+    public var wifiDirectEnabled: Bool
+    public var internetEnabled: Bool
+    public var preferOnline: Bool
+    public var initialTtl: UInt8
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(appId: String, userId: String, bleEnabled: Bool, wifiDirectEnabled: Bool, internetEnabled: Bool, preferOnline: Bool, initialTtl: UInt8) {
+        self.appId = appId
+        self.userId = userId
+        self.bleEnabled = bleEnabled
+        self.wifiDirectEnabled = wifiDirectEnabled
+        self.internetEnabled = internetEnabled
+        self.preferOnline = preferOnline
+        self.initialTtl = initialTtl
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension ProtocolConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeProtocolConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolConfig {
+        return
+            try ProtocolConfig(
+                appId: FfiConverterString.read(from: &buf), 
+                userId: FfiConverterString.read(from: &buf), 
+                bleEnabled: FfiConverterBool.read(from: &buf), 
+                wifiDirectEnabled: FfiConverterBool.read(from: &buf), 
+                internetEnabled: FfiConverterBool.read(from: &buf), 
+                preferOnline: FfiConverterBool.read(from: &buf), 
+                initialTtl: FfiConverterUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ProtocolConfig, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.appId, into: &buf)
+        FfiConverterString.write(value.userId, into: &buf)
+        FfiConverterBool.write(value.bleEnabled, into: &buf)
+        FfiConverterBool.write(value.wifiDirectEnabled, into: &buf)
+        FfiConverterBool.write(value.internetEnabled, into: &buf)
+        FfiConverterBool.write(value.preferOnline, into: &buf)
+        FfiConverterUInt8.write(value.initialTtl, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolConfig_lift(_ buf: RustBuffer) throws -> ProtocolConfig {
+    return try FfiConverterTypeProtocolConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolConfig_lower(_ value: ProtocolConfig) -> RustBuffer {
+    return FfiConverterTypeProtocolConfig.lower(value)
+}
+
+
+public struct ProtocolConfigExtended: Equatable, Hashable {
+    public var appId: String
+    public var userId: String
+    public var transport: TransportConfig
+    public var dors: DorsConfig
+    public var relay: RelayConfig
+    public var path: PathConfig
+    public var reliability: ReliabilityConfig
+    public var initialTtl: UInt8
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(appId: String, userId: String, transport: TransportConfig, dors: DorsConfig, relay: RelayConfig, path: PathConfig, reliability: ReliabilityConfig, initialTtl: UInt8) {
+        self.appId = appId
+        self.userId = userId
+        self.transport = transport
+        self.dors = dors
+        self.relay = relay
+        self.path = path
+        self.reliability = reliability
+        self.initialTtl = initialTtl
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension ProtocolConfigExtended: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeProtocolConfigExtended: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolConfigExtended {
+        return
+            try ProtocolConfigExtended(
+                appId: FfiConverterString.read(from: &buf), 
+                userId: FfiConverterString.read(from: &buf), 
+                transport: FfiConverterTypeTransportConfig.read(from: &buf), 
+                dors: FfiConverterTypeDorsConfig.read(from: &buf), 
+                relay: FfiConverterTypeRelayConfig.read(from: &buf), 
+                path: FfiConverterTypePathConfig.read(from: &buf), 
+                reliability: FfiConverterTypeReliabilityConfig.read(from: &buf), 
+                initialTtl: FfiConverterUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ProtocolConfigExtended, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.appId, into: &buf)
+        FfiConverterString.write(value.userId, into: &buf)
+        FfiConverterTypeTransportConfig.write(value.transport, into: &buf)
+        FfiConverterTypeDorsConfig.write(value.dors, into: &buf)
+        FfiConverterTypeRelayConfig.write(value.relay, into: &buf)
+        FfiConverterTypePathConfig.write(value.path, into: &buf)
+        FfiConverterTypeReliabilityConfig.write(value.reliability, into: &buf)
+        FfiConverterUInt8.write(value.initialTtl, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolConfigExtended_lift(_ buf: RustBuffer) throws -> ProtocolConfigExtended {
+    return try FfiConverterTypeProtocolConfigExtended.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolConfigExtended_lower(_ value: ProtocolConfigExtended) -> RustBuffer {
+    return FfiConverterTypeProtocolConfigExtended.lower(value)
+}
+
+
+public struct RelayConfig: Equatable, Hashable {
+    public var relayThreshold: UInt64
+    public var minBatteryForRelay: UInt8
+    public var allowRelay: Bool
+    public var relayPriority: RelayPriority
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(relayThreshold: UInt64, minBatteryForRelay: UInt8, allowRelay: Bool, relayPriority: RelayPriority) {
+        self.relayThreshold = relayThreshold
+        self.minBatteryForRelay = minBatteryForRelay
+        self.allowRelay = allowRelay
+        self.relayPriority = relayPriority
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension RelayConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRelayConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RelayConfig {
+        return
+            try RelayConfig(
+                relayThreshold: FfiConverterUInt64.read(from: &buf), 
+                minBatteryForRelay: FfiConverterUInt8.read(from: &buf), 
+                allowRelay: FfiConverterBool.read(from: &buf), 
+                relayPriority: FfiConverterTypeRelayPriority.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: RelayConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.relayThreshold, into: &buf)
+        FfiConverterUInt8.write(value.minBatteryForRelay, into: &buf)
+        FfiConverterBool.write(value.allowRelay, into: &buf)
+        FfiConverterTypeRelayPriority.write(value.relayPriority, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRelayConfig_lift(_ buf: RustBuffer) throws -> RelayConfig {
+    return try FfiConverterTypeRelayConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRelayConfig_lower(_ value: RelayConfig) -> RustBuffer {
+    return FfiConverterTypeRelayConfig.lower(value)
+}
+
+
+public struct ReliabilityConfig: Equatable, Hashable {
+    public var ack: AckConfig
+    public var retry: RetryConfig
+    public var dedup: DedupConfig
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(ack: AckConfig, retry: RetryConfig, dedup: DedupConfig) {
+        self.ack = ack
+        self.retry = retry
+        self.dedup = dedup
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension ReliabilityConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeReliabilityConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ReliabilityConfig {
+        return
+            try ReliabilityConfig(
+                ack: FfiConverterTypeAckConfig.read(from: &buf), 
+                retry: FfiConverterTypeRetryConfig.read(from: &buf), 
+                dedup: FfiConverterTypeDedupConfig.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ReliabilityConfig, into buf: inout [UInt8]) {
+        FfiConverterTypeAckConfig.write(value.ack, into: &buf)
+        FfiConverterTypeRetryConfig.write(value.retry, into: &buf)
+        FfiConverterTypeDedupConfig.write(value.dedup, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReliabilityConfig_lift(_ buf: RustBuffer) throws -> ReliabilityConfig {
+    return try FfiConverterTypeReliabilityConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReliabilityConfig_lower(_ value: ReliabilityConfig) -> RustBuffer {
+    return FfiConverterTypeReliabilityConfig.lower(value)
+}
+
+
+public struct RetryConfig: Equatable, Hashable {
+    public var maxRetries: UInt32
+    public var initialDelayMs: UInt64
+    public var maxDelayMs: UInt64
+    public var backoffMultiplier: Float
+    public var outboxMaxLifetimeMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(maxRetries: UInt32, initialDelayMs: UInt64, maxDelayMs: UInt64, backoffMultiplier: Float, outboxMaxLifetimeMs: UInt64) {
+        self.maxRetries = maxRetries
+        self.initialDelayMs = initialDelayMs
+        self.maxDelayMs = maxDelayMs
+        self.backoffMultiplier = backoffMultiplier
+        self.outboxMaxLifetimeMs = outboxMaxLifetimeMs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension RetryConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRetryConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RetryConfig {
+        return
+            try RetryConfig(
+                maxRetries: FfiConverterUInt32.read(from: &buf), 
+                initialDelayMs: FfiConverterUInt64.read(from: &buf), 
+                maxDelayMs: FfiConverterUInt64.read(from: &buf), 
+                backoffMultiplier: FfiConverterFloat.read(from: &buf), 
+                outboxMaxLifetimeMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: RetryConfig, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.maxRetries, into: &buf)
+        FfiConverterUInt64.write(value.initialDelayMs, into: &buf)
+        FfiConverterUInt64.write(value.maxDelayMs, into: &buf)
+        FfiConverterFloat.write(value.backoffMultiplier, into: &buf)
+        FfiConverterUInt64.write(value.outboxMaxLifetimeMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRetryConfig_lift(_ buf: RustBuffer) throws -> RetryConfig {
+    return try FfiConverterTypeRetryConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRetryConfig_lower(_ value: RetryConfig) -> RustBuffer {
+    return FfiConverterTypeRetryConfig.lower(value)
+}
+
+
+public struct RouteEntry: Equatable, Hashable {
+    public var nextHop: String
+    public var hopCount: UInt8
+    public var quality: Float
+    public var lastSeenMs: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(nextHop: String, hopCount: UInt8, quality: Float, lastSeenMs: UInt64) {
+        self.nextHop = nextHop
+        self.hopCount = hopCount
+        self.quality = quality
+        self.lastSeenMs = lastSeenMs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension RouteEntry: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRouteEntry: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RouteEntry {
+        return
+            try RouteEntry(
+                nextHop: FfiConverterString.read(from: &buf), 
+                hopCount: FfiConverterUInt8.read(from: &buf), 
+                quality: FfiConverterFloat.read(from: &buf), 
+                lastSeenMs: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: RouteEntry, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.nextHop, into: &buf)
+        FfiConverterUInt8.write(value.hopCount, into: &buf)
+        FfiConverterFloat.write(value.quality, into: &buf)
+        FfiConverterUInt64.write(value.lastSeenMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRouteEntry_lift(_ buf: RustBuffer) throws -> RouteEntry {
+    return try FfiConverterTypeRouteEntry.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRouteEntry_lower(_ value: RouteEntry) -> RustBuffer {
+    return FfiConverterTypeRouteEntry.lower(value)
+}
+
+
+public struct RoutingStats: Equatable, Hashable {
+    public var destinationCount: UInt32
+    public var routeCount: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(destinationCount: UInt32, routeCount: UInt32) {
+        self.destinationCount = destinationCount
+        self.routeCount = routeCount
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension RoutingStats: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRoutingStats: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RoutingStats {
+        return
+            try RoutingStats(
+                destinationCount: FfiConverterUInt32.read(from: &buf), 
+                routeCount: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: RoutingStats, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.destinationCount, into: &buf)
+        FfiConverterUInt32.write(value.routeCount, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRoutingStats_lift(_ buf: RustBuffer) throws -> RoutingStats {
+    return try FfiConverterTypeRoutingStats.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRoutingStats_lower(_ value: RoutingStats) -> RustBuffer {
+    return FfiConverterTypeRoutingStats.lower(value)
+}
+
+
+public struct TransportConfig: Equatable, Hashable {
+    public var bleEnabled: Bool
+    public var wifiDirectEnabled: Bool
+    public var internetEnabled: Bool
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(bleEnabled: Bool, wifiDirectEnabled: Bool, internetEnabled: Bool) {
+        self.bleEnabled = bleEnabled
+        self.wifiDirectEnabled = wifiDirectEnabled
+        self.internetEnabled = internetEnabled
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension TransportConfig: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransportConfig: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransportConfig {
+        return
+            try TransportConfig(
+                bleEnabled: FfiConverterBool.read(from: &buf), 
+                wifiDirectEnabled: FfiConverterBool.read(from: &buf), 
+                internetEnabled: FfiConverterBool.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TransportConfig, into buf: inout [UInt8]) {
+        FfiConverterBool.write(value.bleEnabled, into: &buf)
+        FfiConverterBool.write(value.wifiDirectEnabled, into: &buf)
+        FfiConverterBool.write(value.internetEnabled, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportConfig_lift(_ buf: RustBuffer) throws -> TransportConfig {
+    return try FfiConverterTypeTransportConfig.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportConfig_lower(_ value: TransportConfig) -> RustBuffer {
+    return FfiConverterTypeTransportConfig.lower(value)
+}
+
+
+public struct TransportMetrics: Equatable, Hashable {
+    public var packetsSent: UInt32
+    public var packetsReceived: UInt32
+    public var bytesSent: UInt32
+    public var bytesReceived: UInt32
+    public var errorRate: Float
+    public var avgLatencyMs: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(packetsSent: UInt32, packetsReceived: UInt32, bytesSent: UInt32, bytesReceived: UInt32, errorRate: Float, avgLatencyMs: UInt32) {
+        self.packetsSent = packetsSent
+        self.packetsReceived = packetsReceived
+        self.bytesSent = bytesSent
+        self.bytesReceived = bytesReceived
+        self.errorRate = errorRate
+        self.avgLatencyMs = avgLatencyMs
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension TransportMetrics: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransportMetrics: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransportMetrics {
+        return
+            try TransportMetrics(
+                packetsSent: FfiConverterUInt32.read(from: &buf), 
+                packetsReceived: FfiConverterUInt32.read(from: &buf), 
+                bytesSent: FfiConverterUInt32.read(from: &buf), 
+                bytesReceived: FfiConverterUInt32.read(from: &buf), 
+                errorRate: FfiConverterFloat.read(from: &buf), 
+                avgLatencyMs: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TransportMetrics, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.packetsSent, into: &buf)
+        FfiConverterUInt32.write(value.packetsReceived, into: &buf)
+        FfiConverterUInt32.write(value.bytesSent, into: &buf)
+        FfiConverterUInt32.write(value.bytesReceived, into: &buf)
+        FfiConverterFloat.write(value.errorRate, into: &buf)
+        FfiConverterUInt32.write(value.avgLatencyMs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportMetrics_lift(_ buf: RustBuffer) throws -> TransportMetrics {
+    return try FfiConverterTypeTransportMetrics.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportMetrics_lower(_ value: TransportMetrics) -> RustBuffer {
+    return FfiConverterTypeTransportMetrics.lower(value)
+}
+
+
+public struct WifiDirectMessage: Equatable, Hashable {
+    public var recipientId: String
+    public var data: [UInt8]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(recipientId: String, data: [UInt8]) {
+        self.recipientId = recipientId
+        self.data = data
+    }
+
+    
+}
+
+#if compiler(>=6)
+extension WifiDirectMessage: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWifiDirectMessage: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WifiDirectMessage {
+        return
+            try WifiDirectMessage(
+                recipientId: FfiConverterString.read(from: &buf), 
+                data: FfiConverterSequenceUInt8.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: WifiDirectMessage, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.recipientId, into: &buf)
+        FfiConverterSequenceUInt8.write(value.data, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWifiDirectMessage_lift(_ buf: RustBuffer) throws -> WifiDirectMessage {
+    return try FfiConverterTypeWifiDirectMessage.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWifiDirectMessage_lower(_ value: WifiDirectMessage) -> RustBuffer {
+    return FfiConverterTypeWifiDirectMessage.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 MessagePriority: Equatable, Hashable {
+    
+    case low
+    case medium
+    case high
+    case critical
+
+
+
+}
+
+#if compiler(>=6)
+extension MessagePriority: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMessagePriority: FfiConverterRustBuffer {
+    typealias SwiftType = MessagePriority
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MessagePriority {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .low
+        
+        case 2: return .medium
+        
+        case 3: return .high
+        
+        case 4: return .critical
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: MessagePriority, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .low:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .medium:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .high:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .critical:
+            writeInt(&buf, Int32(4))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessagePriority_lift(_ buf: RustBuffer) throws -> MessagePriority {
+    return try FfiConverterTypeMessagePriority.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMessagePriority_lower(_ value: MessagePriority) -> RustBuffer {
+    return FfiConverterTypeMessagePriority.lower(value)
+}
+
+
+
+public enum ProtocolError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
+
+    
+    
+    case NotStarted(message: String)
+    
+    case AlreadyStarted(message: String)
+    
+    case InvalidConfiguration(message: String)
+    
+    case SendFailed(message: String)
+    
+    case InvalidState(message: String)
+    
+    case Other(message: String)
+    
+
+    
+
+    
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+    
+}
+
+#if compiler(>=6)
+extension ProtocolError: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeProtocolError: FfiConverterRustBuffer {
+    typealias SwiftType = ProtocolError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        
+
+        
+        case 1: return .NotStarted(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 2: return .AlreadyStarted(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 3: return .InvalidConfiguration(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 4: return .SendFailed(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 5: return .InvalidState(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+        case 6: return .Other(
+            message: try FfiConverterString.read(from: &buf)
+        )
+        
+
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ProtocolError, into buf: inout [UInt8]) {
+        switch value {
+
+        
+
+        
+        case .NotStarted(_ /* message is ignored*/):
+            writeInt(&buf, Int32(1))
+        case .AlreadyStarted(_ /* message is ignored*/):
+            writeInt(&buf, Int32(2))
+        case .InvalidConfiguration(_ /* message is ignored*/):
+            writeInt(&buf, Int32(3))
+        case .SendFailed(_ /* message is ignored*/):
+            writeInt(&buf, Int32(4))
+        case .InvalidState(_ /* message is ignored*/):
+            writeInt(&buf, Int32(5))
+        case .Other(_ /* message is ignored*/):
+            writeInt(&buf, Int32(6))
+
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolError_lift(_ buf: RustBuffer) throws -> ProtocolError {
+    return try FfiConverterTypeProtocolError.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolError_lower(_ value: ProtocolError) -> RustBuffer {
+    return FfiConverterTypeProtocolError.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 ProtocolState: Equatable, Hashable {
+    
+    case stopped
+    case starting
+    case running
+    case paused
+    case stopping
+
+
+
+}
+
+#if compiler(>=6)
+extension ProtocolState: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeProtocolState: FfiConverterRustBuffer {
+    typealias SwiftType = ProtocolState
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ProtocolState {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .stopped
+        
+        case 2: return .starting
+        
+        case 3: return .running
+        
+        case 4: return .paused
+        
+        case 5: return .stopping
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ProtocolState, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .stopped:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .starting:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .running:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .paused:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .stopping:
+            writeInt(&buf, Int32(5))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolState_lift(_ buf: RustBuffer) throws -> ProtocolState {
+    return try FfiConverterTypeProtocolState.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeProtocolState_lower(_ value: ProtocolState) -> RustBuffer {
+    return FfiConverterTypeProtocolState.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 RelayPriority: Equatable, Hashable {
+    
+    case low
+    case medium
+    case high
+
+
+
+}
+
+#if compiler(>=6)
+extension RelayPriority: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRelayPriority: FfiConverterRustBuffer {
+    typealias SwiftType = RelayPriority
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RelayPriority {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .low
+        
+        case 2: return .medium
+        
+        case 3: return .high
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: RelayPriority, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .low:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .medium:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .high:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRelayPriority_lift(_ buf: RustBuffer) throws -> RelayPriority {
+    return try FfiConverterTypeRelayPriority.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRelayPriority_lower(_ value: RelayPriority) -> RustBuffer {
+    return FfiConverterTypeRelayPriority.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 TransportType: Equatable, Hashable {
+    
+    case internet
+    case ble
+    case wiFiDirect
+
+
+
+}
+
+#if compiler(>=6)
+extension TransportType: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransportType: FfiConverterRustBuffer {
+    typealias SwiftType = TransportType
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransportType {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .internet
+        
+        case 2: return .ble
+        
+        case 3: return .wiFiDirect
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: TransportType, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .internet:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .ble:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .wiFiDirect:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportType_lift(_ buf: RustBuffer) throws -> TransportType {
+    return try FfiConverterTypeTransportType.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransportType_lower(_ value: TransportType) -> RustBuffer {
+    return FfiConverterTypeTransportType.lower(value)
+}
+
+
+
+
+
+public protocol EventCallback: AnyObject, Sendable {
+    
+    func onEvent(eventJson: String) 
+    
+}
+
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+fileprivate struct UniffiCallbackInterfaceEventCallback {
+
+    // Create the VTable using a series of closures.
+    // Swift automatically converts these into C callback functions.
+    //
+    // This creates 1-element array, since this seems to be the only way to construct a const
+    // pointer that we can pass to the Rust code.
+    static let vtable: [UniffiVTableCallbackInterfaceEventCallback] = [UniffiVTableCallbackInterfaceEventCallback(
+        uniffiFree: { (uniffiHandle: UInt64) -> () in
+            do {
+                try FfiConverterCallbackInterfaceEventCallback.handleMap.remove(handle: uniffiHandle)
+            } catch {
+                print("Uniffi callback interface EventCallback: handle missing in uniffiFree")
+            }
+        },
+        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
+            do {
+                return try FfiConverterCallbackInterfaceEventCallback.handleMap.clone(handle: uniffiHandle)
+            } catch {
+                fatalError("Uniffi callback interface EventCallback: handle missing in uniffiClone")
+            }
+        },
+        onEvent: { (
+            uniffiHandle: UInt64,
+            eventJson: RustBuffer,
+            uniffiOutReturn: UnsafeMutableRawPointer,
+            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
+        ) in
+            let makeCall = {
+                () throws -> () in
+                guard let uniffiObj = try? FfiConverterCallbackInterfaceEventCallback.handleMap.get(handle: uniffiHandle) else {
+                    throw UniffiInternalError.unexpectedStaleHandle
+                }
+                return uniffiObj.onEvent(
+                     eventJson: try FfiConverterString.lift(eventJson)
+                )
+            }
+
+            
+            let writeReturn = { () }
+            uniffiTraitInterfaceCall(
+                callStatus: uniffiCallStatus,
+                makeCall: makeCall,
+                writeReturn: writeReturn
+            )
+        }
+    )]
+}
+
+private func uniffiCallbackInitEventCallback() {
+    uniffi_offline_protocol_uniffi_fn_init_callback_vtable_eventcallback(UniffiCallbackInterfaceEventCallback.vtable)
+}
+
+// FfiConverter protocol for callback interfaces
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterCallbackInterfaceEventCallback {
+    fileprivate static let handleMap = UniffiHandleMap<EventCallback>()
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+extension FfiConverterCallbackInterfaceEventCallback : FfiConverter {
+    typealias SwiftType = EventCallback
+    typealias FfiType = UInt64
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lift(_ handle: UInt64) throws -> SwiftType {
+        try handleMap.get(handle: handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func lower(_ v: SwiftType) -> UInt64 {
+        return handleMap.insert(obj: v)
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(v))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceEventCallback_lift(_ handle: UInt64) throws -> EventCallback {
+    return try FfiConverterCallbackInterfaceEventCallback.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterCallbackInterfaceEventCallback_lower(_ v: EventCallback) -> UInt64 {
+    return FfiConverterCallbackInterfaceEventCallback.lower(v)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionUInt8: FfiConverterRustBuffer {
+    typealias SwiftType = UInt8?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterUInt8.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterUInt8.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionInt16: FfiConverterRustBuffer {
+    typealias SwiftType = Int16?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterInt16.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterInt16.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer {
+    typealias SwiftType = UInt64?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterUInt64.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterUInt64.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
+    typealias SwiftType = String?
+
+    public 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)
+    }
+
+    public 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
+fileprivate struct FfiConverterOptionTypeBleFragment: FfiConverterRustBuffer {
+    typealias SwiftType = BleFragment?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeBleFragment.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeBleFragment.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeFileProgress: FfiConverterRustBuffer {
+    typealias SwiftType = FileProgress?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeFileProgress.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeFileProgress.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeInternetMessage: FfiConverterRustBuffer {
+    typealias SwiftType = InternetMessage?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeInternetMessage.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeInternetMessage.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeRouteEntry: FfiConverterRustBuffer {
+    typealias SwiftType = RouteEntry?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeRouteEntry.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeRouteEntry.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeTransportMetrics: FfiConverterRustBuffer {
+    typealias SwiftType = TransportMetrics?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeTransportMetrics.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeTransportMetrics.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeWifiDirectMessage: FfiConverterRustBuffer {
+    typealias SwiftType = WifiDirectMessage?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeWifiDirectMessage.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeWifiDirectMessage.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceUInt8: FfiConverterRustBuffer {
+    typealias SwiftType = [UInt8]
+
+    public static func write(_ value: [UInt8], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterUInt8.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [UInt8] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [UInt8]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterUInt8.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
+    typealias SwiftType = [String]
+
+    public 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)
+        }
+    }
+
+    public 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 {
+            seq.append(try FfiConverterString.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeMessageStats: FfiConverterRustBuffer {
+    typealias SwiftType = [MessageStats]
+
+    public static func write(_ value: [MessageStats], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeMessageStats.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MessageStats] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [MessageStats]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeMessageStats.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeNetworkLink: FfiConverterRustBuffer {
+    typealias SwiftType = [NetworkLink]
+
+    public static func write(_ value: [NetworkLink], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeNetworkLink.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [NetworkLink] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [NetworkLink]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeNetworkLink.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeNetworkNode: FfiConverterRustBuffer {
+    typealias SwiftType = [NetworkNode]
+
+    public static func write(_ value: [NetworkNode], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeNetworkNode.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [NetworkNode] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [NetworkNode]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeNetworkNode.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeRouteEntry: FfiConverterRustBuffer {
+    typealias SwiftType = [RouteEntry]
+
+    public static func write(_ value: [RouteEntry], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeRouteEntry.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [RouteEntry] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [RouteEntry]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeRouteEntry.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+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 let initializationResult: InitializationResult = {
+    // Get the bindings contract version from our ComponentInterface
+    let bindings_contract_version = 30
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_offline_protocol_uniffi_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_internet_transport() != 42106) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_wifi_direct_transport() != 19197) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_fragment_received() != 44733) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_next_fragment() != 27429) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_peer_count() != 32781) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_discovered() != 53124) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_lost() != 38687) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_return_fragment() != 4155) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_status_changed() != 19618) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cancel_file_transfer() != 6632) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cleanup_expired_routes() != 32382) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_emit_test_event() != 6796) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_finalize_file() != 55328) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_force_transport() != 28940) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_active_transports() != 5327) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_all_routes() != 27292) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_battery_level() != 12938) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_best_route() != 31041) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dedup_stats() != 43759) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_delivery_success_rate() != 62412) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dors_config() != 28708) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_file_progress() != 37575) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_hops() != 22077) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_latency() != 9158) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_message_stats() != 30825) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_pending_ack_count() != 9023) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_relay_priority() != 38001) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_retry_queue_size() != 53188) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_routing_stats() != 51722) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_state() != 51778) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_topology() != 3250) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_transport_metrics() != 62682) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_has_route() != 44869) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_get_next_message() != 48075) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_message_received() != 62143) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_return_message() != 33628) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_status_changed() != 25243) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_is_relay() != 34892) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_learn_route() != 38824) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_pause() != 51362) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_poll_event() != 28496) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process() != 16160) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process_file_chunk() != 54114) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_receive_message() != 33217) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_release_transport_lock() != 4494) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_neighbor_routes() != 19049) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_transport() != 16891) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_resume() != 39596) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_file() != 33006) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_message() != 36955) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_battery_level() != 65320) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_event_callback() != 14659) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_relay_priority() != 33715) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_should_escalate_to_wifi() != 40161) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_start() != 10699) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_stop() != 37179) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_ack_config() != 58995) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dedup_config() != 4301) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dors_config() != 2649) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_retry_config() != 19988) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_routing_config() != 61324) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_transport_metrics() != 51165) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_get_next_message() != 1936) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_message_received() != 62211) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_connected() != 3197) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_disconnected() != 17734) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_status_changed() != 35006) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_constructor_offlineprotocol_new() != 30125) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_offline_protocol_uniffi_checksum_method_eventcallback_on_event() != 4769) {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    uniffiCallbackInitEventCallback()
+    return InitializationResult.ok
+}()
+
+// Make the ensure init function public so that other modules which have external type references to
+// our types can call it.
+public func uniffiEnsureOfflineProtocolUniffiInitialized() {
+    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