Headless mode

import YunoSDK

// 1. Initialize once at app startup
Yuno.initialize(apiKey: "your-public-api-key")

// 2. Create the headless client
let paymentHeadless = try Yuno.apiClientPayment(
    countryCode: "CO",
    checkoutSession: "session-from-backend"
)

// 3. Build the data from your own form
let data = TokenCollectedData(
    checkoutSession: "session-from-backend",
    paymentMethod: CollectedData(
        type: "CARD",
        vaultedToken: nil,
        card: CardData(
            detail: CardData.Detail(
                number: cardNumber,
                expirationMonth: expMonth,
                expirationYear: expYear,
                securityCode: cvv,
                holderName: holder
            )
        ),
        customer: nil
    )
)

// 4. Tokenize, then create the payment on your backend yourself
let ott = try await paymentHeadless.generateToken(data: data)
let token = ott["token"] as? String ?? ""

await createPaymentOnBackend(token: token)   // your code

// 5. Hand the created payment back to the SDK: it runs any remaining action (3DS) and reports the result
paymentHeadless.continueCardPayment { result in
    switch result.status {
    case .succeeded:      print("Success")
    case .reject:         print("Rejected")
    case .fail:           print("Failed")
    case .processing:     print("Processing")
    case .internalError:  print("Internal error")
    case .userCancelled:  print("User cancelled")
    @unknown default:     break
    }
}

import SdkPayments

// 1. Initialize once at app startup
SdkPayments.initialize(apiKey: "your-public-api-key")

// 2. Implement the controller. Only createPayment + onStatus needed
final class Checkout: SdkPayments.TransactionController {

    func createPayment(token: SdkPayments.TransactionController.OneTimeToken) async throws {
        // Create the payment on your backend with the token.
        // Return when done; the SDK then polls status and runs 3DS if needed.
        try await createPaymentOnBackend(token: token["token"] as? String ?? "")
    }

    func onStatus(status: SdkPayments.TransactionStatus) {
        switch status.status {
        case "INTERNAL_ERROR":  print("Internal error")
        case "USER_CANCEL":     print("User cancelled")
        // Handle other backend statuses (e.g. SUCCEEDED, DECLINED, PENDING) as needed.
        default:                break
        }
    }

    // 3. Build TransactionData from your own form, then start
    func pay(cardNumber: String, cvv: String, expMonth: Int, expYear: Int, holder: String) {
        let paymentSelected = SdkPayments.PaymentMethodSelected(
            paymentMethodType: "CARD",
            transactionData: SdkPayments.TransactionData(
                card: SdkPayments.CardTransactionData(
                    number: cardNumber,
                    securityCode: cvv,
                    expirationMonth: expMonth,
                    expirationYear: expYear,
                    holderName: holder
                )
            )
        )

        let config = SdkPayments.TransactionConfig(
            checkoutSession: "session-from-backend",
            countryCode: "CO",
            controller: self
        )

        SdkPayments.Transaction(config: config)
            .start(paymentSelected: paymentSelected)
    }
}