Events

let checkoutConfig = CheckoutConfig(
    environment: .test,
    session: sessionData,
    transactionData: transactionData,
    merchantShopperId: "shopper-123",
    ownerId: "owner-456",
    onGetShopper: { async in
        TransactionShopper(
            id: "shopper-123",
            firstName: "John",
            lastName: "Doe",
            email: "customer@example.com"
        )
    }
)

let pxpCheckout = try PxpCheckout.initialize(config: checkoutConfig)

onGetShopper: { async in
    let customer = await getCurrentCustomer()

    if let customer {
        return TransactionShopper(
            id: customer.id,
            email: customer.email,
            firstName: customer.firstName,
            lastName: customer.lastName,
            phoneNumber: customer.phone
        )
    }

    return TransactionShopper(id: getOrCreateGuestShopperId())
}

config.onInit = {
    print("Paze component ready")
}

config.onPresentmentResolved = { isVisible in
    if !isVisible {
        showAlternativePaymentMethods()
    }
}

config.onPazeButtonClicked = { async in
    clearErrorMessages()
    trackEvent("paze_button_clicked")
}

config.onCheckoutComplete = { result async in
    guard let decoded = result.checkoutDecodedResponse else { return false }

    let isValid = await validateCheckoutOnBackend(
        sessionId: decoded.sessionId,
        cardLastFour: decoded.maskedCard?.panLastFour
    )

    return isValid
}

config.onCheckoutIncomplete = { result async in
    if result.reason == "User cancelled." {
        return
    }
    showError("Checkout was not completed. Please try again.")
}

config.onComplete = { result async in
    print("Payload ID:", result.completeDecodedResponse?.payloadId ?? "")
}

config.onPreDecryption = { async in
    let approved = await requestManagerApproval()
    return approved
}

config.onPostDecryption = { decrypted async in
    print("Card network:", decrypted.fundingData.cardNetwork)
}

config.onPreAuthorisation = { async in
    guard await validateOrderDetails() else {
        return .cancel
    }

    return .transactionInitData(PazeTransactionInitData(
        riskScreeningData: RiskScreeningData(
            performRiskScreening: true,
            userIp: await getUserIpAddress()
        )
    ))
}

config.onPostAuthorisation = { data async in
    await verifyPaymentOnBackend(systemTransactionId: data.systemTransactionId)
    navigateToOrderConfirmation(merchantTransactionId: data.merchantTransactionId)
}

config.onSubmitError = { result async in
    if let failed = result as? FailedSubmitResult {
        showError(failed.errorReason ?? "Payment failed")
    }
}

config.onError = { error in
    switch error.errorCode {
    case "SDK0118":
        showError("Paze isn't enabled for this session.")
    case "SDK1213":
        showError("Paze is only available for USD transactions.")
    case "SDK1202":
        showError("Paze client ID is missing from the session.")
    case "SDK1202A":
        showError("Paze merchant category code is missing from the session.")
    case "SDK1214", "SDK1200":
        showError("Paze checkout failed. Please try again.")
    default:
        showError(error.errorMessage)
    }
}

struct TransactionShopper {
    var id: String?
    var firstName: String?
    var lastName: String?
    var dateOfBirth: String?
    var email: String?
    var phoneNumber: String?
    var houseNumberOrName: String?
    var street: String?
    var city: String?
    var postalCode: String?
    var countryCode: String?
    var state: String?
    var products: [String: String]?
    var orderDescription: String?
}

struct ShippingAddress {
    var countryCode: String?
    var postalCode: String?
    var address: String?
    var addressLine2: String?
    var city: String?
    var county: String?
    var state: String?
}

public struct PazeCheckoutResult {
    var result: CheckoutResultType          // PazeCheckoutResult.CheckoutResultType
    var checkoutResponse: String?
    var reason: String?
    var checkoutDecodedResponse: PazeCheckoutDecoded?
}

public extension PazeCheckoutResult {
    enum CheckoutResultType {
        case complete    // raw value "COMPLETE"
        case incomplete  // raw value "INCOMPLETE"
    }
}

struct PazeMaskedCard {
    var panLastFour: String
    var paymentCardBrand: String
    var paymentCardNetwork: String
    var paymentCardDescriptor: String
    var paymentCardType: String
    var digitalCardData: PazeDigitalCardData
    var digitalCardId: String?
    var paymentAccountReference: String?
    var panExpirationMonth: String?
    var panExpirationYear: String?
    var billingAddress: PazeCheckoutAddress?
}

struct PazeCompleteResult {
    var completeDecodedResponse: PazeCompleteDecoded?  // payloadId, sessionId, securedPayload
    var decryptedPayload: PazeDecryptTokenResponseSuccess?  // always nil at onComplete
}

// decryptedPayload.shopper — fullName, emailAddress, phone fields
// decryptedPayload.billingAddress — addressLine1, city, state, countryCode, postalCode
// decryptedPayload.fundingData — networkToken, expirationMonth, expirationYear, cardNetwork

class MerchantSubmitResult {
    let merchantTransactionId: String
    let systemTransactionId: String
}

class FailedSubmitResult {
    let errorCode: String?
    let errorReason: String?
    let correlationId: String?
    let httpStatusCode: Int?
    let details: [String]?
}

// error.errorCode — e.g. "SDK1213"
// error.errorMessage — human-readable description