Co-badged Cards

    @objc optional
    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager,
                              willFetchMetadataForState state: PrimerValidationState) {
        // ... Do nothing, or show a loading spinner ...
    }

    @objc optional
    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager,
                              didReceiveMetadata metadata: PrimerPaymentMethodMetadata,
                              forState state: PrimerValidationState) {

        if let cardMetadata = metadata as? PrimerCardNumberEntryMetadata {
          // ... Display received card networks to the user ...
          if let cardState = state as? PrimerCardNumberEntryState {
              // ... If you want to check which card number caused the returned card networks ...
          }
        }
    }

extension MyViewController: PrimerHeadlessUniversalCheckoutRawDataManagerDelegate {

    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager,
                              willFetchMetadataForState cardState: PrimerValidationState) {
        guard let state = cardState as? PrimerCardNumberEntryState else {
            logger.error("Received non-card metadata. Ignoring ...")
            return
        }
        /* ... display spinner ... */
    }

    func primerRawDataManager(_ rawDataManager: PrimerHeadlessUniversalCheckout.RawDataManager,
                                didReceiveMetadata metadata: PrimerPaymentMethodMetadata,
                                forState cardState: PrimerValidationState) {

        guard let metadata = metadata as? PrimerCardNumberEntryMetadata,
              let cardState = cardState as? PrimerCardNumberEntryState else {
            logger.error("Received non-card metadata. Ignoring ...")
            return
        }

        var networksForDisplay: [PrimerCardNetwork] = []
        var isAllowedNetwork: Bool = true

        if metadata.source == .remote, let selectableNetworks = metadata.selectableCardNetworks?.items, !selectableNetworks.isEmpty {
            networksForDisplay = selectableNetworks
        } else if let preferredDetectedNetwork = metadata.detectedCardNetworks.preferred {
            networksForDisplay = [preferredDetectedNetwork]
        } else if let cardNetwork = metadata.detectedCardNetworks.items.first {
            networksForDisplay = [cardNetwork]
            isAllowedNetwork = false
        }

        /* ... networksForDisplay contains the models to display to the user 🎉 ... */
    }
}

let cardAssets: [PrimerCardNetworkAsset] = networksForDisplay.compactMap { network in
  return PrimerHeadlessUniversalCheckout.AssetsManager.getCardNetworkAsset(for: network)
}

cardAssets.forEach { asset in
  // ... display the card, e.g. ... */
  showCard(title: asset.displayName, image: asset.cardImage)
}

let selectedCardNetwork: CardNetwork = primerCardNetwork.value // Enum value for the network

rawDataManager?.rawData = PrimerCardData(
    cardNumber: cardNumber,
    expiryDate: expiryDate,
    cvv: cvvNumber,
    cardholderName: cardholderName,
    cardNetwork: selectedCardNetwork // pass the enum value here
)

rawDataManager.submit()

val rawDataManagerListener =
  object : PrimerHeadlessUniversalCheckoutRawDataManagerListener {

    override fun onMetadataStateChanged(metadataState: PrimerPaymentMethodMetadataState) {
      when (metadataState) {
        is PrimerCardMetadataState ->
          when (metadataState) {
            is PrimerCardMetadataState.Fetched -> // handle metadata fetched state
            is PrimerCardMetadataState.Fetching -> // handle metadata fetching state
          }
      }
    }
  }

val rawDataManagerListener =
  object : PrimerHeadlessUniversalCheckoutRawDataManagerListener {

    override fun onValidationChanged(isValid: Boolean, errors: List<PrimerInputValidationError>) {
      // use the `isValid` to enable/disable pay button
      // use the `errors` list and handle validation errors respectively
    }

    override fun onMetadataStateChanged(metadataState: PrimerPaymentMethodMetadataState) {
      when (metadataState) {
        is PrimerCardMetadataState ->
          when (metadataState) {
            is PrimerCardMetadataState.Fetched -> {
              val cardNumberMetadata = metadataState.cardNumberEntryMetadata
              if (cardNumberMetadata.source === ValidationSource.LOCAL_FALLBACK) {
                // feel free to send an event to your backend
                Log.w(MY_TAG, "Cannot detect card networks.")
              }

              cardNumberMetadata.selectableCardNetworks?.let { networksMetadata ->
                // if `selectableCardNetworks` is non-null,
                // then ask the user to select a card network
                // you can use `selectableCardNetworks.preferred` to pre-select the
                // card network
                val cardNetworks: List<PrimerCardNetwork> = networksMetadata.items
                showCardNetworkSelect(cardNetworks)
              } ?: run {
                  cardNumberMetadata.detectedCardNetworks.let { networksMetadata ->
                    // show the detected card network
                    val cardNetwork: PrimerCardNetwork? =
                      networksMetadata.preferred ?: networksMetadata.items.firstOrNull()
                    showAllowedCardNetwork(cardNetwork)
                  }
                }
            }
            is PrimerCardMetadataState.Fetching -> showLoadingView()
          }
      }
    }
  }

val cardManager = PrimerHeadlessUniversalCheckoutRawDataManager.newInstance("PAYMENT_CARD")

cardManager.setListener(rawDataManagerListener)

// After headless checkout is started
val cardNetworkAsset = PrimerHeadlessUniversalCheckoutAssetsManager.getCardNetworkAsset(
    requireContext(),
    CardNetwork.Type.CARTES_BANCAIRES
)

cardManager.setRawData(
  PrimerCardData(
    cardNumber = cardNumber,
    expiryDate = expiryDate,
    cvv = cvvNumber,
    cardHolderName = cardholderName,
    cardNetwork = CardNetwork.Type.CARTES_BANCAIRES
  )
)

cardManager.submit()