@offline-protocol/mesh-sdk 0.2.0

package/android/src/main/java/uniffi/offline_protocol/offline_protocol.kt

@@ -0,0 +1,4789 @@
+// This file was autogenerated by some hot garbage in the `uniffi` crate.
+// Trust me, you don't want to mess with it!
+
+@file:Suppress("NAME_SHADOWING")
+
+package uniffi.offline_protocol
+
+// Common helper code.
+//
+// Ideally this would live in a separate .kt file where it can be unittested etc
+// in isolation, and perhaps even published as a re-useable package.
+//
+// However, it's important that the details of how this helper code works (e.g. the
+// way that different builtin types are passed across the FFI) exactly match what's
+// expected by the Rust code on the other side of the interface. In practice right
+// now that means coming from the exact some version of `uniffi` that was used to
+// compile the Rust component. The easiest way to ensure this is to bundle the Kotlin
+// helpers directly inline like we're doing here.
+
+import com.sun.jna.Library
+import com.sun.jna.IntegerType
+import com.sun.jna.Native
+import com.sun.jna.Pointer
+import com.sun.jna.Structure
+import com.sun.jna.Callback
+import com.sun.jna.ptr.*
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.CharBuffer
+import java.nio.charset.CodingErrorAction
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
+
+// This is a helper for safely working with byte buffers returned from the Rust code.
+// A rust-owned buffer is represented by its capacity, its current length, and a
+// pointer to the underlying data.
+
+/**
+ * @suppress
+ */
+@Structure.FieldOrder("capacity", "len", "data")
+open class RustBuffer : Structure() {
+    // Note: `capacity` and `len` are actually `ULong` values, but JVM only supports signed values.
+    // When dealing with these fields, make sure to call `toULong()`.
+    @JvmField var capacity: Long = 0
+    @JvmField var len: Long = 0
+    @JvmField var data: Pointer? = null
+
+    class ByValue: RustBuffer(), Structure.ByValue
+    class ByReference: RustBuffer(), Structure.ByReference
+
+   internal fun setValue(other: RustBuffer) {
+        capacity = other.capacity
+        len = other.len
+        data = other.data
+    }
+
+    companion object {
+        internal fun alloc(size: ULong = 0UL) = uniffiRustCall() { status ->
+            // Note: need to convert the size to a `Long` value to make this work with JVM.
+            UniffiLib.ffi_offline_protocol_uniffi_rustbuffer_alloc(size.toLong(), status)
+        }.also {
+            if(it.data == null) {
+               throw RuntimeException("RustBuffer.alloc() returned null data pointer (size=${size})")
+           }
+        }
+
+        internal fun create(capacity: ULong, len: ULong, data: Pointer?): RustBuffer.ByValue {
+            var buf = RustBuffer.ByValue()
+            buf.capacity = capacity.toLong()
+            buf.len = len.toLong()
+            buf.data = data
+            return buf
+        }
+
+        internal fun free(buf: RustBuffer.ByValue) = uniffiRustCall() { status ->
+            UniffiLib.ffi_offline_protocol_uniffi_rustbuffer_free(buf, status)
+        }
+    }
+
+    @Suppress("TooGenericExceptionThrown")
+    fun asByteBuffer() =
+        this.data?.getByteBuffer(0, this.len.toLong())?.also {
+            it.order(ByteOrder.BIG_ENDIAN)
+        }
+}
+
+// This is a helper for safely passing byte references into the rust code.
+// It's not actually used at the moment, because there aren't many things that you
+// can take a direct pointer to in the JVM, and if we're going to copy something
+// then we might as well copy it into a `RustBuffer`. But it's here for API
+// completeness.
+
+@Structure.FieldOrder("len", "data")
+internal open class ForeignBytes : Structure() {
+    @JvmField var len: Int = 0
+    @JvmField var data: Pointer? = null
+
+    class ByValue : ForeignBytes(), Structure.ByValue
+}
+/**
+ * The FfiConverter interface handles converter types to and from the FFI
+ *
+ * All implementing objects should be public to support external types.  When a
+ * type is external we need to import it's FfiConverter.
+ *
+ * @suppress
+ */
+public interface FfiConverter<KotlinType, FfiType> {
+    // Convert an FFI type to a Kotlin type
+    fun lift(value: FfiType): KotlinType
+
+    // Convert an Kotlin type to an FFI type
+    fun lower(value: KotlinType): FfiType
+
+    // Read a Kotlin type from a `ByteBuffer`
+    fun read(buf: ByteBuffer): KotlinType
+
+    // Calculate bytes to allocate when creating a `RustBuffer`
+    //
+    // This must return at least as many bytes as the write() function will
+    // write. It can return more bytes than needed, for example when writing
+    // Strings we can't know the exact bytes needed until we the UTF-8
+    // encoding, so we pessimistically allocate the largest size possible (3
+    // bytes per codepoint).  Allocating extra bytes is not really a big deal
+    // because the `RustBuffer` is short-lived.
+    fun allocationSize(value: KotlinType): ULong
+
+    // Write a Kotlin type to a `ByteBuffer`
+    fun write(value: KotlinType, buf: ByteBuffer)
+
+    // Lower a value into a `RustBuffer`
+    //
+    // This method lowers a value into a `RustBuffer` rather than the normal
+    // FfiType.  It's used by the callback interface code.  Callback interface
+    // returns are always serialized into a `RustBuffer` regardless of their
+    // normal FFI type.
+    fun lowerIntoRustBuffer(value: KotlinType): RustBuffer.ByValue {
+        val rbuf = RustBuffer.alloc(allocationSize(value))
+        try {
+            val bbuf = rbuf.data!!.getByteBuffer(0, rbuf.capacity).also {
+                it.order(ByteOrder.BIG_ENDIAN)
+            }
+            write(value, bbuf)
+            rbuf.writeField("len", bbuf.position().toLong())
+            return rbuf
+        } catch (e: Throwable) {
+            RustBuffer.free(rbuf)
+            throw e
+        }
+    }
+
+    // Lift a value from a `RustBuffer`.
+    //
+    // This here mostly because of the symmetry with `lowerIntoRustBuffer()`.
+    // It's currently only used by the `FfiConverterRustBuffer` class below.
+    fun liftFromRustBuffer(rbuf: RustBuffer.ByValue): KotlinType {
+        val byteBuf = rbuf.asByteBuffer()!!
+        try {
+           val item = read(byteBuf)
+           if (byteBuf.hasRemaining()) {
+               throw RuntimeException("junk remaining in buffer after lifting, something is very wrong!!")
+           }
+           return item
+        } finally {
+            RustBuffer.free(rbuf)
+        }
+    }
+}
+
+/**
+ * FfiConverter that uses `RustBuffer` as the FfiType
+ *
+ * @suppress
+ */
+public interface FfiConverterRustBuffer<KotlinType>: FfiConverter<KotlinType, RustBuffer.ByValue> {
+    override fun lift(value: RustBuffer.ByValue) = liftFromRustBuffer(value)
+    override fun lower(value: KotlinType) = lowerIntoRustBuffer(value)
+}
+// A handful of classes and functions to support the generated data structures.
+// This would be a good candidate for isolating in its own ffi-support lib.
+
+internal const val UNIFFI_CALL_SUCCESS = 0.toByte()
+internal const val UNIFFI_CALL_ERROR = 1.toByte()
+internal const val UNIFFI_CALL_UNEXPECTED_ERROR = 2.toByte()
+
+@Structure.FieldOrder("code", "error_buf")
+internal open class UniffiRustCallStatus : Structure() {
+    @JvmField var code: Byte = 0
+    @JvmField var error_buf: RustBuffer.ByValue = RustBuffer.ByValue()
+
+    class ByValue: UniffiRustCallStatus(), Structure.ByValue
+
+    fun isSuccess(): Boolean {
+        return code == UNIFFI_CALL_SUCCESS
+    }
+
+    fun isError(): Boolean {
+        return code == UNIFFI_CALL_ERROR
+    }
+
+    fun isPanic(): Boolean {
+        return code == UNIFFI_CALL_UNEXPECTED_ERROR
+    }
+
+    companion object {
+        fun create(code: Byte, errorBuf: RustBuffer.ByValue): UniffiRustCallStatus.ByValue {
+            val callStatus = UniffiRustCallStatus.ByValue()
+            callStatus.code = code
+            callStatus.error_buf = errorBuf
+            return callStatus
+        }
+    }
+}
+
+class InternalException(message: String) : kotlin.Exception(message)
+
+/**
+ * Each top-level error class has a companion object that can lift the error from the call status's rust buffer
+ *
+ * @suppress
+ */
+interface UniffiRustCallStatusErrorHandler<E> {
+    fun lift(error_buf: RustBuffer.ByValue): E;
+}
+
+// Helpers for calling Rust
+// In practice we usually need to be synchronized to call this safely, so it doesn't
+// synchronize itself
+
+// Call a rust function that returns a Result<>.  Pass in the Error class companion that corresponds to the Err
+private inline fun <U, E: kotlin.Exception> uniffiRustCallWithError(errorHandler: UniffiRustCallStatusErrorHandler<E>, callback: (UniffiRustCallStatus) -> U): U {
+    var status = UniffiRustCallStatus()
+    val return_value = callback(status)
+    uniffiCheckCallStatus(errorHandler, status)
+    return return_value
+}
+
+// Check UniffiRustCallStatus and throw an error if the call wasn't successful
+private fun<E: kotlin.Exception> uniffiCheckCallStatus(errorHandler: UniffiRustCallStatusErrorHandler<E>, status: UniffiRustCallStatus) {
+    if (status.isSuccess()) {
+        return
+    } else if (status.isError()) {
+        throw errorHandler.lift(status.error_buf)
+    } else if (status.isPanic()) {
+        // 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 (status.error_buf.len > 0) {
+            throw InternalException(FfiConverterString.lift(status.error_buf))
+        } else {
+            throw InternalException("Rust panic")
+        }
+    } else {
+        throw InternalException("Unknown rust call status: $status.code")
+    }
+}
+
+/**
+ * UniffiRustCallStatusErrorHandler implementation for times when we don't expect a CALL_ERROR
+ *
+ * @suppress
+ */
+object UniffiNullRustCallStatusErrorHandler: UniffiRustCallStatusErrorHandler<InternalException> {
+    override fun lift(error_buf: RustBuffer.ByValue): InternalException {
+        RustBuffer.free(error_buf)
+        return InternalException("Unexpected CALL_ERROR")
+    }
+}
+
+// Call a rust function that returns a plain value
+private inline fun <U> uniffiRustCall(callback: (UniffiRustCallStatus) -> U): U {
+    return uniffiRustCallWithError(UniffiNullRustCallStatusErrorHandler, callback)
+}
+
+internal inline fun<T> uniffiTraitInterfaceCall(
+    callStatus: UniffiRustCallStatus,
+    makeCall: () -> T,
+    writeReturn: (T) -> Unit,
+) {
+    try {
+        writeReturn(makeCall())
+    } catch(e: kotlin.Exception) {
+        callStatus.code = UNIFFI_CALL_UNEXPECTED_ERROR
+        callStatus.error_buf = FfiConverterString.lower(e.toString())
+    }
+}
+
+internal inline fun<T, reified E: Throwable> uniffiTraitInterfaceCallWithError(
+    callStatus: UniffiRustCallStatus,
+    makeCall: () -> T,
+    writeReturn: (T) -> Unit,
+    lowerError: (E) -> RustBuffer.ByValue
+) {
+    try {
+        writeReturn(makeCall())
+    } catch(e: kotlin.Exception) {
+        if (e is E) {
+            callStatus.code = UNIFFI_CALL_ERROR
+            callStatus.error_buf = lowerError(e)
+        } else {
+            callStatus.code = UNIFFI_CALL_UNEXPECTED_ERROR
+            callStatus.error_buf = FfiConverterString.lower(e.toString())
+        }
+    }
+}
+// Initial value and increment amount for handles. 
+// These ensure that Kotlin-generated handles always have the lowest bit set
+private const val UNIFFI_HANDLEMAP_INITIAL = 1.toLong()
+private const val UNIFFI_HANDLEMAP_DELTA = 2.toLong()
+
+// Map handles to objects
+//
+// This is used pass an opaque 64-bit handle representing a foreign object to the Rust code.
+internal class UniffiHandleMap<T: Any> {
+    private val map = ConcurrentHashMap<Long, T>()
+    // Start 
+    private val counter = java.util.concurrent.atomic.AtomicLong(UNIFFI_HANDLEMAP_INITIAL)
+
+    val size: Int
+        get() = map.size
+
+    // Insert a new object into the handle map and get a handle for it
+    fun insert(obj: T): Long {
+        val handle = counter.getAndAdd(UNIFFI_HANDLEMAP_DELTA)
+        map.put(handle, obj)
+        return handle
+    }
+
+    // Clone a handle, creating a new one
+    fun clone(handle: Long): Long {
+        val obj = map.get(handle) ?: throw InternalException("UniffiHandleMap.clone: Invalid handle")
+        return insert(obj)
+    }
+
+    // Get an object from the handle map
+    fun get(handle: Long): T {
+        return map.get(handle) ?: throw InternalException("UniffiHandleMap.get: Invalid handle")
+    }
+
+    // Remove an entry from the handlemap and get the Kotlin object back
+    fun remove(handle: Long): T {
+        return map.remove(handle) ?: throw InternalException("UniffiHandleMap: Invalid handle")
+    }
+}
+
+// Contains loading, initialization code,
+// and the FFI Function declarations in a com.sun.jna.Library.
+@Synchronized
+private fun findLibraryName(componentName: String): String {
+    val libOverride = System.getProperty("uniffi.component.$componentName.libraryOverride")
+    if (libOverride != null) {
+        return libOverride
+    }
+    return "uniffi_offline_protocol"
+}
+
+// Define FFI callback types
+internal interface UniffiRustFutureContinuationCallback : com.sun.jna.Callback {
+    fun callback(`data`: Long,`pollResult`: Byte,)
+}
+internal interface UniffiForeignFutureDroppedCallback : com.sun.jna.Callback {
+    fun callback(`handle`: Long,)
+}
+internal interface UniffiCallbackInterfaceFree : com.sun.jna.Callback {
+    fun callback(`handle`: Long,)
+}
+internal interface UniffiCallbackInterfaceClone : com.sun.jna.Callback {
+    fun callback(`handle`: Long,)
+    : Long
+}
+@Structure.FieldOrder("handle", "free")
+internal open class UniffiForeignFutureDroppedCallbackStruct(
+    @JvmField internal var `handle`: Long = 0.toLong(),
+    @JvmField internal var `free`: UniffiForeignFutureDroppedCallback? = null,
+) : Structure() {
+    class UniffiByValue(
+        `handle`: Long = 0.toLong(),
+        `free`: UniffiForeignFutureDroppedCallback? = null,
+    ): UniffiForeignFutureDroppedCallbackStruct(`handle`,`free`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureDroppedCallbackStruct) {
+        `handle` = other.`handle`
+        `free` = other.`free`
+    }
+
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultU8(
+    @JvmField internal var `returnValue`: Byte = 0.toByte(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Byte = 0.toByte(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultU8(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultU8) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteU8 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultU8.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultI8(
+    @JvmField internal var `returnValue`: Byte = 0.toByte(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Byte = 0.toByte(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultI8(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultI8) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteI8 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultI8.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultU16(
+    @JvmField internal var `returnValue`: Short = 0.toShort(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Short = 0.toShort(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultU16(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultU16) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteU16 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultU16.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultI16(
+    @JvmField internal var `returnValue`: Short = 0.toShort(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Short = 0.toShort(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultI16(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultI16) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteI16 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultI16.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultU32(
+    @JvmField internal var `returnValue`: Int = 0,
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Int = 0,
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultU32(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultU32) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteU32 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultU32.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultI32(
+    @JvmField internal var `returnValue`: Int = 0,
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Int = 0,
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultI32(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultI32) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteI32 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultI32.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultU64(
+    @JvmField internal var `returnValue`: Long = 0.toLong(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Long = 0.toLong(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultU64(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultU64) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteU64 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultU64.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultI64(
+    @JvmField internal var `returnValue`: Long = 0.toLong(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Long = 0.toLong(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultI64(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultI64) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteI64 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultI64.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultF32(
+    @JvmField internal var `returnValue`: Float = 0.0f,
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Float = 0.0f,
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultF32(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultF32) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteF32 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultF32.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultF64(
+    @JvmField internal var `returnValue`: Double = 0.0,
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: Double = 0.0,
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultF64(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultF64) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteF64 : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultF64.UniffiByValue,)
+}
+@Structure.FieldOrder("returnValue", "callStatus")
+internal open class UniffiForeignFutureResultRustBuffer(
+    @JvmField internal var `returnValue`: RustBuffer.ByValue = RustBuffer.ByValue(),
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `returnValue`: RustBuffer.ByValue = RustBuffer.ByValue(),
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultRustBuffer(`returnValue`,`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultRustBuffer) {
+        `returnValue` = other.`returnValue`
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteRustBuffer : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultRustBuffer.UniffiByValue,)
+}
+@Structure.FieldOrder("callStatus")
+internal open class UniffiForeignFutureResultVoid(
+    @JvmField internal var `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+) : Structure() {
+    class UniffiByValue(
+        `callStatus`: UniffiRustCallStatus.ByValue = UniffiRustCallStatus.ByValue(),
+    ): UniffiForeignFutureResultVoid(`callStatus`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiForeignFutureResultVoid) {
+        `callStatus` = other.`callStatus`
+    }
+
+}
+internal interface UniffiForeignFutureCompleteVoid : com.sun.jna.Callback {
+    fun callback(`callbackData`: Long,`result`: UniffiForeignFutureResultVoid.UniffiByValue,)
+}
+internal interface UniffiCallbackInterfaceEventCallbackMethod0 : com.sun.jna.Callback {
+    fun callback(`uniffiHandle`: Long,`eventJson`: RustBuffer.ByValue,`uniffiOutReturn`: Pointer,uniffiCallStatus: UniffiRustCallStatus,)
+}
+@Structure.FieldOrder("uniffiFree", "uniffiClone", "onEvent")
+internal open class UniffiVTableCallbackInterfaceEventCallback(
+    @JvmField internal var `uniffiFree`: UniffiCallbackInterfaceFree? = null,
+    @JvmField internal var `uniffiClone`: UniffiCallbackInterfaceClone? = null,
+    @JvmField internal var `onEvent`: UniffiCallbackInterfaceEventCallbackMethod0? = null,
+) : Structure() {
+    class UniffiByValue(
+        `uniffiFree`: UniffiCallbackInterfaceFree? = null,
+        `uniffiClone`: UniffiCallbackInterfaceClone? = null,
+        `onEvent`: UniffiCallbackInterfaceEventCallbackMethod0? = null,
+    ): UniffiVTableCallbackInterfaceEventCallback(`uniffiFree`,`uniffiClone`,`onEvent`,), Structure.ByValue
+
+   internal fun uniffiSetValue(other: UniffiVTableCallbackInterfaceEventCallback) {
+        `uniffiFree` = other.`uniffiFree`
+        `uniffiClone` = other.`uniffiClone`
+        `onEvent` = other.`onEvent`
+    }
+
+}
+
+// A JNA Library to expose the extern-C FFI definitions.
+// This is an implementation detail which will be called internally by the public API.
+
+// For large crates we prevent `MethodTooLargeException` (see #2340)
+// N.B. the name of the extension is very misleading, since it is
+// rather `InterfaceTooLargeException`, caused by too many methods
+// in the interface for large crates.
+//
+// By splitting the otherwise huge interface into two parts
+// * UniffiLib (this)
+// * IntegrityCheckingUniffiLib
+// And all checksum methods are put into `IntegrityCheckingUniffiLib`
+// we allow for ~2x as many methods in the UniffiLib interface.
+//
+// Note: above all written when we used JNA's `loadIndirect` etc.
+// We now use JNA's "direct mapping" - unclear if same considerations apply exactly.
+internal object IntegrityCheckingUniffiLib {
+    init {
+        Native.register(IntegrityCheckingUniffiLib::class.java, findLibraryName(componentName = "offline_protocol"))
+        uniffiCheckContractApiVersion(this)
+        uniffiCheckApiChecksums(this)
+    }
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_internet_transport(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_wifi_direct_transport(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_fragment_received(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_next_fragment(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_peer_count(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_discovered(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_lost(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_return_fragment(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_status_changed(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cancel_file_transfer(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cleanup_expired_routes(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_emit_test_event(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_finalize_file(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_force_transport(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_active_transports(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_all_routes(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_battery_level(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_best_route(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dedup_stats(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_delivery_success_rate(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dors_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_file_progress(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_hops(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_latency(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_message_stats(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_pending_ack_count(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_relay_priority(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_retry_queue_size(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_routing_stats(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_state(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_topology(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_transport_metrics(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_has_route(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_get_next_message(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_message_received(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_return_message(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_status_changed(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_is_relay(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_learn_route(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_pause(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_poll_event(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process_file_chunk(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_receive_message(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_release_transport_lock(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_neighbor_routes(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_transport(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_resume(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_file(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_message(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_battery_level(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_event_callback(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_relay_priority(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_should_escalate_to_wifi(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_start(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_stop(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_ack_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dedup_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dors_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_retry_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_routing_config(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_transport_metrics(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_get_next_message(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_message_received(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_connected(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_disconnected(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_status_changed(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_constructor_offlineprotocol_new(
+    ): Short
+    external fun uniffi_offline_protocol_uniffi_checksum_method_eventcallback_on_event(
+    ): Short
+    external fun ffi_offline_protocol_uniffi_uniffi_contract_version(
+    ): Int
+    
+        
+}
+
+internal object UniffiLib {
+    
+    // The Cleaner for the whole library
+    internal val CLEANER: UniffiCleaner by lazy {
+        UniffiCleaner.create()
+    }
+    
+
+    init {
+        Native.register(UniffiLib::class.java, findLibraryName(componentName = "offline_protocol"))
+        uniffiCallbackInterfaceEventCallback.register(this)
+        
+    }
+    external fun uniffi_offline_protocol_uniffi_fn_clone_offlineprotocol(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun uniffi_offline_protocol_uniffi_fn_free_offlineprotocol(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_constructor_offlineprotocol_new(`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_internet_transport(`ptr`: Long,`serverUrl`: RustBuffer.ByValue,`port`: Short,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_wifi_direct_transport(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_fragment_received(`ptr`: Long,`senderId`: RustBuffer.ByValue,`fragment`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_next_fragment(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_peer_count(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Int
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_discovered(`ptr`: Long,`peerId`: RustBuffer.ByValue,`rssi`: Short,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_lost(`ptr`: Long,`peerId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_return_fragment(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_status_changed(`ptr`: Long,`isAvailable`: Byte,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cancel_file_transfer(`ptr`: Long,`fileId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cleanup_expired_routes(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_emit_test_event(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_finalize_file(`ptr`: Long,`fileId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_force_transport(`ptr`: Long,`transportType`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_active_transports(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_all_routes(`ptr`: Long,`destination`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_battery_level(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_best_route(`ptr`: Long,`destination`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dedup_stats(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_delivery_success_rate(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Float
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dors_config(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_file_progress(`ptr`: Long,`fileId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_hops(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_latency(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_message_stats(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_pending_ack_count(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_relay_priority(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_retry_queue_size(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_routing_stats(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_state(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_topology(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_transport_metrics(`ptr`: Long,`transportType`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_has_route(`ptr`: Long,`destination`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_get_next_message(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_message_received(`ptr`: Long,`senderId`: RustBuffer.ByValue,`data`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_return_message(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_status_changed(`ptr`: Long,`isConnected`: Byte,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_is_relay(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_learn_route(`ptr`: Long,`destination`: RustBuffer.ByValue,`nextHop`: RustBuffer.ByValue,`hopCount`: Byte,`quality`: Float,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_pause(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_poll_event(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process_file_chunk(`ptr`: Long,`fileId`: RustBuffer.ByValue,`chunkIndex`: Int,`data`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_receive_message(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_release_transport_lock(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_neighbor_routes(`ptr`: Long,`neighborId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_transport(`ptr`: Long,`transportType`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_resume(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_file(`ptr`: Long,`recipient`: RustBuffer.ByValue,`filePath`: RustBuffer.ByValue,`fileName`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_message(`ptr`: Long,`recipient`: RustBuffer.ByValue,`content`: RustBuffer.ByValue,`priority`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_battery_level(`ptr`: Long,`level`: Byte,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_event_callback(`ptr`: Long,`callback`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_relay_priority(`ptr`: Long,`priority`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_should_escalate_to_wifi(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_start(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_stop(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_ack_config(`ptr`: Long,`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dedup_config(`ptr`: Long,`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dors_config(`ptr`: Long,`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_retry_config(`ptr`: Long,`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_routing_config(`ptr`: Long,`config`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_transport_metrics(`ptr`: Long,`transportType`: RustBuffer.ByValue,`metrics`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_get_next_message(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_message_received(`ptr`: Long,`senderId`: RustBuffer.ByValue,`data`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_connected(`ptr`: Long,`peerId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_disconnected(`ptr`: Long,`peerId`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_status_changed(`ptr`: Long,`isConnected`: Byte,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun uniffi_offline_protocol_uniffi_fn_init_callback_vtable_eventcallback(`vtable`: UniffiVTableCallbackInterfaceEventCallback,
+): Unit
+external fun ffi_offline_protocol_uniffi_rustbuffer_alloc(`size`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun ffi_offline_protocol_uniffi_rustbuffer_from_bytes(`bytes`: ForeignBytes.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun ffi_offline_protocol_uniffi_rustbuffer_free(`buf`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+external fun ffi_offline_protocol_uniffi_rustbuffer_reserve(`buf`: RustBuffer.ByValue,`additional`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun ffi_offline_protocol_uniffi_rust_future_poll_u8(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_u8(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_u8(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_u8(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun ffi_offline_protocol_uniffi_rust_future_poll_i8(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_i8(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_i8(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_i8(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Byte
+external fun ffi_offline_protocol_uniffi_rust_future_poll_u16(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_u16(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_u16(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_u16(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Short
+external fun ffi_offline_protocol_uniffi_rust_future_poll_i16(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_i16(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_i16(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_i16(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Short
+external fun ffi_offline_protocol_uniffi_rust_future_poll_u32(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_u32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_u32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_u32(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Int
+external fun ffi_offline_protocol_uniffi_rust_future_poll_i32(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_i32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_i32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_i32(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Int
+external fun ffi_offline_protocol_uniffi_rust_future_poll_u64(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_u64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_u64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_u64(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun ffi_offline_protocol_uniffi_rust_future_poll_i64(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_i64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_i64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_i64(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Long
+external fun ffi_offline_protocol_uniffi_rust_future_poll_f32(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_f32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_f32(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_f32(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Float
+external fun ffi_offline_protocol_uniffi_rust_future_poll_f64(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_f64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_f64(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_f64(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Double
+external fun ffi_offline_protocol_uniffi_rust_future_poll_rust_buffer(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_rust_buffer(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_rust_buffer(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_rust_buffer(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): RustBuffer.ByValue
+external fun ffi_offline_protocol_uniffi_rust_future_poll_void(`handle`: Long,`callback`: UniffiRustFutureContinuationCallback,`callbackData`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_cancel_void(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_free_void(`handle`: Long,
+): Unit
+external fun ffi_offline_protocol_uniffi_rust_future_complete_void(`handle`: Long,uniffi_out_err: UniffiRustCallStatus, 
+): Unit
+
+    
+}
+
+private fun uniffiCheckContractApiVersion(lib: IntegrityCheckingUniffiLib) {
+    // Get the bindings contract version from our ComponentInterface
+    val bindings_contract_version = 30
+    // Get the scaffolding contract version by calling the into the dylib
+    val scaffolding_contract_version = lib.ffi_offline_protocol_uniffi_uniffi_contract_version()
+    if (bindings_contract_version != scaffolding_contract_version) {
+        throw RuntimeException("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+    }
+}
+@Suppress("UNUSED_PARAMETER")
+private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) {
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_internet_transport() != 42106.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_add_wifi_direct_transport() != 19197.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_fragment_received() != 44733.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_next_fragment() != 27429.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_get_peer_count() != 32781.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_discovered() != 53124.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_peer_lost() != 38687.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_return_fragment() != 4155.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_ble_status_changed() != 19618.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cancel_file_transfer() != 6632.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_cleanup_expired_routes() != 32382.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_emit_test_event() != 6796.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_finalize_file() != 55328.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_force_transport() != 28940.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_active_transports() != 5327.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_all_routes() != 27292.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_battery_level() != 12938.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_best_route() != 31041.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dedup_stats() != 43759.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_delivery_success_rate() != 62412.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_dors_config() != 28708.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_file_progress() != 37575.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_hops() != 22077.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_median_latency() != 9158.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_message_stats() != 30825.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_pending_ack_count() != 9023.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_relay_priority() != 38001.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_retry_queue_size() != 53188.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_routing_stats() != 51722.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_state() != 51778.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_topology() != 3250.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_get_transport_metrics() != 62682.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_has_route() != 44869.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_get_next_message() != 48075.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_message_received() != 62143.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_return_message() != 33628.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_internet_status_changed() != 25243.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_is_relay() != 34892.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_learn_route() != 38824.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_pause() != 51362.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_poll_event() != 28496.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process() != 16160.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_process_file_chunk() != 54114.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_receive_message() != 33217.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_release_transport_lock() != 4494.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_neighbor_routes() != 19049.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_remove_transport() != 16891.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_resume() != 39596.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_file() != 33006.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_send_message() != 36955.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_battery_level() != 65320.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_event_callback() != 14659.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_set_relay_priority() != 33715.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_should_escalate_to_wifi() != 40161.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_start() != 10699.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_stop() != 37179.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_ack_config() != 58995.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dedup_config() != 4301.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_dors_config() != 2649.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_retry_config() != 19988.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_routing_config() != 61324.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_update_transport_metrics() != 51165.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_get_next_message() != 1936.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_message_received() != 62211.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_connected() != 3197.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_peer_disconnected() != 17734.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_offlineprotocol_wifi_direct_status_changed() != 35006.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_constructor_offlineprotocol_new() != 30125.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_offline_protocol_uniffi_checksum_method_eventcallback_on_event() != 4769.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+}
+
+/**
+ * @suppress
+ */
+public fun uniffiEnsureInitialized() {
+    IntegrityCheckingUniffiLib
+    // UniffiLib() initialized as objects are used, but we still need to explicitly
+    // reference it so initialization across crates works as expected.
+    UniffiLib
+}
+
+// Async support
+
+// Public interface members begin here.
+
+
+// Interface implemented by anything that can contain an object reference.
+//
+// Such types expose a `destroy()` method that must be called to cleanly
+// dispose of the contained objects. Failure to call this method may result
+// in memory leaks.
+//
+// The easiest way to ensure this method is called is to use the `.use`
+// helper method to execute a block and destroy the object at the end.
+interface Disposable {
+    fun destroy()
+    companion object {
+        fun destroy(vararg args: Any?) {
+            for (arg in args) {
+                when (arg) {
+                    is Disposable -> arg.destroy()
+                    is ArrayList<*> -> {
+                        for (idx in arg.indices) {
+                            val element = arg[idx]
+                            if (element is Disposable) {
+                                element.destroy()
+                            }
+                        }
+                    }
+                    is Map<*, *> -> {
+                        for (element in arg.values) {
+                            if (element is Disposable) {
+                                element.destroy()
+                            }
+                        }
+                    }
+                    is Iterable<*> -> {
+                        for (element in arg) {
+                            if (element is Disposable) {
+                                element.destroy()
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @suppress
+ */
+inline fun <T : Disposable?, R> T.use(block: (T) -> R) =
+    try {
+        block(this)
+    } finally {
+        try {
+            // N.B. our implementation is on the nullable type `Disposable?`.
+            this?.destroy()
+        } catch (e: Throwable) {
+            // swallow
+        }
+    }
+
+/** 
+ * Placeholder object used to signal that we're constructing an interface with a FFI handle.
+ *
+ * This is the first argument for interface constructors that input a raw handle. It exists is that
+ * so we can avoid signature conflicts when an interface has a regular constructor than inputs a
+ * Long.
+ *
+ * @suppress
+ * */
+object UniffiWithHandle
+
+/** 
+ * Used to instantiate an interface without an actual pointer, for fakes in tests, mostly.
+ *
+ * @suppress
+ * */
+object NoHandle// 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.
+internal const val IDX_CALLBACK_FREE = 0
+// Callback return codes
+internal const val UNIFFI_CALLBACK_SUCCESS = 0
+internal const val UNIFFI_CALLBACK_ERROR = 1
+internal const val UNIFFI_CALLBACK_UNEXPECTED_ERROR = 2
+
+/**
+ * @suppress
+ */
+public abstract class FfiConverterCallbackInterface<CallbackInterface: Any>: FfiConverter<CallbackInterface, Long> {
+    internal val handleMap = UniffiHandleMap<CallbackInterface>()
+
+    internal fun drop(handle: Long) {
+        handleMap.remove(handle)
+    }
+
+    override fun lift(value: Long): CallbackInterface {
+        return handleMap.get(value)
+    }
+
+    override fun read(buf: ByteBuffer) = lift(buf.getLong())
+
+    override fun lower(value: CallbackInterface) = handleMap.insert(value)
+
+    override fun allocationSize(value: CallbackInterface) = 8UL
+
+    override fun write(value: CallbackInterface, buf: ByteBuffer) {
+        buf.putLong(lower(value))
+    }
+}
+/**
+ * The cleaner interface for Object finalization code to run.
+ * This is the entry point to any implementation that we're using.
+ *
+ * The cleaner registers objects and returns cleanables, so now we are
+ * defining a `UniffiCleaner` with a `UniffiClenaer.Cleanable` to abstract the
+ * different implmentations available at compile time.
+ *
+ * @suppress
+ */
+interface UniffiCleaner {
+    interface Cleanable {
+        fun clean()
+    }
+
+    fun register(value: Any, cleanUpTask: Runnable): UniffiCleaner.Cleanable
+
+    companion object
+}
+
+// The fallback Jna cleaner, which is available for both Android, and the JVM.
+private class UniffiJnaCleaner : UniffiCleaner {
+    private val cleaner = com.sun.jna.internal.Cleaner.getCleaner()
+
+    override fun register(value: Any, cleanUpTask: Runnable): UniffiCleaner.Cleanable =
+        UniffiJnaCleanable(cleaner.register(value, cleanUpTask))
+}
+
+private class UniffiJnaCleanable(
+    private val cleanable: com.sun.jna.internal.Cleaner.Cleanable,
+) : UniffiCleaner.Cleanable {
+    override fun clean() = cleanable.clean()
+}
+
+
+// We decide at uniffi binding generation time whether we were
+// using Android or not.
+// There are further runtime checks to chose the correct implementation
+// of the cleaner.
+private fun UniffiCleaner.Companion.create(): UniffiCleaner =
+    try {
+        // For safety's sake: if the library hasn't been run in android_cleaner = true
+        // mode, but is being run on Android, then we still need to think about
+        // Android API versions.
+        // So we check if java.lang.ref.Cleaner is there, and use that…
+        java.lang.Class.forName("java.lang.ref.Cleaner")
+        JavaLangRefCleaner()
+    } catch (e: ClassNotFoundException) {
+        // … otherwise, fallback to the JNA cleaner.
+        UniffiJnaCleaner()
+    }
+
+private class JavaLangRefCleaner : UniffiCleaner {
+    val cleaner = java.lang.ref.Cleaner.create()
+
+    override fun register(value: Any, cleanUpTask: Runnable): UniffiCleaner.Cleanable =
+        JavaLangRefCleanable(cleaner.register(value, cleanUpTask))
+}
+
+private class JavaLangRefCleanable(
+    val cleanable: java.lang.ref.Cleaner.Cleanable
+) : UniffiCleaner.Cleanable {
+    override fun clean() = cleanable.clean()
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterUByte: FfiConverter<UByte, Byte> {
+    override fun lift(value: Byte): UByte {
+        return value.toUByte()
+    }
+
+    override fun read(buf: ByteBuffer): UByte {
+        return lift(buf.get())
+    }
+
+    override fun lower(value: UByte): Byte {
+        return value.toByte()
+    }
+
+    override fun allocationSize(value: UByte) = 1UL
+
+    override fun write(value: UByte, buf: ByteBuffer) {
+        buf.put(value.toByte())
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterUShort: FfiConverter<UShort, Short> {
+    override fun lift(value: Short): UShort {
+        return value.toUShort()
+    }
+
+    override fun read(buf: ByteBuffer): UShort {
+        return lift(buf.getShort())
+    }
+
+    override fun lower(value: UShort): Short {
+        return value.toShort()
+    }
+
+    override fun allocationSize(value: UShort) = 2UL
+
+    override fun write(value: UShort, buf: ByteBuffer) {
+        buf.putShort(value.toShort())
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterShort: FfiConverter<Short, Short> {
+    override fun lift(value: Short): Short {
+        return value
+    }
+
+    override fun read(buf: ByteBuffer): Short {
+        return buf.getShort()
+    }
+
+    override fun lower(value: Short): Short {
+        return value
+    }
+
+    override fun allocationSize(value: Short) = 2UL
+
+    override fun write(value: Short, buf: ByteBuffer) {
+        buf.putShort(value)
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterUInt: FfiConverter<UInt, Int> {
+    override fun lift(value: Int): UInt {
+        return value.toUInt()
+    }
+
+    override fun read(buf: ByteBuffer): UInt {
+        return lift(buf.getInt())
+    }
+
+    override fun lower(value: UInt): Int {
+        return value.toInt()
+    }
+
+    override fun allocationSize(value: UInt) = 4UL
+
+    override fun write(value: UInt, buf: ByteBuffer) {
+        buf.putInt(value.toInt())
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterULong: FfiConverter<ULong, Long> {
+    override fun lift(value: Long): ULong {
+        return value.toULong()
+    }
+
+    override fun read(buf: ByteBuffer): ULong {
+        return lift(buf.getLong())
+    }
+
+    override fun lower(value: ULong): Long {
+        return value.toLong()
+    }
+
+    override fun allocationSize(value: ULong) = 8UL
+
+    override fun write(value: ULong, buf: ByteBuffer) {
+        buf.putLong(value.toLong())
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterFloat: FfiConverter<Float, Float> {
+    override fun lift(value: Float): Float {
+        return value
+    }
+
+    override fun read(buf: ByteBuffer): Float {
+        return buf.getFloat()
+    }
+
+    override fun lower(value: Float): Float {
+        return value
+    }
+
+    override fun allocationSize(value: Float) = 4UL
+
+    override fun write(value: Float, buf: ByteBuffer) {
+        buf.putFloat(value)
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterBoolean: FfiConverter<Boolean, Byte> {
+    override fun lift(value: Byte): Boolean {
+        return value.toInt() != 0
+    }
+
+    override fun read(buf: ByteBuffer): Boolean {
+        return lift(buf.get())
+    }
+
+    override fun lower(value: Boolean): Byte {
+        return if (value) 1.toByte() else 0.toByte()
+    }
+
+    override fun allocationSize(value: Boolean) = 1UL
+
+    override fun write(value: Boolean, buf: ByteBuffer) {
+        buf.put(lower(value))
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterString: FfiConverter<String, RustBuffer.ByValue> {
+    // Note: we don't inherit from FfiConverterRustBuffer, because we use a
+    // special encoding when lowering/lifting.  We can use `RustBuffer.len` to
+    // store our length and avoid writing it out to the buffer.
+    override fun lift(value: RustBuffer.ByValue): String {
+        try {
+            val byteArr = ByteArray(value.len.toInt())
+            value.asByteBuffer()!!.get(byteArr)
+            return byteArr.toString(Charsets.UTF_8)
+        } finally {
+            RustBuffer.free(value)
+        }
+    }
+
+    override fun read(buf: ByteBuffer): String {
+        val len = buf.getInt()
+        val byteArr = ByteArray(len)
+        buf.get(byteArr)
+        return byteArr.toString(Charsets.UTF_8)
+    }
+
+    fun toUtf8(value: String): ByteBuffer {
+        // Make sure we don't have invalid UTF-16, check for lone surrogates.
+        return Charsets.UTF_8.newEncoder().run {
+            onMalformedInput(CodingErrorAction.REPORT)
+            encode(CharBuffer.wrap(value))
+        }
+    }
+
+    override fun lower(value: String): RustBuffer.ByValue {
+        val byteBuf = toUtf8(value)
+        // Ideally we'd pass these bytes to `ffi_bytebuffer_from_bytes`, but doing so would require us
+        // to copy them into a JNA `Memory`. So we might as well directly copy them into a `RustBuffer`.
+        val rbuf = RustBuffer.alloc(byteBuf.limit().toULong())
+        rbuf.asByteBuffer()!!.put(byteBuf)
+        return rbuf
+    }
+
+    // We aren't sure exactly how many bytes our string will be once it's UTF-8
+    // encoded.  Allocate 3 bytes per UTF-16 code unit which will always be
+    // enough.
+    override fun allocationSize(value: String): ULong {
+        val sizeForLength = 4UL
+        val sizeForString = value.length.toULong() * 3UL
+        return sizeForLength + sizeForString
+    }
+
+    override fun write(value: String, buf: ByteBuffer) {
+        val byteBuf = toUtf8(value)
+        buf.putInt(byteBuf.limit())
+        buf.put(byteBuf)
+    }
+}
+
+
+// This template implements a class for working with a Rust struct via a handle
+// to the live Rust struct on the other side of the FFI.
+//
+// There's some subtlety here, because we have to be careful not to operate on a Rust
+// struct after it has been dropped, and because we must expose a public API for freeing
+// theq Kotlin wrapper object in lieu of reliable finalizers. The core requirements are:
+//
+//   * Each instance holds an opaque handle to the underlying Rust struct.
+//     Method calls need to read this handle from the object's state and pass it in to
+//     the Rust FFI.
+//
+//   * When an instance is no longer needed, its handle should be passed to a
+//     special destructor function provided by the Rust FFI, which will drop the
+//     underlying Rust struct.
+//
+//   * Given an instance, calling code is expected to call the special
+//     `destroy` method in order to free it after use, either by calling it explicitly
+//     or by using a higher-level helper like the `use` method. Failing to do so risks
+//     leaking the underlying Rust struct.
+//
+//   * We can't assume that calling code will do the right thing, and must be prepared
+//     to handle Kotlin method calls executing concurrently with or even after a call to
+//     `destroy`, and to handle multiple (possibly concurrent!) calls to `destroy`.
+//
+//   * We must never allow Rust code to operate on the underlying Rust struct after
+//     the destructor has been called, and must never call the destructor more than once.
+//     Doing so may trigger memory unsafety.
+//
+//   * To mitigate many of the risks of leaking memory and use-after-free unsafety, a `Cleaner`
+//     is implemented to call the destructor when the Kotlin object becomes unreachable.
+//     This is done in a background thread. This is not a panacea, and client code should be aware that
+//      1. the thread may starve if some there are objects that have poorly performing
+//     `drop` methods or do significant work in their `drop` methods.
+//      2. the thread is shared across the whole library. This can be tuned by using `android_cleaner = true`,
+//         or `android = true` in the [`kotlin` section of the `uniffi.toml` file](https://mozilla.github.io/uniffi-rs/kotlin/configuration.html).
+//
+// If we try to implement this with mutual exclusion on access to the handle, there is the
+// possibility of a race between a method call and a concurrent call to `destroy`:
+//
+//    * Thread A starts a method call, reads the value of the handle, but is interrupted
+//      before it can pass the handle over the FFI to Rust.
+//    * Thread B calls `destroy` and frees the underlying Rust struct.
+//    * Thread A resumes, passing the already-read handle value to Rust and triggering
+//      a use-after-free.
+//
+// One possible solution would be to use a `ReadWriteLock`, with each method call taking
+// a read lock (and thus allowed to run concurrently) and the special `destroy` method
+// taking a write lock (and thus blocking on live method calls). However, we aim not to
+// generate methods with any hidden blocking semantics, and a `destroy` method that might
+// block if called incorrectly seems to meet that bar.
+//
+// So, we achieve our goals by giving each instance an associated `AtomicLong` counter to track
+// the number of in-flight method calls, and an `AtomicBoolean` flag to indicate whether `destroy`
+// has been called. These are updated according to the following rules:
+//
+//    * The initial value of the counter is 1, indicating a live object with no in-flight calls.
+//      The initial value for the flag is false.
+//
+//    * At the start of each method call, we atomically check the counter.
+//      If it is 0 then the underlying Rust struct has already been destroyed and the call is aborted.
+//      If it is nonzero them we atomically increment it by 1 and proceed with the method call.
+//
+//    * At the end of each method call, we atomically decrement and check the counter.
+//      If it has reached zero then we destroy the underlying Rust struct.
+//
+//    * When `destroy` is called, we atomically flip the flag from false to true.
+//      If the flag was already true we silently fail.
+//      Otherwise we atomically decrement and check the counter.
+//      If it has reached zero then we destroy the underlying Rust struct.
+//
+// Astute readers may observe that this all sounds very similar to the way that Rust's `Arc<T>` works,
+// and indeed it is, with the addition of a flag to guard against multiple calls to `destroy`.
+//
+// The overall effect is that the underlying Rust struct is destroyed only when `destroy` has been
+// called *and* all in-flight method calls have completed, avoiding violating any of the expectations
+// of the underlying Rust code.
+//
+// This makes a cleaner a better alternative to _not_ calling `destroy()` as
+// and when the object is finished with, but the abstraction is not perfect: if the Rust object's `drop`
+// method is slow, and/or there are many objects to cleanup, and it's on a low end Android device, then the cleaner
+// thread may be starved, and the app will leak memory.
+//
+// In this case, `destroy`ing manually may be a better solution.
+//
+// The cleaner can live side by side with the manual calling of `destroy`. In the order of responsiveness, uniffi objects
+// with Rust peers are reclaimed:
+//
+// 1. By calling the `destroy` method of the object, which calls `rustObject.free()`. If that doesn't happen:
+// 2. When the object becomes unreachable, AND the Cleaner thread gets to call `rustObject.free()`. If the thread is starved then:
+// 3. The memory is reclaimed when the process terminates.
+//
+// [1] https://stackoverflow.com/questions/24376768/can-java-finalize-an-object-when-it-is-still-in-scope/24380219
+//
+
+
+//
+public interface OfflineProtocolInterface {
+    
+    fun `addInternetTransport`(`serverUrl`: kotlin.String, `port`: kotlin.UShort)
+    
+    fun `addWifiDirectTransport`()
+    
+    fun `bleFragmentReceived`(`senderId`: kotlin.String, `fragment`: List<kotlin.UByte>)
+    
+    fun `bleGetNextFragment`(): BleFragment?
+    
+    fun `bleGetPeerCount`(): kotlin.UInt
+    
+    fun `blePeerDiscovered`(`peerId`: kotlin.String, `rssi`: kotlin.Short)
+    
+    fun `blePeerLost`(`peerId`: kotlin.String)
+    
+    fun `bleReturnFragment`()
+    
+    fun `bleStatusChanged`(`isAvailable`: kotlin.Boolean)
+    
+    fun `cancelFileTransfer`(`fileId`: kotlin.String)
+    
+    fun `cleanupExpiredRoutes`()
+    
+    fun `emitTestEvent`()
+    
+    fun `finalizeFile`(`fileId`: kotlin.String)
+    
+    fun `forceTransport`(`transportType`: TransportType)
+    
+    fun `getActiveTransports`(): List<kotlin.String>
+    
+    fun `getAllRoutes`(`destination`: kotlin.String): List<RouteEntry>
+    
+    fun `getBatteryLevel`(): kotlin.UByte?
+    
+    fun `getBestRoute`(`destination`: kotlin.String): RouteEntry?
+    
+    fun `getDedupStats`(): DedupStats
+    
+    fun `getDeliverySuccessRate`(): kotlin.Float
+    
+    fun `getDorsConfig`(): DorsConfig
+    
+    fun `getFileProgress`(`fileId`: kotlin.String): FileProgress?
+    
+    fun `getMedianHops`(): kotlin.UByte
+    
+    fun `getMedianLatency`(): kotlin.ULong
+    
+    fun `getMessageStats`(): List<MessageStats>
+    
+    fun `getPendingAckCount`(): kotlin.ULong
+    
+    fun `getRelayPriority`(): RelayPriority
+    
+    fun `getRetryQueueSize`(): kotlin.ULong
+    
+    fun `getRoutingStats`(): RoutingStats
+    
+    fun `getState`(): ProtocolState
+    
+    fun `getTopology`(): NetworkTopology
+    
+    fun `getTransportMetrics`(`transportType`: TransportType): TransportMetrics?
+    
+    fun `hasRoute`(`destination`: kotlin.String): kotlin.Boolean
+    
+    fun `internetGetNextMessage`(): InternetMessage?
+    
+    fun `internetMessageReceived`(`senderId`: kotlin.String, `data`: List<kotlin.UByte>)
+    
+    fun `internetReturnMessage`()
+    
+    fun `internetStatusChanged`(`isConnected`: kotlin.Boolean)
+    
+    fun `isRelay`(): kotlin.Boolean
+    
+    fun `learnRoute`(`destination`: kotlin.String, `nextHop`: kotlin.String, `hopCount`: kotlin.UByte, `quality`: kotlin.Float)
+    
+    fun `pause`()
+    
+    fun `pollEvent`(): kotlin.String?
+    
+    fun `process`()
+    
+    fun `processFileChunk`(`fileId`: kotlin.String, `chunkIndex`: kotlin.UInt, `data`: List<kotlin.UByte>)
+    
+    fun `receiveMessage`(): kotlin.String?
+    
+    fun `releaseTransportLock`()
+    
+    fun `removeNeighborRoutes`(`neighborId`: kotlin.String)
+    
+    fun `removeTransport`(`transportType`: TransportType)
+    
+    fun `resume`()
+    
+    fun `sendFile`(`recipient`: kotlin.String, `filePath`: kotlin.String, `fileName`: kotlin.String): kotlin.String
+    
+    fun `sendMessage`(`recipient`: kotlin.String, `content`: kotlin.String, `priority`: MessagePriority): kotlin.String
+    
+    fun `setBatteryLevel`(`level`: kotlin.UByte)
+    
+    fun `setEventCallback`(`callback`: EventCallback)
+    
+    fun `setRelayPriority`(`priority`: RelayPriority)
+    
+    fun `shouldEscalateToWifi`(): kotlin.Boolean
+    
+    fun `start`()
+    
+    fun `stop`()
+    
+    fun `updateAckConfig`(`config`: AckConfig)
+    
+    fun `updateDedupConfig`(`config`: DedupConfig)
+    
+    fun `updateDorsConfig`(`config`: DorsConfig)
+    
+    fun `updateRetryConfig`(`config`: RetryConfig)
+    
+    fun `updateRoutingConfig`(`config`: GradientRoutingConfig)
+    
+    fun `updateTransportMetrics`(`transportType`: TransportType, `metrics`: TransportMetrics)
+    
+    fun `wifiDirectGetNextMessage`(): WifiDirectMessage?
+    
+    fun `wifiDirectMessageReceived`(`senderId`: kotlin.String, `data`: List<kotlin.UByte>)
+    
+    fun `wifiDirectPeerConnected`(`peerId`: kotlin.String)
+    
+    fun `wifiDirectPeerDisconnected`(`peerId`: kotlin.String)
+    
+    fun `wifiDirectStatusChanged`(`isConnected`: kotlin.Boolean)
+    
+    companion object
+}
+
+open class OfflineProtocol: Disposable, AutoCloseable, OfflineProtocolInterface
+{
+
+    @Suppress("UNUSED_PARAMETER")
+    /**
+     * @suppress
+     */
+    constructor(withHandle: UniffiWithHandle, handle: Long) {
+        this.handle = handle
+        this.cleanable = UniffiLib.CLEANER.register(this, UniffiCleanAction(handle))
+    }
+
+    /**
+     * @suppress
+     *
+     * This constructor can be used to instantiate a fake object. Only used for tests. Any
+     * attempt to actually use an object constructed this way will fail as there is no
+     * connected Rust object.
+     */
+    @Suppress("UNUSED_PARAMETER")
+    constructor(noHandle: NoHandle) {
+        this.handle = 0
+        this.cleanable = UniffiLib.CLEANER.register(this, UniffiCleanAction(handle))
+    }
+    constructor(`config`: ProtocolConfig) :
+        this(UniffiWithHandle, 
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_constructor_offlineprotocol_new(
+    
+        FfiConverterTypeProtocolConfig.lower(`config`),_status)
+}
+    )
+
+    protected val handle: Long
+    protected val cleanable: UniffiCleaner.Cleanable
+
+    private val wasDestroyed = AtomicBoolean(false)
+    private val callCounter = AtomicLong(1)
+
+    override fun destroy() {
+        // Only allow a single call to this method.
+        // TODO: maybe we should log a warning if called more than once?
+        if (this.wasDestroyed.compareAndSet(false, true)) {
+            // This decrement always matches the initial count of 1 given at creation time.
+            if (this.callCounter.decrementAndGet() == 0L) {
+                cleanable.clean()
+            }
+        }
+    }
+
+    @Synchronized
+    override fun close() {
+        this.destroy()
+    }
+
+    internal inline fun <R> callWithHandle(block: (handle: Long) -> R): R {
+        // Check and increment the call counter, to keep the object alive.
+        // This needs a compare-and-set retry loop in case of concurrent updates.
+        do {
+            val c = this.callCounter.get()
+            if (c == 0L) {
+                throw IllegalStateException("${this.javaClass.simpleName} object has already been destroyed")
+            }
+            if (c == Long.MAX_VALUE) {
+                throw IllegalStateException("${this.javaClass.simpleName} call counter would overflow")
+            }
+        } while (! this.callCounter.compareAndSet(c, c + 1L))
+        // Now we can safely do the method call without the handle being freed concurrently.
+        try {
+            return block(this.uniffiCloneHandle())
+        } finally {
+            // This decrement always matches the increment we performed above.
+            if (this.callCounter.decrementAndGet() == 0L) {
+                cleanable.clean()
+            }
+        }
+    }
+
+    // Use a static inner class instead of a closure so as not to accidentally
+    // capture `this` as part of the cleanable's action.
+    private class UniffiCleanAction(private val handle: Long) : Runnable {
+        override fun run() {
+            if (handle == 0.toLong()) {
+                // Fake object created with `NoHandle`, don't try to free.
+                return;
+            }
+            uniffiRustCall { status ->
+                UniffiLib.uniffi_offline_protocol_uniffi_fn_free_offlineprotocol(handle, status)
+            }
+        }
+    }
+
+    /**
+     * @suppress
+     */
+    fun uniffiCloneHandle(): Long {
+        if (handle == 0.toLong()) {
+            throw InternalException("uniffiCloneHandle() called on NoHandle object");
+        }
+        return uniffiRustCall() { status ->
+            UniffiLib.uniffi_offline_protocol_uniffi_fn_clone_offlineprotocol(handle, status)
+        }
+    }
+
+    
+    @Throws(ProtocolException::class)override fun `addInternetTransport`(`serverUrl`: kotlin.String, `port`: kotlin.UShort)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_internet_transport(
+        it,
+        FfiConverterString.lower(`serverUrl`),FfiConverterUShort.lower(`port`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `addWifiDirectTransport`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_add_wifi_direct_transport(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `bleFragmentReceived`(`senderId`: kotlin.String, `fragment`: List<kotlin.UByte>)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_fragment_received(
+        it,
+        FfiConverterString.lower(`senderId`),FfiConverterSequenceUByte.lower(`fragment`),_status)
+}
+    }
+    
+    
+
+    override fun `bleGetNextFragment`(): BleFragment? {
+            return FfiConverterOptionalTypeBleFragment.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_next_fragment(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `bleGetPeerCount`(): kotlin.UInt {
+            return FfiConverterUInt.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_get_peer_count(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `blePeerDiscovered`(`peerId`: kotlin.String, `rssi`: kotlin.Short)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_discovered(
+        it,
+        FfiConverterString.lower(`peerId`),FfiConverterShort.lower(`rssi`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `blePeerLost`(`peerId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_peer_lost(
+        it,
+        FfiConverterString.lower(`peerId`),_status)
+}
+    }
+    
+    
+
+    override fun `bleReturnFragment`()
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_return_fragment(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `bleStatusChanged`(`isAvailable`: kotlin.Boolean)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_ble_status_changed(
+        it,
+        FfiConverterBoolean.lower(`isAvailable`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `cancelFileTransfer`(`fileId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cancel_file_transfer(
+        it,
+        FfiConverterString.lower(`fileId`),_status)
+}
+    }
+    
+    
+
+    override fun `cleanupExpiredRoutes`()
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_cleanup_expired_routes(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    override fun `emitTestEvent`()
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_emit_test_event(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `finalizeFile`(`fileId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_finalize_file(
+        it,
+        FfiConverterString.lower(`fileId`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `forceTransport`(`transportType`: TransportType)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_force_transport(
+        it,
+        FfiConverterTypeTransportType.lower(`transportType`),_status)
+}
+    }
+    
+    
+
+    override fun `getActiveTransports`(): List<kotlin.String> {
+            return FfiConverterSequenceString.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_active_transports(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getAllRoutes`(`destination`: kotlin.String): List<RouteEntry> {
+            return FfiConverterSequenceTypeRouteEntry.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_all_routes(
+        it,
+        FfiConverterString.lower(`destination`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getBatteryLevel`(): kotlin.UByte? {
+            return FfiConverterOptionalUByte.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_battery_level(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getBestRoute`(`destination`: kotlin.String): RouteEntry? {
+            return FfiConverterOptionalTypeRouteEntry.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_best_route(
+        it,
+        FfiConverterString.lower(`destination`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getDedupStats`(): DedupStats {
+            return FfiConverterTypeDedupStats.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dedup_stats(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getDeliverySuccessRate`(): kotlin.Float {
+            return FfiConverterFloat.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_delivery_success_rate(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getDorsConfig`(): DorsConfig {
+            return FfiConverterTypeDorsConfig.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_dors_config(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getFileProgress`(`fileId`: kotlin.String): FileProgress? {
+            return FfiConverterOptionalTypeFileProgress.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_file_progress(
+        it,
+        FfiConverterString.lower(`fileId`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getMedianHops`(): kotlin.UByte {
+            return FfiConverterUByte.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_hops(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getMedianLatency`(): kotlin.ULong {
+            return FfiConverterULong.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_median_latency(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getMessageStats`(): List<MessageStats> {
+            return FfiConverterSequenceTypeMessageStats.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_message_stats(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getPendingAckCount`(): kotlin.ULong {
+            return FfiConverterULong.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_pending_ack_count(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getRelayPriority`(): RelayPriority {
+            return FfiConverterTypeRelayPriority.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_relay_priority(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getRetryQueueSize`(): kotlin.ULong {
+            return FfiConverterULong.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_retry_queue_size(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getRoutingStats`(): RoutingStats {
+            return FfiConverterTypeRoutingStats.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_routing_stats(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getState`(): ProtocolState {
+            return FfiConverterTypeProtocolState.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_state(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `getTopology`(): NetworkTopology {
+            return FfiConverterTypeNetworkTopology.lift(
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_topology(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `getTransportMetrics`(`transportType`: TransportType): TransportMetrics? {
+            return FfiConverterOptionalTypeTransportMetrics.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_get_transport_metrics(
+        it,
+        FfiConverterTypeTransportType.lower(`transportType`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `hasRoute`(`destination`: kotlin.String): kotlin.Boolean {
+            return FfiConverterBoolean.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_has_route(
+        it,
+        FfiConverterString.lower(`destination`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `internetGetNextMessage`(): InternetMessage? {
+            return FfiConverterOptionalTypeInternetMessage.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_get_next_message(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `internetMessageReceived`(`senderId`: kotlin.String, `data`: List<kotlin.UByte>)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_message_received(
+        it,
+        FfiConverterString.lower(`senderId`),FfiConverterSequenceUByte.lower(`data`),_status)
+}
+    }
+    
+    
+
+    override fun `internetReturnMessage`()
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_return_message(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `internetStatusChanged`(`isConnected`: kotlin.Boolean)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_internet_status_changed(
+        it,
+        FfiConverterBoolean.lower(`isConnected`),_status)
+}
+    }
+    
+    
+
+    override fun `isRelay`(): kotlin.Boolean {
+            return FfiConverterBoolean.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_is_relay(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `learnRoute`(`destination`: kotlin.String, `nextHop`: kotlin.String, `hopCount`: kotlin.UByte, `quality`: kotlin.Float)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_learn_route(
+        it,
+        FfiConverterString.lower(`destination`),FfiConverterString.lower(`nextHop`),FfiConverterUByte.lower(`hopCount`),FfiConverterFloat.lower(`quality`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `pause`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_pause(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    override fun `pollEvent`(): kotlin.String? {
+            return FfiConverterOptionalString.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_poll_event(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `process`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `processFileChunk`(`fileId`: kotlin.String, `chunkIndex`: kotlin.UInt, `data`: List<kotlin.UByte>)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_process_file_chunk(
+        it,
+        FfiConverterString.lower(`fileId`),FfiConverterUInt.lower(`chunkIndex`),FfiConverterSequenceUByte.lower(`data`),_status)
+}
+    }
+    
+    
+
+    override fun `receiveMessage`(): kotlin.String? {
+            return FfiConverterOptionalString.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_receive_message(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    override fun `releaseTransportLock`()
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_release_transport_lock(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    override fun `removeNeighborRoutes`(`neighborId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_neighbor_routes(
+        it,
+        FfiConverterString.lower(`neighborId`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `removeTransport`(`transportType`: TransportType)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_remove_transport(
+        it,
+        FfiConverterTypeTransportType.lower(`transportType`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `resume`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_resume(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `sendFile`(`recipient`: kotlin.String, `filePath`: kotlin.String, `fileName`: kotlin.String): kotlin.String {
+            return FfiConverterString.lift(
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_file(
+        it,
+        FfiConverterString.lower(`recipient`),FfiConverterString.lower(`filePath`),FfiConverterString.lower(`fileName`),_status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `sendMessage`(`recipient`: kotlin.String, `content`: kotlin.String, `priority`: MessagePriority): kotlin.String {
+            return FfiConverterString.lift(
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_send_message(
+        it,
+        FfiConverterString.lower(`recipient`),FfiConverterString.lower(`content`),FfiConverterTypeMessagePriority.lower(`priority`),_status)
+}
+    }
+    )
+    }
+    
+
+    override fun `setBatteryLevel`(`level`: kotlin.UByte)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_battery_level(
+        it,
+        FfiConverterUByte.lower(`level`),_status)
+}
+    }
+    
+    
+
+    override fun `setEventCallback`(`callback`: EventCallback)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_event_callback(
+        it,
+        FfiConverterTypeEventCallback.lower(`callback`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `setRelayPriority`(`priority`: RelayPriority)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_set_relay_priority(
+        it,
+        FfiConverterTypeRelayPriority.lower(`priority`),_status)
+}
+    }
+    
+    
+
+    override fun `shouldEscalateToWifi`(): kotlin.Boolean {
+            return FfiConverterBoolean.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_should_escalate_to_wifi(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `start`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_start(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `stop`()
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_stop(
+        it,
+        _status)
+}
+    }
+    
+    
+
+    override fun `updateAckConfig`(`config`: AckConfig)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_ack_config(
+        it,
+        FfiConverterTypeAckConfig.lower(`config`),_status)
+}
+    }
+    
+    
+
+    override fun `updateDedupConfig`(`config`: DedupConfig)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dedup_config(
+        it,
+        FfiConverterTypeDedupConfig.lower(`config`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `updateDorsConfig`(`config`: DorsConfig)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_dors_config(
+        it,
+        FfiConverterTypeDorsConfig.lower(`config`),_status)
+}
+    }
+    
+    
+
+    override fun `updateRetryConfig`(`config`: RetryConfig)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_retry_config(
+        it,
+        FfiConverterTypeRetryConfig.lower(`config`),_status)
+}
+    }
+    
+    
+
+    override fun `updateRoutingConfig`(`config`: GradientRoutingConfig)
+        = 
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_routing_config(
+        it,
+        FfiConverterTypeGradientRoutingConfig.lower(`config`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `updateTransportMetrics`(`transportType`: TransportType, `metrics`: TransportMetrics)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_update_transport_metrics(
+        it,
+        FfiConverterTypeTransportType.lower(`transportType`),FfiConverterTypeTransportMetrics.lower(`metrics`),_status)
+}
+    }
+    
+    
+
+    override fun `wifiDirectGetNextMessage`(): WifiDirectMessage? {
+            return FfiConverterOptionalTypeWifiDirectMessage.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_get_next_message(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
+    @Throws(ProtocolException::class)override fun `wifiDirectMessageReceived`(`senderId`: kotlin.String, `data`: List<kotlin.UByte>)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_message_received(
+        it,
+        FfiConverterString.lower(`senderId`),FfiConverterSequenceUByte.lower(`data`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `wifiDirectPeerConnected`(`peerId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_connected(
+        it,
+        FfiConverterString.lower(`peerId`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `wifiDirectPeerDisconnected`(`peerId`: kotlin.String)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_peer_disconnected(
+        it,
+        FfiConverterString.lower(`peerId`),_status)
+}
+    }
+    
+    
+
+    
+    @Throws(ProtocolException::class)override fun `wifiDirectStatusChanged`(`isConnected`: kotlin.Boolean)
+        = 
+    callWithHandle {
+    uniffiRustCallWithError(ProtocolException) { _status ->
+    UniffiLib.uniffi_offline_protocol_uniffi_fn_method_offlineprotocol_wifi_direct_status_changed(
+        it,
+        FfiConverterBoolean.lower(`isConnected`),_status)
+}
+    }
+    
+    
+
+    
+
+    
+
+
+    
+    
+    /**
+     * @suppress
+     */
+    companion object
+    
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeOfflineProtocol: FfiConverter<OfflineProtocol, Long> {
+    override fun lower(value: OfflineProtocol): Long {
+        return value.uniffiCloneHandle()
+    }
+
+    override fun lift(value: Long): OfflineProtocol {
+        return OfflineProtocol(UniffiWithHandle, value)
+    }
+
+    override fun read(buf: ByteBuffer): OfflineProtocol {
+        return lift(buf.getLong())
+    }
+
+    override fun allocationSize(value: OfflineProtocol) = 8UL
+
+    override fun write(value: OfflineProtocol, buf: ByteBuffer) {
+        buf.putLong(lower(value))
+    }
+}
+
+
+
+data class AckConfig (
+    var `defaultTimeoutMs`: kotlin.ULong
+    , 
+    var `maxPendingAcks`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeAckConfig: FfiConverterRustBuffer<AckConfig> {
+    override fun read(buf: ByteBuffer): AckConfig {
+        return AckConfig(
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: AckConfig) = (
+            FfiConverterULong.allocationSize(value.`defaultTimeoutMs`) +
+            FfiConverterULong.allocationSize(value.`maxPendingAcks`)
+    )
+
+    override fun write(value: AckConfig, buf: ByteBuffer) {
+            FfiConverterULong.write(value.`defaultTimeoutMs`, buf)
+            FfiConverterULong.write(value.`maxPendingAcks`, buf)
+    }
+}
+
+
+
+data class BleFragment (
+    var `recipientId`: kotlin.String
+    , 
+    var `data`: List<kotlin.UByte>
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeBleFragment: FfiConverterRustBuffer<BleFragment> {
+    override fun read(buf: ByteBuffer): BleFragment {
+        return BleFragment(
+            FfiConverterString.read(buf),
+            FfiConverterSequenceUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: BleFragment) = (
+            FfiConverterString.allocationSize(value.`recipientId`) +
+            FfiConverterSequenceUByte.allocationSize(value.`data`)
+    )
+
+    override fun write(value: BleFragment, buf: ByteBuffer) {
+            FfiConverterString.write(value.`recipientId`, buf)
+            FfiConverterSequenceUByte.write(value.`data`, buf)
+    }
+}
+
+
+
+data class DedupConfig (
+    var `maxTrackedMessages`: kotlin.ULong
+    , 
+    var `retentionTimeSecs`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeDedupConfig: FfiConverterRustBuffer<DedupConfig> {
+    override fun read(buf: ByteBuffer): DedupConfig {
+        return DedupConfig(
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: DedupConfig) = (
+            FfiConverterULong.allocationSize(value.`maxTrackedMessages`) +
+            FfiConverterULong.allocationSize(value.`retentionTimeSecs`)
+    )
+
+    override fun write(value: DedupConfig, buf: ByteBuffer) {
+            FfiConverterULong.write(value.`maxTrackedMessages`, buf)
+            FfiConverterULong.write(value.`retentionTimeSecs`, buf)
+    }
+}
+
+
+
+data class DedupStats (
+    var `totalTracked`: kotlin.ULong
+    , 
+    var `recentTracked`: kotlin.ULong
+    , 
+    var `capacityUsedPercent`: kotlin.UByte
+    , 
+    var `mode`: kotlin.String
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeDedupStats: FfiConverterRustBuffer<DedupStats> {
+    override fun read(buf: ByteBuffer): DedupStats {
+        return DedupStats(
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterUByte.read(buf),
+            FfiConverterString.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: DedupStats) = (
+            FfiConverterULong.allocationSize(value.`totalTracked`) +
+            FfiConverterULong.allocationSize(value.`recentTracked`) +
+            FfiConverterUByte.allocationSize(value.`capacityUsedPercent`) +
+            FfiConverterString.allocationSize(value.`mode`)
+    )
+
+    override fun write(value: DedupStats, buf: ByteBuffer) {
+            FfiConverterULong.write(value.`totalTracked`, buf)
+            FfiConverterULong.write(value.`recentTracked`, buf)
+            FfiConverterUByte.write(value.`capacityUsedPercent`, buf)
+            FfiConverterString.write(value.`mode`, buf)
+    }
+}
+
+
+
+data class DorsConfig (
+    var `preferOnline`: kotlin.Boolean
+    , 
+    var `switchHysteresis`: kotlin.Float
+    , 
+    var `switchCooldownSecs`: kotlin.ULong
+    , 
+    var `bleToWifiRetryThreshold`: kotlin.UInt
+    , 
+    var `rssiSwitchThreshold`: kotlin.Short
+    , 
+    var `congestionQueueThreshold`: kotlin.ULong
+    , 
+    var `stabilityWindowSecs`: kotlin.ULong
+    , 
+    var `poorSignalDurationSecs`: kotlin.ULong
+    , 
+    var `ttlEscalationThreshold`: kotlin.UByte
+    , 
+    var `congestionDurationSecs`: kotlin.ULong
+    , 
+    var `ttlEscalationHoldSecs`: kotlin.ULong
+    , 
+    var `historyWindowSize`: kotlin.ULong
+    , 
+    var `queueRecoveryRatio`: kotlin.Float
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeDorsConfig: FfiConverterRustBuffer<DorsConfig> {
+    override fun read(buf: ByteBuffer): DorsConfig {
+        return DorsConfig(
+            FfiConverterBoolean.read(buf),
+            FfiConverterFloat.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterShort.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterUByte.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterFloat.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: DorsConfig) = (
+            FfiConverterBoolean.allocationSize(value.`preferOnline`) +
+            FfiConverterFloat.allocationSize(value.`switchHysteresis`) +
+            FfiConverterULong.allocationSize(value.`switchCooldownSecs`) +
+            FfiConverterUInt.allocationSize(value.`bleToWifiRetryThreshold`) +
+            FfiConverterShort.allocationSize(value.`rssiSwitchThreshold`) +
+            FfiConverterULong.allocationSize(value.`congestionQueueThreshold`) +
+            FfiConverterULong.allocationSize(value.`stabilityWindowSecs`) +
+            FfiConverterULong.allocationSize(value.`poorSignalDurationSecs`) +
+            FfiConverterUByte.allocationSize(value.`ttlEscalationThreshold`) +
+            FfiConverterULong.allocationSize(value.`congestionDurationSecs`) +
+            FfiConverterULong.allocationSize(value.`ttlEscalationHoldSecs`) +
+            FfiConverterULong.allocationSize(value.`historyWindowSize`) +
+            FfiConverterFloat.allocationSize(value.`queueRecoveryRatio`)
+    )
+
+    override fun write(value: DorsConfig, buf: ByteBuffer) {
+            FfiConverterBoolean.write(value.`preferOnline`, buf)
+            FfiConverterFloat.write(value.`switchHysteresis`, buf)
+            FfiConverterULong.write(value.`switchCooldownSecs`, buf)
+            FfiConverterUInt.write(value.`bleToWifiRetryThreshold`, buf)
+            FfiConverterShort.write(value.`rssiSwitchThreshold`, buf)
+            FfiConverterULong.write(value.`congestionQueueThreshold`, buf)
+            FfiConverterULong.write(value.`stabilityWindowSecs`, buf)
+            FfiConverterULong.write(value.`poorSignalDurationSecs`, buf)
+            FfiConverterUByte.write(value.`ttlEscalationThreshold`, buf)
+            FfiConverterULong.write(value.`congestionDurationSecs`, buf)
+            FfiConverterULong.write(value.`ttlEscalationHoldSecs`, buf)
+            FfiConverterULong.write(value.`historyWindowSize`, buf)
+            FfiConverterFloat.write(value.`queueRecoveryRatio`, buf)
+    }
+}
+
+
+
+data class FileProgress (
+    var `fileId`: kotlin.String
+    , 
+    var `chunksSent`: kotlin.UInt
+    , 
+    var `totalChunks`: kotlin.UInt
+    , 
+    var `percentage`: kotlin.UByte
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeFileProgress: FfiConverterRustBuffer<FileProgress> {
+    override fun read(buf: ByteBuffer): FileProgress {
+        return FileProgress(
+            FfiConverterString.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: FileProgress) = (
+            FfiConverterString.allocationSize(value.`fileId`) +
+            FfiConverterUInt.allocationSize(value.`chunksSent`) +
+            FfiConverterUInt.allocationSize(value.`totalChunks`) +
+            FfiConverterUByte.allocationSize(value.`percentage`)
+    )
+
+    override fun write(value: FileProgress, buf: ByteBuffer) {
+            FfiConverterString.write(value.`fileId`, buf)
+            FfiConverterUInt.write(value.`chunksSent`, buf)
+            FfiConverterUInt.write(value.`totalChunks`, buf)
+            FfiConverterUByte.write(value.`percentage`, buf)
+    }
+}
+
+
+
+data class GradientRoutingConfig (
+    var `maxRoutesPerDestination`: kotlin.UInt
+    , 
+    var `routeTtlSecs`: kotlin.ULong
+    , 
+    var `maxRoutingTableSize`: kotlin.UInt
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeGradientRoutingConfig: FfiConverterRustBuffer<GradientRoutingConfig> {
+    override fun read(buf: ByteBuffer): GradientRoutingConfig {
+        return GradientRoutingConfig(
+            FfiConverterUInt.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterUInt.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: GradientRoutingConfig) = (
+            FfiConverterUInt.allocationSize(value.`maxRoutesPerDestination`) +
+            FfiConverterULong.allocationSize(value.`routeTtlSecs`) +
+            FfiConverterUInt.allocationSize(value.`maxRoutingTableSize`)
+    )
+
+    override fun write(value: GradientRoutingConfig, buf: ByteBuffer) {
+            FfiConverterUInt.write(value.`maxRoutesPerDestination`, buf)
+            FfiConverterULong.write(value.`routeTtlSecs`, buf)
+            FfiConverterUInt.write(value.`maxRoutingTableSize`, buf)
+    }
+}
+
+
+
+data class InternetMessage (
+    var `recipientId`: kotlin.String
+    , 
+    var `data`: List<kotlin.UByte>
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeInternetMessage: FfiConverterRustBuffer<InternetMessage> {
+    override fun read(buf: ByteBuffer): InternetMessage {
+        return InternetMessage(
+            FfiConverterString.read(buf),
+            FfiConverterSequenceUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: InternetMessage) = (
+            FfiConverterString.allocationSize(value.`recipientId`) +
+            FfiConverterSequenceUByte.allocationSize(value.`data`)
+    )
+
+    override fun write(value: InternetMessage, buf: ByteBuffer) {
+            FfiConverterString.write(value.`recipientId`, buf)
+            FfiConverterSequenceUByte.write(value.`data`, buf)
+    }
+}
+
+
+
+data class MessageStats (
+    var `messageId`: kotlin.String
+    , 
+    var `sentAtMs`: kotlin.ULong
+    , 
+    var `deliveredAtMs`: kotlin.ULong?
+    , 
+    var `hopCount`: kotlin.UByte
+    , 
+    var `status`: kotlin.String
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeMessageStats: FfiConverterRustBuffer<MessageStats> {
+    override fun read(buf: ByteBuffer): MessageStats {
+        return MessageStats(
+            FfiConverterString.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterOptionalULong.read(buf),
+            FfiConverterUByte.read(buf),
+            FfiConverterString.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: MessageStats) = (
+            FfiConverterString.allocationSize(value.`messageId`) +
+            FfiConverterULong.allocationSize(value.`sentAtMs`) +
+            FfiConverterOptionalULong.allocationSize(value.`deliveredAtMs`) +
+            FfiConverterUByte.allocationSize(value.`hopCount`) +
+            FfiConverterString.allocationSize(value.`status`)
+    )
+
+    override fun write(value: MessageStats, buf: ByteBuffer) {
+            FfiConverterString.write(value.`messageId`, buf)
+            FfiConverterULong.write(value.`sentAtMs`, buf)
+            FfiConverterOptionalULong.write(value.`deliveredAtMs`, buf)
+            FfiConverterUByte.write(value.`hopCount`, buf)
+            FfiConverterString.write(value.`status`, buf)
+    }
+}
+
+
+
+data class NetworkLink (
+    var `sourceId`: kotlin.String
+    , 
+    var `targetId`: kotlin.String
+    , 
+    var `transport`: kotlin.String
+    , 
+    var `quality`: kotlin.Float
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeNetworkLink: FfiConverterRustBuffer<NetworkLink> {
+    override fun read(buf: ByteBuffer): NetworkLink {
+        return NetworkLink(
+            FfiConverterString.read(buf),
+            FfiConverterString.read(buf),
+            FfiConverterString.read(buf),
+            FfiConverterFloat.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: NetworkLink) = (
+            FfiConverterString.allocationSize(value.`sourceId`) +
+            FfiConverterString.allocationSize(value.`targetId`) +
+            FfiConverterString.allocationSize(value.`transport`) +
+            FfiConverterFloat.allocationSize(value.`quality`)
+    )
+
+    override fun write(value: NetworkLink, buf: ByteBuffer) {
+            FfiConverterString.write(value.`sourceId`, buf)
+            FfiConverterString.write(value.`targetId`, buf)
+            FfiConverterString.write(value.`transport`, buf)
+            FfiConverterFloat.write(value.`quality`, buf)
+    }
+}
+
+
+
+data class NetworkNode (
+    var `nodeId`: kotlin.String
+    , 
+    var `role`: kotlin.String
+    , 
+    var `rssi`: kotlin.Short?
+    , 
+    var `lastSeenMs`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeNetworkNode: FfiConverterRustBuffer<NetworkNode> {
+    override fun read(buf: ByteBuffer): NetworkNode {
+        return NetworkNode(
+            FfiConverterString.read(buf),
+            FfiConverterString.read(buf),
+            FfiConverterOptionalShort.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: NetworkNode) = (
+            FfiConverterString.allocationSize(value.`nodeId`) +
+            FfiConverterString.allocationSize(value.`role`) +
+            FfiConverterOptionalShort.allocationSize(value.`rssi`) +
+            FfiConverterULong.allocationSize(value.`lastSeenMs`)
+    )
+
+    override fun write(value: NetworkNode, buf: ByteBuffer) {
+            FfiConverterString.write(value.`nodeId`, buf)
+            FfiConverterString.write(value.`role`, buf)
+            FfiConverterOptionalShort.write(value.`rssi`, buf)
+            FfiConverterULong.write(value.`lastSeenMs`, buf)
+    }
+}
+
+
+
+data class NetworkTopology (
+    var `nodes`: List<NetworkNode>
+    , 
+    var `links`: List<NetworkLink>
+    , 
+    var `messageStats`: List<MessageStats>
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeNetworkTopology: FfiConverterRustBuffer<NetworkTopology> {
+    override fun read(buf: ByteBuffer): NetworkTopology {
+        return NetworkTopology(
+            FfiConverterSequenceTypeNetworkNode.read(buf),
+            FfiConverterSequenceTypeNetworkLink.read(buf),
+            FfiConverterSequenceTypeMessageStats.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: NetworkTopology) = (
+            FfiConverterSequenceTypeNetworkNode.allocationSize(value.`nodes`) +
+            FfiConverterSequenceTypeNetworkLink.allocationSize(value.`links`) +
+            FfiConverterSequenceTypeMessageStats.allocationSize(value.`messageStats`)
+    )
+
+    override fun write(value: NetworkTopology, buf: ByteBuffer) {
+            FfiConverterSequenceTypeNetworkNode.write(value.`nodes`, buf)
+            FfiConverterSequenceTypeNetworkLink.write(value.`links`, buf)
+            FfiConverterSequenceTypeMessageStats.write(value.`messageStats`, buf)
+    }
+}
+
+
+
+data class PathConfig (
+    var `forwardToTopK`: kotlin.UInt
+    , 
+    var `maxCongestionLevel`: kotlin.UInt
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypePathConfig: FfiConverterRustBuffer<PathConfig> {
+    override fun read(buf: ByteBuffer): PathConfig {
+        return PathConfig(
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: PathConfig) = (
+            FfiConverterUInt.allocationSize(value.`forwardToTopK`) +
+            FfiConverterUInt.allocationSize(value.`maxCongestionLevel`)
+    )
+
+    override fun write(value: PathConfig, buf: ByteBuffer) {
+            FfiConverterUInt.write(value.`forwardToTopK`, buf)
+            FfiConverterUInt.write(value.`maxCongestionLevel`, buf)
+    }
+}
+
+
+
+data class PeerDevice (
+    var `peerId`: kotlin.String
+    , 
+    var `rssi`: kotlin.Short
+    , 
+    var `lastSeenMs`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypePeerDevice: FfiConverterRustBuffer<PeerDevice> {
+    override fun read(buf: ByteBuffer): PeerDevice {
+        return PeerDevice(
+            FfiConverterString.read(buf),
+            FfiConverterShort.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: PeerDevice) = (
+            FfiConverterString.allocationSize(value.`peerId`) +
+            FfiConverterShort.allocationSize(value.`rssi`) +
+            FfiConverterULong.allocationSize(value.`lastSeenMs`)
+    )
+
+    override fun write(value: PeerDevice, buf: ByteBuffer) {
+            FfiConverterString.write(value.`peerId`, buf)
+            FfiConverterShort.write(value.`rssi`, buf)
+            FfiConverterULong.write(value.`lastSeenMs`, buf)
+    }
+}
+
+
+
+data class ProtocolConfig (
+    var `appId`: kotlin.String
+    , 
+    var `userId`: kotlin.String
+    , 
+    var `bleEnabled`: kotlin.Boolean
+    , 
+    var `wifiDirectEnabled`: kotlin.Boolean
+    , 
+    var `internetEnabled`: kotlin.Boolean
+    , 
+    var `preferOnline`: kotlin.Boolean
+    , 
+    var `initialTtl`: kotlin.UByte
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeProtocolConfig: FfiConverterRustBuffer<ProtocolConfig> {
+    override fun read(buf: ByteBuffer): ProtocolConfig {
+        return ProtocolConfig(
+            FfiConverterString.read(buf),
+            FfiConverterString.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: ProtocolConfig) = (
+            FfiConverterString.allocationSize(value.`appId`) +
+            FfiConverterString.allocationSize(value.`userId`) +
+            FfiConverterBoolean.allocationSize(value.`bleEnabled`) +
+            FfiConverterBoolean.allocationSize(value.`wifiDirectEnabled`) +
+            FfiConverterBoolean.allocationSize(value.`internetEnabled`) +
+            FfiConverterBoolean.allocationSize(value.`preferOnline`) +
+            FfiConverterUByte.allocationSize(value.`initialTtl`)
+    )
+
+    override fun write(value: ProtocolConfig, buf: ByteBuffer) {
+            FfiConverterString.write(value.`appId`, buf)
+            FfiConverterString.write(value.`userId`, buf)
+            FfiConverterBoolean.write(value.`bleEnabled`, buf)
+            FfiConverterBoolean.write(value.`wifiDirectEnabled`, buf)
+            FfiConverterBoolean.write(value.`internetEnabled`, buf)
+            FfiConverterBoolean.write(value.`preferOnline`, buf)
+            FfiConverterUByte.write(value.`initialTtl`, buf)
+    }
+}
+
+
+
+data class ProtocolConfigExtended (
+    var `appId`: kotlin.String
+    , 
+    var `userId`: kotlin.String
+    , 
+    var `transport`: TransportConfig
+    , 
+    var `dors`: DorsConfig
+    , 
+    var `relay`: RelayConfig
+    , 
+    var `path`: PathConfig
+    , 
+    var `reliability`: ReliabilityConfig
+    , 
+    var `initialTtl`: kotlin.UByte
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeProtocolConfigExtended: FfiConverterRustBuffer<ProtocolConfigExtended> {
+    override fun read(buf: ByteBuffer): ProtocolConfigExtended {
+        return ProtocolConfigExtended(
+            FfiConverterString.read(buf),
+            FfiConverterString.read(buf),
+            FfiConverterTypeTransportConfig.read(buf),
+            FfiConverterTypeDorsConfig.read(buf),
+            FfiConverterTypeRelayConfig.read(buf),
+            FfiConverterTypePathConfig.read(buf),
+            FfiConverterTypeReliabilityConfig.read(buf),
+            FfiConverterUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: ProtocolConfigExtended) = (
+            FfiConverterString.allocationSize(value.`appId`) +
+            FfiConverterString.allocationSize(value.`userId`) +
+            FfiConverterTypeTransportConfig.allocationSize(value.`transport`) +
+            FfiConverterTypeDorsConfig.allocationSize(value.`dors`) +
+            FfiConverterTypeRelayConfig.allocationSize(value.`relay`) +
+            FfiConverterTypePathConfig.allocationSize(value.`path`) +
+            FfiConverterTypeReliabilityConfig.allocationSize(value.`reliability`) +
+            FfiConverterUByte.allocationSize(value.`initialTtl`)
+    )
+
+    override fun write(value: ProtocolConfigExtended, buf: ByteBuffer) {
+            FfiConverterString.write(value.`appId`, buf)
+            FfiConverterString.write(value.`userId`, buf)
+            FfiConverterTypeTransportConfig.write(value.`transport`, buf)
+            FfiConverterTypeDorsConfig.write(value.`dors`, buf)
+            FfiConverterTypeRelayConfig.write(value.`relay`, buf)
+            FfiConverterTypePathConfig.write(value.`path`, buf)
+            FfiConverterTypeReliabilityConfig.write(value.`reliability`, buf)
+            FfiConverterUByte.write(value.`initialTtl`, buf)
+    }
+}
+
+
+
+data class RelayConfig (
+    var `relayThreshold`: kotlin.ULong
+    , 
+    var `minBatteryForRelay`: kotlin.UByte
+    , 
+    var `allowRelay`: kotlin.Boolean
+    , 
+    var `relayPriority`: RelayPriority
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeRelayConfig: FfiConverterRustBuffer<RelayConfig> {
+    override fun read(buf: ByteBuffer): RelayConfig {
+        return RelayConfig(
+            FfiConverterULong.read(buf),
+            FfiConverterUByte.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterTypeRelayPriority.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: RelayConfig) = (
+            FfiConverterULong.allocationSize(value.`relayThreshold`) +
+            FfiConverterUByte.allocationSize(value.`minBatteryForRelay`) +
+            FfiConverterBoolean.allocationSize(value.`allowRelay`) +
+            FfiConverterTypeRelayPriority.allocationSize(value.`relayPriority`)
+    )
+
+    override fun write(value: RelayConfig, buf: ByteBuffer) {
+            FfiConverterULong.write(value.`relayThreshold`, buf)
+            FfiConverterUByte.write(value.`minBatteryForRelay`, buf)
+            FfiConverterBoolean.write(value.`allowRelay`, buf)
+            FfiConverterTypeRelayPriority.write(value.`relayPriority`, buf)
+    }
+}
+
+
+
+data class ReliabilityConfig (
+    var `ack`: AckConfig
+    , 
+    var `retry`: RetryConfig
+    , 
+    var `dedup`: DedupConfig
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeReliabilityConfig: FfiConverterRustBuffer<ReliabilityConfig> {
+    override fun read(buf: ByteBuffer): ReliabilityConfig {
+        return ReliabilityConfig(
+            FfiConverterTypeAckConfig.read(buf),
+            FfiConverterTypeRetryConfig.read(buf),
+            FfiConverterTypeDedupConfig.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: ReliabilityConfig) = (
+            FfiConverterTypeAckConfig.allocationSize(value.`ack`) +
+            FfiConverterTypeRetryConfig.allocationSize(value.`retry`) +
+            FfiConverterTypeDedupConfig.allocationSize(value.`dedup`)
+    )
+
+    override fun write(value: ReliabilityConfig, buf: ByteBuffer) {
+            FfiConverterTypeAckConfig.write(value.`ack`, buf)
+            FfiConverterTypeRetryConfig.write(value.`retry`, buf)
+            FfiConverterTypeDedupConfig.write(value.`dedup`, buf)
+    }
+}
+
+
+
+data class RetryConfig (
+    var `maxRetries`: kotlin.UInt
+    , 
+    var `initialDelayMs`: kotlin.ULong
+    , 
+    var `maxDelayMs`: kotlin.ULong
+    , 
+    var `backoffMultiplier`: kotlin.Float
+    , 
+    var `outboxMaxLifetimeMs`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeRetryConfig: FfiConverterRustBuffer<RetryConfig> {
+    override fun read(buf: ByteBuffer): RetryConfig {
+        return RetryConfig(
+            FfiConverterUInt.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterFloat.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: RetryConfig) = (
+            FfiConverterUInt.allocationSize(value.`maxRetries`) +
+            FfiConverterULong.allocationSize(value.`initialDelayMs`) +
+            FfiConverterULong.allocationSize(value.`maxDelayMs`) +
+            FfiConverterFloat.allocationSize(value.`backoffMultiplier`) +
+            FfiConverterULong.allocationSize(value.`outboxMaxLifetimeMs`)
+    )
+
+    override fun write(value: RetryConfig, buf: ByteBuffer) {
+            FfiConverterUInt.write(value.`maxRetries`, buf)
+            FfiConverterULong.write(value.`initialDelayMs`, buf)
+            FfiConverterULong.write(value.`maxDelayMs`, buf)
+            FfiConverterFloat.write(value.`backoffMultiplier`, buf)
+            FfiConverterULong.write(value.`outboxMaxLifetimeMs`, buf)
+    }
+}
+
+
+
+data class RouteEntry (
+    var `nextHop`: kotlin.String
+    , 
+    var `hopCount`: kotlin.UByte
+    , 
+    var `quality`: kotlin.Float
+    , 
+    var `lastSeenMs`: kotlin.ULong
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeRouteEntry: FfiConverterRustBuffer<RouteEntry> {
+    override fun read(buf: ByteBuffer): RouteEntry {
+        return RouteEntry(
+            FfiConverterString.read(buf),
+            FfiConverterUByte.read(buf),
+            FfiConverterFloat.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: RouteEntry) = (
+            FfiConverterString.allocationSize(value.`nextHop`) +
+            FfiConverterUByte.allocationSize(value.`hopCount`) +
+            FfiConverterFloat.allocationSize(value.`quality`) +
+            FfiConverterULong.allocationSize(value.`lastSeenMs`)
+    )
+
+    override fun write(value: RouteEntry, buf: ByteBuffer) {
+            FfiConverterString.write(value.`nextHop`, buf)
+            FfiConverterUByte.write(value.`hopCount`, buf)
+            FfiConverterFloat.write(value.`quality`, buf)
+            FfiConverterULong.write(value.`lastSeenMs`, buf)
+    }
+}
+
+
+
+data class RoutingStats (
+    var `destinationCount`: kotlin.UInt
+    , 
+    var `routeCount`: kotlin.UInt
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeRoutingStats: FfiConverterRustBuffer<RoutingStats> {
+    override fun read(buf: ByteBuffer): RoutingStats {
+        return RoutingStats(
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: RoutingStats) = (
+            FfiConverterUInt.allocationSize(value.`destinationCount`) +
+            FfiConverterUInt.allocationSize(value.`routeCount`)
+    )
+
+    override fun write(value: RoutingStats, buf: ByteBuffer) {
+            FfiConverterUInt.write(value.`destinationCount`, buf)
+            FfiConverterUInt.write(value.`routeCount`, buf)
+    }
+}
+
+
+
+data class TransportConfig (
+    var `bleEnabled`: kotlin.Boolean
+    , 
+    var `wifiDirectEnabled`: kotlin.Boolean
+    , 
+    var `internetEnabled`: kotlin.Boolean
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeTransportConfig: FfiConverterRustBuffer<TransportConfig> {
+    override fun read(buf: ByteBuffer): TransportConfig {
+        return TransportConfig(
+            FfiConverterBoolean.read(buf),
+            FfiConverterBoolean.read(buf),
+            FfiConverterBoolean.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: TransportConfig) = (
+            FfiConverterBoolean.allocationSize(value.`bleEnabled`) +
+            FfiConverterBoolean.allocationSize(value.`wifiDirectEnabled`) +
+            FfiConverterBoolean.allocationSize(value.`internetEnabled`)
+    )
+
+    override fun write(value: TransportConfig, buf: ByteBuffer) {
+            FfiConverterBoolean.write(value.`bleEnabled`, buf)
+            FfiConverterBoolean.write(value.`wifiDirectEnabled`, buf)
+            FfiConverterBoolean.write(value.`internetEnabled`, buf)
+    }
+}
+
+
+
+data class TransportMetrics (
+    var `packetsSent`: kotlin.UInt
+    , 
+    var `packetsReceived`: kotlin.UInt
+    , 
+    var `bytesSent`: kotlin.UInt
+    , 
+    var `bytesReceived`: kotlin.UInt
+    , 
+    var `errorRate`: kotlin.Float
+    , 
+    var `avgLatencyMs`: kotlin.UInt
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeTransportMetrics: FfiConverterRustBuffer<TransportMetrics> {
+    override fun read(buf: ByteBuffer): TransportMetrics {
+        return TransportMetrics(
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterUInt.read(buf),
+            FfiConverterFloat.read(buf),
+            FfiConverterUInt.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: TransportMetrics) = (
+            FfiConverterUInt.allocationSize(value.`packetsSent`) +
+            FfiConverterUInt.allocationSize(value.`packetsReceived`) +
+            FfiConverterUInt.allocationSize(value.`bytesSent`) +
+            FfiConverterUInt.allocationSize(value.`bytesReceived`) +
+            FfiConverterFloat.allocationSize(value.`errorRate`) +
+            FfiConverterUInt.allocationSize(value.`avgLatencyMs`)
+    )
+
+    override fun write(value: TransportMetrics, buf: ByteBuffer) {
+            FfiConverterUInt.write(value.`packetsSent`, buf)
+            FfiConverterUInt.write(value.`packetsReceived`, buf)
+            FfiConverterUInt.write(value.`bytesSent`, buf)
+            FfiConverterUInt.write(value.`bytesReceived`, buf)
+            FfiConverterFloat.write(value.`errorRate`, buf)
+            FfiConverterUInt.write(value.`avgLatencyMs`, buf)
+    }
+}
+
+
+
+data class WifiDirectMessage (
+    var `recipientId`: kotlin.String
+    , 
+    var `data`: List<kotlin.UByte>
+    
+){
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeWifiDirectMessage: FfiConverterRustBuffer<WifiDirectMessage> {
+    override fun read(buf: ByteBuffer): WifiDirectMessage {
+        return WifiDirectMessage(
+            FfiConverterString.read(buf),
+            FfiConverterSequenceUByte.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: WifiDirectMessage) = (
+            FfiConverterString.allocationSize(value.`recipientId`) +
+            FfiConverterSequenceUByte.allocationSize(value.`data`)
+    )
+
+    override fun write(value: WifiDirectMessage, buf: ByteBuffer) {
+            FfiConverterString.write(value.`recipientId`, buf)
+            FfiConverterSequenceUByte.write(value.`data`, buf)
+    }
+}
+
+
+
+
+enum class MessagePriority {
+    
+    LOW,
+    MEDIUM,
+    HIGH,
+    CRITICAL;
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeMessagePriority: FfiConverterRustBuffer<MessagePriority> {
+    override fun read(buf: ByteBuffer) = try {
+        MessagePriority.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: MessagePriority) = 4UL
+
+    override fun write(value: MessagePriority, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
+
+
+sealed class ProtocolException(message: String): kotlin.Exception(message) {
+        
+        class NotStarted(message: String) : ProtocolException(message)
+        
+        class AlreadyStarted(message: String) : ProtocolException(message)
+        
+        class InvalidConfiguration(message: String) : ProtocolException(message)
+        
+        class SendFailed(message: String) : ProtocolException(message)
+        
+        class InvalidState(message: String) : ProtocolException(message)
+        
+        class Other(message: String) : ProtocolException(message)
+        
+
+    companion object ErrorHandler : UniffiRustCallStatusErrorHandler<ProtocolException> {
+        override fun lift(error_buf: RustBuffer.ByValue): ProtocolException = FfiConverterTypeProtocolError.lift(error_buf)
+    }
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeProtocolError : FfiConverterRustBuffer<ProtocolException> {
+    override fun read(buf: ByteBuffer): ProtocolException {
+        
+            return when(buf.getInt()) {
+            1 -> ProtocolException.NotStarted(FfiConverterString.read(buf))
+            2 -> ProtocolException.AlreadyStarted(FfiConverterString.read(buf))
+            3 -> ProtocolException.InvalidConfiguration(FfiConverterString.read(buf))
+            4 -> ProtocolException.SendFailed(FfiConverterString.read(buf))
+            5 -> ProtocolException.InvalidState(FfiConverterString.read(buf))
+            6 -> ProtocolException.Other(FfiConverterString.read(buf))
+            else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
+        }
+        
+    }
+
+    override fun allocationSize(value: ProtocolException): ULong {
+        return 4UL
+    }
+
+    override fun write(value: ProtocolException, buf: ByteBuffer) {
+        when(value) {
+            is ProtocolException.NotStarted -> {
+                buf.putInt(1)
+                Unit
+            }
+            is ProtocolException.AlreadyStarted -> {
+                buf.putInt(2)
+                Unit
+            }
+            is ProtocolException.InvalidConfiguration -> {
+                buf.putInt(3)
+                Unit
+            }
+            is ProtocolException.SendFailed -> {
+                buf.putInt(4)
+                Unit
+            }
+            is ProtocolException.InvalidState -> {
+                buf.putInt(5)
+                Unit
+            }
+            is ProtocolException.Other -> {
+                buf.putInt(6)
+                Unit
+            }
+        }.let { /* this makes the `when` an expression, which ensures it is exhaustive */ }
+    }
+
+}
+
+
+
+
+enum class ProtocolState {
+    
+    STOPPED,
+    STARTING,
+    RUNNING,
+    PAUSED,
+    STOPPING;
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeProtocolState: FfiConverterRustBuffer<ProtocolState> {
+    override fun read(buf: ByteBuffer) = try {
+        ProtocolState.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: ProtocolState) = 4UL
+
+    override fun write(value: ProtocolState, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
+
+enum class RelayPriority {
+    
+    LOW,
+    MEDIUM,
+    HIGH;
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeRelayPriority: FfiConverterRustBuffer<RelayPriority> {
+    override fun read(buf: ByteBuffer) = try {
+        RelayPriority.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: RelayPriority) = 4UL
+
+    override fun write(value: RelayPriority, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
+
+enum class TransportType {
+    
+    INTERNET,
+    BLE,
+    WI_FI_DIRECT;
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeTransportType: FfiConverterRustBuffer<TransportType> {
+    override fun read(buf: ByteBuffer) = try {
+        TransportType.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: TransportType) = 4UL
+
+    override fun write(value: TransportType, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
+
+
+public interface EventCallback {
+    
+    fun `onEvent`(`eventJson`: kotlin.String)
+    
+    companion object
+}
+
+
+
+// Put the implementation in an object so we don't pollute the top-level namespace
+internal object uniffiCallbackInterfaceEventCallback {
+    internal object `onEvent`: UniffiCallbackInterfaceEventCallbackMethod0 {
+        override fun callback(`uniffiHandle`: Long,`eventJson`: RustBuffer.ByValue,`uniffiOutReturn`: Pointer,uniffiCallStatus: UniffiRustCallStatus,) {
+            val uniffiObj = FfiConverterTypeEventCallback.handleMap.get(uniffiHandle)
+            val makeCall = { ->
+                uniffiObj.`onEvent`(
+                    FfiConverterString.lift(`eventJson`),
+                )
+            }
+            val writeReturn = { _: Unit -> Unit }
+            uniffiTraitInterfaceCall(uniffiCallStatus, makeCall, writeReturn)
+        }
+    }
+
+    internal object uniffiFree: UniffiCallbackInterfaceFree {
+        override fun callback(handle: Long) {
+            FfiConverterTypeEventCallback.handleMap.remove(handle)
+        }
+    }
+
+    internal object uniffiClone: UniffiCallbackInterfaceClone {
+        override fun callback(handle: Long): Long {
+            return FfiConverterTypeEventCallback.handleMap.clone(handle)
+        }
+    }
+
+    internal var vtable = UniffiVTableCallbackInterfaceEventCallback.UniffiByValue(
+        uniffiFree,
+        uniffiClone,
+        `onEvent`,
+    )
+
+    // Registers the foreign callback with the Rust side.
+    // This method is generated for each callback interface.
+    internal fun register(lib: UniffiLib) {
+        lib.uniffi_offline_protocol_uniffi_fn_init_callback_vtable_eventcallback(vtable)
+    }
+}
+
+/**
+ * The ffiConverter which transforms the Callbacks in to handles to pass to Rust.
+ *
+ * @suppress
+ */
+public object FfiConverterTypeEventCallback: FfiConverterCallbackInterface<EventCallback>()
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalUByte: FfiConverterRustBuffer<kotlin.UByte?> {
+    override fun read(buf: ByteBuffer): kotlin.UByte? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterUByte.read(buf)
+    }
+
+    override fun allocationSize(value: kotlin.UByte?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterUByte.allocationSize(value)
+        }
+    }
+
+    override fun write(value: kotlin.UByte?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterUByte.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalShort: FfiConverterRustBuffer<kotlin.Short?> {
+    override fun read(buf: ByteBuffer): kotlin.Short? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterShort.read(buf)
+    }
+
+    override fun allocationSize(value: kotlin.Short?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterShort.allocationSize(value)
+        }
+    }
+
+    override fun write(value: kotlin.Short?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterShort.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalULong: FfiConverterRustBuffer<kotlin.ULong?> {
+    override fun read(buf: ByteBuffer): kotlin.ULong? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterULong.read(buf)
+    }
+
+    override fun allocationSize(value: kotlin.ULong?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterULong.allocationSize(value)
+        }
+    }
+
+    override fun write(value: kotlin.ULong?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterULong.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalString: FfiConverterRustBuffer<kotlin.String?> {
+    override fun read(buf: ByteBuffer): kotlin.String? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterString.read(buf)
+    }
+
+    override fun allocationSize(value: kotlin.String?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterString.allocationSize(value)
+        }
+    }
+
+    override fun write(value: kotlin.String?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterString.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeBleFragment: FfiConverterRustBuffer<BleFragment?> {
+    override fun read(buf: ByteBuffer): BleFragment? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeBleFragment.read(buf)
+    }
+
+    override fun allocationSize(value: BleFragment?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeBleFragment.allocationSize(value)
+        }
+    }
+
+    override fun write(value: BleFragment?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeBleFragment.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeFileProgress: FfiConverterRustBuffer<FileProgress?> {
+    override fun read(buf: ByteBuffer): FileProgress? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeFileProgress.read(buf)
+    }
+
+    override fun allocationSize(value: FileProgress?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeFileProgress.allocationSize(value)
+        }
+    }
+
+    override fun write(value: FileProgress?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeFileProgress.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeInternetMessage: FfiConverterRustBuffer<InternetMessage?> {
+    override fun read(buf: ByteBuffer): InternetMessage? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeInternetMessage.read(buf)
+    }
+
+    override fun allocationSize(value: InternetMessage?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeInternetMessage.allocationSize(value)
+        }
+    }
+
+    override fun write(value: InternetMessage?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeInternetMessage.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeRouteEntry: FfiConverterRustBuffer<RouteEntry?> {
+    override fun read(buf: ByteBuffer): RouteEntry? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeRouteEntry.read(buf)
+    }
+
+    override fun allocationSize(value: RouteEntry?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeRouteEntry.allocationSize(value)
+        }
+    }
+
+    override fun write(value: RouteEntry?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeRouteEntry.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeTransportMetrics: FfiConverterRustBuffer<TransportMetrics?> {
+    override fun read(buf: ByteBuffer): TransportMetrics? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeTransportMetrics.read(buf)
+    }
+
+    override fun allocationSize(value: TransportMetrics?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeTransportMetrics.allocationSize(value)
+        }
+    }
+
+    override fun write(value: TransportMetrics?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeTransportMetrics.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterOptionalTypeWifiDirectMessage: FfiConverterRustBuffer<WifiDirectMessage?> {
+    override fun read(buf: ByteBuffer): WifiDirectMessage? {
+        if (buf.get().toInt() == 0) {
+            return null
+        }
+        return FfiConverterTypeWifiDirectMessage.read(buf)
+    }
+
+    override fun allocationSize(value: WifiDirectMessage?): ULong {
+        if (value == null) {
+            return 1UL
+        } else {
+            return 1UL + FfiConverterTypeWifiDirectMessage.allocationSize(value)
+        }
+    }
+
+    override fun write(value: WifiDirectMessage?, buf: ByteBuffer) {
+        if (value == null) {
+            buf.put(0)
+        } else {
+            buf.put(1)
+            FfiConverterTypeWifiDirectMessage.write(value, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceUByte: FfiConverterRustBuffer<List<kotlin.UByte>> {
+    override fun read(buf: ByteBuffer): List<kotlin.UByte> {
+        val len = buf.getInt()
+        return List<kotlin.UByte>(len) {
+            FfiConverterUByte.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<kotlin.UByte>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterUByte.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<kotlin.UByte>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterUByte.write(it, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceString: FfiConverterRustBuffer<List<kotlin.String>> {
+    override fun read(buf: ByteBuffer): List<kotlin.String> {
+        val len = buf.getInt()
+        return List<kotlin.String>(len) {
+            FfiConverterString.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<kotlin.String>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterString.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<kotlin.String>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterString.write(it, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceTypeMessageStats: FfiConverterRustBuffer<List<MessageStats>> {
+    override fun read(buf: ByteBuffer): List<MessageStats> {
+        val len = buf.getInt()
+        return List<MessageStats>(len) {
+            FfiConverterTypeMessageStats.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<MessageStats>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterTypeMessageStats.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<MessageStats>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterTypeMessageStats.write(it, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceTypeNetworkLink: FfiConverterRustBuffer<List<NetworkLink>> {
+    override fun read(buf: ByteBuffer): List<NetworkLink> {
+        val len = buf.getInt()
+        return List<NetworkLink>(len) {
+            FfiConverterTypeNetworkLink.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<NetworkLink>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterTypeNetworkLink.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<NetworkLink>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterTypeNetworkLink.write(it, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceTypeNetworkNode: FfiConverterRustBuffer<List<NetworkNode>> {
+    override fun read(buf: ByteBuffer): List<NetworkNode> {
+        val len = buf.getInt()
+        return List<NetworkNode>(len) {
+            FfiConverterTypeNetworkNode.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<NetworkNode>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterTypeNetworkNode.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<NetworkNode>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterTypeNetworkNode.write(it, buf)
+        }
+    }
+}
+
+
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterSequenceTypeRouteEntry: FfiConverterRustBuffer<List<RouteEntry>> {
+    override fun read(buf: ByteBuffer): List<RouteEntry> {
+        val len = buf.getInt()
+        return List<RouteEntry>(len) {
+            FfiConverterTypeRouteEntry.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<RouteEntry>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.map { FfiConverterTypeRouteEntry.allocationSize(it) }.sum()
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<RouteEntry>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterTypeRouteEntry.write(it, buf)
+        }
+    }
+}
+