Implement GPG key QR transfer

apple/Generated/ironstorage_apple.swift

@@ -580,6 +580,24 @@ fileprivate struct FfiConverterString: FfiConverter {
     }
 }
 
+#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)
+    }
+}
+
 
 
 
@@ -1172,6 +1190,279 @@ public func FfiConverterTypeMobileHomeOperation_lower(_ value: MobileHomeOperati
 
 
 
+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_apple_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_apple_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_apple_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_apple_fn_method_mobilekeytransfer_importer(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+
+open func keys() -> [MobileKeyTransferKey]  {
+    return try!  FfiConverterSequenceTypeMobileKeyTransferKey.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_ironstorage_apple_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) 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_apple_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_apple_fn_free_mobilekeytransferimport(handle, $0) }
+    }
+
+
+
+
+open func addFrame(payload: String)throws  -> MobileKeyTransferProgress  {
+    return try  FfiConverterTypeMobileKeyTransferProgress_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
+        uniffiCallStatus in
+    uniffi_ironstorage_apple_fn_method_mobilekeytransferimport_add_frame(
+            self.uniffiCloneHandle(),
+        FfiConverterString.lower(payload),uniffiCallStatus
+    )
+})
+}
+
+open func `import`(passphrase: String?, makeDefault: Bool)throws  -> MobileKeyTransferOutcome  {
+    return try  FfiConverterTypeMobileKeyTransferOutcome_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
+        uniffiCallStatus in
+    uniffi_ironstorage_apple_fn_method_mobilekeytransferimport_import(
+            self.uniffiCloneHandle(),
+        FfiConverterOptionString.lower(passphrase),
+        FfiConverterBool.lower(makeDefault),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 MobileOnboardingOperationProtocol: AnyObject, Sendable {
 
     func cancel()
@@ -2319,6 +2610,304 @@ public func FfiConverterTypeMobileHomeSummaryRow_lower(_ value: MobileHomeSummar
 }
 
 
+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 MobileOnboardingDiscovery: Equatable, Hashable {
     public var branches: [String]
     public var selectedBranch: UInt32
@@ -3880,6 +4469,147 @@ public func FfiConverterTypeMobileHomePhase_lower(_ value: MobileHomePhase) -> R
 
 
 
+public
+enum MobileKeyTransferFfiError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
+
+
+
+    case Failed(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(
+            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(message):
+            writeInt(&buf, Int32(1))
+            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 MobileOnboardingErrorKind: Equatable, Hashable {
 
@@ -4796,6 +5526,30 @@ fileprivate struct FfiConverterOptionTypeMobileHomeNotice: FfiConverterRustBuffe
     }
 }
 
+#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
@@ -4996,6 +5750,56 @@ fileprivate struct FfiConverterSequenceTypeMobileHomeSummaryRow: FfiConverterRus
     }
 }
 
+#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
@@ -5084,6 +5888,13 @@ public func mobileHomeOperation() -> MobileHomeOperation  {
     )
 })
 }
+public func mobileKeyTransfer()throws  -> MobileKeyTransfer  {
+    return try  FfiConverterTypeMobileKeyTransfer_lift(try rustCallWithError(FfiConverterTypeMobileKeyTransferFfiError_lift) {
+        uniffiCallStatus in
+    uniffi_ironstorage_apple_fn_func_mobile_key_transfer(uniffiCallStatus
+    )
+})
+}
 public func mobileOnboardingOperation(serverUrl: String, account: String, repositoryPath: String, applicationToken: String)throws  -> MobileOnboardingOperation  {
     return try  FfiConverterTypeMobileOnboardingOperation_lift(try rustCallWithError(FfiConverterTypeMobileOnboardingFfiError_lift) {
         uniffiCallStatus in
@@ -5162,6 +5973,9 @@ private let initializationResult: InitializationResult = {
     if (uniffi_ironstorage_apple_checksum_func_mobile_home_operation() != 10595) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_ironstorage_apple_checksum_func_mobile_key_transfer() != 57389) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_ironstorage_apple_checksum_func_mobile_onboarding_operation() != 8354) {
         return InitializationResult.apiChecksumMismatch
     }
@@ -5276,6 +6090,21 @@ private let initializationResult: InitializationResult = {
     if (uniffi_ironstorage_apple_checksum_method_mobilehomeoperation_refresh_if_stale() != 27818) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_ironstorage_apple_checksum_method_mobilekeytransfer_export() != 50467) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_ironstorage_apple_checksum_method_mobilekeytransfer_importer() != 55825) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_ironstorage_apple_checksum_method_mobilekeytransfer_keys() != 1261) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_ironstorage_apple_checksum_method_mobilekeytransferimport_add_frame() != 27319) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_ironstorage_apple_checksum_method_mobilekeytransferimport_import() != 37403) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_ironstorage_apple_checksum_method_mobileonboardingoperation_cancel() != 49755) {
         return InitializationResult.apiChecksumMismatch
     }