@tapayadot/accept-react-native 1.3.2 → 1.14.1

package/ios/AcceptSdkReactNativeModule.swift

@@ -1,749 +0,0 @@
-import AcceptSDK
-@_spi(AcceptDemo) import AcceptSDK
-import CoreLocation
-import ExpoModulesCore
-import UIKit
-
-// MARK: - Records
-
-final class CardPaymentIntentRecord: Record {
-    @Field var paymentIntentId: String = ""
-    @Field var amount: Int = 0
-    @Field var requestedCurrency: String = ""
-    @Field var settlementCurrency: String? = nil
-}
-
-final class SepaPaymentIntentRecord: Record {
-    @Field var paymentIntentId: String = ""
-    @Field var amount: Int = 0
-    @Field var requestedCurrency: String = ""
-    @Field var settlementCurrency: String? = nil
-}
-
-final class CertisPaymentIntentRecord: Record {
-    @Field var paymentIntentId: String = ""
-    @Field var amount: Int = 0
-    @Field var requestedCurrency: String = ""
-    @Field var settlementCurrency: String? = nil
-}
-
-final class CardPaymentResultRecord: Record {
-    @Field var status: String = ""
-    @Field var last4: String? = nil
-    @Field var companyName: String = ""
-    @Field var companyAddress1: String = ""
-    @Field var companyAddress2: String? = nil
-    @Field var companyCity: String = ""
-    @Field var companyCountry: String = ""
-    @Field var terminalId: String = ""
-    @Field var authorizationCode: String? = nil
-    @Field var brand: String? = nil
-    @Field var reason: String? = nil
-    @Field var receiptUrl: String? = nil
-    @Field var refundToken: String? = nil
-}
-
-final class RefundIntentRecord: Record {
-    @Field var paymentToken: String = ""
-    @Field var refundToken: String? = nil
-    @Field var reason: String = "customerRequest"
-}
-
-final class RefundResultRecord: Record {
-    @Field var refundToken: String? = nil
-    @Field var status: String = ""
-    @Field var paymentMethod: String? = nil
-    @Field var requestedAmount: Int? = nil
-    @Field var requestedCurrency: String? = nil
-    @Field var settlementAmount: Int? = nil
-    @Field var settlementCurrency: String? = nil
-    @Field var fxRate: Double? = nil
-    @Field var refundReason: String = ""
-    @Field var createdAt: String? = nil
-    @Field var processedAt: String? = nil
-}
-
-final class BankTransferPaymentResultRecord: Record {
-    @Field var status: String = ""
-    @Field var postponed: Bool = false
-    @Field var receivedAt: String? = nil
-    @Field var receivedFromIban: String? = nil
-    @Field var receiptUrl: String? = nil
-}
-
-final class GradientColorsRecord: Record {
-    @Field var start: String = ""
-    @Field var end: String = ""
-}
-
-final class AcceptColorThemeRecord: Record {
-    @Field var accent: String = ""
-    @Field var error: String = ""
-    @Field var warning: String = ""
-    @Field var success: String = ""
-    @Field var brandGradientColors: GradientColorsRecord? = nil
-    @Field var brandSubtleGradientColors: GradientColorsRecord? = nil
-}
-
-final class AcceptImageThemeRecord: Record {
-    @Field var brandLogo: String = ""
-    @Field var toolbarLogo: String = ""
-    @Field var solidLogo: String = ""
-}
-
-final class AcceptThemeConfigurationRecord: Record {
-    @Field var themeId: String? = nil
-    @Field var colors: AcceptColorThemeRecord? = nil
-    @Field var images: AcceptImageThemeRecord? = nil
-}
-
-final class KybPrefillDataRecord: Record {
-    @Field var businessType: String? = nil
-    @Field var countryCode: String? = nil
-    @Field var registrationNumber: String? = nil
-    @Field var vatNumber: String? = nil
-    @Field var legalName: String? = nil
-    @Field var addressLine1: String? = nil
-    @Field var addressLine2: String? = nil
-    @Field var city: String? = nil
-    @Field var postalCode: String? = nil
-    @Field var merchantCategoryCode: Int? = nil
-    @Field var businessEmail: String? = nil
-    @Field var bankAccountIban: String? = nil
-    @Field var businessUrl: String? = nil
-    @Field var productDescription: String? = nil
-    @Field var supportPhone: String? = nil
-
-    func toKybPrefillData() -> KybPrefillData {
-        var data = KybPrefillData()
-        data.countryCode = countryCode
-        data.registrationNumber = registrationNumber
-        data.vatNumber = vatNumber
-        data.legalName = legalName
-        data.addressLine1 = addressLine1
-        data.addressLine2 = addressLine2
-        data.city = city
-        data.postalCode = postalCode
-        data.merchantCategoryCode = merchantCategoryCode
-        data.businessEmail = businessEmail
-        data.bankAccountIban = bankAccountIban
-        data.businessUrl = businessUrl.flatMap { URL(string: $0) }
-        data.productDescription = productDescription
-        data.supportPhone = supportPhone
-        data.businessType = businessType.flatMap { value -> AcceptBusinessType? in
-            switch value {
-            case "individual": .individual
-            case "company": .company
-            case "nonProfit": .nonProfit
-            case "governmentEntity": .governmentEntity
-            default: nil
-            }
-        }
-        return data
-    }
-}
-
-// MARK: - Module
-
-public class AcceptSdkReactNativeModule: Module {
-    public func definition() -> ModuleDefinition {
-        Name("AcceptSdkReactNative")
-
-        AsyncFunction("initialize") { (demo: Bool, theme: AcceptThemeConfigurationRecord?) async throws in
-            do {
-                let themeConfig = try theme?.toAcceptThemeConfiguration() ?? .default
-                try await Accept.initialize(environment: demo ? .sandbox : .production, theme: themeConfig)
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("setTheme") { (theme: AcceptThemeConfigurationRecord) async throws in
-            do {
-                try await Accept.setTheme(try theme.toAcceptThemeConfiguration())
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("setUiBehavior") { (_: [String: Any]) in
-            // No-op on iOS — UI behavior configuration is Android-only.
-        }
-
-        AsyncFunction("authenticate") { (token: String) async throws in
-            do {
-                try await Accept.authenticate(merchantToken: token)
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-            return true
-        }
-
-        AsyncFunction("getStatus") { () async -> String in
-            let status = await Accept.status
-            switch status {
-            case .idle: return "IDLE"
-            case .initialized: return "INITIALIZED"
-            case .authenticated: return "LOGGED_IN"
-            @unknown default: return "IDLE"
-            }
-        }
-
-        AsyncFunction("isPaymentPending") { () async -> Bool in
-            await Accept.isPaymentInProgress()
-        }
-
-        AsyncFunction("logOut") { () async throws in
-            do {
-                try await Accept.logout()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-            return true
-        }
-
-        AsyncFunction("presentKyb") { (prefilling: KybPrefillDataRecord?) async throws in
-            let prefillData = prefilling?.toKybPrefillData()
-            try await Accept.presentKyb(prefilling: prefillData)
-        }
-
-        AsyncFunction("getOnboardingStatus") { () async throws -> [String: Any] in
-            do {
-                let status = try await Accept.getOnboardingStatus()
-                return [
-                    "isOnboarded": status.isOnboarded,
-                    "paymentMethods": status.paymentMethods.map { pm in
-                        [
-                            "method": pm.method.toJsString(),
-                            "status": pm.status.toJsString(),
-                        ]
-                    },
-                ]
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("getPaymentMethodStatus") { (method: String) async throws -> String in
-            do {
-                let status = try await Accept.getPaymentMethodStatus(for: try AcceptPaymentMethod.fromJsString(method))
-                return status.toJsString()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("requestLocationPermission") { () async throws -> Bool in
-            do {
-                try await Accept.requestLocationPermission()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-            return true
-        }
-
-        AsyncFunction("pairWithCompanionApp") { () async throws in
-            do {
-                try await Accept.pairWithCompanionApp()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("isCompanionAppInstalled") { () async -> Bool in
-            await MainActor.run { Accept.isCompanionAppInstalled() }
-        }
-
-        AsyncFunction("presentCompanionAppSheet") { () async throws in
-            do {
-                try await Accept.presentCompanionAppSheet()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("getPaymentStatus") { (paymentIntentId: String) async throws -> String in
-            do {
-                let status = try await Accept.getPaymentStatus(for: paymentIntentId)
-                return try InfoResultSerializer.serialize(status)
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("startCardPayment") { (intentRecord: CardPaymentIntentRecord) async throws -> CardPaymentResultRecord in
-            do {
-                let outcome = try await Accept.pay(intentRecord.toPaymentIntent())
-                return outcome.toCardResult()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("startSepaPayment") { (intentRecord: SepaPaymentIntentRecord) async throws -> BankTransferPaymentResultRecord in
-            do {
-                let outcome = try await Accept.pay(intentRecord.toPaymentIntent())
-                return outcome.toBankTransferResult()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("startCertisPayment") { (intentRecord: CertisPaymentIntentRecord) async throws -> BankTransferPaymentResultRecord in
-            do {
-                let outcome = try await Accept.pay(intentRecord.toPaymentIntent())
-                return outcome.toBankTransferResult()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("refund") { (intent: RefundIntentRecord) async throws -> RefundResultRecord in
-            do {
-                let refund = try await Accept.refund(
-                    paymentToken: intent.paymentToken,
-                    refundToken: intent.refundToken,
-                    reason: try AcceptRefundReason.fromJsString(intent.reason)
-                )
-                return refund.toRecord()
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("cancelActivePayment") { () async throws in
-            do {
-                try await MainActor.run { try Accept.cancelActivePayment() }
-            } catch let error as AcceptSDKError {
-                throw error.toException()
-            }
-        }
-
-        AsyncFunction("enableDemoMode") { () async in
-            await Accept.enableDemoMode()
-        }
-
-        AsyncFunction("disableDemoMode") { () async in
-            await Accept.disableDemoMode()
-        }
-
-        AsyncFunction("isDemoMode") { () async -> Bool in
-            return await MainActor.run { Accept.isDemoMode }
-        }
-    }
-}
-
-// MARK: - Theme conversion
-
-private extension AcceptThemeConfigurationRecord {
-    func toAcceptThemeConfiguration() throws -> AcceptThemeConfiguration {
-        if let id = themeId {
-            return .byId(id)
-        }
-        var config = AcceptThemeConfiguration()
-        if let colorsRecord = colors {
-            config.colors = .local(try colorsRecord.toAcceptColorTheme())
-        }
-        if let imagesRecord = images {
-            config.images = .local(try imagesRecord.toAcceptImageTheme())
-        }
-        return config
-    }
-}
-
-private extension AcceptColorThemeRecord {
-    func toAcceptColorTheme() throws -> AcceptColorTheme {
-        AcceptColorTheme(
-            accent: try color(fromHex: accent),
-            error: try color(fromHex: error),
-            warning: try color(fromHex: warning),
-            success: try color(fromHex: success),
-            brandGradientColors: try brandGradientColors.map { GradientColors(start: try color(fromHex: $0.start), end: try color(fromHex: $0.end)) },
-            brandSubtleGradientColors: try brandSubtleGradientColors.map { GradientColors(start: try color(fromHex: $0.start), end: try color(fromHex: $0.end)) }
-        )
-    }
-}
-
-private extension AcceptImageThemeRecord {
-    func toAcceptImageTheme() throws -> AcceptImageTheme {
-        guard
-            let brandLogoData = Data(base64Encoded: brandLogo),
-            let brandLogoImage = UIImage(data: brandLogoData),
-            let toolbarLogoData = Data(base64Encoded: toolbarLogo),
-            let toolbarLogoImage = UIImage(data: toolbarLogoData),
-            let solidLogoData = Data(base64Encoded: solidLogo),
-            let solidLogoImage = UIImage(data: solidLogoData)
-        else {
-            throw Exception(name: "ThemeError", description: "Invalid base64 image data in AcceptImageTheme")
-        }
-        return AcceptImageTheme(brandLogo: brandLogoImage, toolbarLogo: toolbarLogoImage, solidLogo: solidLogoImage)
-    }
-}
-
-private func color(fromHex input: String) throws -> AcceptColor {
-    let hex = input.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
-    guard hex.count == 3 || hex.count == 6 || hex.count == 8 else {
-        throw Exception(name: "ThemeError", description: "Invalid hex color '\(input)'. Expected #RRGGBB or #AARRGGBB.")
-    }
-    var int: UInt64 = 0
-    guard Scanner(string: hex).scanHexInt64(&int) else {
-        throw Exception(name: "ThemeError", description: "Invalid hex color '\(input)'.")
-    }
-    let a, r, g, b: UInt64
-    switch hex.count {
-    case 3:  (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
-    case 6:  (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
-    case 8:  (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
-    default: fatalError()
-    }
-    return AcceptColor(red: Double(r) / 255, green: Double(g) / 255, blue: Double(b) / 255, alpha: Double(a) / 255)
-}
-
-// MARK: - Error mapping
-
-private extension AcceptSDKError {
-    func toException() -> Exception {
-        switch self {
-        case .notInitialized:
-            return Exception(name: "NotInitialized", description: errorDescription ?? "")
-        case .merchantNotAuthenticated:
-            return Exception(name: "MerchantNotAuthenticated", description: errorDescription ?? "")
-        case .locationPermissionsNotGranted:
-            return Exception(name: "LocationPermissionsNotGranted", description: errorDescription ?? "")
-        case .companionAppNotInstalled:
-            return Exception(name: "CompanionAppNotInstalled", description: errorDescription ?? "")
-        case .failedToAuthenticateMerchant:
-            return Exception(name: "FailedToAuthenticateMerchant", description: errorDescription ?? "")
-        case .failedToPresent:
-            return Exception(name: "FailedToPresent", description: errorDescription ?? "")
-        case .kybAlreadyInProgress:
-            return Exception(name: "KybAlreadyInProgress", description: errorDescription ?? "")
-        case .kybAlreadySubmitted:
-            return Exception(name: "KybAlreadySubmitted", description: errorDescription ?? "")
-        case .paymentAlreadyInProgress:
-            return Exception(name: "PaymentAlreadyInProgress", description: errorDescription ?? "")
-        case .unexpectedPaymentResult:
-            return Exception(name: "UnexpectedPaymentResult", description: errorDescription ?? "")
-        case .paymentNotFound:
-            return Exception(name: "PaymentNotFound", description: errorDescription ?? "")
-        case .refundConflict:
-            return Exception(name: "RefundConflict", description: errorDescription ?? "")
-        case .merchantOperationFailed:
-            return Exception(name: "MerchantOperationFailed", description: errorDescription ?? "")
-        case let .amountBelowMinimum(currency, minimum):
-            return Exception(name: "AmountBelowMinimum", description: "currency=\(currency) minimum=\(minimum)")
-        case let .amountAboveMaximum(currency, maximum):
-            return Exception(name: "AmountAboveMaximum", description: "currency=\(currency) maximum=\(maximum)")
-        case let .unknownCurrency(code):
-            return Exception(name: "UnknownCurrency", description: "code=\(code)")
-        case .noActivePayment:
-            return Exception(name: "NoActivePayment", description: errorDescription ?? "")
-        @unknown default:
-            return Exception(name: "AcceptSDKError", description: errorDescription ?? "")
-        }
-    }
-}
-
-// MARK: - Info result serialization
-
-private struct CardInfoResult: Encodable {
-    let status: String
-    let readerStatus: String
-    let last4: String
-    let companyName: String
-    let companyAddress1: String
-    let companyAddress2: String
-    let companyCity: String
-    let companyCountry: String
-    let terminalId: String
-    let authorizationCode: String
-    let brand: String
-    let reason: String
-    let receiptUrl: String?
-    let refundToken: String?
-    let type: String
-}
-
-private struct BankTransferInfoResult: Encodable {
-    let status: String
-    let postponed: Bool
-    let receivedAt: String
-    let receivedFromIban: String
-    let receiptUrl: String?
-    let type: String
-}
-
-private enum InfoResultSerializer {
-    static func serialize(_ status: any PaymentStatus) throws -> String {
-        let encoder = JSONEncoder()
-        let data: Data
-
-        switch status.paymentMethod {
-        case .card:
-            guard let cardStatus = status as? CardPaymentStatus else {
-                throw Exception(name: "SerializationError", description: "Unexpected card status type")
-            }
-            data = try encoder.encode(CardInfoResult(
-                status: cardStatus.status.rnString,
-                readerStatus: "",
-                last4: cardStatus.details?.last4 ?? "",
-                companyName: cardStatus.merchantDetails.legalName,
-                companyAddress1: cardStatus.merchantDetails.addressLine1,
-                companyAddress2: cardStatus.merchantDetails.addressLine2 ?? "",
-                companyCity: cardStatus.merchantDetails.city,
-                companyCountry: cardStatus.merchantDetails.country,
-                terminalId: cardStatus.terminalId,
-                authorizationCode: cardStatus.details?.authorizationCode ?? "",
-                brand: cardStatus.details?.brand.rawValue.uppercased() ?? "",
-                reason: cardStatus.details?.issuerDeclineReason?.rawValue ?? "",
-                receiptUrl: cardStatus.receiptUrl?.absoluteString,
-                refundToken: cardStatus.refund?.refundToken,
-                type: "card"
-            ))
-
-        case .sepaIct:
-            guard let bankStatus = status as? BankTransferPaymentStatus else {
-                throw Exception(name: "SerializationError", description: "Unexpected bank transfer status type")
-            }
-            data = try encoder.encode(BankTransferInfoResult(
-                status: bankStatus.status.rnString,
-                postponed: bankStatus.details?.postponed ?? false,
-                receivedAt: bankStatus.processedAt.map { ISO8601DateFormatter().string(from: $0) } ?? "",
-                receivedFromIban: bankStatus.details?.bankAccountNumber ?? "",
-                receiptUrl: bankStatus.receiptUrl?.absoluteString,
-                type: "sepa"
-            ))
-
-        case .certisCz:
-            guard let bankStatus = status as? BankTransferPaymentStatus else {
-                throw Exception(name: "SerializationError", description: "Unexpected bank transfer status type")
-            }
-            data = try encoder.encode(BankTransferInfoResult(
-                status: bankStatus.status.rnString,
-                postponed: bankStatus.details?.postponed ?? false,
-                receivedAt: bankStatus.processedAt.map { ISO8601DateFormatter().string(from: $0) } ?? "",
-                receivedFromIban: bankStatus.details?.bankAccountNumber ?? "",
-                receiptUrl: bankStatus.receiptUrl?.absoluteString,
-                type: "certis"
-            ))
-
-        default:
-            throw Exception(name: "UnsupportedPaymentMethod", description: "Payment method not supported by info()")
-        }
-
-        return String(data: data, encoding: .utf8) ?? "{}"
-    }
-}
-
-private extension AcceptTransactionStatus {
-    var rnString: String {
-        switch self {
-        case .pending: "PENDING"
-        case .success: "APPROVED"
-        case .cancelled: "ABORTED"
-        case .refunded: "REFUNDED"
-        case .failed: "DECLINED"
-        case .actionNeeded: "PENDING"
-        @unknown default: "PENDING"
-        }
-    }
-
-    var cardPaymentStatus: String {
-        switch self {
-        case .pending: "pending"
-        case .success: "approved"
-        case .cancelled: "aborted"
-        case .refunded: "refunded"
-        case .failed: "declined"
-        case .actionNeeded: "pending"
-        @unknown default: "pending"
-        }
-    }
-
-    var bankTransferStatus: String {
-        switch self {
-        case .pending: "pending"
-        case .success: "verified"
-        case .cancelled: "aborted"
-        case .refunded: "refunded"
-        case .failed: "declined"
-        case .actionNeeded: "pending"
-        @unknown default: "pending"
-        }
-    }
-}
-
-// MARK: - Payment intent conversion
-
-private extension CardPaymentIntentRecord {
-    func toPaymentIntent() -> AcceptCardPaymentIntent {
-        AcceptCardPaymentIntent(
-            id: paymentIntentId,
-            amount: amount,
-            requestedCurrency: requestedCurrency,
-            settlementCurrency: settlementCurrency ?? requestedCurrency
-        )
-    }
-}
-
-private extension SepaPaymentIntentRecord {
-    func toPaymentIntent() -> AcceptSepaPaymentIntent {
-        AcceptSepaPaymentIntent(
-            id: paymentIntentId,
-            amount: amount,
-            requestedCurrency: requestedCurrency,
-            settlementCurrency: settlementCurrency ?? requestedCurrency
-        )
-    }
-}
-
-private extension CertisPaymentIntentRecord {
-    func toPaymentIntent() -> AcceptCertisPaymentIntent {
-        AcceptCertisPaymentIntent(
-            id: paymentIntentId,
-            amount: amount,
-            requestedCurrency: requestedCurrency,
-            settlementCurrency: settlementCurrency ?? requestedCurrency
-        )
-    }
-}
-
-// MARK: - Payment outcome conversion
-
-private extension AcceptPaymentOutcome where Result == CardPaymentStatus {
-    func toCardResult() -> CardPaymentResultRecord {
-        let record = CardPaymentResultRecord()
-        switch self {
-        case .canceled:
-            record.status = "aborted"
-        case .completed(let status):
-            record.status = status.status.cardPaymentStatus
-            record.last4 = status.details?.last4
-            record.companyName = status.merchantDetails.legalName
-            record.companyAddress1 = status.merchantDetails.addressLine1
-            record.companyAddress2 = status.merchantDetails.addressLine2
-            record.companyCity = status.merchantDetails.city
-            record.companyCountry = status.merchantDetails.country
-            record.terminalId = status.terminalId
-            record.authorizationCode = status.details?.authorizationCode
-            record.brand = status.details?.brand.rawValue.uppercased()
-            record.reason = status.details?.issuerDeclineReason?.rawValue
-            record.receiptUrl = status.receiptUrl?.absoluteString
-            record.refundToken = status.refund?.refundToken
-        }
-        return record
-    }
-}
-
-private extension AcceptPaymentOutcome where Result == BankTransferPaymentStatus {
-    func toBankTransferResult() -> BankTransferPaymentResultRecord {
-        let record = BankTransferPaymentResultRecord()
-        switch self {
-        case .canceled:
-            record.status = "aborted"
-        case .completed(let status):
-            record.status = status.status.bankTransferStatus
-            record.postponed = status.details?.postponed ?? false
-            record.receivedAt = status.processedAt.map { ISO8601DateFormatter().string(from: $0) }
-            record.receivedFromIban = status.details?.bankAccountNumber
-            record.receiptUrl = status.receiptUrl?.absoluteString
-        }
-        return record
-    }
-}
-
-// MARK: - Onboarding status conversion
-
-private extension AcceptPaymentMethod {
-    static func fromJsString(_ value: String) throws -> AcceptPaymentMethod {
-        switch value {
-        case "CARD": return .card
-        case "SEPA": return .sepaIct
-        case "CERTIS": return .certisCz
-        case "CRYPTO": return .crypto
-        default:
-            throw Exception(name: "InvalidPaymentMethod", description: "Unknown payment method: \(value)")
-        }
-    }
-
-    func toJsString() -> String {
-        switch self {
-        case .card: return "CARD"
-        case .sepaIct: return "SEPA"
-        case .certisCz: return "CERTIS"
-        case .crypto: return "CRYPTO"
-        @unknown default: return "UNKNOWN"
-        }
-    }
-}
-
-private extension AcceptPaymentMethodStatus.Status {
-    func toJsString() -> String {
-        switch self {
-        case .notStarted: return "NOT_STARTED"
-        case .pending: return "PENDING"
-        case .active: return "ACTIVE"
-        case .attentionNeeded: return "ATTENTION_NEEDED"
-        case .actionRequired: return "ACTION_REQUIRED"
-        case .blocked: return "BLOCKED"
-        @unknown default: return "UNKNOWN"
-        }
-    }
-}
-
-// MARK: - Refund conversion
-
-private extension AcceptRefundReason {
-    static func fromJsString(_ value: String) throws -> AcceptRefundReason {
-        switch value {
-        case "customerRequest": return .customerRequest
-        case "duplicate": return .duplicate
-        case "fraudulent": return .fraudulent
-        case "expiredCharge": return .expiredCharge
-        default:
-            throw Exception(name: "InvalidRefundReason", description: "Unknown refund reason: \(value)")
-        }
-    }
-
-    func toJsString() -> String {
-        switch self {
-        case .customerRequest: return "customerRequest"
-        case .duplicate: return "duplicate"
-        case .fraudulent: return "fraudulent"
-        case .expiredCharge: return "expiredCharge"
-        @unknown default: return "customerRequest"
-        }
-    }
-}
-
-private extension AcceptTransactionStatus {
-    func toJsString() -> String {
-        switch self {
-        case .pending: return "pending"
-        case .success: return "success"
-        case .cancelled: return "cancelled"
-        case .refunded: return "refunded"
-        case .failed: return "failed"
-        case .actionNeeded: return "actionNeeded"
-        @unknown default: return "pending"
-        }
-    }
-}
-
-private extension AcceptRefund {
-    func toRecord() -> RefundResultRecord {
-        let record = RefundResultRecord()
-        record.refundToken = refundToken
-        record.status = status.toJsString()
-        record.paymentMethod = paymentMethod.toJsString()
-        record.requestedAmount = requestedAmount
-        record.requestedCurrency = requestedCurrency
-        record.settlementAmount = settlementAmount
-        record.settlementCurrency = settlementCurrency
-        record.fxRate = fxRate
-        record.refundReason = refundReason.toJsString()
-        record.createdAt = ISO8601DateFormatter().string(from: createdAt)
-        record.processedAt = processedAt.map { ISO8601DateFormatter().string(from: $0) }
-        return record
-    }
-}