sdk

radroots_sdk.swift (70430B)

---

 // This file was autogenerated by some hot garbage in the `uniffi` crate.
 // Trust me, you don't want to mess with it!
 
 // swiftlint:disable all
 import Foundation
 
 // Depending on the consumer's build setup, the low-level FFI code
 // might be in a separate module, or it might be compiled inline into
 // this module. This is a bit of light hackery to work with both.
 #if canImport(radroots_sdkFFI)
 import radroots_sdkFFI
 #endif
 
 fileprivate extension RustBuffer {
     // Allocate a new buffer, copying the contents of a `UInt8` array.
     init(bytes: [UInt8]) {
         let rbuf = bytes.withUnsafeBufferPointer { ptr in
             RustBuffer.from(ptr)
         }
         self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
     }
 
     static func empty() -> RustBuffer {
         RustBuffer(capacity: 0, len:0, data: nil)
     }
 
     static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
         try! rustCall { ffi_radroots_sdk_ffi_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
     }
 
     // Frees the buffer in place.
     // The buffer must not be used after this is called.
     func deallocate() {
         try! rustCall { ffi_radroots_sdk_ffi_rustbuffer_free(self, $0) }
     }
 }
 
 fileprivate extension ForeignBytes {
     init(bufferPointer: UnsafeBufferPointer<UInt8>) {
         self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
     }
 }
 
 // For every type used in the interface, we provide helper methods for conveniently
 // lifting and lowering that type from C-compatible data, and for reading and writing
 // values of that type in a buffer.
 
 // Helper classes/extensions that don't change.
 // Someday, this will be in a library of its own.
 
 fileprivate extension Data {
     init(rustBuffer: RustBuffer) {
         self.init(
             bytesNoCopy: rustBuffer.data!,
             count: Int(rustBuffer.len),
             deallocator: .none
         )
     }
 }
 
 // Define reader functionality.  Normally this would be defined in a class or
 // struct, but we use standalone functions instead in order to make external
 // types work.
 //
 // With external types, one swift source file needs to be able to call the read
 // method on another source file's FfiConverter, but then what visibility
 // should Reader have?
 // - If Reader is fileprivate, then this means the read() must also
 //   be fileprivate, which doesn't work with external types.
 // - If Reader is internal/public, we'll get compile errors since both source
 //   files will try define the same type.
 //
 // Instead, the read() method and these helper functions input a tuple of data
 
 fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) {
     (data: data, offset: 0)
 }
 
 // Reads an integer at the current offset, in big-endian order, and advances
 // the offset on success. Throws if reading the integer would move the
 // offset past the end of the buffer.
 fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
     let range = reader.offset..<reader.offset + MemoryLayout<T>.size
     guard reader.data.count >= range.upperBound else {
         throw UniffiInternalError.bufferOverflow
     }
     if T.self == UInt8.self {
         let value = reader.data[reader.offset]
         reader.offset += 1
         return value as! T
     }
     var value: T = 0
     let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)})
     reader.offset = range.upperBound
     return value.bigEndian
 }
 
 // Reads an arbitrary number of bytes, to be used to read
 // raw bytes, this is useful when lifting strings
 fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<UInt8> {
     let range = reader.offset..<(reader.offset+count)
     guard reader.data.count >= range.upperBound else {
         throw UniffiInternalError.bufferOverflow
     }
     var value = [UInt8](repeating: 0, count: count)
     value.withUnsafeMutableBufferPointer({ buffer in
         reader.data.copyBytes(to: buffer, from: range)
     })
     reader.offset = range.upperBound
     return value
 }
 
 // Reads a float at the current offset.
 fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
     return Float(bitPattern: try readInt(&reader))
 }
 
 // Reads a float at the current offset.
 fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
     return Double(bitPattern: try readInt(&reader))
 }
 
 // Indicates if the offset has reached the end of the buffer.
 fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
     return reader.offset < reader.data.count
 }
 
 // Define writer functionality.  Normally this would be defined in a class or
 // struct, but we use standalone functions instead in order to make external
 // types work.  See the above discussion on Readers for details.
 
 fileprivate func createWriter() -> [UInt8] {
     return []
 }
 
 fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
     writer.append(contentsOf: byteArr)
 }
 
 // Writes an integer in big-endian order.
 //
 // Warning: make sure what you are trying to write
 // is in the correct type!
 fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
     var value = value.bigEndian
     withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
 }
 
 fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
     writeInt(&writer, value.bitPattern)
 }
 
 fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) {
     writeInt(&writer, value.bitPattern)
 }
 
 // Protocol for types that transfer other types across the FFI. This is
 // analogous to the Rust trait of the same name.
 fileprivate protocol FfiConverter {
     associatedtype FfiType
     associatedtype SwiftType
 
     static func lift(_ value: FfiType) throws -> SwiftType
     static func lower(_ value: SwiftType) -> FfiType
     static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
     static func write(_ value: SwiftType, into buf: inout [UInt8])
 }
 
 // Types conforming to `Primitive` pass themselves directly over the FFI.
 fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
 
 extension FfiConverterPrimitive {
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public static func lift(_ value: FfiType) throws -> SwiftType {
         return value
     }
 
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public static func lower(_ value: SwiftType) -> FfiType {
         return value
     }
 }
 
 // Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
 // Used for complex types where it's hard to write a custom lift/lower.
 fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
 
 extension FfiConverterRustBuffer {
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public static func lift(_ buf: RustBuffer) throws -> SwiftType {
         var reader = createReader(data: Data(rustBuffer: buf))
         let value = try read(from: &reader)
         if hasRemaining(reader) {
             throw UniffiInternalError.incompleteData
         }
         buf.deallocate()
         return value
     }
 
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public static func lower(_ value: SwiftType) -> RustBuffer {
           var writer = createWriter()
           write(value, into: &writer)
           return RustBuffer(bytes: writer)
     }
 }
 // An error type for FFI errors. These errors occur at the UniFFI level, not
 // the library level.
 fileprivate enum UniffiInternalError: LocalizedError {
     case bufferOverflow
     case incompleteData
     case unexpectedOptionalTag
     case unexpectedEnumCase
     case unexpectedNullPointer
     case unexpectedRustCallStatusCode
     case unexpectedRustCallError
     case unexpectedStaleHandle
     case rustPanic(_ message: String)
 
     public var errorDescription: String? {
         switch self {
         case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
         case .incompleteData: return "The buffer still has data after lifting its containing value"
         case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
         case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
         case .unexpectedNullPointer: return "Raw pointer value was null"
         case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
         case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
         case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
         case let .rustPanic(message): return message
         }
     }
 }
 
 fileprivate extension NSLock {
     func withLock<T>(f: () throws -> T) rethrows -> T {
         self.lock()
         defer { self.unlock() }
         return try f()
     }
 }
 
 fileprivate let CALL_SUCCESS: Int8 = 0
 fileprivate let CALL_ERROR: Int8 = 1
 fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
 fileprivate let CALL_CANCELLED: Int8 = 3
 
 fileprivate extension RustCallStatus {
     init() {
         self.init(
             code: CALL_SUCCESS,
             errorBuf: RustBuffer.init(
                 capacity: 0,
                 len: 0,
                 data: nil
             )
         )
     }
 }
 
 private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
     let neverThrow: ((RustBuffer) throws -> Never)? = nil
     return try makeRustCall(callback, errorHandler: neverThrow)
 }
 
 private func rustCallWithError<T, E: Swift.Error>(
     _ errorHandler: @escaping (RustBuffer) throws -> E,
     _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
     try makeRustCall(callback, errorHandler: errorHandler)
 }
 
 private func makeRustCall<T, E: Swift.Error>(
     _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
     errorHandler: ((RustBuffer) throws -> E)?
 ) throws -> T {
     uniffiEnsureRadrootsSdkFfiInitialized()
     var callStatus = RustCallStatus.init()
     let returnedVal = callback(&callStatus)
     try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
     return returnedVal
 }
 
 private func uniffiCheckCallStatus<E: Swift.Error>(
     callStatus: RustCallStatus,
     errorHandler: ((RustBuffer) throws -> E)?
 ) throws {
     switch callStatus.code {
         case CALL_SUCCESS:
             return
 
         case CALL_ERROR:
             if let errorHandler = errorHandler {
                 throw try errorHandler(callStatus.errorBuf)
             } else {
                 callStatus.errorBuf.deallocate()
                 throw UniffiInternalError.unexpectedRustCallError
             }
 
         case CALL_UNEXPECTED_ERROR:
             // When the rust code sees a panic, it tries to construct a RustBuffer
             // with the message.  But if that code panics, then it just sends back
             // an empty buffer.
             if callStatus.errorBuf.len > 0 {
                 throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf))
             } else {
                 callStatus.errorBuf.deallocate()
                 throw UniffiInternalError.rustPanic("Rust panic")
             }
 
         case CALL_CANCELLED:
             fatalError("Cancellation not supported yet")
 
         default:
             throw UniffiInternalError.unexpectedRustCallStatusCode
     }
 }
 
 private func uniffiTraitInterfaceCall<T>(
     callStatus: UnsafeMutablePointer<RustCallStatus>,
     makeCall: () throws -> T,
     writeReturn: (T) -> ()
 ) {
     do {
         try writeReturn(makeCall())
     } catch let error {
         callStatus.pointee.code = CALL_UNEXPECTED_ERROR
         callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
     }
 }
 
 private func uniffiTraitInterfaceCallWithError<T, E>(
     callStatus: UnsafeMutablePointer<RustCallStatus>,
     makeCall: () throws -> T,
     writeReturn: (T) -> (),
     lowerError: (E) -> RustBuffer
 ) {
     do {
         try writeReturn(makeCall())
     } catch let error as E {
         callStatus.pointee.code = CALL_ERROR
         callStatus.pointee.errorBuf = lowerError(error)
     } catch {
         callStatus.pointee.code = CALL_UNEXPECTED_ERROR
         callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
     }
 }
 fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
     // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
     private let lock = NSLock()
     private var map: [UInt64: T] = [:]
     private var currentHandle: UInt64 = 1
 
     func insert(obj: T) -> UInt64 {
         lock.withLock {
             let handle = currentHandle
             currentHandle += 1
             map[handle] = obj
             return handle
         }
     }
 
      func get(handle: UInt64) throws -> T {
         try lock.withLock {
             guard let obj = map[handle] else {
                 throw UniffiInternalError.unexpectedStaleHandle
             }
             return obj
         }
     }
 
     @discardableResult
     func remove(handle: UInt64) throws -> T {
         try lock.withLock {
             guard let obj = map.removeValue(forKey: handle) else {
                 throw UniffiInternalError.unexpectedStaleHandle
             }
             return obj
         }
     }
 
     var count: Int {
         get {
             map.count
         }
     }
 }
 
 
 // Public interface members begin here.
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterUInt16: FfiConverterPrimitive {
     typealias FfiType = UInt16
     typealias SwiftType = UInt16
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt16 {
         return try lift(readInt(&buf))
     }
 
     public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
         writeInt(&buf, lower(value))
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
     typealias FfiType = UInt32
     typealias SwiftType = UInt32
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
         return try lift(readInt(&buf))
     }
 
     public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
         writeInt(&buf, lower(value))
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
     typealias FfiType = UInt64
     typealias SwiftType = UInt64
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
         return try lift(readInt(&buf))
     }
 
     public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
         writeInt(&buf, lower(value))
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterBool : FfiConverter {
     typealias FfiType = Int8
     typealias SwiftType = Bool
 
     public static func lift(_ value: Int8) throws -> Bool {
         return value != 0
     }
 
     public static func lower(_ value: Bool) -> Int8 {
         return value ? 1 : 0
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
         return try lift(readInt(&buf))
     }
 
     public static func write(_ value: Bool, into buf: inout [UInt8]) {
         writeInt(&buf, lower(value))
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterString: FfiConverter {
     typealias SwiftType = String
     typealias FfiType = RustBuffer
 
     public static func lift(_ value: RustBuffer) throws -> String {
         defer {
             value.deallocate()
         }
         if value.data == nil {
             return String()
         }
         let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
         return String(bytes: bytes, encoding: String.Encoding.utf8)!
     }
 
     public static func lower(_ value: String) -> RustBuffer {
         return value.utf8CString.withUnsafeBufferPointer { ptr in
             // The swift string gives us int8_t, we want uint8_t.
             ptr.withMemoryRebound(to: UInt8.self) { ptr in
                 // The swift string gives us a trailing null byte, we don't want it.
                 let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
                 return RustBuffer.from(buf)
             }
         }
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
         let len: Int32 = try readInt(&buf)
         return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
     }
 
     public static func write(_ value: String, into buf: inout [UInt8]) {
         let len = Int32(value.utf8.count)
         writeInt(&buf, len)
         writeBytes(&buf, value.utf8)
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterData: FfiConverterRustBuffer {
     typealias SwiftType = Data
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
         let len: Int32 = try readInt(&buf)
         return Data(try readBytes(&buf, count: Int(len)))
     }
 
     public static func write(_ value: Data, into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         writeBytes(&buf, value)
     }
 }
 
 
 
 
 /**
  * Thread-safe mobile handle delegating lifecycle to [`radroots_sdk::Client`].
  */
 public protocol MobileClientProtocol: AnyObject, Sendable {
 
     /**
      * Returns stable capability DTOs without probing host resources.
      */
     func capabilities()  -> [CapabilityStatus]
 
     /**
      * Explicitly closes SDK-owned resources without installing a runtime.
      */
     func close() async throws
 
     /**
      * Returns whether explicit SDK close completed across all clones.
      */
     func isClosed()  -> Bool
 
 }
 /**
  * Thread-safe mobile handle delegating lifecycle to [`radroots_sdk::Client`].
  */
 open class MobileClient: MobileClientProtocol, @unchecked Sendable {
     fileprivate let pointer: UnsafeMutableRawPointer!
 
     /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public struct NoPointer {
         public init() {}
     }
 
     // TODO: We'd like this to be `private` but for Swifty reasons,
     // we can't implement `FfiConverter` without making this `required` and we can't
     // make it `required` without making it `public`.
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
         self.pointer = pointer
     }
 
     // This constructor can be used to instantiate a fake object.
     // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
     //
     // - Warning:
     //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public init(noPointer: NoPointer) {
         self.pointer = nil
     }
 
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
     public func uniffiClonePointer() -> UnsafeMutableRawPointer {
         return try! rustCall { uniffi_radroots_sdk_ffi_fn_clone_mobileclient(self.pointer, $0) }
     }
     // No primary constructor declared for this class.
 
     deinit {
         guard let pointer = pointer else {
             return
         }
 
         try! rustCall { uniffi_radroots_sdk_ffi_fn_free_mobileclient(pointer, $0) }
     }
 
 
     /**
      * Creates a deterministic, local-only memory client without I/O.
      */
 public static func memory()throws  -> MobileClient  {
     return try  FfiConverterTypeMobileClient_lift(try rustCallWithError(FfiConverterTypeError_lift) {
     uniffi_radroots_sdk_ffi_fn_constructor_mobileclient_memory($0
     )
 })
 }
 
 
 
     /**
      * Returns stable capability DTOs without probing host resources.
      */
 open func capabilities() -> [CapabilityStatus]  {
     return try!  FfiConverterSequenceTypeCapabilityStatus.lift(try! rustCall() {
     uniffi_radroots_sdk_ffi_fn_method_mobileclient_capabilities(self.uniffiClonePointer(),$0
     )
 })
 }
 
     /**
      * Explicitly closes SDK-owned resources without installing a runtime.
      */
 open func close()async throws   {
     return
         try  await uniffiRustCallAsync(
             rustFutureFunc: {
                 uniffi_radroots_sdk_ffi_fn_method_mobileclient_close(
                     self.uniffiClonePointer()
 
                 )
             },
             pollFunc: ffi_radroots_sdk_ffi_rust_future_poll_void,
             completeFunc: ffi_radroots_sdk_ffi_rust_future_complete_void,
             freeFunc: ffi_radroots_sdk_ffi_rust_future_free_void,
             liftFunc: { $0 },
             errorHandler: FfiConverterTypeError_lift
         )
 }
 
     /**
      * Returns whether explicit SDK close completed across all clones.
      */
 open func isClosed() -> Bool  {
     return try!  FfiConverterBool.lift(try! rustCall() {
     uniffi_radroots_sdk_ffi_fn_method_mobileclient_is_closed(self.uniffiClonePointer(),$0
     )
 })
 }
 
 
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeMobileClient: FfiConverter {
 
     typealias FfiType = UnsafeMutableRawPointer
     typealias SwiftType = MobileClient
 
     public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> MobileClient {
         return MobileClient(unsafeFromRawPointer: pointer)
     }
 
     public static func lower(_ value: MobileClient) -> UnsafeMutableRawPointer {
         return value.uniffiClonePointer()
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClient {
         let v: UInt64 = try readInt(&buf)
         // The Rust code won't compile if a pointer won't fit in a UInt64.
         // We have to go via `UInt` because that's the thing that's the size of a pointer.
         let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
         if (ptr == nil) {
             throw UniffiInternalError.unexpectedNullPointer
         }
         return try lift(ptr!)
     }
 
     public static func write(_ value: MobileClient, into buf: inout [UInt8]) {
         // This fiddling is because `Int` is the thing that's the same size as a pointer.
         // The Rust code won't compile if a pointer won't fit in a `UInt64`.
         writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeMobileClient_lift(_ pointer: UnsafeMutableRawPointer) throws -> MobileClient {
     return try FfiConverterTypeMobileClient.lift(pointer)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeMobileClient_lower(_ value: MobileClient) -> UnsafeMutableRawPointer {
     return FfiConverterTypeMobileClient.lower(value)
 }
 
 
 
 
 /**
  * Versioned, presentation-independent capability observation.
  */
 public struct CapabilityStatus {
     public var id: String
     public var compiled: Bool
     public var configured: Bool
     public var availability: CapabilityAvailability
     public var maturity: CapabilityMaturity
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(id: String, compiled: Bool, configured: Bool, availability: CapabilityAvailability, maturity: CapabilityMaturity) {
         self.id = id
         self.compiled = compiled
         self.configured = configured
         self.availability = availability
         self.maturity = maturity
     }
 }
 
 #if compiler(>=6)
 extension CapabilityStatus: Sendable {}
 #endif
 
 
 extension CapabilityStatus: Equatable, Hashable {
     public static func ==(lhs: CapabilityStatus, rhs: CapabilityStatus) -> Bool {
         if lhs.id != rhs.id {
             return false
         }
         if lhs.compiled != rhs.compiled {
             return false
         }
         if lhs.configured != rhs.configured {
             return false
         }
         if lhs.availability != rhs.availability {
             return false
         }
         if lhs.maturity != rhs.maturity {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(id)
         hasher.combine(compiled)
         hasher.combine(configured)
         hasher.combine(availability)
         hasher.combine(maturity)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeCapabilityStatus: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CapabilityStatus {
         return
             try CapabilityStatus(
                 id: FfiConverterString.read(from: &buf),
                 compiled: FfiConverterBool.read(from: &buf),
                 configured: FfiConverterBool.read(from: &buf),
                 availability: FfiConverterTypeCapabilityAvailability.read(from: &buf),
                 maturity: FfiConverterTypeCapabilityMaturity.read(from: &buf)
         )
     }
 
     public static func write(_ value: CapabilityStatus, into buf: inout [UInt8]) {
         FfiConverterString.write(value.id, into: &buf)
         FfiConverterBool.write(value.compiled, into: &buf)
         FfiConverterBool.write(value.configured, into: &buf)
         FfiConverterTypeCapabilityAvailability.write(value.availability, into: &buf)
         FfiConverterTypeCapabilityMaturity.write(value.maturity, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityStatus_lift(_ buf: RustBuffer) throws -> CapabilityStatus {
     return try FfiConverterTypeCapabilityStatus.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityStatus_lower(_ value: CapabilityStatus) -> RustBuffer {
     return FfiConverterTypeCapabilityStatus.lower(value)
 }
 
 
 /**
  * Verified final RHI attestation projection.
  */
 public struct RhiEvidenceAttestation {
     public var issuerPubkey: String
     public var tradeId: String
     public var claimMutationId: String
     public var outcome: TradeEvidenceOutcome
     public var observedAtUnixS: String
     public var tradeGeneration: String
     public var statementDigest: String
     public var supersession: RhiEvidenceSupersession?
     public var canonicalContent: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(issuerPubkey: String, tradeId: String, claimMutationId: String, outcome: TradeEvidenceOutcome, observedAtUnixS: String, tradeGeneration: String, statementDigest: String, supersession: RhiEvidenceSupersession?, canonicalContent: String) {
         self.issuerPubkey = issuerPubkey
         self.tradeId = tradeId
         self.claimMutationId = claimMutationId
         self.outcome = outcome
         self.observedAtUnixS = observedAtUnixS
         self.tradeGeneration = tradeGeneration
         self.statementDigest = statementDigest
         self.supersession = supersession
         self.canonicalContent = canonicalContent
     }
 }
 
 #if compiler(>=6)
 extension RhiEvidenceAttestation: Sendable {}
 #endif
 
 
 extension RhiEvidenceAttestation: Equatable, Hashable {
     public static func ==(lhs: RhiEvidenceAttestation, rhs: RhiEvidenceAttestation) -> Bool {
         if lhs.issuerPubkey != rhs.issuerPubkey {
             return false
         }
         if lhs.tradeId != rhs.tradeId {
             return false
         }
         if lhs.claimMutationId != rhs.claimMutationId {
             return false
         }
         if lhs.outcome != rhs.outcome {
             return false
         }
         if lhs.observedAtUnixS != rhs.observedAtUnixS {
             return false
         }
         if lhs.tradeGeneration != rhs.tradeGeneration {
             return false
         }
         if lhs.statementDigest != rhs.statementDigest {
             return false
         }
         if lhs.supersession != rhs.supersession {
             return false
         }
         if lhs.canonicalContent != rhs.canonicalContent {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(issuerPubkey)
         hasher.combine(tradeId)
         hasher.combine(claimMutationId)
         hasher.combine(outcome)
         hasher.combine(observedAtUnixS)
         hasher.combine(tradeGeneration)
         hasher.combine(statementDigest)
         hasher.combine(supersession)
         hasher.combine(canonicalContent)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeRhiEvidenceAttestation: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RhiEvidenceAttestation {
         return
             try RhiEvidenceAttestation(
                 issuerPubkey: FfiConverterString.read(from: &buf),
                 tradeId: FfiConverterString.read(from: &buf),
                 claimMutationId: FfiConverterString.read(from: &buf),
                 outcome: FfiConverterTypeTradeEvidenceOutcome.read(from: &buf),
                 observedAtUnixS: FfiConverterString.read(from: &buf),
                 tradeGeneration: FfiConverterString.read(from: &buf),
                 statementDigest: FfiConverterString.read(from: &buf),
                 supersession: FfiConverterOptionTypeRhiEvidenceSupersession.read(from: &buf),
                 canonicalContent: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: RhiEvidenceAttestation, into buf: inout [UInt8]) {
         FfiConverterString.write(value.issuerPubkey, into: &buf)
         FfiConverterString.write(value.tradeId, into: &buf)
         FfiConverterString.write(value.claimMutationId, into: &buf)
         FfiConverterTypeTradeEvidenceOutcome.write(value.outcome, into: &buf)
         FfiConverterString.write(value.observedAtUnixS, into: &buf)
         FfiConverterString.write(value.tradeGeneration, into: &buf)
         FfiConverterString.write(value.statementDigest, into: &buf)
         FfiConverterOptionTypeRhiEvidenceSupersession.write(value.supersession, into: &buf)
         FfiConverterString.write(value.canonicalContent, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceAttestation_lift(_ buf: RustBuffer) throws -> RhiEvidenceAttestation {
     return try FfiConverterTypeRhiEvidenceAttestation.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceAttestation_lower(_ value: RhiEvidenceAttestation) -> RustBuffer {
     return FfiConverterTypeRhiEvidenceAttestation.lower(value)
 }
 
 
 /**
  * Bounded projection of one canonical RHI evidence report.
  */
 public struct RhiEvidenceReport {
     public var contractId: String
     public var contractVersion: UInt16
     public var issuerPubkey: String
     public var tradeId: String
     public var claimMutationId: String
     public var outcome: TradeEvidenceOutcome
     public var reasonCodes: [String]
     public var projectionDigest: String
     public var evidenceManifestDigest: String
     public var evidencePolicyDigest: String
     public var observedAtUnixS: String
     public var tradeGeneration: String
     public var statementDigest: String
     public var supersession: RhiEvidenceSupersession?
     public var canonicalContent: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(contractId: String, contractVersion: UInt16, issuerPubkey: String, tradeId: String, claimMutationId: String, outcome: TradeEvidenceOutcome, reasonCodes: [String], projectionDigest: String, evidenceManifestDigest: String, evidencePolicyDigest: String, observedAtUnixS: String, tradeGeneration: String, statementDigest: String, supersession: RhiEvidenceSupersession?, canonicalContent: String) {
         self.contractId = contractId
         self.contractVersion = contractVersion
         self.issuerPubkey = issuerPubkey
         self.tradeId = tradeId
         self.claimMutationId = claimMutationId
         self.outcome = outcome
         self.reasonCodes = reasonCodes
         self.projectionDigest = projectionDigest
         self.evidenceManifestDigest = evidenceManifestDigest
         self.evidencePolicyDigest = evidencePolicyDigest
         self.observedAtUnixS = observedAtUnixS
         self.tradeGeneration = tradeGeneration
         self.statementDigest = statementDigest
         self.supersession = supersession
         self.canonicalContent = canonicalContent
     }
 }
 
 #if compiler(>=6)
 extension RhiEvidenceReport: Sendable {}
 #endif
 
 
 extension RhiEvidenceReport: Equatable, Hashable {
     public static func ==(lhs: RhiEvidenceReport, rhs: RhiEvidenceReport) -> Bool {
         if lhs.contractId != rhs.contractId {
             return false
         }
         if lhs.contractVersion != rhs.contractVersion {
             return false
         }
         if lhs.issuerPubkey != rhs.issuerPubkey {
             return false
         }
         if lhs.tradeId != rhs.tradeId {
             return false
         }
         if lhs.claimMutationId != rhs.claimMutationId {
             return false
         }
         if lhs.outcome != rhs.outcome {
             return false
         }
         if lhs.reasonCodes != rhs.reasonCodes {
             return false
         }
         if lhs.projectionDigest != rhs.projectionDigest {
             return false
         }
         if lhs.evidenceManifestDigest != rhs.evidenceManifestDigest {
             return false
         }
         if lhs.evidencePolicyDigest != rhs.evidencePolicyDigest {
             return false
         }
         if lhs.observedAtUnixS != rhs.observedAtUnixS {
             return false
         }
         if lhs.tradeGeneration != rhs.tradeGeneration {
             return false
         }
         if lhs.statementDigest != rhs.statementDigest {
             return false
         }
         if lhs.supersession != rhs.supersession {
             return false
         }
         if lhs.canonicalContent != rhs.canonicalContent {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(contractId)
         hasher.combine(contractVersion)
         hasher.combine(issuerPubkey)
         hasher.combine(tradeId)
         hasher.combine(claimMutationId)
         hasher.combine(outcome)
         hasher.combine(reasonCodes)
         hasher.combine(projectionDigest)
         hasher.combine(evidenceManifestDigest)
         hasher.combine(evidencePolicyDigest)
         hasher.combine(observedAtUnixS)
         hasher.combine(tradeGeneration)
         hasher.combine(statementDigest)
         hasher.combine(supersession)
         hasher.combine(canonicalContent)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeRhiEvidenceReport: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RhiEvidenceReport {
         return
             try RhiEvidenceReport(
                 contractId: FfiConverterString.read(from: &buf),
                 contractVersion: FfiConverterUInt16.read(from: &buf),
                 issuerPubkey: FfiConverterString.read(from: &buf),
                 tradeId: FfiConverterString.read(from: &buf),
                 claimMutationId: FfiConverterString.read(from: &buf),
                 outcome: FfiConverterTypeTradeEvidenceOutcome.read(from: &buf),
                 reasonCodes: FfiConverterSequenceString.read(from: &buf),
                 projectionDigest: FfiConverterString.read(from: &buf),
                 evidenceManifestDigest: FfiConverterString.read(from: &buf),
                 evidencePolicyDigest: FfiConverterString.read(from: &buf),
                 observedAtUnixS: FfiConverterString.read(from: &buf),
                 tradeGeneration: FfiConverterString.read(from: &buf),
                 statementDigest: FfiConverterString.read(from: &buf),
                 supersession: FfiConverterOptionTypeRhiEvidenceSupersession.read(from: &buf),
                 canonicalContent: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: RhiEvidenceReport, into buf: inout [UInt8]) {
         FfiConverterString.write(value.contractId, into: &buf)
         FfiConverterUInt16.write(value.contractVersion, into: &buf)
         FfiConverterString.write(value.issuerPubkey, into: &buf)
         FfiConverterString.write(value.tradeId, into: &buf)
         FfiConverterString.write(value.claimMutationId, into: &buf)
         FfiConverterTypeTradeEvidenceOutcome.write(value.outcome, into: &buf)
         FfiConverterSequenceString.write(value.reasonCodes, into: &buf)
         FfiConverterString.write(value.projectionDigest, into: &buf)
         FfiConverterString.write(value.evidenceManifestDigest, into: &buf)
         FfiConverterString.write(value.evidencePolicyDigest, into: &buf)
         FfiConverterString.write(value.observedAtUnixS, into: &buf)
         FfiConverterString.write(value.tradeGeneration, into: &buf)
         FfiConverterString.write(value.statementDigest, into: &buf)
         FfiConverterOptionTypeRhiEvidenceSupersession.write(value.supersession, into: &buf)
         FfiConverterString.write(value.canonicalContent, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceReport_lift(_ buf: RustBuffer) throws -> RhiEvidenceReport {
     return try FfiConverterTypeRhiEvidenceReport.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceReport_lower(_ value: RhiEvidenceReport) -> RustBuffer {
     return FfiConverterTypeRhiEvidenceReport.lower(value)
 }
 
 
 /**
  * Exact immutable RHI supersession reference.
  */
 public struct RhiEvidenceSupersession {
     public var reportId: String
     public var eventId: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(reportId: String, eventId: String) {
         self.reportId = reportId
         self.eventId = eventId
     }
 }
 
 #if compiler(>=6)
 extension RhiEvidenceSupersession: Sendable {}
 #endif
 
 
 extension RhiEvidenceSupersession: Equatable, Hashable {
     public static func ==(lhs: RhiEvidenceSupersession, rhs: RhiEvidenceSupersession) -> Bool {
         if lhs.reportId != rhs.reportId {
             return false
         }
         if lhs.eventId != rhs.eventId {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(reportId)
         hasher.combine(eventId)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeRhiEvidenceSupersession: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RhiEvidenceSupersession {
         return
             try RhiEvidenceSupersession(
                 reportId: FfiConverterString.read(from: &buf),
                 eventId: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: RhiEvidenceSupersession, into buf: inout [UInt8]) {
         FfiConverterString.write(value.reportId, into: &buf)
         FfiConverterString.write(value.eventId, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceSupersession_lift(_ buf: RustBuffer) throws -> RhiEvidenceSupersession {
     return try FfiConverterTypeRhiEvidenceSupersession.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeRhiEvidenceSupersession_lower(_ value: RhiEvidenceSupersession) -> RustBuffer {
     return FfiConverterTypeRhiEvidenceSupersession.lower(value)
 }
 
 
 /**
  * Signed NIP-01 event input for verified attestation admission.
  */
 public struct SignedEvent {
     public var id: String
     public var authorPubkey: String
     public var createdAtUnixS: UInt64
     public var kind: UInt32
     public var tags: [[String]]
     public var content: String
     public var signature: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(id: String, authorPubkey: String, createdAtUnixS: UInt64, kind: UInt32, tags: [[String]], content: String, signature: String) {
         self.id = id
         self.authorPubkey = authorPubkey
         self.createdAtUnixS = createdAtUnixS
         self.kind = kind
         self.tags = tags
         self.content = content
         self.signature = signature
     }
 }
 
 #if compiler(>=6)
 extension SignedEvent: Sendable {}
 #endif
 
 
 extension SignedEvent: Equatable, Hashable {
     public static func ==(lhs: SignedEvent, rhs: SignedEvent) -> Bool {
         if lhs.id != rhs.id {
             return false
         }
         if lhs.authorPubkey != rhs.authorPubkey {
             return false
         }
         if lhs.createdAtUnixS != rhs.createdAtUnixS {
             return false
         }
         if lhs.kind != rhs.kind {
             return false
         }
         if lhs.tags != rhs.tags {
             return false
         }
         if lhs.content != rhs.content {
             return false
         }
         if lhs.signature != rhs.signature {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(id)
         hasher.combine(authorPubkey)
         hasher.combine(createdAtUnixS)
         hasher.combine(kind)
         hasher.combine(tags)
         hasher.combine(content)
         hasher.combine(signature)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeSignedEvent: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SignedEvent {
         return
             try SignedEvent(
                 id: FfiConverterString.read(from: &buf),
                 authorPubkey: FfiConverterString.read(from: &buf),
                 createdAtUnixS: FfiConverterUInt64.read(from: &buf),
                 kind: FfiConverterUInt32.read(from: &buf),
                 tags: FfiConverterSequenceSequenceString.read(from: &buf),
                 content: FfiConverterString.read(from: &buf),
                 signature: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: SignedEvent, into buf: inout [UInt8]) {
         FfiConverterString.write(value.id, into: &buf)
         FfiConverterString.write(value.authorPubkey, into: &buf)
         FfiConverterUInt64.write(value.createdAtUnixS, into: &buf)
         FfiConverterUInt32.write(value.kind, into: &buf)
         FfiConverterSequenceSequenceString.write(value.tags, into: &buf)
         FfiConverterString.write(value.content, into: &buf)
         FfiConverterString.write(value.signature, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeSignedEvent_lift(_ buf: RustBuffer) throws -> SignedEvent {
     return try FfiConverterTypeSignedEvent.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeSignedEvent_lower(_ value: SignedEvent) -> RustBuffer {
     return FfiConverterTypeSignedEvent.lower(value)
 }
 
 
 /**
  * Bounded projection of one canonical evidence manifest.
  */
 public struct TradeEvidenceManifest {
     public var contractId: String
     public var contractVersion: UInt16
     public var tradeId: String
     public var tradeGeneration: String
     public var observedAtUnixS: String
     public var coverage: TradeEvidenceCoverage
     public var evidencePolicyDigest: String
     public var manifestDigest: String
     public var canonicalBytesHex: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(contractId: String, contractVersion: UInt16, tradeId: String, tradeGeneration: String, observedAtUnixS: String, coverage: TradeEvidenceCoverage, evidencePolicyDigest: String, manifestDigest: String, canonicalBytesHex: String) {
         self.contractId = contractId
         self.contractVersion = contractVersion
         self.tradeId = tradeId
         self.tradeGeneration = tradeGeneration
         self.observedAtUnixS = observedAtUnixS
         self.coverage = coverage
         self.evidencePolicyDigest = evidencePolicyDigest
         self.manifestDigest = manifestDigest
         self.canonicalBytesHex = canonicalBytesHex
     }
 }
 
 #if compiler(>=6)
 extension TradeEvidenceManifest: Sendable {}
 #endif
 
 
 extension TradeEvidenceManifest: Equatable, Hashable {
     public static func ==(lhs: TradeEvidenceManifest, rhs: TradeEvidenceManifest) -> Bool {
         if lhs.contractId != rhs.contractId {
             return false
         }
         if lhs.contractVersion != rhs.contractVersion {
             return false
         }
         if lhs.tradeId != rhs.tradeId {
             return false
         }
         if lhs.tradeGeneration != rhs.tradeGeneration {
             return false
         }
         if lhs.observedAtUnixS != rhs.observedAtUnixS {
             return false
         }
         if lhs.coverage != rhs.coverage {
             return false
         }
         if lhs.evidencePolicyDigest != rhs.evidencePolicyDigest {
             return false
         }
         if lhs.manifestDigest != rhs.manifestDigest {
             return false
         }
         if lhs.canonicalBytesHex != rhs.canonicalBytesHex {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(contractId)
         hasher.combine(contractVersion)
         hasher.combine(tradeId)
         hasher.combine(tradeGeneration)
         hasher.combine(observedAtUnixS)
         hasher.combine(coverage)
         hasher.combine(evidencePolicyDigest)
         hasher.combine(manifestDigest)
         hasher.combine(canonicalBytesHex)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeTradeEvidenceManifest: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TradeEvidenceManifest {
         return
             try TradeEvidenceManifest(
                 contractId: FfiConverterString.read(from: &buf),
                 contractVersion: FfiConverterUInt16.read(from: &buf),
                 tradeId: FfiConverterString.read(from: &buf),
                 tradeGeneration: FfiConverterString.read(from: &buf),
                 observedAtUnixS: FfiConverterString.read(from: &buf),
                 coverage: FfiConverterTypeTradeEvidenceCoverage.read(from: &buf),
                 evidencePolicyDigest: FfiConverterString.read(from: &buf),
                 manifestDigest: FfiConverterString.read(from: &buf),
                 canonicalBytesHex: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: TradeEvidenceManifest, into buf: inout [UInt8]) {
         FfiConverterString.write(value.contractId, into: &buf)
         FfiConverterUInt16.write(value.contractVersion, into: &buf)
         FfiConverterString.write(value.tradeId, into: &buf)
         FfiConverterString.write(value.tradeGeneration, into: &buf)
         FfiConverterString.write(value.observedAtUnixS, into: &buf)
         FfiConverterTypeTradeEvidenceCoverage.write(value.coverage, into: &buf)
         FfiConverterString.write(value.evidencePolicyDigest, into: &buf)
         FfiConverterString.write(value.manifestDigest, into: &buf)
         FfiConverterString.write(value.canonicalBytesHex, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceManifest_lift(_ buf: RustBuffer) throws -> TradeEvidenceManifest {
     return try FfiConverterTypeTradeEvidenceManifest.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceManifest_lower(_ value: TradeEvidenceManifest) -> RustBuffer {
     return FfiConverterTypeTradeEvidenceManifest.lower(value)
 }
 
 
 /**
  * One unsigned typed event plan ready for host-owned signing.
  */
 public struct TypedEvidenceEventPlan {
     public var contractId: String
     public var kind: UInt32
     public var authorPubkey: String
     public var createdAtUnixS: String
     public var expectedEventId: String
     public var tags: [[String]]
     public var content: String
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(contractId: String, kind: UInt32, authorPubkey: String, createdAtUnixS: String, expectedEventId: String, tags: [[String]], content: String) {
         self.contractId = contractId
         self.kind = kind
         self.authorPubkey = authorPubkey
         self.createdAtUnixS = createdAtUnixS
         self.expectedEventId = expectedEventId
         self.tags = tags
         self.content = content
     }
 }
 
 #if compiler(>=6)
 extension TypedEvidenceEventPlan: Sendable {}
 #endif
 
 
 extension TypedEvidenceEventPlan: Equatable, Hashable {
     public static func ==(lhs: TypedEvidenceEventPlan, rhs: TypedEvidenceEventPlan) -> Bool {
         if lhs.contractId != rhs.contractId {
             return false
         }
         if lhs.kind != rhs.kind {
             return false
         }
         if lhs.authorPubkey != rhs.authorPubkey {
             return false
         }
         if lhs.createdAtUnixS != rhs.createdAtUnixS {
             return false
         }
         if lhs.expectedEventId != rhs.expectedEventId {
             return false
         }
         if lhs.tags != rhs.tags {
             return false
         }
         if lhs.content != rhs.content {
             return false
         }
         return true
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(contractId)
         hasher.combine(kind)
         hasher.combine(authorPubkey)
         hasher.combine(createdAtUnixS)
         hasher.combine(expectedEventId)
         hasher.combine(tags)
         hasher.combine(content)
     }
 }
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeTypedEvidenceEventPlan: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TypedEvidenceEventPlan {
         return
             try TypedEvidenceEventPlan(
                 contractId: FfiConverterString.read(from: &buf),
                 kind: FfiConverterUInt32.read(from: &buf),
                 authorPubkey: FfiConverterString.read(from: &buf),
                 createdAtUnixS: FfiConverterString.read(from: &buf),
                 expectedEventId: FfiConverterString.read(from: &buf),
                 tags: FfiConverterSequenceSequenceString.read(from: &buf),
                 content: FfiConverterString.read(from: &buf)
         )
     }
 
     public static func write(_ value: TypedEvidenceEventPlan, into buf: inout [UInt8]) {
         FfiConverterString.write(value.contractId, into: &buf)
         FfiConverterUInt32.write(value.kind, into: &buf)
         FfiConverterString.write(value.authorPubkey, into: &buf)
         FfiConverterString.write(value.createdAtUnixS, into: &buf)
         FfiConverterString.write(value.expectedEventId, into: &buf)
         FfiConverterSequenceSequenceString.write(value.tags, into: &buf)
         FfiConverterString.write(value.content, into: &buf)
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTypedEvidenceEventPlan_lift(_ buf: RustBuffer) throws -> TypedEvidenceEventPlan {
     return try FfiConverterTypeTypedEvidenceEventPlan.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTypedEvidenceEventPlan_lower(_ value: TypedEvidenceEventPlan) -> RustBuffer {
     return FfiConverterTypeTypedEvidenceEventPlan.lower(value)
 }
 
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**
  * Current side-effect-free capability availability.
  */
 
 public enum CapabilityAvailability {
 
     case available
     case degraded
     case unavailable
     case unsupported
 }
 
 
 #if compiler(>=6)
 extension CapabilityAvailability: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeCapabilityAvailability: FfiConverterRustBuffer {
     typealias SwiftType = CapabilityAvailability
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CapabilityAvailability {
         let variant: Int32 = try readInt(&buf)
         switch variant {
 
         case 1: return .available
 
         case 2: return .degraded
 
         case 3: return .unavailable
 
         case 4: return .unsupported
 
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
     public static func write(_ value: CapabilityAvailability, into buf: inout [UInt8]) {
         switch value {
 
 
         case .available:
             writeInt(&buf, Int32(1))
 
 
         case .degraded:
             writeInt(&buf, Int32(2))
 
 
         case .unavailable:
             writeInt(&buf, Int32(3))
 
 
         case .unsupported:
             writeInt(&buf, Int32(4))
 
         }
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityAvailability_lift(_ buf: RustBuffer) throws -> CapabilityAvailability {
     return try FfiConverterTypeCapabilityAvailability.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityAvailability_lower(_ value: CapabilityAvailability) -> RustBuffer {
     return FfiConverterTypeCapabilityAvailability.lower(value)
 }
 
 
 extension CapabilityAvailability: Equatable, Hashable {}
 
 
 
 
 
 
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**
  * Stable capability maturity independent of runtime availability.
  */
 
 public enum CapabilityMaturity {
 
     case stable
     case preview
     case experimental
 }
 
 
 #if compiler(>=6)
 extension CapabilityMaturity: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeCapabilityMaturity: FfiConverterRustBuffer {
     typealias SwiftType = CapabilityMaturity
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CapabilityMaturity {
         let variant: Int32 = try readInt(&buf)
         switch variant {
 
         case 1: return .stable
 
         case 2: return .preview
 
         case 3: return .experimental
 
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
     public static func write(_ value: CapabilityMaturity, into buf: inout [UInt8]) {
         switch value {
 
 
         case .stable:
             writeInt(&buf, Int32(1))
 
 
         case .preview:
             writeInt(&buf, Int32(2))
 
 
         case .experimental:
             writeInt(&buf, Int32(3))
 
         }
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityMaturity_lift(_ buf: RustBuffer) throws -> CapabilityMaturity {
     return try FfiConverterTypeCapabilityMaturity.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeCapabilityMaturity_lower(_ value: CapabilityMaturity) -> RustBuffer {
     return FfiConverterTypeCapabilityMaturity.lower(value)
 }
 
 
 extension CapabilityMaturity: Equatable, Hashable {}
 
 
 
 
 
 
 
 /**
  * Secret-safe SDK failure at the language boundary.
  */
 public enum Error: Swift.Error {
 
 
 
     case Sdk(code: String, message: String, retryable: Bool
     )
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeError: FfiConverterRustBuffer {
     typealias SwiftType = Error
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Error {
         let variant: Int32 = try readInt(&buf)
         switch variant {
 
 
 
 
         case 1: return .Sdk(
             code: try FfiConverterString.read(from: &buf),
             message: try FfiConverterString.read(from: &buf),
             retryable: try FfiConverterBool.read(from: &buf)
             )
 
          default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
     public static func write(_ value: Error, into buf: inout [UInt8]) {
         switch value {
 
 
 
 
 
         case let .Sdk(code,message,retryable):
             writeInt(&buf, Int32(1))
             FfiConverterString.write(code, into: &buf)
             FfiConverterString.write(message, into: &buf)
             FfiConverterBool.write(retryable, into: &buf)
 
         }
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeError_lift(_ buf: RustBuffer) throws -> Error {
     return try FfiConverterTypeError.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeError_lower(_ value: Error) -> RustBuffer {
     return FfiConverterTypeError.lower(value)
 }
 
 
 extension Error: Equatable, Hashable {}
 
 
 
 
 extension Error: Foundation.LocalizedError {
     public var errorDescription: String? {
         String(reflecting: self)
     }
 }
 
 
 
 
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**
  * Final evidence coverage vocabulary.
  */
 
 public enum TradeEvidenceCoverage {
 
     case missing
     case partial
     case scopeSatisfied
     case unsupported
 }
 
 
 #if compiler(>=6)
 extension TradeEvidenceCoverage: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeTradeEvidenceCoverage: FfiConverterRustBuffer {
     typealias SwiftType = TradeEvidenceCoverage
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TradeEvidenceCoverage {
         let variant: Int32 = try readInt(&buf)
         switch variant {
 
         case 1: return .missing
 
         case 2: return .partial
 
         case 3: return .scopeSatisfied
 
         case 4: return .unsupported
 
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
     public static func write(_ value: TradeEvidenceCoverage, into buf: inout [UInt8]) {
         switch value {
 
 
         case .missing:
             writeInt(&buf, Int32(1))
 
 
         case .partial:
             writeInt(&buf, Int32(2))
 
 
         case .scopeSatisfied:
             writeInt(&buf, Int32(3))
 
 
         case .unsupported:
             writeInt(&buf, Int32(4))
 
         }
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceCoverage_lift(_ buf: RustBuffer) throws -> TradeEvidenceCoverage {
     return try FfiConverterTypeTradeEvidenceCoverage.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceCoverage_lower(_ value: TradeEvidenceCoverage) -> RustBuffer {
     return FfiConverterTypeTradeEvidenceCoverage.lower(value)
 }
 
 
 extension TradeEvidenceCoverage: Equatable, Hashable {}
 
 
 
 
 
 
 // Note that we don't yet support `indirect` for enums.
 // See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
 /**
  * Final evidence outcome vocabulary.
  */
 
 public enum TradeEvidenceOutcome {
 
     case valid
     case invalid
     case indeterminate
 }
 
 
 #if compiler(>=6)
 extension TradeEvidenceOutcome: Sendable {}
 #endif
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public struct FfiConverterTypeTradeEvidenceOutcome: FfiConverterRustBuffer {
     typealias SwiftType = TradeEvidenceOutcome
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TradeEvidenceOutcome {
         let variant: Int32 = try readInt(&buf)
         switch variant {
 
         case 1: return .valid
 
         case 2: return .invalid
 
         case 3: return .indeterminate
 
         default: throw UniffiInternalError.unexpectedEnumCase
         }
     }
 
     public static func write(_ value: TradeEvidenceOutcome, into buf: inout [UInt8]) {
         switch value {
 
 
         case .valid:
             writeInt(&buf, Int32(1))
 
 
         case .invalid:
             writeInt(&buf, Int32(2))
 
 
         case .indeterminate:
             writeInt(&buf, Int32(3))
 
         }
     }
 }
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceOutcome_lift(_ buf: RustBuffer) throws -> TradeEvidenceOutcome {
     return try FfiConverterTypeTradeEvidenceOutcome.lift(buf)
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 public func FfiConverterTypeTradeEvidenceOutcome_lower(_ value: TradeEvidenceOutcome) -> RustBuffer {
     return FfiConverterTypeTradeEvidenceOutcome.lower(value)
 }
 
 
 extension TradeEvidenceOutcome: Equatable, Hashable {}
 
 
 
 
 
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterOptionTypeRhiEvidenceSupersession: FfiConverterRustBuffer {
     typealias SwiftType = RhiEvidenceSupersession?
 
     public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
         guard let value = value else {
             writeInt(&buf, Int8(0))
             return
         }
         writeInt(&buf, Int8(1))
         FfiConverterTypeRhiEvidenceSupersession.write(value, into: &buf)
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
         switch try readInt(&buf) as Int8 {
         case 0: return nil
         case 1: return try FfiConverterTypeRhiEvidenceSupersession.read(from: &buf)
         default: throw UniffiInternalError.unexpectedOptionalTag
         }
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
     typealias SwiftType = [String]
 
     public static func write(_ value: [String], into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         for item in value {
             FfiConverterString.write(item, into: &buf)
         }
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
         let len: Int32 = try readInt(&buf)
         var seq = [String]()
         seq.reserveCapacity(Int(len))
         for _ in 0 ..< len {
             seq.append(try FfiConverterString.read(from: &buf))
         }
         return seq
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterSequenceTypeCapabilityStatus: FfiConverterRustBuffer {
     typealias SwiftType = [CapabilityStatus]
 
     public static func write(_ value: [CapabilityStatus], into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         for item in value {
             FfiConverterTypeCapabilityStatus.write(item, into: &buf)
         }
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CapabilityStatus] {
         let len: Int32 = try readInt(&buf)
         var seq = [CapabilityStatus]()
         seq.reserveCapacity(Int(len))
         for _ in 0 ..< len {
             seq.append(try FfiConverterTypeCapabilityStatus.read(from: &buf))
         }
         return seq
     }
 }
 
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
 fileprivate struct FfiConverterSequenceSequenceString: FfiConverterRustBuffer {
     typealias SwiftType = [[String]]
 
     public static func write(_ value: [[String]], into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         for item in value {
             FfiConverterSequenceString.write(item, into: &buf)
         }
     }
 
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [[String]] {
         let len: Int32 = try readInt(&buf)
         var seq = [[String]]()
         seq.reserveCapacity(Int(len))
         for _ in 0 ..< len {
             seq.append(try FfiConverterSequenceString.read(from: &buf))
         }
         return seq
     }
 }
 private let UNIFFI_RUST_FUTURE_POLL_READY: Int8 = 0
 private let UNIFFI_RUST_FUTURE_POLL_MAYBE_READY: Int8 = 1
 
 fileprivate let uniffiContinuationHandleMap = UniffiHandleMap<UnsafeContinuation<Int8, Never>>()
 
 fileprivate func uniffiRustCallAsync<F, T>(
     rustFutureFunc: () -> UInt64,
     pollFunc: (UInt64, @escaping UniffiRustFutureContinuationCallback, UInt64) -> (),
     completeFunc: (UInt64, UnsafeMutablePointer<RustCallStatus>) -> F,
     freeFunc: (UInt64) -> (),
     liftFunc: (F) throws -> T,
     errorHandler: ((RustBuffer) throws -> Swift.Error)?
 ) async throws -> T {
     // Make sure to call the ensure init function since future creation doesn't have a
     // RustCallStatus param, so doesn't use makeRustCall()
     uniffiEnsureRadrootsSdkFfiInitialized()
     let rustFuture = rustFutureFunc()
     defer {
         freeFunc(rustFuture)
     }
     var pollResult: Int8;
     repeat {
         pollResult = await withUnsafeContinuation {
             pollFunc(
                 rustFuture,
                 uniffiFutureContinuationCallback,
                 uniffiContinuationHandleMap.insert(obj: $0)
             )
         }
     } while pollResult != UNIFFI_RUST_FUTURE_POLL_READY
 
     return try liftFunc(makeRustCall(
         { completeFunc(rustFuture, $0) },
         errorHandler: errorHandler
     ))
 }
 
 // Callback handlers for an async calls.  These are invoked by Rust when the future is ready.  They
 // lift the return value or error and resume the suspended function.
 fileprivate func uniffiFutureContinuationCallback(handle: UInt64, pollResult: Int8) {
     if let continuation = try? uniffiContinuationHandleMap.remove(handle: handle) {
         continuation.resume(returning: pollResult)
     } else {
         print("uniffiFutureContinuationCallback invalid handle")
     }
 }
 public func parseRhiEvidenceReport(canonicalContent: String)throws  -> RhiEvidenceReport  {
     return try  FfiConverterTypeRhiEvidenceReport_lift(try rustCallWithError(FfiConverterTypeError_lift) {
     uniffi_radroots_sdk_ffi_fn_func_parse_rhi_evidence_report(
         FfiConverterString.lower(canonicalContent),$0
     )
 })
 }
 public func parseTradeEvidenceManifest(canonicalBytes: Data)throws  -> TradeEvidenceManifest  {
     return try  FfiConverterTypeTradeEvidenceManifest_lift(try rustCallWithError(FfiConverterTypeError_lift) {
     uniffi_radroots_sdk_ffi_fn_func_parse_trade_evidence_manifest(
         FfiConverterData.lower(canonicalBytes),$0
     )
 })
 }
 public func prepareRhiEvidenceAttestation(canonicalContent: String, createdAtUnixS: UInt64)throws  -> TypedEvidenceEventPlan  {
     return try  FfiConverterTypeTypedEvidenceEventPlan_lift(try rustCallWithError(FfiConverterTypeError_lift) {
     uniffi_radroots_sdk_ffi_fn_func_prepare_rhi_evidence_attestation(
         FfiConverterString.lower(canonicalContent),
         FfiConverterUInt64.lower(createdAtUnixS),$0
     )
 })
 }
 public func validateRhiEvidenceAttestation(event: SignedEvent)throws  -> RhiEvidenceAttestation  {
     return try  FfiConverterTypeRhiEvidenceAttestation_lift(try rustCallWithError(FfiConverterTypeError_lift) {
     uniffi_radroots_sdk_ffi_fn_func_validate_rhi_evidence_attestation(
         FfiConverterTypeSignedEvent_lower(event),$0
     )
 })
 }
 
 private enum InitializationResult {
     case ok
     case contractVersionMismatch
     case apiChecksumMismatch
 }
 // Use a global variable to perform the versioning checks. Swift ensures that
 // the code inside is only computed once.
 private let initializationResult: InitializationResult = {
     // Get the bindings contract version from our ComponentInterface
     let bindings_contract_version = 29
     // Get the scaffolding contract version by calling the into the dylib
     let scaffolding_contract_version = ffi_radroots_sdk_ffi_uniffi_contract_version()
     if bindings_contract_version != scaffolding_contract_version {
         return InitializationResult.contractVersionMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_func_parse_rhi_evidence_report() != 37549) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_func_parse_trade_evidence_manifest() != 35922) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_func_prepare_rhi_evidence_attestation() != 53127) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_func_validate_rhi_evidence_attestation() != 46555) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_method_mobileclient_capabilities() != 23938) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_method_mobileclient_close() != 15210) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_method_mobileclient_is_closed() != 40205) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_radroots_sdk_ffi_checksum_constructor_mobileclient_memory() != 50243) {
         return InitializationResult.apiChecksumMismatch
     }
 
     return InitializationResult.ok
 }()
 
 // Make the ensure init function public so that other modules which have external type references to
 // our types can call it.
 public func uniffiEnsureRadrootsSdkFfiInitialized() {
     switch initializationResult {
     case .ok:
         break
     case .contractVersionMismatch:
         fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
     case .apiChecksumMismatch:
         fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
 }
 
 // swiftlint:enable all