IronStorage/apple/Generated/ironstorage_mobile.swift

// 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(ironstorage_mobileFFI)
import ironstorage_mobileFFI
#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_ironstorage_mobile_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_ironstorage_mobile_rustbuffer_free(self, $0) }
    }
}

fileprivate extension ForeignBytes {
    init(bufferPointer: UnsafeBufferPointer<UInt8>) {
        self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
    }

    init(rawBufferPointer: UnsafeRawBufferPointer) {
        self.init(
            len: Int32(rawBufferPointer.count),
            data: rawBufferPointer.baseAddress?.assumingMemoryBound(to: UInt8.self)
        )
    }
}

// Converter for `&[u8]` / `[ByRef] bytes` arguments.
//
// Conforms to `FfiConverter` so the compiler enforces the full converter
// method set. Only the scope-bound `lower(_:_body:)` overload is sound —
// zero-copy byte buffers only flow foreign -> Rust, and only in argument
// position. The four protocol-witness methods (`lift`, `lower`, `read`,
// `write`) `fatalError` at runtime if anyone reaches them.
//
// The scope-bound `lower` takes a closure because the `ForeignBytes`
// pointer is only guaranteed valid for the duration of
// `Data.withUnsafeBytes`. Callers must run the full FFI call inside
// the closure body.
fileprivate enum FfiConverterByRefBytes: FfiConverter {
    typealias SwiftType = Data
    typealias FfiType = ForeignBytes

    static func lower<R>(_ value: Data, _ body: (ForeignBytes) throws -> R) rethrows -> R {
        return try value.withUnsafeBytes { rawBuf in
            try body(ForeignBytes(rawBufferPointer: rawBuf))
        }
    }

    static func lower(_ value: Data) -> ForeignBytes {
        fatalError("ByRef bytes cannot use the plain lower: returning ForeignBytes escapes the Data.withUnsafeBytes scope. Use the scope-bound lower(_:_body:) overload instead.")
    }

    static func lift(_ value: ForeignBytes) throws -> Data {
        fatalError("ByRef bytes cannot be lifted: zero-copy &[u8] only flows foreign->Rust")
    }

    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
        fatalError("ByRef bytes cannot be read from a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
    }

    static func write(_ value: Data, into buf: inout [UInt8]) {
        fatalError("ByRef bytes cannot be written to a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
    }
}

// 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 .rustPanic: return "Native Rust failure ([REDACTED])"
        }
    }
}

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 {
    uniffiEnsureIronstorageMobileInitialized()
    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 {
                _ = try FfiConverterString.lift(callStatus.errorBuf)
                throw UniffiInternalError.rustPanic("Native Rust failure ([REDACTED])")
            } 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 {
        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
        callStatus.pointee.errorBuf = FfiConverterString.lower("Native callback failed ([REDACTED])")
    }
}

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("Native callback failed ([REDACTED])")
    }
}
// Initial value and increment amount for handles.
// These ensure that SWIFT handles always have the lowest bit set
fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1
fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2

fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
    // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
    private let lock = NSLock()
    private var map: [UInt64: T] = [:]
    private var currentHandle: UInt64 = UNIFFI_HANDLEMAP_INITIAL

    func insert(obj: T) -> UInt64 {
        lock.withLock {
            return doInsert(obj)
        }
    }

    // Low-level insert function, this assumes `lock` is held.
    private func doInsert(_ obj: T) -> UInt64 {
        let handle = currentHandle
        currentHandle += UNIFFI_HANDLEMAP_DELTA
        map[handle] = obj
        return handle
    }

     func get(handle: UInt64) throws -> T {
        try lock.withLock {
            guard let obj = map[handle] else {
                throw UniffiInternalError.unexpectedStaleHandle
            }
            return obj
        }
    }

     func clone(handle: UInt64) throws -> UInt64 {
        try lock.withLock {
            guard let obj = map[handle] else {
                throw UniffiInternalError.unexpectedStaleHandle
            }
            return doInsert(obj)
        }
    }

    @discardableResult
    func remove(handle: UInt64) throws -> T {
        try lock.withLock {
            guard let obj = map.removeValue(forKey: handle) else {
                throw UniffiInternalError.unexpectedStaleHandle
            }
            return obj
        }
    }

    var count: Int {
        get {
            map.count
        }
    }
}


// Public interface members begin here.
// Magic number for the Rust proxy to call using the same mechanism as every other method,
// to free the callback once it's dropped by Rust.
private let IDX_CALLBACK_FREE: Int32 = 0
// Callback return codes
private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
private let UNIFFI_CALLBACK_ERROR: Int32 = 1
private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct 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 FfiConverterInt64: FfiConverterPrimitive {
    typealias FfiType = Int64
    typealias SwiftType = Int64

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int64 {
        return try lift(readInt(&buf))
    }

    public static func write(_ value: Int64, 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))
        // Use Swift's native UTF-8 decoder; `String(bytes:encoding:.utf8)` goes
        // through Foundation's NSString and silently strips a leading U+FEFF BOM.
        // Invalid UTF-8 substitutes U+FFFD instead of trapping (unreachable
        // given Rust's `String` invariant).
        return String(decoding: bytes, as: UTF8.self)
    }

    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)
        // See `lift` above for why we avoid Foundation's NSString-backed decoder here.
        return String(decoding: try readBytes(&buf, count: Int(len)), as: UTF8.self)
    }

    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)
    }
}




public protocol MobileAndroidKeystore: AnyObject, Sendable {

    func deviceState() throws  -> MobileAndroidDeviceState

    func createKey(specification: MobileAndroidKeySpecification) throws

    func encrypt(alias: String, authorization: MobileAndroidAuthorization, aad: Data, value: Data) throws  -> MobileAndroidCiphertext

    func decrypt(alias: String, authorization: MobileAndroidAuthorization, aad: Data, value: MobileAndroidCiphertext) throws  -> Data

    func deleteKey(alias: String) throws

    func aliases() throws  -> [String]

    func cancelPending()

}
open class MobileAndroidKeystoreImpl: MobileAndroidKeystore, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileandroidkeystore(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileandroidkeystore(handle, $0) }
    }




open func deviceState()throws  -> MobileAndroidDeviceState  {
    return try  FfiConverterTypeMobileAndroidDeviceState_lift(try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_device_state(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func createKey(specification: MobileAndroidKeySpecification)throws   {try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_create_key(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileAndroidKeySpecification_lower(specification),uniffiCallStatus
    )
}
}

open func encrypt(alias: String, authorization: MobileAndroidAuthorization, aad: Data, value: Data)throws  -> MobileAndroidCiphertext  {
    return try  FfiConverterTypeMobileAndroidCiphertext_lift(try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_encrypt(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(alias),
        FfiConverterTypeMobileAndroidAuthorization_lower(authorization),
        FfiConverterData.lower(aad),
        FfiConverterData.lower(value),uniffiCallStatus
    )
})
}

open func decrypt(alias: String, authorization: MobileAndroidAuthorization, aad: Data, value: MobileAndroidCiphertext)throws  -> Data  {
    return try  FfiConverterData.lift(try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_decrypt(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(alias),
        FfiConverterTypeMobileAndroidAuthorization_lower(authorization),
        FfiConverterData.lower(aad),
        FfiConverterTypeMobileAndroidCiphertext_lower(value),uniffiCallStatus
    )
})
}

open func deleteKey(alias: String)throws   {try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_delete_key(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(alias),uniffiCallStatus
    )
}
}

open func aliases()throws  -> [String]  {
    return try  FfiConverterSequenceString.lift(try rustCallWithError(FfiConverterTypeMobileAndroidKeystoreError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_aliases(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func cancelPending()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidkeystore_cancel_pending(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}



}



// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceMobileAndroidKeystore {

    // Create the VTable using a series of closures.
    // Swift automatically converts these into C callback functions.
    //
    // Store the vtable directly.
    static let vtable: UniffiVTableCallbackInterfaceMobileAndroidKeystore = UniffiVTableCallbackInterfaceMobileAndroidKeystore(
        uniffiFree: { (uniffiHandle: UInt64) -> () in
            do {
                try FfiConverterTypeMobileAndroidKeystore.handleMap.remove(handle: uniffiHandle)
            } catch {
                print("Uniffi callback interface MobileAndroidKeystore: handle missing in uniffiFree")
            }
        },
        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
            do {
                return try FfiConverterTypeMobileAndroidKeystore.handleMap.clone(handle: uniffiHandle)
            } catch {
                fatalError("Uniffi callback interface MobileAndroidKeystore: handle missing in uniffiClone")
            }
        },
        deviceState: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> MobileAndroidDeviceState in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.deviceState(
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterTypeMobileAndroidDeviceState_lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        createKey: { (
            uniffiHandle: UInt64,
            specification: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.createKey(
                     specification: try FfiConverterTypeMobileAndroidKeySpecification_lift(specification)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        encrypt: { (
            uniffiHandle: UInt64,
            alias: RustBuffer,
            authorization: RustBuffer,
            aad: RustBuffer,
            value: RustBuffer,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> MobileAndroidCiphertext in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.encrypt(
                     alias: try FfiConverterString.lift(alias),
                     authorization: try FfiConverterTypeMobileAndroidAuthorization_lift(authorization),
                     aad: try FfiConverterData.lift(aad),
                     value: try FfiConverterData.lift(value)
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterTypeMobileAndroidCiphertext_lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        decrypt: { (
            uniffiHandle: UInt64,
            alias: RustBuffer,
            authorization: RustBuffer,
            aad: RustBuffer,
            value: RustBuffer,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> Data in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.decrypt(
                     alias: try FfiConverterString.lift(alias),
                     authorization: try FfiConverterTypeMobileAndroidAuthorization_lift(authorization),
                     aad: try FfiConverterData.lift(aad),
                     value: try FfiConverterTypeMobileAndroidCiphertext_lift(value)
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterData.lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        deleteKey: { (
            uniffiHandle: UInt64,
            alias: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.deleteKey(
                     alias: try FfiConverterString.lift(alias)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        aliases: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> [String] in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.aliases(
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterSequenceString.lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileAndroidKeystoreError_lower
            )
        },
        cancelPending: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileAndroidKeystore.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return uniffiObj.cancelPending(
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCall(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn
            )
        }
    )

    // Rust stores this pointer for future callback invocations, so it must live
    // for the process lifetime (not just for the init function call).
    //
    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
    // This is safe because the pointee is initialized once during static init
    // and never mutated by either side of the FFI.  Its fields are C function pointers.
    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceMobileAndroidKeystore> = {
        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceMobileAndroidKeystore>.allocate(capacity: 1)
        ptr.initialize(to: vtable)
        return UnsafePointer(ptr)
    }()
}

private func uniffiCallbackInitMobileAndroidKeystore() {
    uniffi_ironstorage_mobile_fn_init_callback_vtable_mobileandroidkeystore(UniffiCallbackInterfaceMobileAndroidKeystore.vtablePtr)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidKeystore: FfiConverter {
    fileprivate static let handleMap = UniffiHandleMap<MobileAndroidKeystore>()

    typealias FfiType = UInt64
    typealias SwiftType = MobileAndroidKeystore

    public static func lift(_ handle: UInt64) throws -> MobileAndroidKeystore {
        if ((handle & 1) == 0) {
            // Rust-generated handle, construct a new class that uses the handle to implement the
            // interface
            return MobileAndroidKeystoreImpl(unsafeFromHandle: handle)
        } else {
            // Swift-generated handle, get the object from the handle map
            return try handleMap.remove(handle: handle)
        }
    }

    public static func lower(_ value: MobileAndroidKeystore) -> UInt64 {
         if let rustImpl = value as? MobileAndroidKeystoreImpl {
             // Rust-implemented object.  Clone the handle and return it
            return rustImpl.uniffiCloneHandle()
         } else {
            // Swift object, generate a new vtable handle and return that.
            return handleMap.insert(obj: value)
         }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidKeystore {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileAndroidKeystore, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeystore_lift(_ handle: UInt64) throws -> MobileAndroidKeystore {
    return try FfiConverterTypeMobileAndroidKeystore.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeystore_lower(_ value: MobileAndroidKeystore) -> UInt64 {
    return FfiConverterTypeMobileAndroidKeystore.lower(value)
}






public protocol MobileAndroidOnboardingProtocol: AnyObject, Sendable {

    func cancel()

    func generate(userId: String, passphrase: String) throws  -> MobileAndroidSetupStatus

    func importKey(armor: String, passphrase: String?) throws  -> MobileAndroidSetupStatus

    func progress()  -> MobileOnboardingProgress

    func remote(serverUrl: String, account: String, repositoryPath: String, applicationToken: String) throws  -> MobileAndroidRemoteOnboarding

    func replaceToken(account: String, applicationToken: String) throws

    func setupLocal(fingerprint: String, passphrase: String?) throws  -> MobileOnboardingOutcome

    func status() throws  -> MobileAndroidSetupStatus

}
open class MobileAndroidOnboarding: MobileAndroidOnboardingProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileandroidonboarding(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileandroidonboarding(handle, $0) }
    }




open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func generate(userId: String, passphrase: String)throws  -> MobileAndroidSetupStatus  {
    return try  FfiConverterTypeMobileAndroidSetupStatus_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_generate(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(userId),
        FfiConverterString.lower(passphrase),uniffiCallStatus
    )
})
}

open func importKey(armor: String, passphrase: String?)throws  -> MobileAndroidSetupStatus  {
    return try  FfiConverterTypeMobileAndroidSetupStatus_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_import_key(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(armor),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func progress() -> MobileOnboardingProgress  {
    return try!  FfiConverterTypeMobileOnboardingProgress_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_progress(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func remote(serverUrl: String, account: String, repositoryPath: String, applicationToken: String)throws  -> MobileAndroidRemoteOnboarding  {
    return try  FfiConverterTypeMobileAndroidRemoteOnboarding_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_remote(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(serverUrl),
        FfiConverterString.lower(account),
        FfiConverterString.lower(repositoryPath),
        FfiConverterString.lower(applicationToken),uniffiCallStatus
    )
})
}

open func replaceToken(account: String, applicationToken: String)throws   {try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_replace_token(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(account),
        FfiConverterString.lower(applicationToken),uniffiCallStatus
    )
}
}

open func setupLocal(fingerprint: String, passphrase: String?)throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_setup_local(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(fingerprint),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func status()throws  -> MobileAndroidSetupStatus  {
    return try  FfiConverterTypeMobileAndroidSetupStatus_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidonboarding_status(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidOnboarding: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileAndroidOnboarding

    public static func lift(_ handle: UInt64) throws -> MobileAndroidOnboarding {
        return MobileAndroidOnboarding(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileAndroidOnboarding) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidOnboarding {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileAndroidOnboarding, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidOnboarding_lift(_ handle: UInt64) throws -> MobileAndroidOnboarding {
    return try FfiConverterTypeMobileAndroidOnboarding.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidOnboarding_lower(_ value: MobileAndroidOnboarding) -> UInt64 {
    return FfiConverterTypeMobileAndroidOnboarding.lower(value)
}






public protocol MobileAndroidRemoteOnboardingProtocol: AnyObject, Sendable {

    func cancel()

    func cloneStore(branch: String, fingerprint: String, passphrase: String?, useExisting: Bool) throws  -> MobileOnboardingOutcome

    func connect() throws  -> MobileOnboardingOutcome

    func discover() throws  -> MobileOnboardingDiscovery

}
open class MobileAndroidRemoteOnboarding: MobileAndroidRemoteOnboardingProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileandroidremoteonboarding(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileandroidremoteonboarding(handle, $0) }
    }




open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidremoteonboarding_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func cloneStore(branch: String, fingerprint: String, passphrase: String?, useExisting: Bool)throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidremoteonboarding_clone_store(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(branch),
        FfiConverterString.lower(fingerprint),
        FfiConverterOptionString.lower(passphrase),
        FfiConverterBool.lower(useExisting),uniffiCallStatus
    )
})
}

open func connect()throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidremoteonboarding_connect(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func discover()throws  -> MobileOnboardingDiscovery  {
    return try  FfiConverterTypeMobileOnboardingDiscovery_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileandroidremoteonboarding_discover(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidRemoteOnboarding: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileAndroidRemoteOnboarding

    public static func lift(_ handle: UInt64) throws -> MobileAndroidRemoteOnboarding {
        return MobileAndroidRemoteOnboarding(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileAndroidRemoteOnboarding) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidRemoteOnboarding {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileAndroidRemoteOnboarding, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidRemoteOnboarding_lift(_ handle: UInt64) throws -> MobileAndroidRemoteOnboarding {
    return try FfiConverterTypeMobileAndroidRemoteOnboarding.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidRemoteOnboarding_lower(_ value: MobileAndroidRemoteOnboarding) -> UInt64 {
    return FfiConverterTypeMobileAndroidRemoteOnboarding.lower(value)
}






public protocol MobileAuthenticationProtocol: AnyObject, Sendable {

    func acknowledgeWatchSnapshot(receipt: Data) throws  -> MobileWatchSnapshotStatus

    func addEntryEditorField(editor: UInt64, kind: MobileEntryEditorFieldKind, name: String?, value: String) throws  -> MobileEntryEditorPage

    func addEntryEditorOtpImage(editor: UInt64, image: Data) throws  -> MobileEntryEditorPage

    func beginCreateEntry(directory: String, name: String, passphrase: String?) throws  -> MobileEntryEditorSession

    func beginEntryEditor(path: String) throws  -> MobileEntryEditorSession

    func cachedTotpPage() throws  -> MobileTotpPage?

    func cancel() throws

    func checkpointEntryEditor(editor: UInt64, version: UInt64) throws

    func checkpointEntryEditorInputs(editor: UInt64, version: UInt64, fields: [MobileEntryEditorInput]) throws

    func copyEntryField(path: String, field: UInt64) throws  -> MobileEntryCopy

    func copyPresentedEntryField(path: String, fieldId: UInt64, revision: String) throws  -> MobileEntryCopy

    func copyPresentedTotpCode(path: String, revision: String, unixSeconds: UInt64) throws  -> MobileEntryCopy

    func copyTotpCode(path: String, unixSeconds: UInt64) throws  -> MobileEntryCopy

    func createDirectory(parent: String, name: String) throws

    func discardEntryEditor(editor: UInt64) throws

    func enrollBiometricUnlock(passphrase: String) throws  -> MobileAuthenticationState

    func entryEditor(editor: UInt64) throws  -> MobileEntryEditorPage

    func entryPage(path: String, unixSeconds: UInt64) throws  -> MobileEntryPresentation

    func failWatchSnapshot(revision: UInt64, detail: String) throws  -> MobileWatchSnapshotStatus

    func generateEntryEditorPassword(editor: UInt64, length: UInt32?, noSymbols: Bool) throws  -> MobileEntryEditorPage

    func gitIdentity() throws  -> MobileGitIdentity

    func manualLock() throws

    func mobileAppearance() throws  -> MobileAppearance

    func navigationEntry(directory: String, rowId: String, revision: String, passphrase: String?, unixSeconds: UInt64) throws  -> MobileEntryPresentation

    func performEntryMutation(request: MobileMutationRequest) throws  -> MobileMutationOutcome

    func preferences(watchSupported: Bool, watchPaired: Bool, watchAppInstalled: Bool) throws  -> MobilePreferences

    func prepareEntryMutation(path: String, action: MobileMutationAction) throws  -> MobileMutationPlan

    func preparePresentedEntryMutation(path: String, revision: String, action: MobileMutationAction) throws  -> MobileMutationPlan

    func prepareWatchSnapshot(platformPairingIdentity: String) throws  -> MobileWatchSnapshotTransfer

    func refreshEntryPresentation(path: String, revision: String, unixSeconds: UInt64) throws  -> MobileEntryPresentation

    func removeApplicationToken() throws

    func removeEntryEditorField(editor: UInt64, field: UInt64) throws  -> MobileEntryEditorPage

    func reorderEntryEditorField(editor: UInt64, field: UInt64, index: UInt32) throws  -> MobileEntryEditorPage

    func replaceEntryField(path: String, field: UInt64, value: String) throws  -> MobileEntryPage

    func replacePresentedEntryField(path: String, fieldId: UInt64, revision: String, value: String) throws  -> MobileEntryPage

    func restoreBiometricLease() throws  -> MobileAuthenticationState

    func resumeEntryEditor(editor: UInt64, passphrase: String?) throws  -> MobileEntryEditorRecovery

    func revealEntryField(path: String, field: UInt64) throws  -> String

    func revealPresentedEntryField(path: String, fieldId: UInt64, revision: String) throws  -> String

    func saveEntryEditor(editor: UInt64, fields: [MobileEntryEditorInput]) throws  -> MobileEntryPage

    func searchCachedTotpPage(query: String) throws  -> MobileTotpPage?

    func setAuthenticationTimeout(seconds: UInt64) throws

    func setBiometricUnlock(enabled: Bool) throws  -> MobileAuthenticationState

    func setGitIdentity(name: String, email: String) throws  -> MobileGitIdentity

    func setMobileAppearance(appearance: MobileAppearance) throws

    func setTotpWatchShared(path: String, shared: Bool, unixSeconds: UInt64) throws  -> MobileTotpDetail

    func setWatchSnapshotUnavailable(unpaired: Bool, detail: String) throws  -> MobileWatchSnapshotStatus

    func state() throws  -> MobileAuthenticationState

    func totpDetail(path: String, unixSeconds: UInt64) throws  -> MobileTotpDetail

    func totpPage(operation: MobileTotpOperation) throws  -> MobileTotpPage

    func touchUserActivity() throws

    func unlockEntry(path: String, passphrase: String?) throws  -> MobileAuthenticationState

    func unlockTotp(passphrase: String?) throws  -> MobileAuthenticationState

    func updateEntryEditor(editor: UInt64, fields: [MobileEntryEditorInput]) throws  -> MobileEntryEditorPage

    func watchSnapshotStatus() throws  -> MobileWatchSnapshotStatus

    func lifecycle(event: MobileLifecycleEvent) throws  -> MobileAuthenticationState

}
open class MobileAuthentication: MobileAuthenticationProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileauthentication(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileauthentication(handle, $0) }
    }




open func acknowledgeWatchSnapshot(receipt: Data)throws  -> MobileWatchSnapshotStatus  {
    return try  FfiConverterTypeMobileWatchSnapshotStatus_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_acknowledge_watch_snapshot(
            self.uniffiCloneHandle(),
        FfiConverterData.lower(receipt),uniffiCallStatus
    )
})
}

open func addEntryEditorField(editor: UInt64, kind: MobileEntryEditorFieldKind, name: String?, value: String)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_add_entry_editor_field(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterTypeMobileEntryEditorFieldKind_lower(kind),
        FfiConverterOptionString.lower(name),
        FfiConverterString.lower(value),uniffiCallStatus
    )
})
}

open func addEntryEditorOtpImage(editor: UInt64, image: Data)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_add_entry_editor_otp_image(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterData.lower(image),uniffiCallStatus
    )
})
}

open func beginCreateEntry(directory: String, name: String, passphrase: String?)throws  -> MobileEntryEditorSession  {
    return try  FfiConverterTypeMobileEntryEditorSession_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_begin_create_entry(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(directory),
        FfiConverterString.lower(name),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func beginEntryEditor(path: String)throws  -> MobileEntryEditorSession  {
    return try  FfiConverterTypeMobileEntryEditorSession_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_begin_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),uniffiCallStatus
    )
})
}

open func cachedTotpPage()throws  -> MobileTotpPage?  {
    return try  FfiConverterOptionTypeMobileTotpPage.lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_cached_totp_page(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func cancel()throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func checkpointEntryEditor(editor: UInt64, version: UInt64)throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_checkpoint_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterUInt64.lower(version),uniffiCallStatus
    )
}
}

open func checkpointEntryEditorInputs(editor: UInt64, version: UInt64, fields: [MobileEntryEditorInput])throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_checkpoint_entry_editor_inputs(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterUInt64.lower(version),
        FfiConverterSequenceTypeMobileEntryEditorInput.lower(fields),uniffiCallStatus
    )
}
}

open func copyEntryField(path: String, field: UInt64)throws  -> MobileEntryCopy  {
    return try  FfiConverterTypeMobileEntryCopy_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_copy_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(field),uniffiCallStatus
    )
})
}

open func copyPresentedEntryField(path: String, fieldId: UInt64, revision: String)throws  -> MobileEntryCopy  {
    return try  FfiConverterTypeMobileEntryCopy_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_copy_presented_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(fieldId),
        FfiConverterString.lower(revision),uniffiCallStatus
    )
})
}

open func copyPresentedTotpCode(path: String, revision: String, unixSeconds: UInt64)throws  -> MobileEntryCopy  {
    return try  FfiConverterTypeMobileEntryCopy_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_copy_presented_totp_code(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterString.lower(revision),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func copyTotpCode(path: String, unixSeconds: UInt64)throws  -> MobileEntryCopy  {
    return try  FfiConverterTypeMobileEntryCopy_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_copy_totp_code(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func createDirectory(parent: String, name: String)throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_create_directory(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(parent),
        FfiConverterString.lower(name),uniffiCallStatus
    )
}
}

open func discardEntryEditor(editor: UInt64)throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_discard_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),uniffiCallStatus
    )
}
}

open func enrollBiometricUnlock(passphrase: String)throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_enroll_biometric_unlock(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(passphrase),uniffiCallStatus
    )
})
}

open func entryEditor(editor: UInt64)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),uniffiCallStatus
    )
})
}

open func entryPage(path: String, unixSeconds: UInt64)throws  -> MobileEntryPresentation  {
    return try  FfiConverterTypeMobileEntryPresentation_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_entry_page(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func failWatchSnapshot(revision: UInt64, detail: String)throws  -> MobileWatchSnapshotStatus  {
    return try  FfiConverterTypeMobileWatchSnapshotStatus_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_fail_watch_snapshot(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(revision),
        FfiConverterString.lower(detail),uniffiCallStatus
    )
})
}

open func generateEntryEditorPassword(editor: UInt64, length: UInt32?, noSymbols: Bool)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_generate_entry_editor_password(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterOptionUInt32.lower(length),
        FfiConverterBool.lower(noSymbols),uniffiCallStatus
    )
})
}

open func gitIdentity()throws  -> MobileGitIdentity  {
    return try  FfiConverterTypeMobileGitIdentity_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_git_identity(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func manualLock()throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_manual_lock(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func mobileAppearance()throws  -> MobileAppearance  {
    return try  FfiConverterTypeMobileAppearance_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_mobile_appearance(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func navigationEntry(directory: String, rowId: String, revision: String, passphrase: String?, unixSeconds: UInt64)throws  -> MobileEntryPresentation  {
    return try  FfiConverterTypeMobileEntryPresentation_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_navigation_entry(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(directory),
        FfiConverterString.lower(rowId),
        FfiConverterString.lower(revision),
        FfiConverterOptionString.lower(passphrase),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func performEntryMutation(request: MobileMutationRequest)throws  -> MobileMutationOutcome  {
    return try  FfiConverterTypeMobileMutationOutcome_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_perform_entry_mutation(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileMutationRequest_lower(request),uniffiCallStatus
    )
})
}

open func preferences(watchSupported: Bool, watchPaired: Bool, watchAppInstalled: Bool)throws  -> MobilePreferences  {
    return try  FfiConverterTypeMobilePreferences_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_preferences(
            self.uniffiCloneHandle(),
        FfiConverterBool.lower(watchSupported),
        FfiConverterBool.lower(watchPaired),
        FfiConverterBool.lower(watchAppInstalled),uniffiCallStatus
    )
})
}

open func prepareEntryMutation(path: String, action: MobileMutationAction)throws  -> MobileMutationPlan  {
    return try  FfiConverterTypeMobileMutationPlan_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_prepare_entry_mutation(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterTypeMobileMutationAction_lower(action),uniffiCallStatus
    )
})
}

open func preparePresentedEntryMutation(path: String, revision: String, action: MobileMutationAction)throws  -> MobileMutationPlan  {
    return try  FfiConverterTypeMobileMutationPlan_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_prepare_presented_entry_mutation(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterString.lower(revision),
        FfiConverterTypeMobileMutationAction_lower(action),uniffiCallStatus
    )
})
}

open func prepareWatchSnapshot(platformPairingIdentity: String)throws  -> MobileWatchSnapshotTransfer  {
    return try  FfiConverterTypeMobileWatchSnapshotTransfer_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_prepare_watch_snapshot(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(platformPairingIdentity),uniffiCallStatus
    )
})
}

open func refreshEntryPresentation(path: String, revision: String, unixSeconds: UInt64)throws  -> MobileEntryPresentation  {
    return try  FfiConverterTypeMobileEntryPresentation_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_refresh_entry_presentation(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterString.lower(revision),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func removeApplicationToken()throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_remove_application_token(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func removeEntryEditorField(editor: UInt64, field: UInt64)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_remove_entry_editor_field(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterUInt64.lower(field),uniffiCallStatus
    )
})
}

open func reorderEntryEditorField(editor: UInt64, field: UInt64, index: UInt32)throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_reorder_entry_editor_field(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterUInt64.lower(field),
        FfiConverterUInt32.lower(index),uniffiCallStatus
    )
})
}

open func replaceEntryField(path: String, field: UInt64, value: String)throws  -> MobileEntryPage  {
    return try  FfiConverterTypeMobileEntryPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_replace_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(field),
        FfiConverterString.lower(value),uniffiCallStatus
    )
})
}

open func replacePresentedEntryField(path: String, fieldId: UInt64, revision: String, value: String)throws  -> MobileEntryPage  {
    return try  FfiConverterTypeMobileEntryPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_replace_presented_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(fieldId),
        FfiConverterString.lower(revision),
        FfiConverterString.lower(value),uniffiCallStatus
    )
})
}

open func restoreBiometricLease()throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_restore_biometric_lease(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func resumeEntryEditor(editor: UInt64, passphrase: String?)throws  -> MobileEntryEditorRecovery  {
    return try  FfiConverterTypeMobileEntryEditorRecovery_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_resume_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func revealEntryField(path: String, field: UInt64)throws  -> String  {
    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_reveal_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(field),uniffiCallStatus
    )
})
}

open func revealPresentedEntryField(path: String, fieldId: UInt64, revision: String)throws  -> String  {
    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_reveal_presented_entry_field(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(fieldId),
        FfiConverterString.lower(revision),uniffiCallStatus
    )
})
}

open func saveEntryEditor(editor: UInt64, fields: [MobileEntryEditorInput])throws  -> MobileEntryPage  {
    return try  FfiConverterTypeMobileEntryPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_save_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterSequenceTypeMobileEntryEditorInput.lower(fields),uniffiCallStatus
    )
})
}

open func searchCachedTotpPage(query: String)throws  -> MobileTotpPage?  {
    return try  FfiConverterOptionTypeMobileTotpPage.lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_search_cached_totp_page(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(query),uniffiCallStatus
    )
})
}

open func setAuthenticationTimeout(seconds: UInt64)throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_authentication_timeout(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(seconds),uniffiCallStatus
    )
}
}

open func setBiometricUnlock(enabled: Bool)throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_biometric_unlock(
            self.uniffiCloneHandle(),
        FfiConverterBool.lower(enabled),uniffiCallStatus
    )
})
}

open func setGitIdentity(name: String, email: String)throws  -> MobileGitIdentity  {
    return try  FfiConverterTypeMobileGitIdentity_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_git_identity(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(name),
        FfiConverterString.lower(email),uniffiCallStatus
    )
})
}

open func setMobileAppearance(appearance: MobileAppearance)throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_mobile_appearance(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileAppearance_lower(appearance),uniffiCallStatus
    )
}
}

open func setTotpWatchShared(path: String, shared: Bool, unixSeconds: UInt64)throws  -> MobileTotpDetail  {
    return try  FfiConverterTypeMobileTotpDetail_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_totp_watch_shared(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterBool.lower(shared),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func setWatchSnapshotUnavailable(unpaired: Bool, detail: String)throws  -> MobileWatchSnapshotStatus  {
    return try  FfiConverterTypeMobileWatchSnapshotStatus_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_set_watch_snapshot_unavailable(
            self.uniffiCloneHandle(),
        FfiConverterBool.lower(unpaired),
        FfiConverterString.lower(detail),uniffiCallStatus
    )
})
}

open func state()throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_state(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func totpDetail(path: String, unixSeconds: UInt64)throws  -> MobileTotpDetail  {
    return try  FfiConverterTypeMobileTotpDetail_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_totp_detail(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterUInt64.lower(unixSeconds),uniffiCallStatus
    )
})
}

open func totpPage(operation: MobileTotpOperation)throws  -> MobileTotpPage  {
    return try  FfiConverterTypeMobileTotpPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_totp_page(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileTotpOperation_lower(operation),uniffiCallStatus
    )
})
}

open func touchUserActivity()throws   {try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_touch_user_activity(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func unlockEntry(path: String, passphrase: String?)throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_unlock_entry(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func unlockTotp(passphrase: String?)throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_unlock_totp(
            self.uniffiCloneHandle(),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func updateEntryEditor(editor: UInt64, fields: [MobileEntryEditorInput])throws  -> MobileEntryEditorPage  {
    return try  FfiConverterTypeMobileEntryEditorPage_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_update_entry_editor(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(editor),
        FfiConverterSequenceTypeMobileEntryEditorInput.lower(fields),uniffiCallStatus
    )
})
}

open func watchSnapshotStatus()throws  -> MobileWatchSnapshotStatus  {
    return try  FfiConverterTypeMobileWatchSnapshotStatus_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_watch_snapshot_status(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func lifecycle(event: MobileLifecycleEvent)throws  -> MobileAuthenticationState  {
    return try  FfiConverterTypeMobileAuthenticationState_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileauthentication_lifecycle(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileLifecycleEvent_lower(event),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAuthentication: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileAuthentication

    public static func lift(_ handle: UInt64) throws -> MobileAuthentication {
        return MobileAuthentication(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileAuthentication) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAuthentication {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileAuthentication, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthentication_lift(_ handle: UInt64) throws -> MobileAuthentication {
    return try FfiConverterTypeMobileAuthentication.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthentication_lower(_ value: MobileAuthentication) -> UInt64 {
    return FfiConverterTypeMobileAuthentication.lower(value)
}






public protocol MobileClipboard: AnyObject, Sendable {

    func read() throws  -> MobileClipboardContent

    func write(value: Data) throws

    func clear() throws

    func waitForTimeout(milliseconds: UInt64)  -> MobileClipboardWait

}
open class MobileClipboardImpl: MobileClipboard, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileclipboard(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileclipboard(handle, $0) }
    }




open func read()throws  -> MobileClipboardContent  {
    return try  FfiConverterTypeMobileClipboardContent_lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileclipboard_read(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func write(value: Data)throws   {try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileclipboard_write(
            self.uniffiCloneHandle(),
        FfiConverterData.lower(value),uniffiCallStatus
    )
}
}

open func clear()throws   {try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileclipboard_clear(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func waitForTimeout(milliseconds: UInt64) -> MobileClipboardWait  {
    return try!  FfiConverterTypeMobileClipboardWait_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileclipboard_wait_for_timeout(
            self.uniffiCloneHandle(),
        FfiConverterUInt64.lower(milliseconds),uniffiCallStatus
    )
})
}



}



// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceMobileClipboard {

    // Create the VTable using a series of closures.
    // Swift automatically converts these into C callback functions.
    //
    // Store the vtable directly.
    static let vtable: UniffiVTableCallbackInterfaceMobileClipboard = UniffiVTableCallbackInterfaceMobileClipboard(
        uniffiFree: { (uniffiHandle: UInt64) -> () in
            do {
                try FfiConverterTypeMobileClipboard.handleMap.remove(handle: uniffiHandle)
            } catch {
                print("Uniffi callback interface MobileClipboard: handle missing in uniffiFree")
            }
        },
        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
            do {
                return try FfiConverterTypeMobileClipboard.handleMap.clone(handle: uniffiHandle)
            } catch {
                fatalError("Uniffi callback interface MobileClipboard: handle missing in uniffiClone")
            }
        },
        read: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> MobileClipboardContent in
                guard let uniffiObj = try? FfiConverterTypeMobileClipboard.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.read(
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterTypeMobileClipboardContent_lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobilePlatformFfiError_lower
            )
        },
        write: { (
            uniffiHandle: UInt64,
            value: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileClipboard.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.write(
                     value: try FfiConverterData.lift(value)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobilePlatformFfiError_lower
            )
        },
        clear: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileClipboard.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.clear(
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobilePlatformFfiError_lower
            )
        },
        waitForTimeout: { (
            uniffiHandle: UInt64,
            milliseconds: UInt64,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> MobileClipboardWait in
                guard let uniffiObj = try? FfiConverterTypeMobileClipboard.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return uniffiObj.waitForTimeout(
                     milliseconds: try FfiConverterUInt64.lift(milliseconds)
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterTypeMobileClipboardWait_lower($0) }
            uniffiTraitInterfaceCall(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn
            )
        }
    )

    // Rust stores this pointer for future callback invocations, so it must live
    // for the process lifetime (not just for the init function call).
    //
    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
    // This is safe because the pointee is initialized once during static init
    // and never mutated by either side of the FFI.  Its fields are C function pointers.
    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceMobileClipboard> = {
        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceMobileClipboard>.allocate(capacity: 1)
        ptr.initialize(to: vtable)
        return UnsafePointer(ptr)
    }()
}

private func uniffiCallbackInitMobileClipboard() {
    uniffi_ironstorage_mobile_fn_init_callback_vtable_mobileclipboard(UniffiCallbackInterfaceMobileClipboard.vtablePtr)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileClipboard: FfiConverter {
    fileprivate static let handleMap = UniffiHandleMap<MobileClipboard>()

    typealias FfiType = UInt64
    typealias SwiftType = MobileClipboard

    public static func lift(_ handle: UInt64) throws -> MobileClipboard {
        if ((handle & 1) == 0) {
            // Rust-generated handle, construct a new class that uses the handle to implement the
            // interface
            return MobileClipboardImpl(unsafeFromHandle: handle)
        } else {
            // Swift-generated handle, get the object from the handle map
            return try handleMap.remove(handle: handle)
        }
    }

    public static func lower(_ value: MobileClipboard) -> UInt64 {
         if let rustImpl = value as? MobileClipboardImpl {
             // Rust-implemented object.  Clone the handle and return it
            return rustImpl.uniffiCloneHandle()
         } else {
            // Swift object, generate a new vtable handle and return that.
            return handleMap.insert(obj: value)
         }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClipboard {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileClipboard, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboard_lift(_ handle: UInt64) throws -> MobileClipboard {
    return try FfiConverterTypeMobileClipboard.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboard_lower(_ value: MobileClipboard) -> UInt64 {
    return FfiConverterTypeMobileClipboard.lower(value)
}






public protocol MobileClock: AnyObject, Sendable {

    func monotonicMilliseconds()  -> UInt64

}
open class MobileClockImpl: MobileClock, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileclock(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileclock(handle, $0) }
    }




open func monotonicMilliseconds() -> UInt64  {
    return try!  FfiConverterUInt64.lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileclock_monotonic_milliseconds(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}



// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceMobileClock {

    // Create the VTable using a series of closures.
    // Swift automatically converts these into C callback functions.
    //
    // Store the vtable directly.
    static let vtable: UniffiVTableCallbackInterfaceMobileClock = UniffiVTableCallbackInterfaceMobileClock(
        uniffiFree: { (uniffiHandle: UInt64) -> () in
            do {
                try FfiConverterTypeMobileClock.handleMap.remove(handle: uniffiHandle)
            } catch {
                print("Uniffi callback interface MobileClock: handle missing in uniffiFree")
            }
        },
        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
            do {
                return try FfiConverterTypeMobileClock.handleMap.clone(handle: uniffiHandle)
            } catch {
                fatalError("Uniffi callback interface MobileClock: handle missing in uniffiClone")
            }
        },
        monotonicMilliseconds: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutablePointer<UInt64>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> UInt64 in
                guard let uniffiObj = try? FfiConverterTypeMobileClock.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return uniffiObj.monotonicMilliseconds(
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterUInt64.lower($0) }
            uniffiTraitInterfaceCall(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn
            )
        }
    )

    // Rust stores this pointer for future callback invocations, so it must live
    // for the process lifetime (not just for the init function call).
    //
    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
    // This is safe because the pointee is initialized once during static init
    // and never mutated by either side of the FFI.  Its fields are C function pointers.
    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceMobileClock> = {
        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceMobileClock>.allocate(capacity: 1)
        ptr.initialize(to: vtable)
        return UnsafePointer(ptr)
    }()
}

private func uniffiCallbackInitMobileClock() {
    uniffi_ironstorage_mobile_fn_init_callback_vtable_mobileclock(UniffiCallbackInterfaceMobileClock.vtablePtr)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileClock: FfiConverter {
    fileprivate static let handleMap = UniffiHandleMap<MobileClock>()

    typealias FfiType = UInt64
    typealias SwiftType = MobileClock

    public static func lift(_ handle: UInt64) throws -> MobileClock {
        if ((handle & 1) == 0) {
            // Rust-generated handle, construct a new class that uses the handle to implement the
            // interface
            return MobileClockImpl(unsafeFromHandle: handle)
        } else {
            // Swift-generated handle, get the object from the handle map
            return try handleMap.remove(handle: handle)
        }
    }

    public static func lower(_ value: MobileClock) -> UInt64 {
         if let rustImpl = value as? MobileClockImpl {
             // Rust-implemented object.  Clone the handle and return it
            return rustImpl.uniffiCloneHandle()
         } else {
            // Swift object, generate a new vtable handle and return that.
            return handleMap.insert(obj: value)
         }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClock {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileClock, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClock_lift(_ handle: UInt64) throws -> MobileClock {
    return try FfiConverterTypeMobileClock.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClock_lower(_ value: MobileClock) -> UInt64 {
    return FfiConverterTypeMobileClock.lower(value)
}






public protocol MobileHomeOperationProtocol: AnyObject, Sendable {

    func activityKnown()  -> Bool

    func cached() throws  -> MobileHomePage

    func cancel()

    func commit(message: String) throws  -> MobileHomePage

    func fetch() throws  -> MobileHomePage

    func identity() throws  -> MobileGitIdentity

    func progress()  -> MobileHomeProgress

    func pull() throws  -> MobileHomePage

    func push() throws  -> MobileHomePage

    func refreshGesture() throws  -> MobileHomePage

    func refreshIfStale() throws  -> MobileHomePage

    func sync() throws  -> MobileHomePage

}
open class MobileHomeOperation: MobileHomeOperationProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobilehomeoperation(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobilehomeoperation(handle, $0) }
    }




open func activityKnown() -> Bool  {
    return try!  FfiConverterBool.lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_activity_known(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func cached()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_cached(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func commit(message: String)throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_commit(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(message),uniffiCallStatus
    )
})
}

open func fetch()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_fetch(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func identity()throws  -> MobileGitIdentity  {
    return try  FfiConverterTypeMobileGitIdentity_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_identity(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func progress() -> MobileHomeProgress  {
    return try!  FfiConverterTypeMobileHomeProgress_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_progress(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func pull()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_pull(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func push()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_push(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func refreshGesture()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_refresh_gesture(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func refreshIfStale()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_refresh_if_stale(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func sync()throws  -> MobileHomePage  {
    return try  FfiConverterTypeMobileHomePage_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilehomeoperation_sync(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeOperation: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileHomeOperation

    public static func lift(_ handle: UInt64) throws -> MobileHomeOperation {
        return MobileHomeOperation(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileHomeOperation) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeOperation {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileHomeOperation, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeOperation_lift(_ handle: UInt64) throws -> MobileHomeOperation {
    return try FfiConverterTypeMobileHomeOperation.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeOperation_lower(_ value: MobileHomeOperation) -> UInt64 {
    return FfiConverterTypeMobileHomeOperation.lower(value)
}






public protocol MobileKeyTransferProtocol: AnyObject, Sendable {

    func export(fingerprint: String, kind: MobileKeyTransferKind, passphrase: String?) throws  -> MobileKeyTransferExport

    func importer()  -> MobileKeyTransferImport

    func keys()  -> [MobileKeyTransferKey]

}
open class MobileKeyTransfer: MobileKeyTransferProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobilekeytransfer(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobilekeytransfer(handle, $0) }
    }




open func export(fingerprint: String, kind: MobileKeyTransferKind, passphrase: String?)throws  -> MobileKeyTransferExport  {
    return try  FfiConverterTypeMobileKeyTransferExport_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilekeytransfer_export(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(fingerprint),
        FfiConverterTypeMobileKeyTransferKind_lower(kind),
        FfiConverterOptionString.lower(passphrase),uniffiCallStatus
    )
})
}

open func importer() -> MobileKeyTransferImport  {
    return try!  FfiConverterTypeMobileKeyTransferImport_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilekeytransfer_importer(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func keys() -> [MobileKeyTransferKey]  {
    return try!  FfiConverterSequenceTypeMobileKeyTransferKey.lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilekeytransfer_keys(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransfer: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileKeyTransfer

    public static func lift(_ handle: UInt64) throws -> MobileKeyTransfer {
        return MobileKeyTransfer(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileKeyTransfer) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransfer {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileKeyTransfer, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransfer_lift(_ handle: UInt64) throws -> MobileKeyTransfer {
    return try FfiConverterTypeMobileKeyTransfer.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransfer_lower(_ value: MobileKeyTransfer) -> UInt64 {
    return FfiConverterTypeMobileKeyTransfer.lower(value)
}






public protocol MobileKeyTransferImportProtocol: AnyObject, Sendable {

    func addFrame(payload: String) throws  -> MobileKeyTransferProgress

    func `import`(passphrase: String?, makeDefault: Bool, overwrite: Bool) throws  -> MobileKeyTransferOutcome

}
open class MobileKeyTransferImport: MobileKeyTransferImportProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobilekeytransferimport(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobilekeytransferimport(handle, $0) }
    }




open func addFrame(payload: String)throws  -> MobileKeyTransferProgress  {
    return try  FfiConverterTypeMobileKeyTransferProgress_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilekeytransferimport_add_frame(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(payload),uniffiCallStatus
    )
})
}

open func `import`(passphrase: String?, makeDefault: Bool, overwrite: Bool)throws  -> MobileKeyTransferOutcome  {
    return try  FfiConverterTypeMobileKeyTransferOutcome_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilekeytransferimport_import(
            self.uniffiCloneHandle(),
        FfiConverterOptionString.lower(passphrase),
        FfiConverterBool.lower(makeDefault),
        FfiConverterBool.lower(overwrite),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferImport: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileKeyTransferImport

    public static func lift(_ handle: UInt64) throws -> MobileKeyTransferImport {
        return MobileKeyTransferImport(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileKeyTransferImport) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferImport {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileKeyTransferImport, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferImport_lift(_ handle: UInt64) throws -> MobileKeyTransferImport {
    return try FfiConverterTypeMobileKeyTransferImport.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferImport_lower(_ value: MobileKeyTransferImport) -> UInt64 {
    return FfiConverterTypeMobileKeyTransferImport.lower(value)
}






public protocol MobileLocalOnboardingOperationProtocol: AnyObject, Sendable {

    func cancel()

    func generate(userId: String, passphrase: String, replaceExistingKey: Bool) throws  -> MobileOnboardingOutcome

}
open class MobileLocalOnboardingOperation: MobileLocalOnboardingOperationProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobilelocalonboardingoperation(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobilelocalonboardingoperation(handle, $0) }
    }




open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilelocalonboardingoperation_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func generate(userId: String, passphrase: String, replaceExistingKey: Bool)throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilelocalonboardingoperation_generate(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(userId),
        FfiConverterString.lower(passphrase),
        FfiConverterBool.lower(replaceExistingKey),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileLocalOnboardingOperation: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileLocalOnboardingOperation

    public static func lift(_ handle: UInt64) throws -> MobileLocalOnboardingOperation {
        return MobileLocalOnboardingOperation(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileLocalOnboardingOperation) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileLocalOnboardingOperation {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileLocalOnboardingOperation, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileLocalOnboardingOperation_lift(_ handle: UInt64) throws -> MobileLocalOnboardingOperation {
    return try FfiConverterTypeMobileLocalOnboardingOperation.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileLocalOnboardingOperation_lower(_ value: MobileLocalOnboardingOperation) -> UInt64 {
    return FfiConverterTypeMobileLocalOnboardingOperation.lower(value)
}






public protocol MobileOnboardingOperationProtocol: AnyObject, Sendable {

    func cancel()

    func connectLocalStore() throws  -> MobileOnboardingOutcome

    func discover() throws  -> MobileOnboardingDiscovery

    func progress()  -> MobileOnboardingProgress

    func setup(branch: String, useExisting: Bool) throws  -> MobileOnboardingOutcome

}
open class MobileOnboardingOperation: MobileOnboardingOperationProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileonboardingoperation(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileonboardingoperation(handle, $0) }
    }




open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileonboardingoperation_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func connectLocalStore()throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileonboardingoperation_connect_local_store(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func discover()throws  -> MobileOnboardingDiscovery  {
    return try  FfiConverterTypeMobileOnboardingDiscovery_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileonboardingoperation_discover(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func progress() -> MobileOnboardingProgress  {
    return try!  FfiConverterTypeMobileOnboardingProgress_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileonboardingoperation_progress(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func setup(branch: String, useExisting: Bool)throws  -> MobileOnboardingOutcome  {
    return try  FfiConverterTypeMobileOnboardingOutcome_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileonboardingoperation_setup(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(branch),
        FfiConverterBool.lower(useExisting),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingOperation: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileOnboardingOperation

    public static func lift(_ handle: UInt64) throws -> MobileOnboardingOperation {
        return MobileOnboardingOperation(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileOnboardingOperation) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingOperation {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileOnboardingOperation, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingOperation_lift(_ handle: UInt64) throws -> MobileOnboardingOperation {
    return try FfiConverterTypeMobileOnboardingOperation.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingOperation_lower(_ value: MobileOnboardingOperation) -> UInt64 {
    return FfiConverterTypeMobileOnboardingOperation.lower(value)
}






public protocol MobilePrivateRuntimeProtocol: AnyObject, Sendable {

    func openPasswordSearchResult(id: String, revision: String) throws  -> MobilePasswordNavigation

    func passwordNameSearch(query: String) throws  -> [MobileNavigationRow]

    func passwordNavigation(path: String, selected: String?, revision: String?, activate: Bool) throws  -> MobilePasswordNavigation

    func activate() throws

    func androidHomeOperation(backend: MobileSecretBackend, clock: MobileClock) throws  -> MobileHomeOperation

    func androidOnboarding(backend: MobileSecretBackend) throws  -> MobileAndroidOnboarding

    func androidSecretBackend(keystore: MobileAndroidKeystore) throws  -> MobileSecretBackend

    func authentication(backend: MobileSecretBackend, clock: MobileClock) throws  -> MobileAuthentication

    func clearDisposableCache() throws

    func layout()  -> MobilePrivateStorageLayout

    func shell()  -> MobileShell

    func status()  -> MobilePrivateStorageStatus

    func verifySecureStorage(backend: MobileSecretBackend) throws

}
open class MobilePrivateRuntime: MobilePrivateRuntimeProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobileprivateruntime(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobileprivateruntime(handle, $0) }
    }




open func openPasswordSearchResult(id: String, revision: String)throws  -> MobilePasswordNavigation  {
    return try  FfiConverterTypeMobilePasswordNavigation_lift(try rustCallWithError(FfiConverterTypeMobilePasswordFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_open_password_search_result(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(id),
        FfiConverterString.lower(revision),uniffiCallStatus
    )
})
}

open func passwordNameSearch(query: String)throws  -> [MobileNavigationRow]  {
    return try  FfiConverterSequenceTypeMobileNavigationRow.lift(try rustCallWithError(FfiConverterTypeMobilePasswordFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_password_name_search(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(query),uniffiCallStatus
    )
})
}

open func passwordNavigation(path: String, selected: String?, revision: String?, activate: Bool)throws  -> MobilePasswordNavigation  {
    return try  FfiConverterTypeMobilePasswordNavigation_lift(try rustCallWithError(FfiConverterTypeMobilePasswordFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_password_navigation(
            self.uniffiCloneHandle(),
        FfiConverterString.lower(path),
        FfiConverterOptionString.lower(selected),
        FfiConverterOptionString.lower(revision),
        FfiConverterBool.lower(activate),uniffiCallStatus
    )
})
}

open func activate()throws   {try rustCallWithError(FfiConverterTypeMobilePrivateStorageFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_activate(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func androidHomeOperation(backend: MobileSecretBackend, clock: MobileClock)throws  -> MobileHomeOperation  {
    return try  FfiConverterTypeMobileHomeOperation_lift(try rustCallWithError(FfiConverterTypeMobileHomeFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_android_home_operation(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretBackend_lower(backend),
        FfiConverterTypeMobileClock_lower(clock),uniffiCallStatus
    )
})
}

open func androidOnboarding(backend: MobileSecretBackend)throws  -> MobileAndroidOnboarding  {
    return try  FfiConverterTypeMobileAndroidOnboarding_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_android_onboarding(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretBackend_lower(backend),uniffiCallStatus
    )
})
}

open func androidSecretBackend(keystore: MobileAndroidKeystore)throws  -> MobileSecretBackend  {
    return try  FfiConverterTypeMobileSecretBackend_lift(try rustCallWithError(FfiConverterTypeMobilePrivateStorageFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_android_secret_backend(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileAndroidKeystore_lower(keystore),uniffiCallStatus
    )
})
}

open func authentication(backend: MobileSecretBackend, clock: MobileClock)throws  -> MobileAuthentication  {
    return try  FfiConverterTypeMobileAuthentication_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_authentication(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretBackend_lower(backend),
        FfiConverterTypeMobileClock_lower(clock),uniffiCallStatus
    )
})
}

open func clearDisposableCache()throws   {try rustCallWithError(FfiConverterTypeMobilePrivateStorageFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_clear_disposable_cache(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func layout() -> MobilePrivateStorageLayout  {
    return try!  FfiConverterTypeMobilePrivateStorageLayout_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_layout(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func shell() -> MobileShell  {
    return try!  FfiConverterTypeMobileShell_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_shell(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func status() -> MobilePrivateStorageStatus  {
    return try!  FfiConverterTypeMobilePrivateStorageStatus_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_status(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}

open func verifySecureStorage(backend: MobileSecretBackend)throws   {try rustCallWithError(FfiConverterTypeMobilePrivateStorageFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobileprivateruntime_verify_secure_storage(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretBackend_lower(backend),uniffiCallStatus
    )
}
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateRuntime: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobilePrivateRuntime

    public static func lift(_ handle: UInt64) throws -> MobilePrivateRuntime {
        return MobilePrivateRuntime(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobilePrivateRuntime) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateRuntime {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobilePrivateRuntime, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateRuntime_lift(_ handle: UInt64) throws -> MobilePrivateRuntime {
    return try FfiConverterTypeMobilePrivateRuntime.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateRuntime_lower(_ value: MobilePrivateRuntime) -> UInt64 {
    return FfiConverterTypeMobilePrivateRuntime.lower(value)
}






/**
 * Receives storage-encoded opaque bytes; cannot select accounts, leases or protection.
 */
public protocol MobileSecretBackend: AnyObject, Sendable {

    func create(locator: MobileSecretLocator, protection: MobileSecretProtection, value: Data) throws

    func retrieve(locator: MobileSecretLocator, protection: MobileSecretProtection) throws  -> Data

    func replace(locator: MobileSecretLocator, protection: MobileSecretProtection, value: Data) throws

    func delete(locator: MobileSecretLocator, protection: MobileSecretProtection) throws

    func lock() throws

    func unlock() throws

}
/**
 * Receives storage-encoded opaque bytes; cannot select accounts, leases or protection.
 */
open class MobileSecretBackendImpl: MobileSecretBackend, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobilesecretbackend(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobilesecretbackend(handle, $0) }
    }




open func create(locator: MobileSecretLocator, protection: MobileSecretProtection, value: Data)throws   {try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_create(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretLocator_lower(locator),
        FfiConverterTypeMobileSecretProtection_lower(protection),
        FfiConverterData.lower(value),uniffiCallStatus
    )
}
}

open func retrieve(locator: MobileSecretLocator, protection: MobileSecretProtection)throws  -> Data  {
    return try  FfiConverterData.lift(try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_retrieve(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretLocator_lower(locator),
        FfiConverterTypeMobileSecretProtection_lower(protection),uniffiCallStatus
    )
})
}

open func replace(locator: MobileSecretLocator, protection: MobileSecretProtection, value: Data)throws   {try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_replace(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretLocator_lower(locator),
        FfiConverterTypeMobileSecretProtection_lower(protection),
        FfiConverterData.lower(value),uniffiCallStatus
    )
}
}

open func delete(locator: MobileSecretLocator, protection: MobileSecretProtection)throws   {try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_delete(
            self.uniffiCloneHandle(),
        FfiConverterTypeMobileSecretLocator_lower(locator),
        FfiConverterTypeMobileSecretProtection_lower(protection),uniffiCallStatus
    )
}
}

open func lock()throws   {try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_lock(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func unlock()throws   {try rustCallWithError(FfiConverterTypeMobileSecretError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobilesecretbackend_unlock(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}



}



// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceMobileSecretBackend {

    // Create the VTable using a series of closures.
    // Swift automatically converts these into C callback functions.
    //
    // Store the vtable directly.
    static let vtable: UniffiVTableCallbackInterfaceMobileSecretBackend = UniffiVTableCallbackInterfaceMobileSecretBackend(
        uniffiFree: { (uniffiHandle: UInt64) -> () in
            do {
                try FfiConverterTypeMobileSecretBackend.handleMap.remove(handle: uniffiHandle)
            } catch {
                print("Uniffi callback interface MobileSecretBackend: handle missing in uniffiFree")
            }
        },
        uniffiClone: { (uniffiHandle: UInt64) -> UInt64 in
            do {
                return try FfiConverterTypeMobileSecretBackend.handleMap.clone(handle: uniffiHandle)
            } catch {
                fatalError("Uniffi callback interface MobileSecretBackend: handle missing in uniffiClone")
            }
        },
        create: { (
            uniffiHandle: UInt64,
            locator: RustBuffer,
            protection: RustBuffer,
            value: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.create(
                     locator: try FfiConverterTypeMobileSecretLocator_lift(locator),
                     protection: try FfiConverterTypeMobileSecretProtection_lift(protection),
                     value: try FfiConverterData.lift(value)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        },
        retrieve: { (
            uniffiHandle: UInt64,
            locator: RustBuffer,
            protection: RustBuffer,
            uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> Data in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.retrieve(
                     locator: try FfiConverterTypeMobileSecretLocator_lift(locator),
                     protection: try FfiConverterTypeMobileSecretProtection_lift(protection)
                )
            }


            let writeReturn = { uniffiOutReturn.pointee = FfiConverterData.lower($0) }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        },
        replace: { (
            uniffiHandle: UInt64,
            locator: RustBuffer,
            protection: RustBuffer,
            value: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.replace(
                     locator: try FfiConverterTypeMobileSecretLocator_lift(locator),
                     protection: try FfiConverterTypeMobileSecretProtection_lift(protection),
                     value: try FfiConverterData.lift(value)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        },
        delete: { (
            uniffiHandle: UInt64,
            locator: RustBuffer,
            protection: RustBuffer,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.delete(
                     locator: try FfiConverterTypeMobileSecretLocator_lift(locator),
                     protection: try FfiConverterTypeMobileSecretProtection_lift(protection)
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        },
        lock: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.lock(
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        },
        unlock: { (
            uniffiHandle: UInt64,
            uniffiOutReturn: UnsafeMutableRawPointer,
            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
        ) in
            let makeCall = {
                () throws -> () in
                guard let uniffiObj = try? FfiConverterTypeMobileSecretBackend.handleMap.get(handle: uniffiHandle) else {
                    throw UniffiInternalError.unexpectedStaleHandle
                }
                return try uniffiObj.unlock(
                )
            }


            let writeReturn = { () }
            uniffiTraitInterfaceCallWithError(
                callStatus: uniffiCallStatus,
                makeCall: makeCall,
                writeReturn: writeReturn,
                lowerError: FfiConverterTypeMobileSecretError_lower
            )
        }
    )

    // Rust stores this pointer for future callback invocations, so it must live
    // for the process lifetime (not just for the init function call).
    //
    // `nonisolated(unsafe)` is needed under Swift 6 strict concurrency.
    // This is safe because the pointee is initialized once during static init
    // and never mutated by either side of the FFI.  Its fields are C function pointers.
    nonisolated(unsafe) static let vtablePtr: UnsafePointer<UniffiVTableCallbackInterfaceMobileSecretBackend> = {
        let ptr = UnsafeMutablePointer<UniffiVTableCallbackInterfaceMobileSecretBackend>.allocate(capacity: 1)
        ptr.initialize(to: vtable)
        return UnsafePointer(ptr)
    }()
}

private func uniffiCallbackInitMobileSecretBackend() {
    uniffi_ironstorage_mobile_fn_init_callback_vtable_mobilesecretbackend(UniffiCallbackInterfaceMobileSecretBackend.vtablePtr)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileSecretBackend: FfiConverter {
    fileprivate static let handleMap = UniffiHandleMap<MobileSecretBackend>()

    typealias FfiType = UInt64
    typealias SwiftType = MobileSecretBackend

    public static func lift(_ handle: UInt64) throws -> MobileSecretBackend {
        if ((handle & 1) == 0) {
            // Rust-generated handle, construct a new class that uses the handle to implement the
            // interface
            return MobileSecretBackendImpl(unsafeFromHandle: handle)
        } else {
            // Swift-generated handle, get the object from the handle map
            return try handleMap.remove(handle: handle)
        }
    }

    public static func lower(_ value: MobileSecretBackend) -> UInt64 {
         if let rustImpl = value as? MobileSecretBackendImpl {
             // Rust-implemented object.  Clone the handle and return it
            return rustImpl.uniffiCloneHandle()
         } else {
            // Swift object, generate a new vtable handle and return that.
            return handleMap.insert(obj: value)
         }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileSecretBackend {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileSecretBackend, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretBackend_lift(_ handle: UInt64) throws -> MobileSecretBackend {
    return try FfiConverterTypeMobileSecretBackend.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretBackend_lower(_ value: MobileSecretBackend) -> UInt64 {
    return FfiConverterTypeMobileSecretBackend.lower(value)
}






public protocol MobileTotpOperationProtocol: AnyObject, Sendable {

    func cancel()

    func progress()  -> MobileTotpDiscoveryProgress

}
open class MobileTotpOperation: MobileTotpOperationProtocol, @unchecked Sendable {
    fileprivate let handle: UInt64

    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public struct NoHandle {
        public init() {}
    }

    // TODO: We'd like this to be `private` but for Swifty reasons,
    // we can't implement `FfiConverter` without making this `required` and we can't
    // make it `required` without making it `public`.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    required public init(unsafeFromHandle handle: UInt64) {
        self.handle = handle
    }

    // This constructor can be used to instantiate a fake object.
    // - Parameter noHandle: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
    //
    // - Warning:
    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing handle the FFI lower functions will crash.
#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public init(noHandle: NoHandle) {
        self.handle = 0
    }

#if swift(>=5.8)
    @_documentation(visibility: private)
#endif
    public func uniffiCloneHandle() -> UInt64 {
        return try! rustCall { uniffi_ironstorage_mobile_fn_clone_mobiletotpoperation(self.handle, $0) }
    }
    // No primary constructor declared for this class.

    deinit {
        if handle == 0 {
            // Mock objects have handle=0 don't try to free them
            return
        }

        try! rustCall { uniffi_ironstorage_mobile_fn_free_mobiletotpoperation(handle, $0) }
    }




open func cancel()  {try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobiletotpoperation_cancel(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
}
}

open func progress() -> MobileTotpDiscoveryProgress  {
    return try!  FfiConverterTypeMobileTotpDiscoveryProgress_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_method_mobiletotpoperation_progress(
            self.uniffiCloneHandle(),uniffiCallStatus
    )
})
}



}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpOperation: FfiConverter {
    typealias FfiType = UInt64
    typealias SwiftType = MobileTotpOperation

    public static func lift(_ handle: UInt64) throws -> MobileTotpOperation {
        return MobileTotpOperation(unsafeFromHandle: handle)
    }

    public static func lower(_ value: MobileTotpOperation) -> UInt64 {
        return value.uniffiCloneHandle()
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpOperation {
        let handle: UInt64 = try readInt(&buf)
        return try lift(handle)
    }

    public static func write(_ value: MobileTotpOperation, into buf: inout [UInt8]) {
        writeInt(&buf, lower(value))
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpOperation_lift(_ handle: UInt64) throws -> MobileTotpOperation {
    return try FfiConverterTypeMobileTotpOperation.lift(handle)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpOperation_lower(_ value: MobileTotpOperation) -> UInt64 {
    return FfiConverterTypeMobileTotpOperation.lower(value)
}




public struct MobileAndroidCiphertext: Equatable, Hashable {
    public var nonce: Data
    public var bytes: Data

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(nonce: Data, bytes: Data) {
        self.nonce = nonce
        self.bytes = bytes
    }




}

#if compiler(>=6)
extension MobileAndroidCiphertext: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidCiphertext: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidCiphertext {
        return
            try MobileAndroidCiphertext(
                nonce: FfiConverterData.read(from: &buf),
                bytes: FfiConverterData.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAndroidCiphertext, into buf: inout [UInt8]) {
        FfiConverterData.write(value.nonce, into: &buf)
        FfiConverterData.write(value.bytes, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidCiphertext_lift(_ buf: RustBuffer) throws -> MobileAndroidCiphertext {
    return try FfiConverterTypeMobileAndroidCiphertext.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidCiphertext_lower(_ value: MobileAndroidCiphertext) -> RustBuffer {
    return FfiConverterTypeMobileAndroidCiphertext.lower(value)
}


public struct MobileAndroidDeviceState: Equatable, Hashable {
    public var api: UInt32
    public var locked: Bool
    public var secure: Bool
    public var strongBiometric: Bool
    public var strongbox: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(api: UInt32, locked: Bool, secure: Bool, strongBiometric: Bool, strongbox: Bool) {
        self.api = api
        self.locked = locked
        self.secure = secure
        self.strongBiometric = strongBiometric
        self.strongbox = strongbox
    }




}

#if compiler(>=6)
extension MobileAndroidDeviceState: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidDeviceState: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidDeviceState {
        return
            try MobileAndroidDeviceState(
                api: FfiConverterUInt32.read(from: &buf),
                locked: FfiConverterBool.read(from: &buf),
                secure: FfiConverterBool.read(from: &buf),
                strongBiometric: FfiConverterBool.read(from: &buf),
                strongbox: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAndroidDeviceState, into buf: inout [UInt8]) {
        FfiConverterUInt32.write(value.api, into: &buf)
        FfiConverterBool.write(value.locked, into: &buf)
        FfiConverterBool.write(value.secure, into: &buf)
        FfiConverterBool.write(value.strongBiometric, into: &buf)
        FfiConverterBool.write(value.strongbox, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidDeviceState_lift(_ buf: RustBuffer) throws -> MobileAndroidDeviceState {
    return try FfiConverterTypeMobileAndroidDeviceState.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidDeviceState_lower(_ value: MobileAndroidDeviceState) -> RustBuffer {
    return FfiConverterTypeMobileAndroidDeviceState.lower(value)
}


public struct MobileAndroidKeySpecification: Equatable, Hashable {
    public var alias: String
    public var authorization: MobileAndroidAuthorization
    public var unlockedDevice: Bool
    public var invalidateOnEnrollment: Bool
    public var strongbox: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(alias: String, authorization: MobileAndroidAuthorization, unlockedDevice: Bool, invalidateOnEnrollment: Bool, strongbox: Bool) {
        self.alias = alias
        self.authorization = authorization
        self.unlockedDevice = unlockedDevice
        self.invalidateOnEnrollment = invalidateOnEnrollment
        self.strongbox = strongbox
    }




}

#if compiler(>=6)
extension MobileAndroidKeySpecification: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidKeySpecification: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidKeySpecification {
        return
            try MobileAndroidKeySpecification(
                alias: FfiConverterString.read(from: &buf),
                authorization: FfiConverterTypeMobileAndroidAuthorization.read(from: &buf),
                unlockedDevice: FfiConverterBool.read(from: &buf),
                invalidateOnEnrollment: FfiConverterBool.read(from: &buf),
                strongbox: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAndroidKeySpecification, into buf: inout [UInt8]) {
        FfiConverterString.write(value.alias, into: &buf)
        FfiConverterTypeMobileAndroidAuthorization.write(value.authorization, into: &buf)
        FfiConverterBool.write(value.unlockedDevice, into: &buf)
        FfiConverterBool.write(value.invalidateOnEnrollment, into: &buf)
        FfiConverterBool.write(value.strongbox, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeySpecification_lift(_ buf: RustBuffer) throws -> MobileAndroidKeySpecification {
    return try FfiConverterTypeMobileAndroidKeySpecification.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeySpecification_lower(_ value: MobileAndroidKeySpecification) -> RustBuffer {
    return FfiConverterTypeMobileAndroidKeySpecification.lower(value)
}


public struct MobileAndroidSetupKey: Equatable, Hashable {
    public var fingerprint: String
    public var userIds: [String]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(fingerprint: String, userIds: [String]) {
        self.fingerprint = fingerprint
        self.userIds = userIds
    }




}

#if compiler(>=6)
extension MobileAndroidSetupKey: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidSetupKey: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidSetupKey {
        return
            try MobileAndroidSetupKey(
                fingerprint: FfiConverterString.read(from: &buf),
                userIds: FfiConverterSequenceString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAndroidSetupKey, into buf: inout [UInt8]) {
        FfiConverterString.write(value.fingerprint, into: &buf)
        FfiConverterSequenceString.write(value.userIds, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidSetupKey_lift(_ buf: RustBuffer) throws -> MobileAndroidSetupKey {
    return try FfiConverterTypeMobileAndroidSetupKey.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidSetupKey_lower(_ value: MobileAndroidSetupKey) -> RustBuffer {
    return FfiConverterTypeMobileAndroidSetupKey.lower(value)
}


public struct MobileAndroidSetupStatus: Equatable, Hashable {
    public var configured: Bool
    public var connected: Bool
    public var existingClone: Bool
    public var keys: [MobileAndroidSetupKey]
    public var selectedKey: String?
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(configured: Bool, connected: Bool, existingClone: Bool, keys: [MobileAndroidSetupKey], selectedKey: String?, title: String, detail: String) {
        self.configured = configured
        self.connected = connected
        self.existingClone = existingClone
        self.keys = keys
        self.selectedKey = selectedKey
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileAndroidSetupStatus: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidSetupStatus: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidSetupStatus {
        return
            try MobileAndroidSetupStatus(
                configured: FfiConverterBool.read(from: &buf),
                connected: FfiConverterBool.read(from: &buf),
                existingClone: FfiConverterBool.read(from: &buf),
                keys: FfiConverterSequenceTypeMobileAndroidSetupKey.read(from: &buf),
                selectedKey: FfiConverterOptionString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAndroidSetupStatus, into buf: inout [UInt8]) {
        FfiConverterBool.write(value.configured, into: &buf)
        FfiConverterBool.write(value.connected, into: &buf)
        FfiConverterBool.write(value.existingClone, into: &buf)
        FfiConverterSequenceTypeMobileAndroidSetupKey.write(value.keys, into: &buf)
        FfiConverterOptionString.write(value.selectedKey, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidSetupStatus_lift(_ buf: RustBuffer) throws -> MobileAndroidSetupStatus {
    return try FfiConverterTypeMobileAndroidSetupStatus.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidSetupStatus_lower(_ value: MobileAndroidSetupStatus) -> RustBuffer {
    return FfiConverterTypeMobileAndroidSetupStatus.lower(value)
}


public struct MobileAuthenticationState: Equatable, Hashable {
    public var unlocked: Bool
    public var biometricUnlockEnabled: Bool
    public var remainingSeconds: UInt64

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(unlocked: Bool, biometricUnlockEnabled: Bool, remainingSeconds: UInt64) {
        self.unlocked = unlocked
        self.biometricUnlockEnabled = biometricUnlockEnabled
        self.remainingSeconds = remainingSeconds
    }




}

#if compiler(>=6)
extension MobileAuthenticationState: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAuthenticationState: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAuthenticationState {
        return
            try MobileAuthenticationState(
                unlocked: FfiConverterBool.read(from: &buf),
                biometricUnlockEnabled: FfiConverterBool.read(from: &buf),
                remainingSeconds: FfiConverterUInt64.read(from: &buf)
        )
    }

    public static func write(_ value: MobileAuthenticationState, into buf: inout [UInt8]) {
        FfiConverterBool.write(value.unlocked, into: &buf)
        FfiConverterBool.write(value.biometricUnlockEnabled, into: &buf)
        FfiConverterUInt64.write(value.remainingSeconds, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationState_lift(_ buf: RustBuffer) throws -> MobileAuthenticationState {
    return try FfiConverterTypeMobileAuthenticationState.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationState_lower(_ value: MobileAuthenticationState) -> RustBuffer {
    return FfiConverterTypeMobileAuthenticationState.lower(value)
}


public struct MobileCameraFrame: Equatable, Hashable {
    public var width: UInt32
    public var height: UInt32
    public var rowStride: UInt32
    public var pixelStride: UInt32
    public var luminance: Data

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(width: UInt32, height: UInt32, rowStride: UInt32, pixelStride: UInt32, luminance: Data) {
        self.width = width
        self.height = height
        self.rowStride = rowStride
        self.pixelStride = pixelStride
        self.luminance = luminance
    }




}

#if compiler(>=6)
extension MobileCameraFrame: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileCameraFrame: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileCameraFrame {
        return
            try MobileCameraFrame(
                width: FfiConverterUInt32.read(from: &buf),
                height: FfiConverterUInt32.read(from: &buf),
                rowStride: FfiConverterUInt32.read(from: &buf),
                pixelStride: FfiConverterUInt32.read(from: &buf),
                luminance: FfiConverterData.read(from: &buf)
        )
    }

    public static func write(_ value: MobileCameraFrame, into buf: inout [UInt8]) {
        FfiConverterUInt32.write(value.width, into: &buf)
        FfiConverterUInt32.write(value.height, into: &buf)
        FfiConverterUInt32.write(value.rowStride, into: &buf)
        FfiConverterUInt32.write(value.pixelStride, into: &buf)
        FfiConverterData.write(value.luminance, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileCameraFrame_lift(_ buf: RustBuffer) throws -> MobileCameraFrame {
    return try FfiConverterTypeMobileCameraFrame.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileCameraFrame_lower(_ value: MobileCameraFrame) -> RustBuffer {
    return FfiConverterTypeMobileCameraFrame.lower(value)
}


public struct MobileCredentialRequest: Equatable, Hashable {
    public var requestId: String
    public var package: String
    public var signingCertificateSha256: String
    public var origins: [String]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(requestId: String, package: String, signingCertificateSha256: String, origins: [String]) {
        self.requestId = requestId
        self.package = package
        self.signingCertificateSha256 = signingCertificateSha256
        self.origins = origins
    }




}

#if compiler(>=6)
extension MobileCredentialRequest: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileCredentialRequest: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileCredentialRequest {
        return
            try MobileCredentialRequest(
                requestId: FfiConverterString.read(from: &buf),
                package: FfiConverterString.read(from: &buf),
                signingCertificateSha256: FfiConverterString.read(from: &buf),
                origins: FfiConverterSequenceString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileCredentialRequest, into buf: inout [UInt8]) {
        FfiConverterString.write(value.requestId, into: &buf)
        FfiConverterString.write(value.package, into: &buf)
        FfiConverterString.write(value.signingCertificateSha256, into: &buf)
        FfiConverterSequenceString.write(value.origins, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileCredentialRequest_lift(_ buf: RustBuffer) throws -> MobileCredentialRequest {
    return try FfiConverterTypeMobileCredentialRequest.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileCredentialRequest_lower(_ value: MobileCredentialRequest) -> RustBuffer {
    return FfiConverterTypeMobileCredentialRequest.lower(value)
}


public struct MobileEntryCopy: Equatable, Hashable {
    public var value: String
    public var timeoutSeconds: UInt64

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(value: String, timeoutSeconds: UInt64) {
        self.value = value
        self.timeoutSeconds = timeoutSeconds
    }




}

#if compiler(>=6)
extension MobileEntryCopy: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryCopy: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryCopy {
        return
            try MobileEntryCopy(
                value: FfiConverterString.read(from: &buf),
                timeoutSeconds: FfiConverterUInt64.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryCopy, into buf: inout [UInt8]) {
        FfiConverterString.write(value.value, into: &buf)
        FfiConverterUInt64.write(value.timeoutSeconds, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryCopy_lift(_ buf: RustBuffer) throws -> MobileEntryCopy {
    return try FfiConverterTypeMobileEntryCopy.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryCopy_lower(_ value: MobileEntryCopy) -> RustBuffer {
    return FfiConverterTypeMobileEntryCopy.lower(value)
}


public struct MobileEntryEditorField: Equatable, Hashable {
    public var id: UInt64
    public var kind: MobileEntryEditorFieldKind
    public var name: String?
    public var label: String
    public var icon: MobileIcon
    public var value: String?
    public var maskedValue: String
    public var diagnostic: String?
    public var sensitive: Bool
    public var multiline: Bool
    public var nameEditable: Bool
    public var removable: Bool
    public var reorderable: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: UInt64, kind: MobileEntryEditorFieldKind, name: String?, label: String, icon: MobileIcon, value: String?, maskedValue: String, diagnostic: String?, sensitive: Bool, multiline: Bool, nameEditable: Bool, removable: Bool, reorderable: Bool) {
        self.id = id
        self.kind = kind
        self.name = name
        self.label = label
        self.icon = icon
        self.value = value
        self.maskedValue = maskedValue
        self.diagnostic = diagnostic
        self.sensitive = sensitive
        self.multiline = multiline
        self.nameEditable = nameEditable
        self.removable = removable
        self.reorderable = reorderable
    }




}

#if compiler(>=6)
extension MobileEntryEditorField: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorField: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorField {
        return
            try MobileEntryEditorField(
                id: FfiConverterUInt64.read(from: &buf),
                kind: FfiConverterTypeMobileEntryEditorFieldKind.read(from: &buf),
                name: FfiConverterOptionString.read(from: &buf),
                label: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                value: FfiConverterOptionString.read(from: &buf),
                maskedValue: FfiConverterString.read(from: &buf),
                diagnostic: FfiConverterOptionString.read(from: &buf),
                sensitive: FfiConverterBool.read(from: &buf),
                multiline: FfiConverterBool.read(from: &buf),
                nameEditable: FfiConverterBool.read(from: &buf),
                removable: FfiConverterBool.read(from: &buf),
                reorderable: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryEditorField, into buf: inout [UInt8]) {
        FfiConverterUInt64.write(value.id, into: &buf)
        FfiConverterTypeMobileEntryEditorFieldKind.write(value.kind, into: &buf)
        FfiConverterOptionString.write(value.name, into: &buf)
        FfiConverterString.write(value.label, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterOptionString.write(value.value, into: &buf)
        FfiConverterString.write(value.maskedValue, into: &buf)
        FfiConverterOptionString.write(value.diagnostic, into: &buf)
        FfiConverterBool.write(value.sensitive, into: &buf)
        FfiConverterBool.write(value.multiline, into: &buf)
        FfiConverterBool.write(value.nameEditable, into: &buf)
        FfiConverterBool.write(value.removable, into: &buf)
        FfiConverterBool.write(value.reorderable, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorField_lift(_ buf: RustBuffer) throws -> MobileEntryEditorField {
    return try FfiConverterTypeMobileEntryEditorField.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorField_lower(_ value: MobileEntryEditorField) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorField.lower(value)
}


public struct MobileEntryEditorInput: Equatable, Hashable {
    public var id: UInt64
    public var name: String?
    public var value: String?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: UInt64, name: String?, value: String?) {
        self.id = id
        self.name = name
        self.value = value
    }




}

#if compiler(>=6)
extension MobileEntryEditorInput: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorInput: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorInput {
        return
            try MobileEntryEditorInput(
                id: FfiConverterUInt64.read(from: &buf),
                name: FfiConverterOptionString.read(from: &buf),
                value: FfiConverterOptionString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryEditorInput, into buf: inout [UInt8]) {
        FfiConverterUInt64.write(value.id, into: &buf)
        FfiConverterOptionString.write(value.name, into: &buf)
        FfiConverterOptionString.write(value.value, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorInput_lift(_ buf: RustBuffer) throws -> MobileEntryEditorInput {
    return try FfiConverterTypeMobileEntryEditorInput.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorInput_lower(_ value: MobileEntryEditorInput) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorInput.lower(value)
}


public struct MobileEntryEditorPage: Equatable, Hashable {
    public var path: String
    public var title: String
    public var fields: [MobileEntryEditorField]
    public var dirty: Bool
    public var creating: Bool
    public var defaultPasswordLength: UInt32
    public var maximumPasswordLength: UInt32

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(path: String, title: String, fields: [MobileEntryEditorField], dirty: Bool, creating: Bool, defaultPasswordLength: UInt32, maximumPasswordLength: UInt32) {
        self.path = path
        self.title = title
        self.fields = fields
        self.dirty = dirty
        self.creating = creating
        self.defaultPasswordLength = defaultPasswordLength
        self.maximumPasswordLength = maximumPasswordLength
    }




}

#if compiler(>=6)
extension MobileEntryEditorPage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorPage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorPage {
        return
            try MobileEntryEditorPage(
                path: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                fields: FfiConverterSequenceTypeMobileEntryEditorField.read(from: &buf),
                dirty: FfiConverterBool.read(from: &buf),
                creating: FfiConverterBool.read(from: &buf),
                defaultPasswordLength: FfiConverterUInt32.read(from: &buf),
                maximumPasswordLength: FfiConverterUInt32.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryEditorPage, into buf: inout [UInt8]) {
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterSequenceTypeMobileEntryEditorField.write(value.fields, into: &buf)
        FfiConverterBool.write(value.dirty, into: &buf)
        FfiConverterBool.write(value.creating, into: &buf)
        FfiConverterUInt32.write(value.defaultPasswordLength, into: &buf)
        FfiConverterUInt32.write(value.maximumPasswordLength, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorPage_lift(_ buf: RustBuffer) throws -> MobileEntryEditorPage {
    return try FfiConverterTypeMobileEntryEditorPage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorPage_lower(_ value: MobileEntryEditorPage) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorPage.lower(value)
}


public struct MobileEntryEditorRecovery: Equatable, Hashable {
    public var session: MobileEntryEditorSession
    public var inputs: [MobileEntryEditorInput]?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(session: MobileEntryEditorSession, inputs: [MobileEntryEditorInput]?) {
        self.session = session
        self.inputs = inputs
    }




}

#if compiler(>=6)
extension MobileEntryEditorRecovery: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorRecovery: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorRecovery {
        return
            try MobileEntryEditorRecovery(
                session: FfiConverterTypeMobileEntryEditorSession.read(from: &buf),
                inputs: FfiConverterOptionSequenceTypeMobileEntryEditorInput.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryEditorRecovery, into buf: inout [UInt8]) {
        FfiConverterTypeMobileEntryEditorSession.write(value.session, into: &buf)
        FfiConverterOptionSequenceTypeMobileEntryEditorInput.write(value.inputs, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorRecovery_lift(_ buf: RustBuffer) throws -> MobileEntryEditorRecovery {
    return try FfiConverterTypeMobileEntryEditorRecovery.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorRecovery_lower(_ value: MobileEntryEditorRecovery) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorRecovery.lower(value)
}


public struct MobileEntryEditorSession: Equatable, Hashable {
    public var id: UInt64
    public var page: MobileEntryEditorPage

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: UInt64, page: MobileEntryEditorPage) {
        self.id = id
        self.page = page
    }




}

#if compiler(>=6)
extension MobileEntryEditorSession: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorSession: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorSession {
        return
            try MobileEntryEditorSession(
                id: FfiConverterUInt64.read(from: &buf),
                page: FfiConverterTypeMobileEntryEditorPage.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryEditorSession, into buf: inout [UInt8]) {
        FfiConverterUInt64.write(value.id, into: &buf)
        FfiConverterTypeMobileEntryEditorPage.write(value.page, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorSession_lift(_ buf: RustBuffer) throws -> MobileEntryEditorSession {
    return try FfiConverterTypeMobileEntryEditorSession.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorSession_lower(_ value: MobileEntryEditorSession) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorSession.lower(value)
}


public struct MobileEntryField: Equatable, Hashable {
    public var id: UInt64
    public var label: String
    public var icon: MobileIcon
    public var value: String?
    public var maskedValue: String
    public var detail: String?
    public var diagnostic: String?
    public var sensitive: Bool
    public var multiline: Bool
    public var selectable: Bool
    public var editable: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: UInt64, label: String, icon: MobileIcon, value: String?, maskedValue: String, detail: String?, diagnostic: String?, sensitive: Bool, multiline: Bool, selectable: Bool, editable: Bool) {
        self.id = id
        self.label = label
        self.icon = icon
        self.value = value
        self.maskedValue = maskedValue
        self.detail = detail
        self.diagnostic = diagnostic
        self.sensitive = sensitive
        self.multiline = multiline
        self.selectable = selectable
        self.editable = editable
    }




}

#if compiler(>=6)
extension MobileEntryField: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryField: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryField {
        return
            try MobileEntryField(
                id: FfiConverterUInt64.read(from: &buf),
                label: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                value: FfiConverterOptionString.read(from: &buf),
                maskedValue: FfiConverterString.read(from: &buf),
                detail: FfiConverterOptionString.read(from: &buf),
                diagnostic: FfiConverterOptionString.read(from: &buf),
                sensitive: FfiConverterBool.read(from: &buf),
                multiline: FfiConverterBool.read(from: &buf),
                selectable: FfiConverterBool.read(from: &buf),
                editable: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryField, into buf: inout [UInt8]) {
        FfiConverterUInt64.write(value.id, into: &buf)
        FfiConverterString.write(value.label, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterOptionString.write(value.value, into: &buf)
        FfiConverterString.write(value.maskedValue, into: &buf)
        FfiConverterOptionString.write(value.detail, into: &buf)
        FfiConverterOptionString.write(value.diagnostic, into: &buf)
        FfiConverterBool.write(value.sensitive, into: &buf)
        FfiConverterBool.write(value.multiline, into: &buf)
        FfiConverterBool.write(value.selectable, into: &buf)
        FfiConverterBool.write(value.editable, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryField_lift(_ buf: RustBuffer) throws -> MobileEntryField {
    return try FfiConverterTypeMobileEntryField.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryField_lower(_ value: MobileEntryField) -> RustBuffer {
    return FfiConverterTypeMobileEntryField.lower(value)
}


public struct MobileEntryPage: Equatable, Hashable {
    public var id: String
    public var revision: String
    public var title: String
    public var sections: [MobileEntrySection]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, revision: String, title: String, sections: [MobileEntrySection]) {
        self.id = id
        self.revision = revision
        self.title = title
        self.sections = sections
    }




}

#if compiler(>=6)
extension MobileEntryPage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryPage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryPage {
        return
            try MobileEntryPage(
                id: FfiConverterString.read(from: &buf),
                revision: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                sections: FfiConverterSequenceTypeMobileEntrySection.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryPage, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.revision, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterSequenceTypeMobileEntrySection.write(value.sections, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryPage_lift(_ buf: RustBuffer) throws -> MobileEntryPage {
    return try FfiConverterTypeMobileEntryPage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryPage_lower(_ value: MobileEntryPage) -> RustBuffer {
    return FfiConverterTypeMobileEntryPage.lower(value)
}


public struct MobileEntryPresentation: Equatable, Hashable {
    public var page: MobileEntryPage
    public var totp: MobileTotpDetail?
    public var cacheNotice: String?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(page: MobileEntryPage, totp: MobileTotpDetail?, cacheNotice: String?) {
        self.page = page
        self.totp = totp
        self.cacheNotice = cacheNotice
    }




}

#if compiler(>=6)
extension MobileEntryPresentation: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryPresentation: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryPresentation {
        return
            try MobileEntryPresentation(
                page: FfiConverterTypeMobileEntryPage.read(from: &buf),
                totp: FfiConverterOptionTypeMobileTotpDetail.read(from: &buf),
                cacheNotice: FfiConverterOptionString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntryPresentation, into buf: inout [UInt8]) {
        FfiConverterTypeMobileEntryPage.write(value.page, into: &buf)
        FfiConverterOptionTypeMobileTotpDetail.write(value.totp, into: &buf)
        FfiConverterOptionString.write(value.cacheNotice, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryPresentation_lift(_ buf: RustBuffer) throws -> MobileEntryPresentation {
    return try FfiConverterTypeMobileEntryPresentation.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryPresentation_lower(_ value: MobileEntryPresentation) -> RustBuffer {
    return FfiConverterTypeMobileEntryPresentation.lower(value)
}


public struct MobileEntrySection: Equatable, Hashable {
    public var kind: MobileEntrySectionKind
    public var title: String
    public var fields: [MobileEntryField]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(kind: MobileEntrySectionKind, title: String, fields: [MobileEntryField]) {
        self.kind = kind
        self.title = title
        self.fields = fields
    }




}

#if compiler(>=6)
extension MobileEntrySection: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntrySection: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntrySection {
        return
            try MobileEntrySection(
                kind: FfiConverterTypeMobileEntrySectionKind.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                fields: FfiConverterSequenceTypeMobileEntryField.read(from: &buf)
        )
    }

    public static func write(_ value: MobileEntrySection, into buf: inout [UInt8]) {
        FfiConverterTypeMobileEntrySectionKind.write(value.kind, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterSequenceTypeMobileEntryField.write(value.fields, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntrySection_lift(_ buf: RustBuffer) throws -> MobileEntrySection {
    return try FfiConverterTypeMobileEntrySection.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntrySection_lower(_ value: MobileEntrySection) -> RustBuffer {
    return FfiConverterTypeMobileEntrySection.lower(value)
}


public struct MobileGitIdentity: Equatable, Hashable {
    public var name: String
    public var email: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(name: String, email: String) {
        self.name = name
        self.email = email
    }




}

#if compiler(>=6)
extension MobileGitIdentity: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileGitIdentity: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileGitIdentity {
        return
            try MobileGitIdentity(
                name: FfiConverterString.read(from: &buf),
                email: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileGitIdentity, into buf: inout [UInt8]) {
        FfiConverterString.write(value.name, into: &buf)
        FfiConverterString.write(value.email, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileGitIdentity_lift(_ buf: RustBuffer) throws -> MobileGitIdentity {
    return try FfiConverterTypeMobileGitIdentity.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileGitIdentity_lower(_ value: MobileGitIdentity) -> RustBuffer {
    return FfiConverterTypeMobileGitIdentity.lower(value)
}


public struct MobileHomeAction: Equatable, Hashable {
    public var kind: MobileHomeActionKind
    public var title: String
    public var icon: MobileIcon

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(kind: MobileHomeActionKind, title: String, icon: MobileIcon) {
        self.kind = kind
        self.title = title
        self.icon = icon
    }




}

#if compiler(>=6)
extension MobileHomeAction: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeAction: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeAction {
        return
            try MobileHomeAction(
                kind: FfiConverterTypeMobileHomeActionKind.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeAction, into buf: inout [UInt8]) {
        FfiConverterTypeMobileHomeActionKind.write(value.kind, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeAction_lift(_ buf: RustBuffer) throws -> MobileHomeAction {
    return try FfiConverterTypeMobileHomeAction.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeAction_lower(_ value: MobileHomeAction) -> RustBuffer {
    return FfiConverterTypeMobileHomeAction.lower(value)
}


public struct MobileHomeChange: Equatable, Hashable {
    public var id: String
    public var title: String
    public var detail: String
    public var icon: MobileIcon
    public var kind: MobileHomeChangeKind
    public var status: MobileHomeChangeStatus

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, title: String, detail: String, icon: MobileIcon, kind: MobileHomeChangeKind, status: MobileHomeChangeStatus) {
        self.id = id
        self.title = title
        self.detail = detail
        self.icon = icon
        self.kind = kind
        self.status = status
    }




}

#if compiler(>=6)
extension MobileHomeChange: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeChange: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeChange {
        return
            try MobileHomeChange(
                id: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                kind: FfiConverterTypeMobileHomeChangeKind.read(from: &buf),
                status: FfiConverterTypeMobileHomeChangeStatus.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeChange, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterTypeMobileHomeChangeKind.write(value.kind, into: &buf)
        FfiConverterTypeMobileHomeChangeStatus.write(value.status, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChange_lift(_ buf: RustBuffer) throws -> MobileHomeChange {
    return try FfiConverterTypeMobileHomeChange.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChange_lower(_ value: MobileHomeChange) -> RustBuffer {
    return FfiConverterTypeMobileHomeChange.lower(value)
}


public struct MobileHomeCommit: Equatable, Hashable {
    public var id: String
    public var title: String
    public var detail: String
    public var icon: MobileIcon
    public var timestamp: Int64
    public var changes: [MobileHomeChange]
    public var actions: [MobileHomeAction]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, title: String, detail: String, icon: MobileIcon, timestamp: Int64, changes: [MobileHomeChange], actions: [MobileHomeAction]) {
        self.id = id
        self.title = title
        self.detail = detail
        self.icon = icon
        self.timestamp = timestamp
        self.changes = changes
        self.actions = actions
    }




}

#if compiler(>=6)
extension MobileHomeCommit: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeCommit: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeCommit {
        return
            try MobileHomeCommit(
                id: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                timestamp: FfiConverterInt64.read(from: &buf),
                changes: FfiConverterSequenceTypeMobileHomeChange.read(from: &buf),
                actions: FfiConverterSequenceTypeMobileHomeAction.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeCommit, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterInt64.write(value.timestamp, into: &buf)
        FfiConverterSequenceTypeMobileHomeChange.write(value.changes, into: &buf)
        FfiConverterSequenceTypeMobileHomeAction.write(value.actions, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeCommit_lift(_ buf: RustBuffer) throws -> MobileHomeCommit {
    return try FfiConverterTypeMobileHomeCommit.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeCommit_lower(_ value: MobileHomeCommit) -> RustBuffer {
    return FfiConverterTypeMobileHomeCommit.lower(value)
}


public struct MobileHomeNotice: Equatable, Hashable {
    public var title: String
    public var detail: String
    public var icon: MobileIcon

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(title: String, detail: String, icon: MobileIcon) {
        self.title = title
        self.detail = detail
        self.icon = icon
    }




}

#if compiler(>=6)
extension MobileHomeNotice: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeNotice: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeNotice {
        return
            try MobileHomeNotice(
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeNotice, into buf: inout [UInt8]) {
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeNotice_lift(_ buf: RustBuffer) throws -> MobileHomeNotice {
    return try FfiConverterTypeMobileHomeNotice.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeNotice_lower(_ value: MobileHomeNotice) -> RustBuffer {
    return FfiConverterTypeMobileHomeNotice.lower(value)
}


public struct MobileHomePage: Equatable, Hashable {
    public var remoteConfigured: Bool
    public var freshness: MobileHomeFreshness
    public var refreshedAt: Int64?
    public var summaries: [MobileHomeSummaryRow]
    public var incoming: [MobileHomeCommit]
    public var outgoing: [MobileHomeCommit]
    public var incomingTotal: UInt32
    public var outgoingTotal: UInt32
    public var notice: MobileHomeNotice?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(remoteConfigured: Bool, freshness: MobileHomeFreshness, refreshedAt: Int64?, summaries: [MobileHomeSummaryRow], incoming: [MobileHomeCommit], outgoing: [MobileHomeCommit], incomingTotal: UInt32, outgoingTotal: UInt32, notice: MobileHomeNotice?) {
        self.remoteConfigured = remoteConfigured
        self.freshness = freshness
        self.refreshedAt = refreshedAt
        self.summaries = summaries
        self.incoming = incoming
        self.outgoing = outgoing
        self.incomingTotal = incomingTotal
        self.outgoingTotal = outgoingTotal
        self.notice = notice
    }




}

#if compiler(>=6)
extension MobileHomePage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomePage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomePage {
        return
            try MobileHomePage(
                remoteConfigured: FfiConverterBool.read(from: &buf),
                freshness: FfiConverterTypeMobileHomeFreshness.read(from: &buf),
                refreshedAt: FfiConverterOptionInt64.read(from: &buf),
                summaries: FfiConverterSequenceTypeMobileHomeSummaryRow.read(from: &buf),
                incoming: FfiConverterSequenceTypeMobileHomeCommit.read(from: &buf),
                outgoing: FfiConverterSequenceTypeMobileHomeCommit.read(from: &buf),
                incomingTotal: FfiConverterUInt32.read(from: &buf),
                outgoingTotal: FfiConverterUInt32.read(from: &buf),
                notice: FfiConverterOptionTypeMobileHomeNotice.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomePage, into buf: inout [UInt8]) {
        FfiConverterBool.write(value.remoteConfigured, into: &buf)
        FfiConverterTypeMobileHomeFreshness.write(value.freshness, into: &buf)
        FfiConverterOptionInt64.write(value.refreshedAt, into: &buf)
        FfiConverterSequenceTypeMobileHomeSummaryRow.write(value.summaries, into: &buf)
        FfiConverterSequenceTypeMobileHomeCommit.write(value.incoming, into: &buf)
        FfiConverterSequenceTypeMobileHomeCommit.write(value.outgoing, into: &buf)
        FfiConverterUInt32.write(value.incomingTotal, into: &buf)
        FfiConverterUInt32.write(value.outgoingTotal, into: &buf)
        FfiConverterOptionTypeMobileHomeNotice.write(value.notice, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomePage_lift(_ buf: RustBuffer) throws -> MobileHomePage {
    return try FfiConverterTypeMobileHomePage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomePage_lower(_ value: MobileHomePage) -> RustBuffer {
    return FfiConverterTypeMobileHomePage.lower(value)
}


public struct MobileHomeProgress: Equatable, Hashable {
    public var action: MobileHomeActionKind?
    public var phase: MobileHomePhase
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(action: MobileHomeActionKind?, phase: MobileHomePhase, title: String, detail: String) {
        self.action = action
        self.phase = phase
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileHomeProgress: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeProgress: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeProgress {
        return
            try MobileHomeProgress(
                action: FfiConverterOptionTypeMobileHomeActionKind.read(from: &buf),
                phase: FfiConverterTypeMobileHomePhase.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeProgress, into buf: inout [UInt8]) {
        FfiConverterOptionTypeMobileHomeActionKind.write(value.action, into: &buf)
        FfiConverterTypeMobileHomePhase.write(value.phase, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeProgress_lift(_ buf: RustBuffer) throws -> MobileHomeProgress {
    return try FfiConverterTypeMobileHomeProgress.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeProgress_lower(_ value: MobileHomeProgress) -> RustBuffer {
    return FfiConverterTypeMobileHomeProgress.lower(value)
}


public struct MobileHomeSummaryRow: Equatable, Hashable {
    public var id: String
    public var title: String
    public var detail: String
    public var icon: MobileIcon
    public var actions: [MobileHomeAction]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, title: String, detail: String, icon: MobileIcon, actions: [MobileHomeAction]) {
        self.id = id
        self.title = title
        self.detail = detail
        self.icon = icon
        self.actions = actions
    }




}

#if compiler(>=6)
extension MobileHomeSummaryRow: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeSummaryRow: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeSummaryRow {
        return
            try MobileHomeSummaryRow(
                id: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                actions: FfiConverterSequenceTypeMobileHomeAction.read(from: &buf)
        )
    }

    public static func write(_ value: MobileHomeSummaryRow, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterSequenceTypeMobileHomeAction.write(value.actions, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeSummaryRow_lift(_ buf: RustBuffer) throws -> MobileHomeSummaryRow {
    return try FfiConverterTypeMobileHomeSummaryRow.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeSummaryRow_lower(_ value: MobileHomeSummaryRow) -> RustBuffer {
    return FfiConverterTypeMobileHomeSummaryRow.lower(value)
}


public struct MobileKeyTransferExport: Equatable, Hashable {
    public var key: MobileKeyTransferKey
    public var frames: [MobileKeyTransferFrame]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(key: MobileKeyTransferKey, frames: [MobileKeyTransferFrame]) {
        self.key = key
        self.frames = frames
    }




}

#if compiler(>=6)
extension MobileKeyTransferExport: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferExport: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferExport {
        return
            try MobileKeyTransferExport(
                key: FfiConverterTypeMobileKeyTransferKey.read(from: &buf),
                frames: FfiConverterSequenceTypeMobileKeyTransferFrame.read(from: &buf)
        )
    }

    public static func write(_ value: MobileKeyTransferExport, into buf: inout [UInt8]) {
        FfiConverterTypeMobileKeyTransferKey.write(value.key, into: &buf)
        FfiConverterSequenceTypeMobileKeyTransferFrame.write(value.frames, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferExport_lift(_ buf: RustBuffer) throws -> MobileKeyTransferExport {
    return try FfiConverterTypeMobileKeyTransferExport.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferExport_lower(_ value: MobileKeyTransferExport) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferExport.lower(value)
}


public struct MobileKeyTransferFrame: Equatable, Hashable {
    public var sequence: UInt32
    public var total: UInt32
    public var width: UInt32
    public var modules: Data

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(sequence: UInt32, total: UInt32, width: UInt32, modules: Data) {
        self.sequence = sequence
        self.total = total
        self.width = width
        self.modules = modules
    }




}

#if compiler(>=6)
extension MobileKeyTransferFrame: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferFrame: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferFrame {
        return
            try MobileKeyTransferFrame(
                sequence: FfiConverterUInt32.read(from: &buf),
                total: FfiConverterUInt32.read(from: &buf),
                width: FfiConverterUInt32.read(from: &buf),
                modules: FfiConverterData.read(from: &buf)
        )
    }

    public static func write(_ value: MobileKeyTransferFrame, into buf: inout [UInt8]) {
        FfiConverterUInt32.write(value.sequence, into: &buf)
        FfiConverterUInt32.write(value.total, into: &buf)
        FfiConverterUInt32.write(value.width, into: &buf)
        FfiConverterData.write(value.modules, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferFrame_lift(_ buf: RustBuffer) throws -> MobileKeyTransferFrame {
    return try FfiConverterTypeMobileKeyTransferFrame.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferFrame_lower(_ value: MobileKeyTransferFrame) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferFrame.lower(value)
}


public struct MobileKeyTransferKey: Equatable, Hashable {
    public var fingerprint: String
    public var title: String
    public var detail: String
    public var kind: MobileKeyTransferKind
    public var requiresPassphrase: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(fingerprint: String, title: String, detail: String, kind: MobileKeyTransferKind, requiresPassphrase: Bool) {
        self.fingerprint = fingerprint
        self.title = title
        self.detail = detail
        self.kind = kind
        self.requiresPassphrase = requiresPassphrase
    }




}

#if compiler(>=6)
extension MobileKeyTransferKey: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferKey: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferKey {
        return
            try MobileKeyTransferKey(
                fingerprint: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                kind: FfiConverterTypeMobileKeyTransferKind.read(from: &buf),
                requiresPassphrase: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileKeyTransferKey, into buf: inout [UInt8]) {
        FfiConverterString.write(value.fingerprint, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileKeyTransferKind.write(value.kind, into: &buf)
        FfiConverterBool.write(value.requiresPassphrase, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferKey_lift(_ buf: RustBuffer) throws -> MobileKeyTransferKey {
    return try FfiConverterTypeMobileKeyTransferKey.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferKey_lower(_ value: MobileKeyTransferKey) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferKey.lower(value)
}


public struct MobileKeyTransferOutcome: Equatable, Hashable {
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(title: String, detail: String) {
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileKeyTransferOutcome: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferOutcome: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferOutcome {
        return
            try MobileKeyTransferOutcome(
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileKeyTransferOutcome, into buf: inout [UInt8]) {
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferOutcome_lift(_ buf: RustBuffer) throws -> MobileKeyTransferOutcome {
    return try FfiConverterTypeMobileKeyTransferOutcome.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferOutcome_lower(_ value: MobileKeyTransferOutcome) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferOutcome.lower(value)
}


public struct MobileKeyTransferProgress: Equatable, Hashable {
    public var received: UInt32
    public var total: UInt32
    public var duplicate: Bool
    public var key: MobileKeyTransferKey?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(received: UInt32, total: UInt32, duplicate: Bool, key: MobileKeyTransferKey?) {
        self.received = received
        self.total = total
        self.duplicate = duplicate
        self.key = key
    }




}

#if compiler(>=6)
extension MobileKeyTransferProgress: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferProgress: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferProgress {
        return
            try MobileKeyTransferProgress(
                received: FfiConverterUInt32.read(from: &buf),
                total: FfiConverterUInt32.read(from: &buf),
                duplicate: FfiConverterBool.read(from: &buf),
                key: FfiConverterOptionTypeMobileKeyTransferKey.read(from: &buf)
        )
    }

    public static func write(_ value: MobileKeyTransferProgress, into buf: inout [UInt8]) {
        FfiConverterUInt32.write(value.received, into: &buf)
        FfiConverterUInt32.write(value.total, into: &buf)
        FfiConverterBool.write(value.duplicate, into: &buf)
        FfiConverterOptionTypeMobileKeyTransferKey.write(value.key, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferProgress_lift(_ buf: RustBuffer) throws -> MobileKeyTransferProgress {
    return try FfiConverterTypeMobileKeyTransferProgress.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferProgress_lower(_ value: MobileKeyTransferProgress) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferProgress.lower(value)
}


public struct MobileMutationDestination: Equatable, Hashable {
    public var path: String
    public var title: String
    public var detail: String
    public var requiresOverwrite: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(path: String, title: String, detail: String, requiresOverwrite: Bool) {
        self.path = path
        self.title = title
        self.detail = detail
        self.requiresOverwrite = requiresOverwrite
    }




}

#if compiler(>=6)
extension MobileMutationDestination: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileMutationDestination: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileMutationDestination {
        return
            try MobileMutationDestination(
                path: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                requiresOverwrite: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileMutationDestination, into buf: inout [UInt8]) {
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterBool.write(value.requiresOverwrite, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationDestination_lift(_ buf: RustBuffer) throws -> MobileMutationDestination {
    return try FfiConverterTypeMobileMutationDestination.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationDestination_lower(_ value: MobileMutationDestination) -> RustBuffer {
    return FfiConverterTypeMobileMutationDestination.lower(value)
}


public struct MobileMutationOutcome: Equatable, Hashable {
    public var action: MobileMutationAction
    public var source: String
    public var destination: String?
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(action: MobileMutationAction, source: String, destination: String?, title: String, detail: String) {
        self.action = action
        self.source = source
        self.destination = destination
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileMutationOutcome: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileMutationOutcome: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileMutationOutcome {
        return
            try MobileMutationOutcome(
                action: FfiConverterTypeMobileMutationAction.read(from: &buf),
                source: FfiConverterString.read(from: &buf),
                destination: FfiConverterOptionString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileMutationOutcome, into buf: inout [UInt8]) {
        FfiConverterTypeMobileMutationAction.write(value.action, into: &buf)
        FfiConverterString.write(value.source, into: &buf)
        FfiConverterOptionString.write(value.destination, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationOutcome_lift(_ buf: RustBuffer) throws -> MobileMutationOutcome {
    return try FfiConverterTypeMobileMutationOutcome.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationOutcome_lower(_ value: MobileMutationOutcome) -> RustBuffer {
    return FfiConverterTypeMobileMutationOutcome.lower(value)
}


public struct MobileMutationPlan: Equatable, Hashable {
    public var action: MobileMutationAction
    public var source: String
    public var sourceTitle: String
    public var revision: String
    public var destinations: [MobileMutationDestination]
    public var hasOpenEditor: Bool
    public var hasDirtyEditor: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(action: MobileMutationAction, source: String, sourceTitle: String, revision: String, destinations: [MobileMutationDestination], hasOpenEditor: Bool, hasDirtyEditor: Bool) {
        self.action = action
        self.source = source
        self.sourceTitle = sourceTitle
        self.revision = revision
        self.destinations = destinations
        self.hasOpenEditor = hasOpenEditor
        self.hasDirtyEditor = hasDirtyEditor
    }




}

#if compiler(>=6)
extension MobileMutationPlan: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileMutationPlan: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileMutationPlan {
        return
            try MobileMutationPlan(
                action: FfiConverterTypeMobileMutationAction.read(from: &buf),
                source: FfiConverterString.read(from: &buf),
                sourceTitle: FfiConverterString.read(from: &buf),
                revision: FfiConverterString.read(from: &buf),
                destinations: FfiConverterSequenceTypeMobileMutationDestination.read(from: &buf),
                hasOpenEditor: FfiConverterBool.read(from: &buf),
                hasDirtyEditor: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileMutationPlan, into buf: inout [UInt8]) {
        FfiConverterTypeMobileMutationAction.write(value.action, into: &buf)
        FfiConverterString.write(value.source, into: &buf)
        FfiConverterString.write(value.sourceTitle, into: &buf)
        FfiConverterString.write(value.revision, into: &buf)
        FfiConverterSequenceTypeMobileMutationDestination.write(value.destinations, into: &buf)
        FfiConverterBool.write(value.hasOpenEditor, into: &buf)
        FfiConverterBool.write(value.hasDirtyEditor, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationPlan_lift(_ buf: RustBuffer) throws -> MobileMutationPlan {
    return try FfiConverterTypeMobileMutationPlan.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationPlan_lower(_ value: MobileMutationPlan) -> RustBuffer {
    return FfiConverterTypeMobileMutationPlan.lower(value)
}


public struct MobileMutationRequest: Equatable, Hashable {
    public var action: MobileMutationAction
    public var source: String
    public var revision: String
    public var destination: String?
    public var confirmed: Bool
    public var overwrite: Bool
    public var discardEditor: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(action: MobileMutationAction, source: String, revision: String, destination: String?, confirmed: Bool, overwrite: Bool, discardEditor: Bool) {
        self.action = action
        self.source = source
        self.revision = revision
        self.destination = destination
        self.confirmed = confirmed
        self.overwrite = overwrite
        self.discardEditor = discardEditor
    }




}

#if compiler(>=6)
extension MobileMutationRequest: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileMutationRequest: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileMutationRequest {
        return
            try MobileMutationRequest(
                action: FfiConverterTypeMobileMutationAction.read(from: &buf),
                source: FfiConverterString.read(from: &buf),
                revision: FfiConverterString.read(from: &buf),
                destination: FfiConverterOptionString.read(from: &buf),
                confirmed: FfiConverterBool.read(from: &buf),
                overwrite: FfiConverterBool.read(from: &buf),
                discardEditor: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileMutationRequest, into buf: inout [UInt8]) {
        FfiConverterTypeMobileMutationAction.write(value.action, into: &buf)
        FfiConverterString.write(value.source, into: &buf)
        FfiConverterString.write(value.revision, into: &buf)
        FfiConverterOptionString.write(value.destination, into: &buf)
        FfiConverterBool.write(value.confirmed, into: &buf)
        FfiConverterBool.write(value.overwrite, into: &buf)
        FfiConverterBool.write(value.discardEditor, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationRequest_lift(_ buf: RustBuffer) throws -> MobileMutationRequest {
    return try FfiConverterTypeMobileMutationRequest.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationRequest_lower(_ value: MobileMutationRequest) -> RustBuffer {
    return FfiConverterTypeMobileMutationRequest.lower(value)
}


public struct MobileNavigationRow: Equatable, Hashable {
    public var row: MobilePasswordRow
    public var revision: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(row: MobilePasswordRow, revision: String) {
        self.row = row
        self.revision = revision
    }




}

#if compiler(>=6)
extension MobileNavigationRow: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileNavigationRow: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileNavigationRow {
        return
            try MobileNavigationRow(
                row: FfiConverterTypeMobilePasswordRow.read(from: &buf),
                revision: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileNavigationRow, into buf: inout [UInt8]) {
        FfiConverterTypeMobilePasswordRow.write(value.row, into: &buf)
        FfiConverterString.write(value.revision, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileNavigationRow_lift(_ buf: RustBuffer) throws -> MobileNavigationRow {
    return try FfiConverterTypeMobileNavigationRow.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileNavigationRow_lower(_ value: MobileNavigationRow) -> RustBuffer {
    return FfiConverterTypeMobileNavigationRow.lower(value)
}


public struct MobileOnboardingDiscovery: Equatable, Hashable {
    public var branches: [String]
    public var selectedBranch: UInt32

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(branches: [String], selectedBranch: UInt32) {
        self.branches = branches
        self.selectedBranch = selectedBranch
    }




}

#if compiler(>=6)
extension MobileOnboardingDiscovery: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingDiscovery: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingDiscovery {
        return
            try MobileOnboardingDiscovery(
                branches: FfiConverterSequenceString.read(from: &buf),
                selectedBranch: FfiConverterUInt32.read(from: &buf)
        )
    }

    public static func write(_ value: MobileOnboardingDiscovery, into buf: inout [UInt8]) {
        FfiConverterSequenceString.write(value.branches, into: &buf)
        FfiConverterUInt32.write(value.selectedBranch, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingDiscovery_lift(_ buf: RustBuffer) throws -> MobileOnboardingDiscovery {
    return try FfiConverterTypeMobileOnboardingDiscovery.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingDiscovery_lower(_ value: MobileOnboardingDiscovery) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingDiscovery.lower(value)
}


public struct MobileOnboardingOutcome: Equatable, Hashable {
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(title: String, detail: String) {
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileOnboardingOutcome: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingOutcome: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingOutcome {
        return
            try MobileOnboardingOutcome(
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileOnboardingOutcome, into buf: inout [UInt8]) {
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingOutcome_lift(_ buf: RustBuffer) throws -> MobileOnboardingOutcome {
    return try FfiConverterTypeMobileOnboardingOutcome.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingOutcome_lower(_ value: MobileOnboardingOutcome) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingOutcome.lower(value)
}


public struct MobileOnboardingProgress: Equatable, Hashable {
    public var phase: MobileOnboardingPhase
    public var title: String
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(phase: MobileOnboardingPhase, title: String, detail: String) {
        self.phase = phase
        self.title = title
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileOnboardingProgress: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingProgress: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingProgress {
        return
            try MobileOnboardingProgress(
                phase: FfiConverterTypeMobileOnboardingPhase.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileOnboardingProgress, into buf: inout [UInt8]) {
        FfiConverterTypeMobileOnboardingPhase.write(value.phase, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingProgress_lift(_ buf: RustBuffer) throws -> MobileOnboardingProgress {
    return try FfiConverterTypeMobileOnboardingProgress.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingProgress_lower(_ value: MobileOnboardingProgress) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingProgress.lower(value)
}


public struct MobilePage: Equatable, Hashable {
    public var tab: MobileTab
    public var title: String
    public var icon: MobileIcon
    public var state: MobileShellState
    public var stateTitle: String
    public var stateDetail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(tab: MobileTab, title: String, icon: MobileIcon, state: MobileShellState, stateTitle: String, stateDetail: String) {
        self.tab = tab
        self.title = title
        self.icon = icon
        self.state = state
        self.stateTitle = stateTitle
        self.stateDetail = stateDetail
    }




}

#if compiler(>=6)
extension MobilePage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePage {
        return
            try MobilePage(
                tab: FfiConverterTypeMobileTab.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                state: FfiConverterTypeMobileShellState.read(from: &buf),
                stateTitle: FfiConverterString.read(from: &buf),
                stateDetail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePage, into buf: inout [UInt8]) {
        FfiConverterTypeMobileTab.write(value.tab, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterTypeMobileShellState.write(value.state, into: &buf)
        FfiConverterString.write(value.stateTitle, into: &buf)
        FfiConverterString.write(value.stateDetail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePage_lift(_ buf: RustBuffer) throws -> MobilePage {
    return try FfiConverterTypeMobilePage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePage_lower(_ value: MobilePage) -> RustBuffer {
    return FfiConverterTypeMobilePage.lower(value)
}


public struct MobilePasswordNavigation: Equatable, Hashable {
    public var path: String
    public var title: String
    public var parent: String?
    public var revision: String
    public var rows: [MobileNavigationRow]
    public var selected: MobileNavigationRow?
    public var stale: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(path: String, title: String, parent: String?, revision: String, rows: [MobileNavigationRow], selected: MobileNavigationRow?, stale: Bool) {
        self.path = path
        self.title = title
        self.parent = parent
        self.revision = revision
        self.rows = rows
        self.selected = selected
        self.stale = stale
    }




}

#if compiler(>=6)
extension MobilePasswordNavigation: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordNavigation: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordNavigation {
        return
            try MobilePasswordNavigation(
                path: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                parent: FfiConverterOptionString.read(from: &buf),
                revision: FfiConverterString.read(from: &buf),
                rows: FfiConverterSequenceTypeMobileNavigationRow.read(from: &buf),
                selected: FfiConverterOptionTypeMobileNavigationRow.read(from: &buf),
                stale: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePasswordNavigation, into buf: inout [UInt8]) {
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterOptionString.write(value.parent, into: &buf)
        FfiConverterString.write(value.revision, into: &buf)
        FfiConverterSequenceTypeMobileNavigationRow.write(value.rows, into: &buf)
        FfiConverterOptionTypeMobileNavigationRow.write(value.selected, into: &buf)
        FfiConverterBool.write(value.stale, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordNavigation_lift(_ buf: RustBuffer) throws -> MobilePasswordNavigation {
    return try FfiConverterTypeMobilePasswordNavigation.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordNavigation_lower(_ value: MobilePasswordNavigation) -> RustBuffer {
    return FfiConverterTypeMobilePasswordNavigation.lower(value)
}


public struct MobilePasswordPage: Equatable, Hashable {
    public var id: String
    public var path: String
    public var title: String
    public var rows: [MobilePasswordRow]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, path: String, title: String, rows: [MobilePasswordRow]) {
        self.id = id
        self.path = path
        self.title = title
        self.rows = rows
    }




}

#if compiler(>=6)
extension MobilePasswordPage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordPage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordPage {
        return
            try MobilePasswordPage(
                id: FfiConverterString.read(from: &buf),
                path: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                rows: FfiConverterSequenceTypeMobilePasswordRow.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePasswordPage, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterSequenceTypeMobilePasswordRow.write(value.rows, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordPage_lift(_ buf: RustBuffer) throws -> MobilePasswordPage {
    return try FfiConverterTypeMobilePasswordPage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordPage_lower(_ value: MobilePasswordPage) -> RustBuffer {
    return FfiConverterTypeMobilePasswordPage.lower(value)
}


public struct MobilePasswordRow: Equatable, Hashable {
    public var id: String
    public var path: String
    public var title: String
    public var detail: String
    public var icon: MobileIcon
    public var kind: MobilePasswordRowKind

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(id: String, path: String, title: String, detail: String, icon: MobileIcon, kind: MobilePasswordRowKind) {
        self.id = id
        self.path = path
        self.title = title
        self.detail = detail
        self.icon = icon
        self.kind = kind
    }




}

#if compiler(>=6)
extension MobilePasswordRow: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordRow: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordRow {
        return
            try MobilePasswordRow(
                id: FfiConverterString.read(from: &buf),
                path: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                icon: FfiConverterTypeMobileIcon.read(from: &buf),
                kind: FfiConverterTypeMobilePasswordRowKind.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePasswordRow, into buf: inout [UInt8]) {
        FfiConverterString.write(value.id, into: &buf)
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterTypeMobileIcon.write(value.icon, into: &buf)
        FfiConverterTypeMobilePasswordRowKind.write(value.kind, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordRow_lift(_ buf: RustBuffer) throws -> MobilePasswordRow {
    return try FfiConverterTypeMobilePasswordRow.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordRow_lower(_ value: MobilePasswordRow) -> RustBuffer {
    return FfiConverterTypeMobilePasswordRow.lower(value)
}


public struct MobilePlatformLayout: Equatable, Hashable {
    public var configuration: String
    public var vault: String
    public var keys: String
    public var cache: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(configuration: String, vault: String, keys: String, cache: String) {
        self.configuration = configuration
        self.vault = vault
        self.keys = keys
        self.cache = cache
    }




}

#if compiler(>=6)
extension MobilePlatformLayout: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePlatformLayout: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePlatformLayout {
        return
            try MobilePlatformLayout(
                configuration: FfiConverterString.read(from: &buf),
                vault: FfiConverterString.read(from: &buf),
                keys: FfiConverterString.read(from: &buf),
                cache: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePlatformLayout, into buf: inout [UInt8]) {
        FfiConverterString.write(value.configuration, into: &buf)
        FfiConverterString.write(value.vault, into: &buf)
        FfiConverterString.write(value.keys, into: &buf)
        FfiConverterString.write(value.cache, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformLayout_lift(_ buf: RustBuffer) throws -> MobilePlatformLayout {
    return try FfiConverterTypeMobilePlatformLayout.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformLayout_lower(_ value: MobilePlatformLayout) -> RustBuffer {
    return FfiConverterTypeMobilePlatformLayout.lower(value)
}


public struct MobilePlatformPaths: Equatable, Hashable {
    public var dataRoot: String
    public var cacheRoot: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(dataRoot: String, cacheRoot: String) {
        self.dataRoot = dataRoot
        self.cacheRoot = cacheRoot
    }




}

#if compiler(>=6)
extension MobilePlatformPaths: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePlatformPaths: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePlatformPaths {
        return
            try MobilePlatformPaths(
                dataRoot: FfiConverterString.read(from: &buf),
                cacheRoot: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePlatformPaths, into buf: inout [UInt8]) {
        FfiConverterString.write(value.dataRoot, into: &buf)
        FfiConverterString.write(value.cacheRoot, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformPaths_lift(_ buf: RustBuffer) throws -> MobilePlatformPaths {
    return try FfiConverterTypeMobilePlatformPaths.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformPaths_lower(_ value: MobilePlatformPaths) -> RustBuffer {
    return FfiConverterTypeMobilePlatformPaths.lower(value)
}


public struct MobilePreferences: Equatable, Hashable {
    public var syncConfigured: Bool
    public var repositoryTitle: String
    public var repositoryUrl: String
    public var serverTitle: String
    public var serverIdentity: String
    public var applicationAccount: String?
    public var defaultKeyTitle: String
    public var defaultKeyFingerprint: String
    public var authenticationTimeoutSeconds: UInt64
    public var biometricUnlockEnabled: Bool
    public var appearance: MobileAppearance
    public var watchState: MobileWatchPreferenceState
    public var watchTitle: String
    public var watchDetail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(syncConfigured: Bool, repositoryTitle: String, repositoryUrl: String, serverTitle: String, serverIdentity: String, applicationAccount: String?, defaultKeyTitle: String, defaultKeyFingerprint: String, authenticationTimeoutSeconds: UInt64, biometricUnlockEnabled: Bool, appearance: MobileAppearance, watchState: MobileWatchPreferenceState, watchTitle: String, watchDetail: String) {
        self.syncConfigured = syncConfigured
        self.repositoryTitle = repositoryTitle
        self.repositoryUrl = repositoryUrl
        self.serverTitle = serverTitle
        self.serverIdentity = serverIdentity
        self.applicationAccount = applicationAccount
        self.defaultKeyTitle = defaultKeyTitle
        self.defaultKeyFingerprint = defaultKeyFingerprint
        self.authenticationTimeoutSeconds = authenticationTimeoutSeconds
        self.biometricUnlockEnabled = biometricUnlockEnabled
        self.appearance = appearance
        self.watchState = watchState
        self.watchTitle = watchTitle
        self.watchDetail = watchDetail
    }




}

#if compiler(>=6)
extension MobilePreferences: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePreferences: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePreferences {
        return
            try MobilePreferences(
                syncConfigured: FfiConverterBool.read(from: &buf),
                repositoryTitle: FfiConverterString.read(from: &buf),
                repositoryUrl: FfiConverterString.read(from: &buf),
                serverTitle: FfiConverterString.read(from: &buf),
                serverIdentity: FfiConverterString.read(from: &buf),
                applicationAccount: FfiConverterOptionString.read(from: &buf),
                defaultKeyTitle: FfiConverterString.read(from: &buf),
                defaultKeyFingerprint: FfiConverterString.read(from: &buf),
                authenticationTimeoutSeconds: FfiConverterUInt64.read(from: &buf),
                biometricUnlockEnabled: FfiConverterBool.read(from: &buf),
                appearance: FfiConverterTypeMobileAppearance.read(from: &buf),
                watchState: FfiConverterTypeMobileWatchPreferenceState.read(from: &buf),
                watchTitle: FfiConverterString.read(from: &buf),
                watchDetail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePreferences, into buf: inout [UInt8]) {
        FfiConverterBool.write(value.syncConfigured, into: &buf)
        FfiConverterString.write(value.repositoryTitle, into: &buf)
        FfiConverterString.write(value.repositoryUrl, into: &buf)
        FfiConverterString.write(value.serverTitle, into: &buf)
        FfiConverterString.write(value.serverIdentity, into: &buf)
        FfiConverterOptionString.write(value.applicationAccount, into: &buf)
        FfiConverterString.write(value.defaultKeyTitle, into: &buf)
        FfiConverterString.write(value.defaultKeyFingerprint, into: &buf)
        FfiConverterUInt64.write(value.authenticationTimeoutSeconds, into: &buf)
        FfiConverterBool.write(value.biometricUnlockEnabled, into: &buf)
        FfiConverterTypeMobileAppearance.write(value.appearance, into: &buf)
        FfiConverterTypeMobileWatchPreferenceState.write(value.watchState, into: &buf)
        FfiConverterString.write(value.watchTitle, into: &buf)
        FfiConverterString.write(value.watchDetail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePreferences_lift(_ buf: RustBuffer) throws -> MobilePreferences {
    return try FfiConverterTypeMobilePreferences.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePreferences_lower(_ value: MobilePreferences) -> RustBuffer {
    return FfiConverterTypeMobilePreferences.lower(value)
}


public struct MobilePrivateDirectories: Equatable, Hashable {
    public var files: String
    public var noBackup: String
    public var cache: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(files: String, noBackup: String, cache: String) {
        self.files = files
        self.noBackup = noBackup
        self.cache = cache
    }




}

#if compiler(>=6)
extension MobilePrivateDirectories: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateDirectories: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateDirectories {
        return
            try MobilePrivateDirectories(
                files: FfiConverterString.read(from: &buf),
                noBackup: FfiConverterString.read(from: &buf),
                cache: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePrivateDirectories, into buf: inout [UInt8]) {
        FfiConverterString.write(value.files, into: &buf)
        FfiConverterString.write(value.noBackup, into: &buf)
        FfiConverterString.write(value.cache, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateDirectories_lift(_ buf: RustBuffer) throws -> MobilePrivateDirectories {
    return try FfiConverterTypeMobilePrivateDirectories.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateDirectories_lower(_ value: MobilePrivateDirectories) -> RustBuffer {
    return FfiConverterTypeMobilePrivateDirectories.lower(value)
}


public struct MobilePrivateStorageLayout: Equatable, Hashable {
    public var data: String
    public var configuration: String
    public var vault: String
    public var keys: String
    public var catalog: String
    public var scratch: String
    public var cache: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(data: String, configuration: String, vault: String, keys: String, catalog: String, scratch: String, cache: String) {
        self.data = data
        self.configuration = configuration
        self.vault = vault
        self.keys = keys
        self.catalog = catalog
        self.scratch = scratch
        self.cache = cache
    }




}

#if compiler(>=6)
extension MobilePrivateStorageLayout: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateStorageLayout: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateStorageLayout {
        return
            try MobilePrivateStorageLayout(
                data: FfiConverterString.read(from: &buf),
                configuration: FfiConverterString.read(from: &buf),
                vault: FfiConverterString.read(from: &buf),
                keys: FfiConverterString.read(from: &buf),
                catalog: FfiConverterString.read(from: &buf),
                scratch: FfiConverterString.read(from: &buf),
                cache: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePrivateStorageLayout, into buf: inout [UInt8]) {
        FfiConverterString.write(value.data, into: &buf)
        FfiConverterString.write(value.configuration, into: &buf)
        FfiConverterString.write(value.vault, into: &buf)
        FfiConverterString.write(value.keys, into: &buf)
        FfiConverterString.write(value.catalog, into: &buf)
        FfiConverterString.write(value.scratch, into: &buf)
        FfiConverterString.write(value.cache, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageLayout_lift(_ buf: RustBuffer) throws -> MobilePrivateStorageLayout {
    return try FfiConverterTypeMobilePrivateStorageLayout.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageLayout_lower(_ value: MobilePrivateStorageLayout) -> RustBuffer {
    return FfiConverterTypeMobilePrivateStorageLayout.lower(value)
}


public struct MobilePrivateStorageStatus: Equatable, Hashable {
    public var version: UInt32
    public var configured: Bool
    public var recoveredTemporaryFiles: Bool
    public var recoveredCatalog: Bool
    public var secureBindingPresent: Bool
    public var recovery: MobilePrivateStorageErrorKind?

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(version: UInt32, configured: Bool, recoveredTemporaryFiles: Bool, recoveredCatalog: Bool, secureBindingPresent: Bool, recovery: MobilePrivateStorageErrorKind?) {
        self.version = version
        self.configured = configured
        self.recoveredTemporaryFiles = recoveredTemporaryFiles
        self.recoveredCatalog = recoveredCatalog
        self.secureBindingPresent = secureBindingPresent
        self.recovery = recovery
    }




}

#if compiler(>=6)
extension MobilePrivateStorageStatus: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateStorageStatus: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateStorageStatus {
        return
            try MobilePrivateStorageStatus(
                version: FfiConverterUInt32.read(from: &buf),
                configured: FfiConverterBool.read(from: &buf),
                recoveredTemporaryFiles: FfiConverterBool.read(from: &buf),
                recoveredCatalog: FfiConverterBool.read(from: &buf),
                secureBindingPresent: FfiConverterBool.read(from: &buf),
                recovery: FfiConverterOptionTypeMobilePrivateStorageErrorKind.read(from: &buf)
        )
    }

    public static func write(_ value: MobilePrivateStorageStatus, into buf: inout [UInt8]) {
        FfiConverterUInt32.write(value.version, into: &buf)
        FfiConverterBool.write(value.configured, into: &buf)
        FfiConverterBool.write(value.recoveredTemporaryFiles, into: &buf)
        FfiConverterBool.write(value.recoveredCatalog, into: &buf)
        FfiConverterBool.write(value.secureBindingPresent, into: &buf)
        FfiConverterOptionTypeMobilePrivateStorageErrorKind.write(value.recovery, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageStatus_lift(_ buf: RustBuffer) throws -> MobilePrivateStorageStatus {
    return try FfiConverterTypeMobilePrivateStorageStatus.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageStatus_lower(_ value: MobilePrivateStorageStatus) -> RustBuffer {
    return FfiConverterTypeMobilePrivateStorageStatus.lower(value)
}


public struct MobileShell: Equatable, Hashable {
    public var selectedTab: MobileTab
    public var pages: [MobilePage]

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(selectedTab: MobileTab, pages: [MobilePage]) {
        self.selectedTab = selectedTab
        self.pages = pages
    }




}

#if compiler(>=6)
extension MobileShell: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileShell: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileShell {
        return
            try MobileShell(
                selectedTab: FfiConverterTypeMobileTab.read(from: &buf),
                pages: FfiConverterSequenceTypeMobilePage.read(from: &buf)
        )
    }

    public static func write(_ value: MobileShell, into buf: inout [UInt8]) {
        FfiConverterTypeMobileTab.write(value.selectedTab, into: &buf)
        FfiConverterSequenceTypeMobilePage.write(value.pages, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileShell_lift(_ buf: RustBuffer) throws -> MobileShell {
    return try FfiConverterTypeMobileShell.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileShell_lower(_ value: MobileShell) -> RustBuffer {
    return FfiConverterTypeMobileShell.lower(value)
}


public struct MobileTotpDetail: Equatable, Hashable {
    public var path: String
    public var issuer: String?
    public var account: String
    public var code: String
    public var validUntil: UInt64
    public var remainingSeconds: UInt64
    public var period: UInt64
    public var sharedWithWatch: Bool
    public var watch: MobileWatchSnapshotStatus

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(path: String, issuer: String?, account: String, code: String, validUntil: UInt64, remainingSeconds: UInt64, period: UInt64, sharedWithWatch: Bool, watch: MobileWatchSnapshotStatus) {
        self.path = path
        self.issuer = issuer
        self.account = account
        self.code = code
        self.validUntil = validUntil
        self.remainingSeconds = remainingSeconds
        self.period = period
        self.sharedWithWatch = sharedWithWatch
        self.watch = watch
    }




}

#if compiler(>=6)
extension MobileTotpDetail: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpDetail: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpDetail {
        return
            try MobileTotpDetail(
                path: FfiConverterString.read(from: &buf),
                issuer: FfiConverterOptionString.read(from: &buf),
                account: FfiConverterString.read(from: &buf),
                code: FfiConverterString.read(from: &buf),
                validUntil: FfiConverterUInt64.read(from: &buf),
                remainingSeconds: FfiConverterUInt64.read(from: &buf),
                period: FfiConverterUInt64.read(from: &buf),
                sharedWithWatch: FfiConverterBool.read(from: &buf),
                watch: FfiConverterTypeMobileWatchSnapshotStatus.read(from: &buf)
        )
    }

    public static func write(_ value: MobileTotpDetail, into buf: inout [UInt8]) {
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterOptionString.write(value.issuer, into: &buf)
        FfiConverterString.write(value.account, into: &buf)
        FfiConverterString.write(value.code, into: &buf)
        FfiConverterUInt64.write(value.validUntil, into: &buf)
        FfiConverterUInt64.write(value.remainingSeconds, into: &buf)
        FfiConverterUInt64.write(value.period, into: &buf)
        FfiConverterBool.write(value.sharedWithWatch, into: &buf)
        FfiConverterTypeMobileWatchSnapshotStatus.write(value.watch, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDetail_lift(_ buf: RustBuffer) throws -> MobileTotpDetail {
    return try FfiConverterTypeMobileTotpDetail.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDetail_lower(_ value: MobileTotpDetail) -> RustBuffer {
    return FfiConverterTypeMobileTotpDetail.lower(value)
}


public struct MobileTotpDiscoveryProgress: Equatable, Hashable {
    public var phase: MobileTotpDiscoveryPhase
    public var total: UInt32
    public var inspected: UInt32
    public var cacheHits: UInt32
    public var matches: UInt32
    public var unavailable: UInt32

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(phase: MobileTotpDiscoveryPhase, total: UInt32, inspected: UInt32, cacheHits: UInt32, matches: UInt32, unavailable: UInt32) {
        self.phase = phase
        self.total = total
        self.inspected = inspected
        self.cacheHits = cacheHits
        self.matches = matches
        self.unavailable = unavailable
    }




}

#if compiler(>=6)
extension MobileTotpDiscoveryProgress: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpDiscoveryProgress: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpDiscoveryProgress {
        return
            try MobileTotpDiscoveryProgress(
                phase: FfiConverterTypeMobileTotpDiscoveryPhase.read(from: &buf),
                total: FfiConverterUInt32.read(from: &buf),
                inspected: FfiConverterUInt32.read(from: &buf),
                cacheHits: FfiConverterUInt32.read(from: &buf),
                matches: FfiConverterUInt32.read(from: &buf),
                unavailable: FfiConverterUInt32.read(from: &buf)
        )
    }

    public static func write(_ value: MobileTotpDiscoveryProgress, into buf: inout [UInt8]) {
        FfiConverterTypeMobileTotpDiscoveryPhase.write(value.phase, into: &buf)
        FfiConverterUInt32.write(value.total, into: &buf)
        FfiConverterUInt32.write(value.inspected, into: &buf)
        FfiConverterUInt32.write(value.cacheHits, into: &buf)
        FfiConverterUInt32.write(value.matches, into: &buf)
        FfiConverterUInt32.write(value.unavailable, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDiscoveryProgress_lift(_ buf: RustBuffer) throws -> MobileTotpDiscoveryProgress {
    return try FfiConverterTypeMobileTotpDiscoveryProgress.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDiscoveryProgress_lower(_ value: MobileTotpDiscoveryProgress) -> RustBuffer {
    return FfiConverterTypeMobileTotpDiscoveryProgress.lower(value)
}


public struct MobileTotpPage: Equatable, Hashable {
    public var rows: [MobileTotpRow]
    public var unavailableEntries: UInt32
    public var cacheNotice: String?
    public var watch: MobileWatchSnapshotStatus

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(rows: [MobileTotpRow], unavailableEntries: UInt32, cacheNotice: String?, watch: MobileWatchSnapshotStatus) {
        self.rows = rows
        self.unavailableEntries = unavailableEntries
        self.cacheNotice = cacheNotice
        self.watch = watch
    }




}

#if compiler(>=6)
extension MobileTotpPage: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpPage: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpPage {
        return
            try MobileTotpPage(
                rows: FfiConverterSequenceTypeMobileTotpRow.read(from: &buf),
                unavailableEntries: FfiConverterUInt32.read(from: &buf),
                cacheNotice: FfiConverterOptionString.read(from: &buf),
                watch: FfiConverterTypeMobileWatchSnapshotStatus.read(from: &buf)
        )
    }

    public static func write(_ value: MobileTotpPage, into buf: inout [UInt8]) {
        FfiConverterSequenceTypeMobileTotpRow.write(value.rows, into: &buf)
        FfiConverterUInt32.write(value.unavailableEntries, into: &buf)
        FfiConverterOptionString.write(value.cacheNotice, into: &buf)
        FfiConverterTypeMobileWatchSnapshotStatus.write(value.watch, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpPage_lift(_ buf: RustBuffer) throws -> MobileTotpPage {
    return try FfiConverterTypeMobileTotpPage.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpPage_lower(_ value: MobileTotpPage) -> RustBuffer {
    return FfiConverterTypeMobileTotpPage.lower(value)
}


public struct MobileTotpRow: Equatable, Hashable {
    public var path: String
    public var issuer: String?
    public var account: String
    public var title: String
    public var detail: String
    public var sharedWithWatch: Bool

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(path: String, issuer: String?, account: String, title: String, detail: String, sharedWithWatch: Bool) {
        self.path = path
        self.issuer = issuer
        self.account = account
        self.title = title
        self.detail = detail
        self.sharedWithWatch = sharedWithWatch
    }




}

#if compiler(>=6)
extension MobileTotpRow: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpRow: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpRow {
        return
            try MobileTotpRow(
                path: FfiConverterString.read(from: &buf),
                issuer: FfiConverterOptionString.read(from: &buf),
                account: FfiConverterString.read(from: &buf),
                title: FfiConverterString.read(from: &buf),
                detail: FfiConverterString.read(from: &buf),
                sharedWithWatch: FfiConverterBool.read(from: &buf)
        )
    }

    public static func write(_ value: MobileTotpRow, into buf: inout [UInt8]) {
        FfiConverterString.write(value.path, into: &buf)
        FfiConverterOptionString.write(value.issuer, into: &buf)
        FfiConverterString.write(value.account, into: &buf)
        FfiConverterString.write(value.title, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
        FfiConverterBool.write(value.sharedWithWatch, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpRow_lift(_ buf: RustBuffer) throws -> MobileTotpRow {
    return try FfiConverterTypeMobileTotpRow.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpRow_lower(_ value: MobileTotpRow) -> RustBuffer {
    return FfiConverterTypeMobileTotpRow.lower(value)
}


public struct MobileWatchSnapshotStatus: Equatable, Hashable {
    public var state: MobileWatchSnapshotState
    public var revision: UInt64?
    public var detail: String

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(state: MobileWatchSnapshotState, revision: UInt64?, detail: String) {
        self.state = state
        self.revision = revision
        self.detail = detail
    }




}

#if compiler(>=6)
extension MobileWatchSnapshotStatus: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileWatchSnapshotStatus: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileWatchSnapshotStatus {
        return
            try MobileWatchSnapshotStatus(
                state: FfiConverterTypeMobileWatchSnapshotState.read(from: &buf),
                revision: FfiConverterOptionUInt64.read(from: &buf),
                detail: FfiConverterString.read(from: &buf)
        )
    }

    public static func write(_ value: MobileWatchSnapshotStatus, into buf: inout [UInt8]) {
        FfiConverterTypeMobileWatchSnapshotState.write(value.state, into: &buf)
        FfiConverterOptionUInt64.write(value.revision, into: &buf)
        FfiConverterString.write(value.detail, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotStatus_lift(_ buf: RustBuffer) throws -> MobileWatchSnapshotStatus {
    return try FfiConverterTypeMobileWatchSnapshotStatus.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotStatus_lower(_ value: MobileWatchSnapshotStatus) -> RustBuffer {
    return FfiConverterTypeMobileWatchSnapshotStatus.lower(value)
}


public struct MobileWatchSnapshotTransfer: Equatable, Hashable {
    public var revision: UInt64
    public var selectedEntries: UInt32
    public var snapshot: Data
    public var deliveredReceipt: Data

    // Default memberwise initializers are never public by default, so we
    // declare one manually.
    public init(revision: UInt64, selectedEntries: UInt32, snapshot: Data, deliveredReceipt: Data) {
        self.revision = revision
        self.selectedEntries = selectedEntries
        self.snapshot = snapshot
        self.deliveredReceipt = deliveredReceipt
    }




}

#if compiler(>=6)
extension MobileWatchSnapshotTransfer: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileWatchSnapshotTransfer: FfiConverterRustBuffer {
    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileWatchSnapshotTransfer {
        return
            try MobileWatchSnapshotTransfer(
                revision: FfiConverterUInt64.read(from: &buf),
                selectedEntries: FfiConverterUInt32.read(from: &buf),
                snapshot: FfiConverterData.read(from: &buf),
                deliveredReceipt: FfiConverterData.read(from: &buf)
        )
    }

    public static func write(_ value: MobileWatchSnapshotTransfer, into buf: inout [UInt8]) {
        FfiConverterUInt64.write(value.revision, into: &buf)
        FfiConverterUInt32.write(value.selectedEntries, into: &buf)
        FfiConverterData.write(value.snapshot, into: &buf)
        FfiConverterData.write(value.deliveredReceipt, into: &buf)
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotTransfer_lift(_ buf: RustBuffer) throws -> MobileWatchSnapshotTransfer {
    return try FfiConverterTypeMobileWatchSnapshotTransfer.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotTransfer_lower(_ value: MobileWatchSnapshotTransfer) -> RustBuffer {
    return FfiConverterTypeMobileWatchSnapshotTransfer.lower(value)
}



public enum MobileAndroidAuthorization: Equatable, Hashable {

    case none
    case strongBiometric
    case userPresence





}

#if compiler(>=6)
extension MobileAndroidAuthorization: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidAuthorization: FfiConverterRustBuffer {
    typealias SwiftType = MobileAndroidAuthorization

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidAuthorization {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .none

        case 2: return .strongBiometric

        case 3: return .userPresence

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileAndroidAuthorization, into buf: inout [UInt8]) {
        switch value {


        case .none:
            writeInt(&buf, Int32(1))


        case .strongBiometric:
            writeInt(&buf, Int32(2))


        case .userPresence:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidAuthorization_lift(_ buf: RustBuffer) throws -> MobileAndroidAuthorization {
    return try FfiConverterTypeMobileAndroidAuthorization.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidAuthorization_lower(_ value: MobileAndroidAuthorization) -> RustBuffer {
    return FfiConverterTypeMobileAndroidAuthorization.lower(value)
}



public
enum MobileAndroidKeystoreError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case MissingKey
    case Invalidated
    case Lockout
    case Locked
    case Denied
    case Cancelled
    case Corrupted
    case UnsupportedProtection
    case StrongboxUnavailable
    case AlreadyExists
    case Unavailable






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileAndroidKeystoreError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAndroidKeystoreError: FfiConverterRustBuffer {
    typealias SwiftType = MobileAndroidKeystoreError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAndroidKeystoreError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .MissingKey
        case 2: return .Invalidated
        case 3: return .Lockout
        case 4: return .Locked
        case 5: return .Denied
        case 6: return .Cancelled
        case 7: return .Corrupted
        case 8: return .UnsupportedProtection
        case 9: return .StrongboxUnavailable
        case 10: return .AlreadyExists
        case 11: return .Unavailable

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileAndroidKeystoreError, into buf: inout [UInt8]) {
        switch value {





        case .MissingKey:
            writeInt(&buf, Int32(1))


        case .Invalidated:
            writeInt(&buf, Int32(2))


        case .Lockout:
            writeInt(&buf, Int32(3))


        case .Locked:
            writeInt(&buf, Int32(4))


        case .Denied:
            writeInt(&buf, Int32(5))


        case .Cancelled:
            writeInt(&buf, Int32(6))


        case .Corrupted:
            writeInt(&buf, Int32(7))


        case .UnsupportedProtection:
            writeInt(&buf, Int32(8))


        case .StrongboxUnavailable:
            writeInt(&buf, Int32(9))


        case .AlreadyExists:
            writeInt(&buf, Int32(10))


        case .Unavailable:
            writeInt(&buf, Int32(11))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeystoreError_lift(_ buf: RustBuffer) throws -> MobileAndroidKeystoreError {
    return try FfiConverterTypeMobileAndroidKeystoreError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAndroidKeystoreError_lower(_ value: MobileAndroidKeystoreError) -> RustBuffer {
    return FfiConverterTypeMobileAndroidKeystoreError.lower(value)
}



public enum MobileAppearance: Equatable, Hashable {

    case system
    case light
    case dark





}

#if compiler(>=6)
extension MobileAppearance: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAppearance: FfiConverterRustBuffer {
    typealias SwiftType = MobileAppearance

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAppearance {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .system

        case 2: return .light

        case 3: return .dark

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileAppearance, into buf: inout [UInt8]) {
        switch value {


        case .system:
            writeInt(&buf, Int32(1))


        case .light:
            writeInt(&buf, Int32(2))


        case .dark:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAppearance_lift(_ buf: RustBuffer) throws -> MobileAppearance {
    return try FfiConverterTypeMobileAppearance.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAppearance_lower(_ value: MobileAppearance) -> RustBuffer {
    return FfiConverterTypeMobileAppearance.lower(value)
}




public enum MobileAuthenticationErrorKind: Equatable, Hashable {

    case passphraseRequired
    case invalidPassphrase
    case cancelled
    case biometryUnavailable
    case configuration
    case keyMaterial
    case entry
    case secureStorage
    case expired
    case conflict





}

#if compiler(>=6)
extension MobileAuthenticationErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAuthenticationErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileAuthenticationErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAuthenticationErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .passphraseRequired

        case 2: return .invalidPassphrase

        case 3: return .cancelled

        case 4: return .biometryUnavailable

        case 5: return .configuration

        case 6: return .keyMaterial

        case 7: return .entry

        case 8: return .secureStorage

        case 9: return .expired

        case 10: return .conflict

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileAuthenticationErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .passphraseRequired:
            writeInt(&buf, Int32(1))


        case .invalidPassphrase:
            writeInt(&buf, Int32(2))


        case .cancelled:
            writeInt(&buf, Int32(3))


        case .biometryUnavailable:
            writeInt(&buf, Int32(4))


        case .configuration:
            writeInt(&buf, Int32(5))


        case .keyMaterial:
            writeInt(&buf, Int32(6))


        case .entry:
            writeInt(&buf, Int32(7))


        case .secureStorage:
            writeInt(&buf, Int32(8))


        case .expired:
            writeInt(&buf, Int32(9))


        case .conflict:
            writeInt(&buf, Int32(10))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationErrorKind_lift(_ buf: RustBuffer) throws -> MobileAuthenticationErrorKind {
    return try FfiConverterTypeMobileAuthenticationErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationErrorKind_lower(_ value: MobileAuthenticationErrorKind) -> RustBuffer {
    return FfiConverterTypeMobileAuthenticationErrorKind.lower(value)
}



public
enum MobileAuthenticationFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobileAuthenticationErrorKind, title: String, detail: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileAuthenticationFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileAuthenticationFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobileAuthenticationFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileAuthenticationFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobileAuthenticationErrorKind.read(from: &buf),
            title: try FfiConverterString.read(from: &buf),
            detail: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileAuthenticationFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind,title,detail):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobileAuthenticationErrorKind.write(kind, into: &buf)
            FfiConverterString.write(title, into: &buf)
            FfiConverterString.write(detail, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationFfiError_lift(_ buf: RustBuffer) throws -> MobileAuthenticationFfiError {
    return try FfiConverterTypeMobileAuthenticationFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileAuthenticationFfiError_lower(_ value: MobileAuthenticationFfiError) -> RustBuffer {
    return FfiConverterTypeMobileAuthenticationFfiError.lower(value)
}



public enum MobileClipboardContent: Equatable, Hashable {

    case text(value: Data
    )
    case emptyOrNonText





}

#if compiler(>=6)
extension MobileClipboardContent: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileClipboardContent: FfiConverterRustBuffer {
    typealias SwiftType = MobileClipboardContent

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClipboardContent {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .text(value: try FfiConverterData.read(from: &buf)
        )

        case 2: return .emptyOrNonText

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileClipboardContent, into buf: inout [UInt8]) {
        switch value {


        case let .text(value):
            writeInt(&buf, Int32(1))
            FfiConverterData.write(value, into: &buf)


        case .emptyOrNonText:
            writeInt(&buf, Int32(2))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardContent_lift(_ buf: RustBuffer) throws -> MobileClipboardContent {
    return try FfiConverterTypeMobileClipboardContent.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardContent_lower(_ value: MobileClipboardContent) -> RustBuffer {
    return FfiConverterTypeMobileClipboardContent.lower(value)
}




public enum MobileClipboardDisposition: Equatable, Hashable {

    case restoredPrevious
    case cleared
    case preservedNewer





}

#if compiler(>=6)
extension MobileClipboardDisposition: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileClipboardDisposition: FfiConverterRustBuffer {
    typealias SwiftType = MobileClipboardDisposition

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClipboardDisposition {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .restoredPrevious

        case 2: return .cleared

        case 3: return .preservedNewer

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileClipboardDisposition, into buf: inout [UInt8]) {
        switch value {


        case .restoredPrevious:
            writeInt(&buf, Int32(1))


        case .cleared:
            writeInt(&buf, Int32(2))


        case .preservedNewer:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardDisposition_lift(_ buf: RustBuffer) throws -> MobileClipboardDisposition {
    return try FfiConverterTypeMobileClipboardDisposition.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardDisposition_lower(_ value: MobileClipboardDisposition) -> RustBuffer {
    return FfiConverterTypeMobileClipboardDisposition.lower(value)
}




public enum MobileClipboardWait: Equatable, Hashable {

    case elapsed
    case cancelled





}

#if compiler(>=6)
extension MobileClipboardWait: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileClipboardWait: FfiConverterRustBuffer {
    typealias SwiftType = MobileClipboardWait

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileClipboardWait {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .elapsed

        case 2: return .cancelled

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileClipboardWait, into buf: inout [UInt8]) {
        switch value {


        case .elapsed:
            writeInt(&buf, Int32(1))


        case .cancelled:
            writeInt(&buf, Int32(2))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardWait_lift(_ buf: RustBuffer) throws -> MobileClipboardWait {
    return try FfiConverterTypeMobileClipboardWait.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileClipboardWait_lower(_ value: MobileClipboardWait) -> RustBuffer {
    return FfiConverterTypeMobileClipboardWait.lower(value)
}




public enum MobileEntryEditorFieldKind: Equatable, Hashable {

    case password
    case field
    case note
    case otpUri





}

#if compiler(>=6)
extension MobileEntryEditorFieldKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntryEditorFieldKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileEntryEditorFieldKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntryEditorFieldKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .password

        case 2: return .field

        case 3: return .note

        case 4: return .otpUri

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileEntryEditorFieldKind, into buf: inout [UInt8]) {
        switch value {


        case .password:
            writeInt(&buf, Int32(1))


        case .field:
            writeInt(&buf, Int32(2))


        case .note:
            writeInt(&buf, Int32(3))


        case .otpUri:
            writeInt(&buf, Int32(4))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorFieldKind_lift(_ buf: RustBuffer) throws -> MobileEntryEditorFieldKind {
    return try FfiConverterTypeMobileEntryEditorFieldKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntryEditorFieldKind_lower(_ value: MobileEntryEditorFieldKind) -> RustBuffer {
    return FfiConverterTypeMobileEntryEditorFieldKind.lower(value)
}




public enum MobileEntrySectionKind: Equatable, Hashable {

    case password
    case details
    case oneTimePassword
    case notes





}

#if compiler(>=6)
extension MobileEntrySectionKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileEntrySectionKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileEntrySectionKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileEntrySectionKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .password

        case 2: return .details

        case 3: return .oneTimePassword

        case 4: return .notes

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileEntrySectionKind, into buf: inout [UInt8]) {
        switch value {


        case .password:
            writeInt(&buf, Int32(1))


        case .details:
            writeInt(&buf, Int32(2))


        case .oneTimePassword:
            writeInt(&buf, Int32(3))


        case .notes:
            writeInt(&buf, Int32(4))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntrySectionKind_lift(_ buf: RustBuffer) throws -> MobileEntrySectionKind {
    return try FfiConverterTypeMobileEntrySectionKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileEntrySectionKind_lower(_ value: MobileEntrySectionKind) -> RustBuffer {
    return FfiConverterTypeMobileEntrySectionKind.lower(value)
}




public enum MobileHomeActionKind: Equatable, Hashable {

    case commit
    case fetch
    case pull
    case push





}

#if compiler(>=6)
extension MobileHomeActionKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeActionKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeActionKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeActionKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .commit

        case 2: return .fetch

        case 3: return .pull

        case 4: return .push

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeActionKind, into buf: inout [UInt8]) {
        switch value {


        case .commit:
            writeInt(&buf, Int32(1))


        case .fetch:
            writeInt(&buf, Int32(2))


        case .pull:
            writeInt(&buf, Int32(3))


        case .push:
            writeInt(&buf, Int32(4))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeActionKind_lift(_ buf: RustBuffer) throws -> MobileHomeActionKind {
    return try FfiConverterTypeMobileHomeActionKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeActionKind_lower(_ value: MobileHomeActionKind) -> RustBuffer {
    return FfiConverterTypeMobileHomeActionKind.lower(value)
}




public enum MobileHomeChangeKind: Equatable, Hashable {

    case passwordEntry
    case recipientPolicy
    case recipientSignature
    case repositoryFile





}

#if compiler(>=6)
extension MobileHomeChangeKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeChangeKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeChangeKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeChangeKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .passwordEntry

        case 2: return .recipientPolicy

        case 3: return .recipientSignature

        case 4: return .repositoryFile

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeChangeKind, into buf: inout [UInt8]) {
        switch value {


        case .passwordEntry:
            writeInt(&buf, Int32(1))


        case .recipientPolicy:
            writeInt(&buf, Int32(2))


        case .recipientSignature:
            writeInt(&buf, Int32(3))


        case .repositoryFile:
            writeInt(&buf, Int32(4))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChangeKind_lift(_ buf: RustBuffer) throws -> MobileHomeChangeKind {
    return try FfiConverterTypeMobileHomeChangeKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChangeKind_lower(_ value: MobileHomeChangeKind) -> RustBuffer {
    return FfiConverterTypeMobileHomeChangeKind.lower(value)
}




public enum MobileHomeChangeStatus: Equatable, Hashable {

    case added
    case modified
    case deleted





}

#if compiler(>=6)
extension MobileHomeChangeStatus: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeChangeStatus: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeChangeStatus

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeChangeStatus {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .added

        case 2: return .modified

        case 3: return .deleted

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeChangeStatus, into buf: inout [UInt8]) {
        switch value {


        case .added:
            writeInt(&buf, Int32(1))


        case .modified:
            writeInt(&buf, Int32(2))


        case .deleted:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChangeStatus_lift(_ buf: RustBuffer) throws -> MobileHomeChangeStatus {
    return try FfiConverterTypeMobileHomeChangeStatus.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeChangeStatus_lower(_ value: MobileHomeChangeStatus) -> RustBuffer {
    return FfiConverterTypeMobileHomeChangeStatus.lower(value)
}




public enum MobileHomeErrorKind: Equatable, Hashable {

    case missingConfiguration
    case configuration
    case authentication
    case conflict
    case dirtyLocalChanges
    case noChanges
    case offline
    case interrupted
    case secureStorage
    case repository
    case partialProgress





}

#if compiler(>=6)
extension MobileHomeErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .missingConfiguration

        case 2: return .configuration

        case 3: return .authentication

        case 4: return .conflict

        case 5: return .dirtyLocalChanges

        case 6: return .noChanges

        case 7: return .offline

        case 8: return .interrupted

        case 9: return .secureStorage

        case 10: return .repository

        case 11: return .partialProgress

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .missingConfiguration:
            writeInt(&buf, Int32(1))


        case .configuration:
            writeInt(&buf, Int32(2))


        case .authentication:
            writeInt(&buf, Int32(3))


        case .conflict:
            writeInt(&buf, Int32(4))


        case .dirtyLocalChanges:
            writeInt(&buf, Int32(5))


        case .noChanges:
            writeInt(&buf, Int32(6))


        case .offline:
            writeInt(&buf, Int32(7))


        case .interrupted:
            writeInt(&buf, Int32(8))


        case .secureStorage:
            writeInt(&buf, Int32(9))


        case .repository:
            writeInt(&buf, Int32(10))


        case .partialProgress:
            writeInt(&buf, Int32(11))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeErrorKind_lift(_ buf: RustBuffer) throws -> MobileHomeErrorKind {
    return try FfiConverterTypeMobileHomeErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeErrorKind_lower(_ value: MobileHomeErrorKind) -> RustBuffer {
    return FfiConverterTypeMobileHomeErrorKind.lower(value)
}



public
enum MobileHomeFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobileHomeErrorKind, title: String, detail: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileHomeFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobileHomeErrorKind.read(from: &buf),
            title: try FfiConverterString.read(from: &buf),
            detail: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind,title,detail):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobileHomeErrorKind.write(kind, into: &buf)
            FfiConverterString.write(title, into: &buf)
            FfiConverterString.write(detail, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeFfiError_lift(_ buf: RustBuffer) throws -> MobileHomeFfiError {
    return try FfiConverterTypeMobileHomeFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeFfiError_lower(_ value: MobileHomeFfiError) -> RustBuffer {
    return FfiConverterTypeMobileHomeFfiError.lower(value)
}



public enum MobileHomeFreshness: Equatable, Hashable {

    case neverRefreshed
    case cached
    case current





}

#if compiler(>=6)
extension MobileHomeFreshness: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomeFreshness: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeFreshness

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomeFreshness {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .neverRefreshed

        case 2: return .cached

        case 3: return .current

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomeFreshness, into buf: inout [UInt8]) {
        switch value {


        case .neverRefreshed:
            writeInt(&buf, Int32(1))


        case .cached:
            writeInt(&buf, Int32(2))


        case .current:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeFreshness_lift(_ buf: RustBuffer) throws -> MobileHomeFreshness {
    return try FfiConverterTypeMobileHomeFreshness.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomeFreshness_lower(_ value: MobileHomeFreshness) -> RustBuffer {
    return FfiConverterTypeMobileHomeFreshness.lower(value)
}




public enum MobileHomePhase: Equatable, Hashable {

    case validating
    case authenticating
    case receiving
    case integrating
    case sending
    case finishing





}

#if compiler(>=6)
extension MobileHomePhase: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileHomePhase: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomePhase

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileHomePhase {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .validating

        case 2: return .authenticating

        case 3: return .receiving

        case 4: return .integrating

        case 5: return .sending

        case 6: return .finishing

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileHomePhase, into buf: inout [UInt8]) {
        switch value {


        case .validating:
            writeInt(&buf, Int32(1))


        case .authenticating:
            writeInt(&buf, Int32(2))


        case .receiving:
            writeInt(&buf, Int32(3))


        case .integrating:
            writeInt(&buf, Int32(4))


        case .sending:
            writeInt(&buf, Int32(5))


        case .finishing:
            writeInt(&buf, Int32(6))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomePhase_lift(_ buf: RustBuffer) throws -> MobileHomePhase {
    return try FfiConverterTypeMobileHomePhase.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileHomePhase_lower(_ value: MobileHomePhase) -> RustBuffer {
    return FfiConverterTypeMobileHomePhase.lower(value)
}




public enum MobileIcon: Equatable, Hashable {

    case home
    case key
    case search
    case timer
    case settings
    case warning
    case branch
    case success
    case sync
    case protected
    case repository
    case history
    case incoming
    case outgoing
    case recipients
    case signature
    case file
    case merge
    case refresh
    case folder
    case user
    case email
    case website
    case text
    case note





}

#if compiler(>=6)
extension MobileIcon: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileIcon: FfiConverterRustBuffer {
    typealias SwiftType = MobileIcon

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileIcon {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .home

        case 2: return .key

        case 3: return .search

        case 4: return .timer

        case 5: return .settings

        case 6: return .warning

        case 7: return .branch

        case 8: return .success

        case 9: return .sync

        case 10: return .protected

        case 11: return .repository

        case 12: return .history

        case 13: return .incoming

        case 14: return .outgoing

        case 15: return .recipients

        case 16: return .signature

        case 17: return .file

        case 18: return .merge

        case 19: return .refresh

        case 20: return .folder

        case 21: return .user

        case 22: return .email

        case 23: return .website

        case 24: return .text

        case 25: return .note

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileIcon, into buf: inout [UInt8]) {
        switch value {


        case .home:
            writeInt(&buf, Int32(1))


        case .key:
            writeInt(&buf, Int32(2))


        case .search:
            writeInt(&buf, Int32(3))


        case .timer:
            writeInt(&buf, Int32(4))


        case .settings:
            writeInt(&buf, Int32(5))


        case .warning:
            writeInt(&buf, Int32(6))


        case .branch:
            writeInt(&buf, Int32(7))


        case .success:
            writeInt(&buf, Int32(8))


        case .sync:
            writeInt(&buf, Int32(9))


        case .protected:
            writeInt(&buf, Int32(10))


        case .repository:
            writeInt(&buf, Int32(11))


        case .history:
            writeInt(&buf, Int32(12))


        case .incoming:
            writeInt(&buf, Int32(13))


        case .outgoing:
            writeInt(&buf, Int32(14))


        case .recipients:
            writeInt(&buf, Int32(15))


        case .signature:
            writeInt(&buf, Int32(16))


        case .file:
            writeInt(&buf, Int32(17))


        case .merge:
            writeInt(&buf, Int32(18))


        case .refresh:
            writeInt(&buf, Int32(19))


        case .folder:
            writeInt(&buf, Int32(20))


        case .user:
            writeInt(&buf, Int32(21))


        case .email:
            writeInt(&buf, Int32(22))


        case .website:
            writeInt(&buf, Int32(23))


        case .text:
            writeInt(&buf, Int32(24))


        case .note:
            writeInt(&buf, Int32(25))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileIcon_lift(_ buf: RustBuffer) throws -> MobileIcon {
    return try FfiConverterTypeMobileIcon.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileIcon_lower(_ value: MobileIcon) -> RustBuffer {
    return FfiConverterTypeMobileIcon.lower(value)
}




public enum MobileKeyTransferErrorKind: Equatable, Hashable {

    case existingKey
    case failed





}

#if compiler(>=6)
extension MobileKeyTransferErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileKeyTransferErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .existingKey

        case 2: return .failed

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileKeyTransferErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .existingKey:
            writeInt(&buf, Int32(1))


        case .failed:
            writeInt(&buf, Int32(2))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferErrorKind_lift(_ buf: RustBuffer) throws -> MobileKeyTransferErrorKind {
    return try FfiConverterTypeMobileKeyTransferErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferErrorKind_lower(_ value: MobileKeyTransferErrorKind) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferErrorKind.lower(value)
}



public
enum MobileKeyTransferFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobileKeyTransferErrorKind, message: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileKeyTransferFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobileKeyTransferFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobileKeyTransferErrorKind.read(from: &buf),
            message: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileKeyTransferFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind,message):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobileKeyTransferErrorKind.write(kind, into: &buf)
            FfiConverterString.write(message, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferFfiError_lift(_ buf: RustBuffer) throws -> MobileKeyTransferFfiError {
    return try FfiConverterTypeMobileKeyTransferFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferFfiError_lower(_ value: MobileKeyTransferFfiError) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferFfiError.lower(value)
}



public enum MobileKeyTransferKind: Equatable, Hashable {

    case `public`
    case `private`





}

#if compiler(>=6)
extension MobileKeyTransferKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileKeyTransferKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileKeyTransferKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileKeyTransferKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .`public`

        case 2: return .`private`

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileKeyTransferKind, into buf: inout [UInt8]) {
        switch value {


        case .`public`:
            writeInt(&buf, Int32(1))


        case .`private`:
            writeInt(&buf, Int32(2))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferKind_lift(_ buf: RustBuffer) throws -> MobileKeyTransferKind {
    return try FfiConverterTypeMobileKeyTransferKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileKeyTransferKind_lower(_ value: MobileKeyTransferKind) -> RustBuffer {
    return FfiConverterTypeMobileKeyTransferKind.lower(value)
}




public enum MobileLifecycleEvent: Equatable, Hashable {

    case foreground
    case background
    case deviceLocked
    case memoryPressure
    case processRecreated
    case userActivity
    case cancel





}

#if compiler(>=6)
extension MobileLifecycleEvent: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileLifecycleEvent: FfiConverterRustBuffer {
    typealias SwiftType = MobileLifecycleEvent

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileLifecycleEvent {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .foreground

        case 2: return .background

        case 3: return .deviceLocked

        case 4: return .memoryPressure

        case 5: return .processRecreated

        case 6: return .userActivity

        case 7: return .cancel

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileLifecycleEvent, into buf: inout [UInt8]) {
        switch value {


        case .foreground:
            writeInt(&buf, Int32(1))


        case .background:
            writeInt(&buf, Int32(2))


        case .deviceLocked:
            writeInt(&buf, Int32(3))


        case .memoryPressure:
            writeInt(&buf, Int32(4))


        case .processRecreated:
            writeInt(&buf, Int32(5))


        case .userActivity:
            writeInt(&buf, Int32(6))


        case .cancel:
            writeInt(&buf, Int32(7))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileLifecycleEvent_lift(_ buf: RustBuffer) throws -> MobileLifecycleEvent {
    return try FfiConverterTypeMobileLifecycleEvent.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileLifecycleEvent_lower(_ value: MobileLifecycleEvent) -> RustBuffer {
    return FfiConverterTypeMobileLifecycleEvent.lower(value)
}




public enum MobileMutationAction: Equatable, Hashable {

    case move
    case copy
    case delete





}

#if compiler(>=6)
extension MobileMutationAction: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileMutationAction: FfiConverterRustBuffer {
    typealias SwiftType = MobileMutationAction

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileMutationAction {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .move

        case 2: return .copy

        case 3: return .delete

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileMutationAction, into buf: inout [UInt8]) {
        switch value {


        case .move:
            writeInt(&buf, Int32(1))


        case .copy:
            writeInt(&buf, Int32(2))


        case .delete:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationAction_lift(_ buf: RustBuffer) throws -> MobileMutationAction {
    return try FfiConverterTypeMobileMutationAction.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileMutationAction_lower(_ value: MobileMutationAction) -> RustBuffer {
    return FfiConverterTypeMobileMutationAction.lower(value)
}




public enum MobileOnboardingErrorKind: Equatable, Hashable {

    case invalidInput
    case unsupportedRemote
    case authentication
    case repository
    case existingClone
    case existingKey
    case interrupted
    case secureStorage
    case configuration
    case alreadyConfigured





}

#if compiler(>=6)
extension MobileOnboardingErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileOnboardingErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .invalidInput

        case 2: return .unsupportedRemote

        case 3: return .authentication

        case 4: return .repository

        case 5: return .existingClone

        case 6: return .existingKey

        case 7: return .interrupted

        case 8: return .secureStorage

        case 9: return .configuration

        case 10: return .alreadyConfigured

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileOnboardingErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .invalidInput:
            writeInt(&buf, Int32(1))


        case .unsupportedRemote:
            writeInt(&buf, Int32(2))


        case .authentication:
            writeInt(&buf, Int32(3))


        case .repository:
            writeInt(&buf, Int32(4))


        case .existingClone:
            writeInt(&buf, Int32(5))


        case .existingKey:
            writeInt(&buf, Int32(6))


        case .interrupted:
            writeInt(&buf, Int32(7))


        case .secureStorage:
            writeInt(&buf, Int32(8))


        case .configuration:
            writeInt(&buf, Int32(9))


        case .alreadyConfigured:
            writeInt(&buf, Int32(10))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingErrorKind_lift(_ buf: RustBuffer) throws -> MobileOnboardingErrorKind {
    return try FfiConverterTypeMobileOnboardingErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingErrorKind_lower(_ value: MobileOnboardingErrorKind) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingErrorKind.lower(value)
}



public
enum MobileOnboardingFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobileOnboardingErrorKind, title: String, detail: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileOnboardingFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobileOnboardingFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobileOnboardingErrorKind.read(from: &buf),
            title: try FfiConverterString.read(from: &buf),
            detail: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileOnboardingFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind,title,detail):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobileOnboardingErrorKind.write(kind, into: &buf)
            FfiConverterString.write(title, into: &buf)
            FfiConverterString.write(detail, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingFfiError_lift(_ buf: RustBuffer) throws -> MobileOnboardingFfiError {
    return try FfiConverterTypeMobileOnboardingFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingFfiError_lower(_ value: MobileOnboardingFfiError) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingFfiError.lower(value)
}



public enum MobileOnboardingPhase: Equatable, Hashable {

    case validating
    case authenticating
    case receiving
    case integrating
    case finishing





}

#if compiler(>=6)
extension MobileOnboardingPhase: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileOnboardingPhase: FfiConverterRustBuffer {
    typealias SwiftType = MobileOnboardingPhase

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileOnboardingPhase {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .validating

        case 2: return .authenticating

        case 3: return .receiving

        case 4: return .integrating

        case 5: return .finishing

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileOnboardingPhase, into buf: inout [UInt8]) {
        switch value {


        case .validating:
            writeInt(&buf, Int32(1))


        case .authenticating:
            writeInt(&buf, Int32(2))


        case .receiving:
            writeInt(&buf, Int32(3))


        case .integrating:
            writeInt(&buf, Int32(4))


        case .finishing:
            writeInt(&buf, Int32(5))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingPhase_lift(_ buf: RustBuffer) throws -> MobileOnboardingPhase {
    return try FfiConverterTypeMobileOnboardingPhase.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileOnboardingPhase_lower(_ value: MobileOnboardingPhase) -> RustBuffer {
    return FfiConverterTypeMobileOnboardingPhase.lower(value)
}




public enum MobilePasswordErrorKind: Equatable, Hashable {

    case missingConfiguration
    case configuration
    case invalidPath
    case directoryMissing
    case repository





}

#if compiler(>=6)
extension MobilePasswordErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobilePasswordErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .missingConfiguration

        case 2: return .configuration

        case 3: return .invalidPath

        case 4: return .directoryMissing

        case 5: return .repository

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePasswordErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .missingConfiguration:
            writeInt(&buf, Int32(1))


        case .configuration:
            writeInt(&buf, Int32(2))


        case .invalidPath:
            writeInt(&buf, Int32(3))


        case .directoryMissing:
            writeInt(&buf, Int32(4))


        case .repository:
            writeInt(&buf, Int32(5))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordErrorKind_lift(_ buf: RustBuffer) throws -> MobilePasswordErrorKind {
    return try FfiConverterTypeMobilePasswordErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordErrorKind_lower(_ value: MobilePasswordErrorKind) -> RustBuffer {
    return FfiConverterTypeMobilePasswordErrorKind.lower(value)
}



public
enum MobilePasswordFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobilePasswordErrorKind, title: String, detail: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobilePasswordFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobilePasswordFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobilePasswordErrorKind.read(from: &buf),
            title: try FfiConverterString.read(from: &buf),
            detail: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePasswordFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind,title,detail):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobilePasswordErrorKind.write(kind, into: &buf)
            FfiConverterString.write(title, into: &buf)
            FfiConverterString.write(detail, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordFfiError_lift(_ buf: RustBuffer) throws -> MobilePasswordFfiError {
    return try FfiConverterTypeMobilePasswordFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordFfiError_lower(_ value: MobilePasswordFfiError) -> RustBuffer {
    return FfiConverterTypeMobilePasswordFfiError.lower(value)
}



public enum MobilePasswordRowKind: Equatable, Hashable {

    case directory
    case entry





}

#if compiler(>=6)
extension MobilePasswordRowKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePasswordRowKind: FfiConverterRustBuffer {
    typealias SwiftType = MobilePasswordRowKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePasswordRowKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .directory

        case 2: return .entry

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePasswordRowKind, into buf: inout [UInt8]) {
        switch value {


        case .directory:
            writeInt(&buf, Int32(1))


        case .entry:
            writeInt(&buf, Int32(2))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordRowKind_lift(_ buf: RustBuffer) throws -> MobilePasswordRowKind {
    return try FfiConverterTypeMobilePasswordRowKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePasswordRowKind_lower(_ value: MobilePasswordRowKind) -> RustBuffer {
    return FfiConverterTypeMobilePasswordRowKind.lower(value)
}



public
enum MobilePlatformFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case InvalidPaths
    case InvalidCameraFrame
    case QrNotFound
    case InvalidQrPayload
    case InvalidCredentialRequest
    case ClipboardFailed
    case Cancelled






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobilePlatformFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePlatformFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobilePlatformFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePlatformFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .InvalidPaths
        case 2: return .InvalidCameraFrame
        case 3: return .QrNotFound
        case 4: return .InvalidQrPayload
        case 5: return .InvalidCredentialRequest
        case 6: return .ClipboardFailed
        case 7: return .Cancelled

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePlatformFfiError, into buf: inout [UInt8]) {
        switch value {





        case .InvalidPaths:
            writeInt(&buf, Int32(1))


        case .InvalidCameraFrame:
            writeInt(&buf, Int32(2))


        case .QrNotFound:
            writeInt(&buf, Int32(3))


        case .InvalidQrPayload:
            writeInt(&buf, Int32(4))


        case .InvalidCredentialRequest:
            writeInt(&buf, Int32(5))


        case .ClipboardFailed:
            writeInt(&buf, Int32(6))


        case .Cancelled:
            writeInt(&buf, Int32(7))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformFfiError_lift(_ buf: RustBuffer) throws -> MobilePlatformFfiError {
    return try FfiConverterTypeMobilePlatformFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePlatformFfiError_lower(_ value: MobilePlatformFfiError) -> RustBuffer {
    return FfiConverterTypeMobilePlatformFfiError.lower(value)
}


public
enum MobilePreferenceError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Configuration(message: String
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobilePreferenceError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePreferenceError: FfiConverterRustBuffer {
    typealias SwiftType = MobilePreferenceError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePreferenceError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Configuration(
            message: try FfiConverterString.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePreferenceError, into buf: inout [UInt8]) {
        switch value {





        case let .Configuration(message):
            writeInt(&buf, Int32(1))
            FfiConverterString.write(message, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePreferenceError_lift(_ buf: RustBuffer) throws -> MobilePreferenceError {
    return try FfiConverterTypeMobilePreferenceError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePreferenceError_lower(_ value: MobilePreferenceError) -> RustBuffer {
    return FfiConverterTypeMobilePreferenceError.lower(value)
}



public enum MobilePrivateStorageErrorKind: Equatable, Hashable {

    case invalidRoots
    case unsafePath
    case missingRoot
    case accessDenied
    case readOnly
    case storageFull
    case busy
    case io
    case corruptLayout
    case migrationRequired
    case corruptConfiguration
    case configurationMissingWithData
    case interruptedSetup
    case restoredWithoutKeystore
    case secureStorageLocked
    case secureStorageUnavailable
    case invalidSecureBinding





}

#if compiler(>=6)
extension MobilePrivateStorageErrorKind: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateStorageErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobilePrivateStorageErrorKind

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateStorageErrorKind {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .invalidRoots

        case 2: return .unsafePath

        case 3: return .missingRoot

        case 4: return .accessDenied

        case 5: return .readOnly

        case 6: return .storageFull

        case 7: return .busy

        case 8: return .io

        case 9: return .corruptLayout

        case 10: return .migrationRequired

        case 11: return .corruptConfiguration

        case 12: return .configurationMissingWithData

        case 13: return .interruptedSetup

        case 14: return .restoredWithoutKeystore

        case 15: return .secureStorageLocked

        case 16: return .secureStorageUnavailable

        case 17: return .invalidSecureBinding

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePrivateStorageErrorKind, into buf: inout [UInt8]) {
        switch value {


        case .invalidRoots:
            writeInt(&buf, Int32(1))


        case .unsafePath:
            writeInt(&buf, Int32(2))


        case .missingRoot:
            writeInt(&buf, Int32(3))


        case .accessDenied:
            writeInt(&buf, Int32(4))


        case .readOnly:
            writeInt(&buf, Int32(5))


        case .storageFull:
            writeInt(&buf, Int32(6))


        case .busy:
            writeInt(&buf, Int32(7))


        case .io:
            writeInt(&buf, Int32(8))


        case .corruptLayout:
            writeInt(&buf, Int32(9))


        case .migrationRequired:
            writeInt(&buf, Int32(10))


        case .corruptConfiguration:
            writeInt(&buf, Int32(11))


        case .configurationMissingWithData:
            writeInt(&buf, Int32(12))


        case .interruptedSetup:
            writeInt(&buf, Int32(13))


        case .restoredWithoutKeystore:
            writeInt(&buf, Int32(14))


        case .secureStorageLocked:
            writeInt(&buf, Int32(15))


        case .secureStorageUnavailable:
            writeInt(&buf, Int32(16))


        case .invalidSecureBinding:
            writeInt(&buf, Int32(17))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageErrorKind_lift(_ buf: RustBuffer) throws -> MobilePrivateStorageErrorKind {
    return try FfiConverterTypeMobilePrivateStorageErrorKind.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageErrorKind_lower(_ value: MobilePrivateStorageErrorKind) -> RustBuffer {
    return FfiConverterTypeMobilePrivateStorageErrorKind.lower(value)
}



public
enum MobilePrivateStorageFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case Failed(kind: MobilePrivateStorageErrorKind
    )






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobilePrivateStorageFfiError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobilePrivateStorageFfiError: FfiConverterRustBuffer {
    typealias SwiftType = MobilePrivateStorageFfiError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobilePrivateStorageFfiError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .Failed(
            kind: try FfiConverterTypeMobilePrivateStorageErrorKind.read(from: &buf)
            )

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobilePrivateStorageFfiError, into buf: inout [UInt8]) {
        switch value {





        case let .Failed(kind):
            writeInt(&buf, Int32(1))
            FfiConverterTypeMobilePrivateStorageErrorKind.write(kind, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageFfiError_lift(_ buf: RustBuffer) throws -> MobilePrivateStorageFfiError {
    return try FfiConverterTypeMobilePrivateStorageFfiError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobilePrivateStorageFfiError_lower(_ value: MobilePrivateStorageFfiError) -> RustBuffer {
    return FfiConverterTypeMobilePrivateStorageFfiError.lower(value)
}


public
enum MobileSecretError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {



    case AlreadyExists
    case Missing
    case Locked
    case Denied
    case Cancelled
    case Corrupted
    case UnsupportedProtection
    case Unavailable
    case DeviceKeyMissing
    case Invalidated
    case Lockout






    public var errorDescription: String? {
        String(reflecting: self)
    }

}

#if compiler(>=6)
extension MobileSecretError: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileSecretError: FfiConverterRustBuffer {
    typealias SwiftType = MobileSecretError

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileSecretError {
        let variant: Int32 = try readInt(&buf)
        switch variant {




        case 1: return .AlreadyExists
        case 2: return .Missing
        case 3: return .Locked
        case 4: return .Denied
        case 5: return .Cancelled
        case 6: return .Corrupted
        case 7: return .UnsupportedProtection
        case 8: return .Unavailable
        case 9: return .DeviceKeyMissing
        case 10: return .Invalidated
        case 11: return .Lockout

         default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileSecretError, into buf: inout [UInt8]) {
        switch value {





        case .AlreadyExists:
            writeInt(&buf, Int32(1))


        case .Missing:
            writeInt(&buf, Int32(2))


        case .Locked:
            writeInt(&buf, Int32(3))


        case .Denied:
            writeInt(&buf, Int32(4))


        case .Cancelled:
            writeInt(&buf, Int32(5))


        case .Corrupted:
            writeInt(&buf, Int32(6))


        case .UnsupportedProtection:
            writeInt(&buf, Int32(7))


        case .Unavailable:
            writeInt(&buf, Int32(8))


        case .DeviceKeyMissing:
            writeInt(&buf, Int32(9))


        case .Invalidated:
            writeInt(&buf, Int32(10))


        case .Lockout:
            writeInt(&buf, Int32(11))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretError_lift(_ buf: RustBuffer) throws -> MobileSecretError {
    return try FfiConverterTypeMobileSecretError.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretError_lower(_ value: MobileSecretError) -> RustBuffer {
    return FfiConverterTypeMobileSecretError.lower(value)
}



public enum MobileSecretLocator: Equatable, Hashable {

    case applicationBinding
    case openPgpPassphrase(fingerprint: String
    )
    case httpsGitCredential(serverId: String, applicationId: String
    )
    case sshKeyPassphrase(fingerprint: String
    )





}

#if compiler(>=6)
extension MobileSecretLocator: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileSecretLocator: FfiConverterRustBuffer {
    typealias SwiftType = MobileSecretLocator

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileSecretLocator {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .applicationBinding

        case 2: return .openPgpPassphrase(fingerprint: try FfiConverterString.read(from: &buf)
        )

        case 3: return .httpsGitCredential(serverId: try FfiConverterString.read(from: &buf), applicationId: try FfiConverterString.read(from: &buf)
        )

        case 4: return .sshKeyPassphrase(fingerprint: try FfiConverterString.read(from: &buf)
        )

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileSecretLocator, into buf: inout [UInt8]) {
        switch value {


        case .applicationBinding:
            writeInt(&buf, Int32(1))


        case let .openPgpPassphrase(fingerprint):
            writeInt(&buf, Int32(2))
            FfiConverterString.write(fingerprint, into: &buf)


        case let .httpsGitCredential(serverId,applicationId):
            writeInt(&buf, Int32(3))
            FfiConverterString.write(serverId, into: &buf)
            FfiConverterString.write(applicationId, into: &buf)


        case let .sshKeyPassphrase(fingerprint):
            writeInt(&buf, Int32(4))
            FfiConverterString.write(fingerprint, into: &buf)

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretLocator_lift(_ buf: RustBuffer) throws -> MobileSecretLocator {
    return try FfiConverterTypeMobileSecretLocator.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretLocator_lower(_ value: MobileSecretLocator) -> RustBuffer {
    return FfiConverterTypeMobileSecretLocator.lower(value)
}




public enum MobileSecretProtection: Equatable, Hashable {

    case deviceUnlocked
    case requireUserPresence
    case biometryCurrentSet





}

#if compiler(>=6)
extension MobileSecretProtection: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileSecretProtection: FfiConverterRustBuffer {
    typealias SwiftType = MobileSecretProtection

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileSecretProtection {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .deviceUnlocked

        case 2: return .requireUserPresence

        case 3: return .biometryCurrentSet

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileSecretProtection, into buf: inout [UInt8]) {
        switch value {


        case .deviceUnlocked:
            writeInt(&buf, Int32(1))


        case .requireUserPresence:
            writeInt(&buf, Int32(2))


        case .biometryCurrentSet:
            writeInt(&buf, Int32(3))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretProtection_lift(_ buf: RustBuffer) throws -> MobileSecretProtection {
    return try FfiConverterTypeMobileSecretProtection.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileSecretProtection_lower(_ value: MobileSecretProtection) -> RustBuffer {
    return FfiConverterTypeMobileSecretProtection.lower(value)
}




public enum MobileShellState: Equatable, Hashable {

    case loading
    case empty
    case ready
    case locked
    case error
    case stale





}

#if compiler(>=6)
extension MobileShellState: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileShellState: FfiConverterRustBuffer {
    typealias SwiftType = MobileShellState

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileShellState {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .loading

        case 2: return .empty

        case 3: return .ready

        case 4: return .locked

        case 5: return .error

        case 6: return .stale

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileShellState, into buf: inout [UInt8]) {
        switch value {


        case .loading:
            writeInt(&buf, Int32(1))


        case .empty:
            writeInt(&buf, Int32(2))


        case .ready:
            writeInt(&buf, Int32(3))


        case .locked:
            writeInt(&buf, Int32(4))


        case .error:
            writeInt(&buf, Int32(5))


        case .stale:
            writeInt(&buf, Int32(6))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileShellState_lift(_ buf: RustBuffer) throws -> MobileShellState {
    return try FfiConverterTypeMobileShellState.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileShellState_lower(_ value: MobileShellState) -> RustBuffer {
    return FfiConverterTypeMobileShellState.lower(value)
}




public enum MobileTab: Equatable, Hashable {

    case home
    case passwords
    case search
    case totp
    case preferences





}

#if compiler(>=6)
extension MobileTab: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTab: FfiConverterRustBuffer {
    typealias SwiftType = MobileTab

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTab {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .home

        case 2: return .passwords

        case 3: return .search

        case 4: return .totp

        case 5: return .preferences

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileTab, into buf: inout [UInt8]) {
        switch value {


        case .home:
            writeInt(&buf, Int32(1))


        case .passwords:
            writeInt(&buf, Int32(2))


        case .search:
            writeInt(&buf, Int32(3))


        case .totp:
            writeInt(&buf, Int32(4))


        case .preferences:
            writeInt(&buf, Int32(5))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTab_lift(_ buf: RustBuffer) throws -> MobileTab {
    return try FfiConverterTypeMobileTab.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTab_lower(_ value: MobileTab) -> RustBuffer {
    return FfiConverterTypeMobileTab.lower(value)
}




public enum MobileTotpDiscoveryPhase: Equatable, Hashable {

    case preparing
    case inspecting
    case saving
    case complete
    case cancelled





}

#if compiler(>=6)
extension MobileTotpDiscoveryPhase: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileTotpDiscoveryPhase: FfiConverterRustBuffer {
    typealias SwiftType = MobileTotpDiscoveryPhase

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileTotpDiscoveryPhase {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .preparing

        case 2: return .inspecting

        case 3: return .saving

        case 4: return .complete

        case 5: return .cancelled

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileTotpDiscoveryPhase, into buf: inout [UInt8]) {
        switch value {


        case .preparing:
            writeInt(&buf, Int32(1))


        case .inspecting:
            writeInt(&buf, Int32(2))


        case .saving:
            writeInt(&buf, Int32(3))


        case .complete:
            writeInt(&buf, Int32(4))


        case .cancelled:
            writeInt(&buf, Int32(5))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDiscoveryPhase_lift(_ buf: RustBuffer) throws -> MobileTotpDiscoveryPhase {
    return try FfiConverterTypeMobileTotpDiscoveryPhase.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileTotpDiscoveryPhase_lower(_ value: MobileTotpDiscoveryPhase) -> RustBuffer {
    return FfiConverterTypeMobileTotpDiscoveryPhase.lower(value)
}




public enum MobileWatchPreferenceState: Equatable, Hashable {

    case unsupported
    case notPaired
    case appNotInstalled
    case ready
    case pending
    case delivered
    case current
    case failed





}

#if compiler(>=6)
extension MobileWatchPreferenceState: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileWatchPreferenceState: FfiConverterRustBuffer {
    typealias SwiftType = MobileWatchPreferenceState

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileWatchPreferenceState {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .unsupported

        case 2: return .notPaired

        case 3: return .appNotInstalled

        case 4: return .ready

        case 5: return .pending

        case 6: return .delivered

        case 7: return .current

        case 8: return .failed

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileWatchPreferenceState, into buf: inout [UInt8]) {
        switch value {


        case .unsupported:
            writeInt(&buf, Int32(1))


        case .notPaired:
            writeInt(&buf, Int32(2))


        case .appNotInstalled:
            writeInt(&buf, Int32(3))


        case .ready:
            writeInt(&buf, Int32(4))


        case .pending:
            writeInt(&buf, Int32(5))


        case .delivered:
            writeInt(&buf, Int32(6))


        case .current:
            writeInt(&buf, Int32(7))


        case .failed:
            writeInt(&buf, Int32(8))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchPreferenceState_lift(_ buf: RustBuffer) throws -> MobileWatchPreferenceState {
    return try FfiConverterTypeMobileWatchPreferenceState.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchPreferenceState_lower(_ value: MobileWatchPreferenceState) -> RustBuffer {
    return FfiConverterTypeMobileWatchPreferenceState.lower(value)
}




public enum MobileWatchSnapshotState: Equatable, Hashable {

    case unavailable
    case unpaired
    case pending
    case delivered
    case current
    case failed





}

#if compiler(>=6)
extension MobileWatchSnapshotState: Sendable {}
#endif

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMobileWatchSnapshotState: FfiConverterRustBuffer {
    typealias SwiftType = MobileWatchSnapshotState

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MobileWatchSnapshotState {
        let variant: Int32 = try readInt(&buf)
        switch variant {

        case 1: return .unavailable

        case 2: return .unpaired

        case 3: return .pending

        case 4: return .delivered

        case 5: return .current

        case 6: return .failed

        default: throw UniffiInternalError.unexpectedEnumCase
        }
    }

    public static func write(_ value: MobileWatchSnapshotState, into buf: inout [UInt8]) {
        switch value {


        case .unavailable:
            writeInt(&buf, Int32(1))


        case .unpaired:
            writeInt(&buf, Int32(2))


        case .pending:
            writeInt(&buf, Int32(3))


        case .delivered:
            writeInt(&buf, Int32(4))


        case .current:
            writeInt(&buf, Int32(5))


        case .failed:
            writeInt(&buf, Int32(6))

        }
    }
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotState_lift(_ buf: RustBuffer) throws -> MobileWatchSnapshotState {
    return try FfiConverterTypeMobileWatchSnapshotState.lift(buf)
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMobileWatchSnapshotState_lower(_ value: MobileWatchSnapshotState) -> RustBuffer {
    return FfiConverterTypeMobileWatchSnapshotState.lower(value)
}


#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer {
    typealias SwiftType = UInt32?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterUInt32.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 FfiConverterUInt32.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionUInt64: FfiConverterRustBuffer {
    typealias SwiftType = UInt64?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterUInt64.write(value, into: &buf)
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
        switch try readInt(&buf) as Int8 {
        case 0: return nil
        case 1: return try FfiConverterUInt64.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionInt64: FfiConverterRustBuffer {
    typealias SwiftType = Int64?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterInt64.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 FfiConverterInt64.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
    typealias SwiftType = String?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterString.write(value, into: &buf)
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
        switch try readInt(&buf) as Int8 {
        case 0: return nil
        case 1: return try FfiConverterString.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileAuthentication: FfiConverterRustBuffer {
    typealias SwiftType = MobileAuthentication?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileAuthentication.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 FfiConverterTypeMobileAuthentication.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileHomeNotice: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeNotice?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileHomeNotice.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 FfiConverterTypeMobileHomeNotice.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileKeyTransferKey: FfiConverterRustBuffer {
    typealias SwiftType = MobileKeyTransferKey?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileKeyTransferKey.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 FfiConverterTypeMobileKeyTransferKey.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileNavigationRow: FfiConverterRustBuffer {
    typealias SwiftType = MobileNavigationRow?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileNavigationRow.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 FfiConverterTypeMobileNavigationRow.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileTotpDetail: FfiConverterRustBuffer {
    typealias SwiftType = MobileTotpDetail?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileTotpDetail.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 FfiConverterTypeMobileTotpDetail.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileTotpPage: FfiConverterRustBuffer {
    typealias SwiftType = MobileTotpPage?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileTotpPage.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 FfiConverterTypeMobileTotpPage.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobileHomeActionKind: FfiConverterRustBuffer {
    typealias SwiftType = MobileHomeActionKind?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobileHomeActionKind.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 FfiConverterTypeMobileHomeActionKind.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeMobilePrivateStorageErrorKind: FfiConverterRustBuffer {
    typealias SwiftType = MobilePrivateStorageErrorKind?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterTypeMobilePrivateStorageErrorKind.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 FfiConverterTypeMobilePrivateStorageErrorKind.read(from: &buf)
        default: throw UniffiInternalError.unexpectedOptionalTag
        }
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionSequenceTypeMobileEntryEditorInput: FfiConverterRustBuffer {
    typealias SwiftType = [MobileEntryEditorInput]?

    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
        guard let value = value else {
            writeInt(&buf, Int8(0))
            return
        }
        writeInt(&buf, Int8(1))
        FfiConverterSequenceTypeMobileEntryEditorInput.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 FfiConverterSequenceTypeMobileEntryEditorInput.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 FfiConverterSequenceTypeMobileAndroidSetupKey: FfiConverterRustBuffer {
    typealias SwiftType = [MobileAndroidSetupKey]

    public static func write(_ value: [MobileAndroidSetupKey], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileAndroidSetupKey.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileAndroidSetupKey] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileAndroidSetupKey]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileAndroidSetupKey.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileEntryEditorField: FfiConverterRustBuffer {
    typealias SwiftType = [MobileEntryEditorField]

    public static func write(_ value: [MobileEntryEditorField], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileEntryEditorField.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileEntryEditorField] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileEntryEditorField]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileEntryEditorField.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileEntryEditorInput: FfiConverterRustBuffer {
    typealias SwiftType = [MobileEntryEditorInput]

    public static func write(_ value: [MobileEntryEditorInput], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileEntryEditorInput.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileEntryEditorInput] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileEntryEditorInput]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileEntryEditorInput.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileEntryField: FfiConverterRustBuffer {
    typealias SwiftType = [MobileEntryField]

    public static func write(_ value: [MobileEntryField], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileEntryField.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileEntryField] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileEntryField]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileEntryField.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileEntrySection: FfiConverterRustBuffer {
    typealias SwiftType = [MobileEntrySection]

    public static func write(_ value: [MobileEntrySection], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileEntrySection.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileEntrySection] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileEntrySection]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileEntrySection.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileHomeAction: FfiConverterRustBuffer {
    typealias SwiftType = [MobileHomeAction]

    public static func write(_ value: [MobileHomeAction], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileHomeAction.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileHomeAction] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileHomeAction]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileHomeAction.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileHomeChange: FfiConverterRustBuffer {
    typealias SwiftType = [MobileHomeChange]

    public static func write(_ value: [MobileHomeChange], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileHomeChange.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileHomeChange] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileHomeChange]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileHomeChange.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileHomeCommit: FfiConverterRustBuffer {
    typealias SwiftType = [MobileHomeCommit]

    public static func write(_ value: [MobileHomeCommit], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileHomeCommit.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileHomeCommit] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileHomeCommit]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileHomeCommit.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileHomeSummaryRow: FfiConverterRustBuffer {
    typealias SwiftType = [MobileHomeSummaryRow]

    public static func write(_ value: [MobileHomeSummaryRow], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileHomeSummaryRow.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileHomeSummaryRow] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileHomeSummaryRow]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileHomeSummaryRow.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileKeyTransferFrame: FfiConverterRustBuffer {
    typealias SwiftType = [MobileKeyTransferFrame]

    public static func write(_ value: [MobileKeyTransferFrame], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileKeyTransferFrame.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileKeyTransferFrame] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileKeyTransferFrame]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileKeyTransferFrame.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileKeyTransferKey: FfiConverterRustBuffer {
    typealias SwiftType = [MobileKeyTransferKey]

    public static func write(_ value: [MobileKeyTransferKey], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileKeyTransferKey.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileKeyTransferKey] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileKeyTransferKey]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileKeyTransferKey.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileMutationDestination: FfiConverterRustBuffer {
    typealias SwiftType = [MobileMutationDestination]

    public static func write(_ value: [MobileMutationDestination], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileMutationDestination.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileMutationDestination] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileMutationDestination]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileMutationDestination.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileNavigationRow: FfiConverterRustBuffer {
    typealias SwiftType = [MobileNavigationRow]

    public static func write(_ value: [MobileNavigationRow], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileNavigationRow.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileNavigationRow] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileNavigationRow]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileNavigationRow.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobilePage: FfiConverterRustBuffer {
    typealias SwiftType = [MobilePage]

    public static func write(_ value: [MobilePage], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobilePage.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobilePage] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobilePage]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobilePage.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobilePasswordRow: FfiConverterRustBuffer {
    typealias SwiftType = [MobilePasswordRow]

    public static func write(_ value: [MobilePasswordRow], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobilePasswordRow.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobilePasswordRow] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobilePasswordRow]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobilePasswordRow.read(from: &buf))
        }
        return seq
    }
}

#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeMobileTotpRow: FfiConverterRustBuffer {
    typealias SwiftType = [MobileTotpRow]

    public static func write(_ value: [MobileTotpRow], into buf: inout [UInt8]) {
        let len = Int32(value.count)
        writeInt(&buf, len)
        for item in value {
            FfiConverterTypeMobileTotpRow.write(item, into: &buf)
        }
    }

    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MobileTotpRow] {
        let len: Int32 = try readInt(&buf)
        var seq = [MobileTotpRow]()
        seq.reserveCapacity(Int(len))
        for _ in 0 ..< len {
            seq.append(try FfiConverterTypeMobileTotpRow.read(from: &buf))
        }
        return seq
    }
}
public func mobileAuthentication()throws  -> MobileAuthentication  {
    return try  FfiConverterTypeMobileAuthentication_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_authentication(uniffiCallStatus
    )
})
}
public func mobileEditorProcessRecreatedNotice() -> String  {
    return try!  FfiConverterString.lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_editor_process_recreated_notice(uniffiCallStatus
    )
})
}
public func mobileHomeOperation(authentication: MobileAuthentication?) -> MobileHomeOperation  {
    return try!  FfiConverterTypeMobileHomeOperation_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_home_operation(
        FfiConverterOptionTypeMobileAuthentication.lower(authentication),uniffiCallStatus
    )
})
}
public func mobileKeyTransfer()throws  -> MobileKeyTransfer  {
    return try  FfiConverterTypeMobileKeyTransfer_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_key_transfer(uniffiCallStatus
    )
})
}
public func mobileLocalKeyTransferImporter() -> MobileKeyTransferImport  {
    return try!  FfiConverterTypeMobileKeyTransferImport_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_local_key_transfer_importer(uniffiCallStatus
    )
})
}
public func mobileLocalOnboardingOperation() -> MobileLocalOnboardingOperation  {
    return try!  FfiConverterTypeMobileLocalOnboardingOperation_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_local_onboarding_operation(uniffiCallStatus
    )
})
}
public func mobileOnboardingOperation(serverUrl: String, account: String, repositoryPath: String, applicationToken: String)throws  -> MobileOnboardingOperation  {
    return try  FfiConverterTypeMobileOnboardingOperation_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_onboarding_operation(
        FfiConverterString.lower(serverUrl),
        FfiConverterString.lower(account),
        FfiConverterString.lower(repositoryPath),
        FfiConverterString.lower(applicationToken),uniffiCallStatus
    )
})
}
public func mobilePasswordPage(path: String?)throws  -> MobilePasswordPage  {
    return try  FfiConverterTypeMobilePasswordPage_lift(try rustCallWithError(FfiConverterTypeMobilePasswordFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_password_page(
        FfiConverterOptionString.lower(path),uniffiCallStatus
    )
})
}
public func mobilePasswordSearch(query: String)throws  -> MobilePasswordPage  {
    return try  FfiConverterTypeMobilePasswordPage_lift(try rustCallWithError(FfiConverterTypeMobilePasswordFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_password_search(
        FfiConverterString.lower(query),uniffiCallStatus
    )
})
}
public func mobileShell() -> MobileShell  {
    return try!  FfiConverterTypeMobileShell_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_shell(uniffiCallStatus
    )
})
}
public func mobileShellFixture(state: MobileShellState) -> MobileShell  {
    return try!  FfiConverterTypeMobileShell_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_shell_fixture(
        FfiConverterTypeMobileShellState_lower(state),uniffiCallStatus
    )
})
}
public func mobileTotpOperation() -> MobileTotpOperation  {
    return try!  FfiConverterTypeMobileTotpOperation_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_totp_operation(uniffiCallStatus
    )
})
}
public func productName() -> String  {
    return try!  FfiConverterString.lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_product_name(uniffiCallStatus
    )
})
}
public func replaceConfiguredMobileApplicationToken(account: String, applicationToken: String)throws   {try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_replace_configured_mobile_application_token(
        FfiConverterString.lower(account),
        FfiConverterString.lower(applicationToken),uniffiCallStatus
    )
}
}
public func setSelectedMobileTab(tab: MobileTab)throws   {try rustCallWithError(FfiConverterTypeMobilePreferenceError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_set_selected_mobile_tab(
        FfiConverterTypeMobileTab_lower(tab),uniffiCallStatus
    )
}
}
/**
 * Revoke a copy while the Android window still has foreground clipboard access.
 */
public func clearMobileEntryCopy(copy: MobileEntryCopy, clipboard: MobileClipboard)throws   {try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_clear_mobile_entry_copy(
        FfiConverterTypeMobileEntryCopy_lower(copy),
        FfiConverterTypeMobileClipboard_lower(clipboard),uniffiCallStatus
    )
}
}
public func copyMobileEntry(copy: MobileEntryCopy, clipboard: MobileClipboard)throws  -> MobileClipboardDisposition  {
    return try  FfiConverterTypeMobileClipboardDisposition_lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_copy_mobile_entry(
        FfiConverterTypeMobileEntryCopy_lower(copy),
        FfiConverterTypeMobileClipboard_lower(clipboard),uniffiCallStatus
    )
})
}
/**
 * Android never retains or resurrects previous clipboard contents.
 */
public func copyMobileEntryClearing(copy: MobileEntryCopy, clipboard: MobileClipboard)throws  -> MobileClipboardDisposition  {
    return try  FfiConverterTypeMobileClipboardDisposition_lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_copy_mobile_entry_clearing(
        FfiConverterTypeMobileEntryCopy_lower(copy),
        FfiConverterTypeMobileClipboard_lower(clipboard),uniffiCallStatus
    )
})
}
public func decodeMobileCameraFrame(frame: MobileCameraFrame)throws  -> Data  {
    return try  FfiConverterData.lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_decode_mobile_camera_frame(
        FfiConverterTypeMobileCameraFrame_lower(frame),uniffiCallStatus
    )
})
}
public func mobileAuthenticationWithPlatform(paths: MobilePlatformPaths, backend: MobileSecretBackend, clock: MobileClock)throws  -> MobileAuthentication  {
    return try  FfiConverterTypeMobileAuthentication_lift(try rustCallWithError(FfiConverterTypeMobileAuthenticationFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_authentication_with_platform(
        FfiConverterTypeMobilePlatformPaths_lower(paths),
        FfiConverterTypeMobileSecretBackend_lower(backend),
        FfiConverterTypeMobileClock_lower(clock),uniffiCallStatus
    )
})
}
public func mobilePlatformLayout(paths: MobilePlatformPaths)throws  -> MobilePlatformLayout  {
    return try  FfiConverterTypeMobilePlatformLayout_lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_platform_layout(
        FfiConverterTypeMobilePlatformPaths_lower(paths),uniffiCallStatus
    )
})
}
public func validateMobileCredentialRequest(request: MobileCredentialRequest)throws  -> MobileCredentialRequest  {
    return try  FfiConverterTypeMobileCredentialRequest_lift(try rustCallWithError(FfiConverterTypeMobilePlatformFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_validate_mobile_credential_request(
        FfiConverterTypeMobileCredentialRequest_lower(request),uniffiCallStatus
    )
})
}
public func mobilePrivateStorageFailure(error: MobilePrivateStorageErrorKind) -> MobileShell  {
    return try!  FfiConverterTypeMobileShell_lift(try! rustCall() {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_mobile_private_storage_failure(
        FfiConverterTypeMobilePrivateStorageErrorKind_lower(error),uniffiCallStatus
    )
})
}
public func openMobilePrivateRuntime(directories: MobilePrivateDirectories)throws  -> MobilePrivateRuntime  {
    return try  FfiConverterTypeMobilePrivateRuntime_lift(try rustCallWithError(FfiConverterTypeMobilePrivateStorageFfiError_lift) {
        uniffiCallStatus in
    uniffi_ironstorage_mobile_fn_func_open_mobile_private_runtime(
        FfiConverterTypeMobilePrivateDirectories_lower(directories),uniffiCallStatus
    )
})
}

private enum InitializationResult {
    case ok
    case contractVersionMismatch
    case apiChecksumMismatch
}
// Use a global variable to perform the versioning checks. Swift ensures that
// the code inside is only computed once.
private let initializationResult: InitializationResult = {
    // Get the bindings contract version from our ComponentInterface
    let bindings_contract_version = 30
    // Get the scaffolding contract version by calling the into the dylib
    let scaffolding_contract_version = ffi_ironstorage_mobile_uniffi_contract_version()
    if bindings_contract_version != scaffolding_contract_version {
        return InitializationResult.contractVersionMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_authentication() != 54684) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_editor_process_recreated_notice() != 20887) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_home_operation() != 10726) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_key_transfer() != 24461) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_local_key_transfer_importer() != 45641) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_local_onboarding_operation() != 21270) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_onboarding_operation() != 61078) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_password_page() != 35214) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_password_search() != 32796) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_shell() != 1601) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_shell_fixture() != 50477) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_totp_operation() != 64534) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_product_name() != 4441) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_replace_configured_mobile_application_token() != 21971) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_set_selected_mobile_tab() != 23876) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_clear_mobile_entry_copy() != 51777) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_copy_mobile_entry() != 39081) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_copy_mobile_entry_clearing() != 43699) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_decode_mobile_camera_frame() != 45472) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_authentication_with_platform() != 48013) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_platform_layout() != 25741) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_validate_mobile_credential_request() != 60738) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_mobile_private_storage_failure() != 38666) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_func_open_mobile_private_runtime() != 27207) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_acknowledge_watch_snapshot() != 21391) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_add_entry_editor_field() != 47914) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_add_entry_editor_otp_image() != 54235) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_begin_create_entry() != 47677) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_begin_entry_editor() != 3082) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_cached_totp_page() != 49580) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_cancel() != 40449) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_checkpoint_entry_editor() != 51032) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_checkpoint_entry_editor_inputs() != 62194) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_copy_entry_field() != 46283) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_copy_presented_entry_field() != 16973) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_copy_presented_totp_code() != 32197) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_copy_totp_code() != 51013) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_create_directory() != 45979) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_discard_entry_editor() != 59865) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_enroll_biometric_unlock() != 6533) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_entry_editor() != 40530) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_entry_page() != 7262) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_fail_watch_snapshot() != 5556) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_generate_entry_editor_password() != 13589) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_git_identity() != 35303) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_manual_lock() != 54277) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_mobile_appearance() != 38885) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_navigation_entry() != 45161) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_perform_entry_mutation() != 36745) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_preferences() != 16343) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_prepare_entry_mutation() != 24463) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_prepare_presented_entry_mutation() != 26205) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_prepare_watch_snapshot() != 63315) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_refresh_entry_presentation() != 17168) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_remove_application_token() != 34406) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_remove_entry_editor_field() != 27871) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_reorder_entry_editor_field() != 30542) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_replace_entry_field() != 5390) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_replace_presented_entry_field() != 2917) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_restore_biometric_lease() != 7408) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_resume_entry_editor() != 56859) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_reveal_entry_field() != 13272) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_reveal_presented_entry_field() != 3039) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_save_entry_editor() != 9869) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_search_cached_totp_page() != 41925) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_authentication_timeout() != 28648) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_biometric_unlock() != 30931) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_git_identity() != 30660) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_mobile_appearance() != 4454) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_totp_watch_shared() != 15677) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_set_watch_snapshot_unavailable() != 56751) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_state() != 55462) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_totp_detail() != 1912) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_totp_page() != 46420) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_touch_user_activity() != 36477) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_unlock_entry() != 6320) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_unlock_totp() != 3673) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_update_entry_editor() != 1037) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_watch_snapshot_status() != 21716) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileauthentication_lifecycle() != 7147) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_activity_known() != 61390) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_cached() != 29336) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_cancel() != 47907) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_commit() != 26020) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_fetch() != 25832) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_identity() != 10598) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_progress() != 21317) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_pull() != 38293) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_push() != 23745) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_refresh_gesture() != 9425) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_refresh_if_stale() != 39139) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilehomeoperation_sync() != 13675) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilekeytransfer_export() != 52660) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilekeytransfer_importer() != 12105) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilekeytransfer_keys() != 3804) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilekeytransferimport_add_frame() != 62030) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilekeytransferimport_import() != 64195) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilelocalonboardingoperation_cancel() != 35729) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilelocalonboardingoperation_generate() != 25292) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileonboardingoperation_cancel() != 7349) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileonboardingoperation_connect_local_store() != 14357) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileonboardingoperation_discover() != 45767) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileonboardingoperation_progress() != 42063) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileonboardingoperation_setup() != 27093) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobiletotpoperation_cancel() != 6026) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobiletotpoperation_progress() != 30340) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_device_state() != 19346) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_create_key() != 7937) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_encrypt() != 65449) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_decrypt() != 39727) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_delete_key() != 20162) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_aliases() != 16519) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidkeystore_cancel_pending() != 39774) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_cancel() != 32177) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_generate() != 35096) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_import_key() != 8889) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_progress() != 56154) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_remote() != 42493) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_replace_token() != 46064) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_setup_local() != 43343) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidonboarding_status() != 41645) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidremoteonboarding_cancel() != 58015) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidremoteonboarding_clone_store() != 33517) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidremoteonboarding_connect() != 5133) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileandroidremoteonboarding_discover() != 30506) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileclipboard_read() != 47092) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileclipboard_write() != 39923) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileclipboard_clear() != 60674) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileclipboard_wait_for_timeout() != 37177) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileclock_monotonic_milliseconds() != 57973) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_create() != 58960) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_retrieve() != 14295) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_replace() != 59075) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_delete() != 19766) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_lock() != 22370) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobilesecretbackend_unlock() != 2737) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_open_password_search_result() != 26489) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_password_name_search() != 31132) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_password_navigation() != 52267) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_activate() != 64835) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_android_home_operation() != 20347) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_android_onboarding() != 59478) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_android_secret_backend() != 24373) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_authentication() != 21237) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_clear_disposable_cache() != 35831) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_layout() != 33040) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_shell() != 42966) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_status() != 46293) {
        return InitializationResult.apiChecksumMismatch
    }
    if (uniffi_ironstorage_mobile_checksum_method_mobileprivateruntime_verify_secure_storage() != 12909) {
        return InitializationResult.apiChecksumMismatch
    }

    uniffiCallbackInitMobileAndroidKeystore()
    uniffiCallbackInitMobileClipboard()
    uniffiCallbackInitMobileClock()
    uniffiCallbackInitMobileSecretBackend()
    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 uniffiEnsureIronstorageMobileInitialized() {
    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
// IronStorage diagnostic redaction; wire values and checksums remain generated.
extension MobileAndroidCiphertext: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidCiphertext([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAndroidDeviceState: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidDeviceState([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAndroidKeySpecification: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidKeySpecification([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAndroidKeystoreError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidKeystoreError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAndroidSetupKey: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidSetupKey([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAndroidSetupStatus: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAndroidSetupStatus([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAuthenticationFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAuthenticationFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileAuthenticationState: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileAuthenticationState([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileCameraFrame: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileCameraFrame([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileClipboardContent: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileClipboardContent([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileCredentialRequest: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileCredentialRequest([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryCopy: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryCopy([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryEditorField: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryEditorField([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryEditorInput: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryEditorInput([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryEditorPage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryEditorPage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryEditorRecovery: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryEditorRecovery([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryEditorSession: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryEditorSession([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryField: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryField([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryPage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryPage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntryPresentation: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntryPresentation([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileEntrySection: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileEntrySection([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileGitIdentity: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileGitIdentity([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeAction: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeAction([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeChange: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeChange([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeCommit: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeCommit([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeNotice: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeNotice([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomePage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomePage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeProgress: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeProgress([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileHomeSummaryRow: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileHomeSummaryRow([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferExport: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferExport([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferFrame: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferFrame([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferKey: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferKey([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferOutcome: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferOutcome([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileKeyTransferProgress: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileKeyTransferProgress([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileMutationDestination: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileMutationDestination([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileMutationOutcome: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileMutationOutcome([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileMutationPlan: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileMutationPlan([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileMutationRequest: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileMutationRequest([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileNavigationRow: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileNavigationRow([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileOnboardingDiscovery: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileOnboardingDiscovery([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileOnboardingFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileOnboardingFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileOnboardingOutcome: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileOnboardingOutcome([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileOnboardingProgress: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileOnboardingProgress([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePasswordFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePasswordFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePasswordNavigation: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePasswordNavigation([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePasswordPage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePasswordPage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePasswordRow: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePasswordRow([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePlatformFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePlatformFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePlatformLayout: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePlatformLayout([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePlatformPaths: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePlatformPaths([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePreferenceError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePreferenceError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePreferences: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePreferences([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePrivateDirectories: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePrivateDirectories([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePrivateStorageFfiError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePrivateStorageFfiError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePrivateStorageLayout: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePrivateStorageLayout([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobilePrivateStorageStatus: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobilePrivateStorageStatus([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileSecretError: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileSecretError([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileSecretLocator: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileSecretLocator([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileShell: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileShell([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileTotpDetail: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileTotpDetail([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileTotpDiscoveryProgress: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileTotpDiscoveryProgress([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileTotpPage: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileTotpPage([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileTotpRow: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileTotpRow([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileWatchSnapshotStatus: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileWatchSnapshotStatus([REDACTED])" }
    public var debugDescription: String { description }
}
extension MobileWatchSnapshotTransfer: CustomStringConvertible, CustomDebugStringConvertible {
    public var description: String { "MobileWatchSnapshotTransfer([REDACTED])" }
    public var debugDescription: String { description }
}