SDK for Android: UI & Core

Overview

Introduction

Mobile SDK for Android: UI & Core is an software development kit with open-source code that can be used to integrate Android applications with the JetPay payment platform.

SDK for Android: UI & Core provides the functionality for interaction of customers with the user interface and for interaction of a mobile application with the payment platform which allows sending and receiving necessary information during payment processing. Additionally, the open-source code available with SDK for Android: UI & Core provides flexibility for configuring the user interface in accordance with the aspects of the application.

SDK for Android: UI & Core can be embedded in mobile applications developed for Android version 5.0 or later. The libraries and code examples are available on GitHub:

List of SDK for Android: UI & Core releases: https://github.com/Jetpay/msdk-android-ui/releases
Code examples: https://github.com/Jetpay/msdk-android-ui

Capabilities

The following functional capabilities are supported by SDK for Android: UI & Core:

Processing different types of payments made with cards and Google Pay as well as other payment methods available for the merchant's project. Supported payment types include:
- One-time one-step purchases
- One-time two-step purchases (an authorization hold can be placed via the SDK and subsequent debiting of the authorized amount is carried out via Gate or Dashboard).
- COF purchases (they can be registered via the SDK and then managed via Gate or Dashboard).
Note: For card and Google Pay payments, the payment interface described in this section is used. With other payment methods, Payment Page is used during payment processing.
Performing payment card verification (it involves debiting a zero amount from the customer's card)
Checking current payment information
Auxiliary procedures and additional capabilities to boost payment acceptance rates:
- Submission of additional payment information
- Payment retries
- Cascade payment processing
- Collecting customer data
Additional capabilities to improve user experience:
- Saving customer payment data
- Payment interface language support
- Sending email notifications with the list of purchased items to customers
Customizing the appearance of the payment interface including the color scheme settings and the option to add the logo.

Workflow

Generally, the following workflow is relevant when one-step purchases are processed with the use of SDK for Android: UI & Core.

In the user interface of a mobile application, the customer initiates a purchase by clicking the payment button or in a different fashion set up on the merchant side.
In the mobile application, a set of parameters for creating a payment session is generated. Then, with the help of SDK for Android: UI & Core, this set is converted into a string for signing, and the string is sent to the server side of the merchant web service.
On the server side of the merchant web service, the parameters can be checked and supplemented if necessary, and the signature to the final parameter set is generated, following which the prepared data is sent back to SDK for Android: UI & Core.
With the help of SDK for Android: UI & Core, a payment session is initiated in the payment platform.
On the payment platform side, the payment interface is prepared in accordance with the invocation parameters, and the data for opening the interface is passed to the customer's device.
In the mobile application, the payment form is displayed to the customer.
The customer selects a payment method (if no method was selected when the payment session was initiated), specifies the necessary information, and confirms the purchase.
SDK for Android: UI & Core sends a purchase request to the payment platform.
On the payment platform side, the payment is registered and all necessary technical actions are performed; these actions include sending the required data to the payment environment—to the providers and payment systems.
The payment is processed in the payment environment. Then the payment result information is received in the payment platform.
In the payment platform, the information about the payment result is processed and a callback is sent to the server side of the web service.
The information about the purchase result is sent from the payment platform to SDK for Android: UI & Core.
The notification with the result information is displayed to the customer in the user interface.

User interface

When card and Google Pay payments are processed, the customer uses with the user interface designed by the JetPay specialists. Though, you can customized the user interface by changing colors and adding your company's logo.

Setup

Integration steps

To integrate the web service with the JetPay payment platform by using SDK for Android: UI & Core:

Address the following organizational issues of interaction with JetPay:
1. If your company has not obtained a project identifier and a secret key for interacting with JetPay, submit the application for connecting to the JetPay payment platform.
2. If your company has obtained a project identifier and a secret key for interacting with JetPay, inform the technical support specialists about the company's intention to integrate by using SDK for Android: UI & Core and coordinate the procedure of testing and launching the functionality.
Complete the following preliminary technical steps:
1. Download and link the SDK for Android: UI & Core libraries.
2. Ensure the collection of data necessary for opening the payment form. The minimum data set needed in order to open the payment form consists of the project, payment, and customer identifiers as well as of the payment amount and currency.
3. Ensure signature generation for the data on the server side of the mobile application.
4. Ensure the receipt of and the response to the notifications from SDK for Android: UI & Core as well as the receipt of and the response to the callbacks from the payment platform on the web service side.
With the technical support specialists, coordinate the timeline and the main steps of integrating, testing (including testing available payment methods), and launching the solution.
1. For testing, use the test project identifier and the details of test cards.
2. For switching to the production mode, change the value of the test project identifier to the value of the production project identifier received from JetPay.

If you have any questions about working with SDK for Android: UI & Core, contact the JetPay technical support specialists (support@jetpay.kz).

Libraries installation

For the mobile applications developed for Android version 5.0 or later, linking the SDK for Android: UI & Core libraries via MavenCentral is supported. To link the libraries:

Open the build.gradle.kts module in the application.

Specify the mavenCentral repository in the repositories section:

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

Add the following code in the dependencies section:

implementation "kz.jetpay:msdk-ui:LATEST_VERSION"

Signature generation

Make sure that the data is signed on the server side of the web service with the use of the secret key received from JetPay. To work with the signature, you can use ready-to-use components, such as language-specific SDKs for web services (details), or your own in-house solutions. The procedure of working with the signature is described in Signature generation and verification.

Testing

Before you start processing real payments via SDK for Android: UI & Core, we suggest recommended that you test payment processing in the test project. You can obtain the identifier and the secret key of the test project when accessing the JetPay test environment. Along with that, upon the coordination with the JetPay specialists, it is possible to test the use of the Google Pay method and additional capabilities, such as cascade payment processing and collection of customer data.

To test payment processing:

Open the build.gradle.kts module in the application.
Specify the test project identifier (projectId) and the secret key of the given project (projectSecretKey).
Run the gradle synchronization process.

To switch to the production mode, change the test values (the identifier and the secret key of the test project) to the production ones.

Use

Opening payment form

SDK for Android: UI & Core allows you to process one-time purchases and place authorization holds as part of executing two-step purchases, register COF purchases and verify payment cards. To initiate these actions, you need a certain parameter set. The required minimum of parameters is passed in the JetPayPaymentInfo object while other parameters can be passed in the JetPayPaymentOptions object, requested from the customer, or received from the payment platform.

To open the payment form:

Create the JetPayPaymentInfo object.

Your object must contain the following required parameters:
- projectId (integer)—a project identifier assigned by JetPay
- paymentId (string)—a payment identifier unique within the project
- paymentCurrency (string)—the payment currency code in the ISO 4217 alpha-3 format
- paymentAmount (integer)—the payment amount in the smallest currency unit
- customerId (string)—a customer's identifier within the project
- signature (string)—a request signature generated after all required parameters have been specified
You can also add any other parameters listed in the following table.

val JetPayPaymentInfo = JetPayPaymentInfo(
        projectId = 77655,
        paymentId = "payment_322",
        paymentAmount = 100,
        paymentCurrency = "USD",
        paymentDescription = "Cool stuff shop payment", 
        customerId = "customer_003",
        regionCode = "DE",           //Code of the customer's country
        token = "o8i7u65y4t3rkjhgfdw3456789oikjhgfdfghjkl...", //Token associated with certain payment data
        languageCode = "de",         //Payment interface language code
        receiptData = "eyAKICAicG9zaXRpb25zIjpbIAogICAgIIjoxLAogICAgICAgICJhbW91bnQiOjU5OTAsCiAgQ==",
        //Data to be included in the notification with the list of the purchased items
        hideSavedWallets = false,    //Parameter to enable hiding or displaying saved payment instruments
        forcePaymentMethod = "card"    //Identifier of the preselected payment method
   )

Sign the parameters contained in the JetPayPaymentInfo object.

JetPayPaymentInfo.signature = SignatureGenerator.generateSignature(
        paramsToSign = JetPayPaymentInfo.getParamsForSignature(),
        secret = SECRET_KEY
   )

Create the JetPayPaymentOptions object that contains the required parameter actionType (string) with the value specifying the required operation type: Sale, Auth, or Verify. You can also add any other objects and parameters listed in the following table.

In addition to the required JetPayPaymentInfo object and the actionType parameter, the following example contains several additional parameters including the additionalFields object with data specified in the fields that are used for collecting customer information.

val paymentOptions = paymentOptions {
        paymentInfo = JetPayPaymentInfo
        actionType = JetPayActionType.Sale
        brandColor = "#800008"
        isDarkTheme = false
        logoImage = BitmapFactory.decodeResource(resources, R.drawable.example_logo)
        hideScanningCards = false 
        isTestEnvironment = true
        merchantId = BuildConfig.GPAY_MERCHANT_ID
        merchantName = "Example Merchant Name"
        screenDisplayModes {
          mode(JetPayScreenDisplayMode.HIDE_DECLINE_FINAL_SCREEN)
          mode(JetPayScreenDisplayMode.HIDE_SUCCESS_FINAL_SCREEN)
        }
        additionalFields {
          field {
            type = JetPayAdditionalFieldType.CUSTOMER_EMAIL
            value = "mail@mail.com"
          }
          field {
            type = JetPayAdditionalFieldType.CUSTOMER_FIRST_NAME
            value = "firstName"
          }
        }
}

Create the JetPayPaymentSDK object.
```
val sdk = JetPayPaymentSDK(
        context = applicationContext,
        paymentOptions = paymentOptions,
        )
```
If necessary, you can open the payment form in the test mode in order to get information about errors if there were any when payment parameters were specified or to test processing payments with a certain payment result. In the JetPayPaymentSDK object, specify the JetPayPaymentSDK.JetPayMockModeType.SUCCESS value for the mockModeType parameter (if you need to receive Success payment result). You can also pass values JetPayPaymentSDK.JetPayMockModeType.DECLINE (if you need to receive Decline payment result) and JetPayPaymentSDK.JetPayMockModeType.DISABLED (if you need to switch to the production mode).
Open the payment form.
```
sdk.openPaymentScreen(this, 1234)
```

Processing payments

By default, SDK for Android: UI & Core allows you to process one-step purchases (action type Sale). This type of checkout works right out-of-the-box and requires no additional setup.

In addition, SDK for Android: UI & Core supports processing two-step purchases (which involves placing an authorization hold via the SDK and subsequent debiting of the authorized amount). To perform a two-step purchase:

Open the payment form with JetPayActionType.Auth specified as a value for the action type parameter in the paymentOptions object:
```
JetPayPaymentOptions.JetPayActionType.Auth;
```
When required, initiate debiting of the authorized amount via Dashboard or Gate by sending the request to the /v2/payment/card/capture endpoint.

Payment card verification

Payment instrument verification can be used when you need to validate a card without withdrawing funds instantly (for example, before performing a payout) or when you need to save card details for subsequent use. It is essentially a payment that involves debiting a dummy (zero) amount from the customer's card.

To perform verification, open the payment form with JetPayActionType.Verify specified as a value for the action type parameter in the paymentOptions object:

JetPayPaymentOptions.JetPayActionType.Verify;

Payment status information

To receive payment result notifications, use the onActivityResult method.

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
 
        when (resultCode) {
            EcmpJetPayPaymentSDK.RESULT_SUCCESS -> {
                Toast.makeText(this, "Payment was finished successfully", Toast.LENGTH_SHORT).show()
                Log.d("PaymentSDK", "Payment was finished successfully")
            }
            JetPayPaymentSDK.RESULT_CANCELLED -> {
                Toast.makeText(this, "Payment was cancelled", Toast.LENGTH_SHORT).show()
                Log.d("PaymentSDK", "Payment was cancelled")
            }
            JetPayPaymentSDK.RESULT_DECLINE -> {
                Toast.makeText(this, "Payment was declined", Toast.LENGTH_SHORT).show()
                Log.d("PaymentSDK", "Payment was declined")
            }
            JetPayPaymentSDK.RESULT_ERROR -> {
                val errorCode = data?.getStringExtra(JetPayPaymentSDK.EXTRA_ERROR_CODE)
                val message = data?.getStringExtra(JetPayPaymentSDK.EXTRA_ERROR_MESSAGE)
                Toast.makeText(this, "Payment was interrupted. See logs", Toast.LENGTH_SHORT).show()
                Log.d(
                    "PaymentSDK",
                    "Payment was interrupted. Error code: $errorCode. Message: $message"
                )
            }
        }
    }

Possible payment result codes:

RESULT_SUCCESS—payment has been completed.
RESULT_CANCELLED—payment has been cancelled.
RESULT_DECLINE—payment has been denied.
RESULT_ERROR—error occurred when the payment was being processed.

Additional capabilities

Submitting additional payment information

Generally, for processing a payment, it is enough to send a set of parameters that are mandatory for its initiation. However, in some cases, a payment system or a provider can require additional data necessary for processing a particular payment. This can be due to region-specific requirements, the need for an additional anti-fraud check, or other factors. The information about submitting additional payment data is provided in Submission of additional payment information.

The final set of required parameters can vary depending on a specific provider or a payment system. The list of parameters relevant for a particular payment is displayed to the customer on the payment form. The customer fills in the required data, confirms the payment, and receives the payment result information.

Cascade payment processing

In case of a payment attempt failure, the capability of cascade payment processing can be used. This capability implies executing a sequence of payment attempts via alternative providers without the payment method change and can be set up upon coordination with the JetPay specialists.

If this capability is set up for the project in use, then after the first unsuccessful attempt, a notification is received from SDK for Android: UI & Core. This notification contains the cascading_with_redirect = true attribute-value pair. Along with that, the error page with the button to retry making the payment is shown to the customer. If the 3‑D Secure authentication is not required as part of the additional attempt, then the attempt is executed without any further interaction with the customer. Otherwise, a separate page opens for repeating the authentication process.

Collecting customer data

In some cases, alongside the mandatory parameters, it can be relevant to require the additional ones (such as phone numbers and email addresses) from the customers. To have this capability set up, the merchant should decide which data has to be mandatory to be specified by the customers and communicate data collection preferences to the technical support specialists. For more information about using the capability, see Collecting customer data.

Payment interface language support

By default, when using SDK for Android: UI & Core, the payment interface is localized according either to the language of the customer's device—if this language is supported for the project in use—or to a language set as default for other cases (generally, English). Along with that, if relevant, you can localize the payment interface for particular sessions. For this, every request for opening the payment form must contain a corresponding language code in the languageCode (details).

Warning: If the language you specify is not supported for the project, the payment form will not open and the error information will be displayed to the customer.

The following languages are supported for the SDK interface and can be promptly set up in the projects of the payment platform.

de—German
en—English
es—Spanish
fr—French
hu—Hungarian
it—Italian
kk—Kazakh
ru—Russian

Saving payment data

SDK for Android: UI & Core allows saving payment data of the customer for subsequent processing of payments without the need for the said customer to re-enter such data. This capability is set up individually for each project. The merchant has to let the technical support know which of the two options is preferable: always save payment data or ask the customer to select the option. For more information about this capability, refer to Saving customer payment data.

As a result of saving payment data, a separate identifier is generated for each payment instrument. This identifier is associated with the identifier of a certain customer (customerId). To display saved payment data to the customer, pass false in the hideSavedWallets parameter of the JetPayPaymentOptions object.

Parameters for opening payment form

When working with SDK for Android: UI & Core, you can pass the following optional parameters in the JetPayPaymentInfo object.

Parameter	Description
`paymentDescription` String	Description of the payment. A string that contains between 1 and 255 characters. Example: `Fancy shoes purchase`
`receiptData` String	Data to be included in the notification with the list of the purchased items, passed as a JSON object encoded using the Base64 scheme. Example: `eyAgCiAgICAgICJwb3NpdGlvbnMiOlsgIAogICAgICAgICB7ICAKICAgICAgI CAgICAgInF1YW50aXR5IjozLAogICAgICAgICAgICAiYW1vdW50IjoxMDAwMC wKICAgICAgICAgICAgInRheCI6MTgsCiAgICAg`
`token` String	Token associated with certain payment data. A string that contains between 1 and 255 characters. Example: `6bbd9255e484f00cc778246c5b7489aa4c498b8bb5231e85942437c`
`hideSavedWallets` Boolean	Parameter to enable hiding or displaying saved payment instruments in the payment form. Possible values: `true`—saved payment data is hidden `false`—saved payment data is displayed.
`forcePaymentMethod` String	The identifier of the preselected payment method as specified in IDs of payment methods supported by Payment Page. Example: `card`
`JetPayThreeDSecureInfo` Object	Object that contains additional objects and parameters necessary for the 3‑D Secure 2 authentication.
`languageCode` String	Payment interface language code in the ISO 639-1 alpha-2 format. Example: `EN`
`regionCode` String	Code of the customer's country in the ISO 3166-1 alpha-2 format. Example: `GB`

You can pass the following optional parameters in the JetPayPaymentOptions object.

Parameter	Description
`merchantID` String	The Google Pay identifier of the merchant.
`merchantName` String	The Google Pay name of the merchant.
`logoImage` Bitmap	A bitmap file that contains the logo of the merchant.
`brandColor` String	Payment interface color in hexadecimal format. Example: `#800080`
`isTestEnvironment` Boolean	Parameter to indicate a test payment. Possible values: `true` `false`
`additionalFields` List	Additional fields that contain information about the customer. Example: `JetPayAdditionalField(JetPayAdditionalFieldType.CUSTOMER_EMAIL,"mail@mail.com")`
`recipientInfo` Object—object with information about the recipient of the payment.
`pan` String	Card number. Example: `5413330000000019`
`card_holder` String	First and last name (as specified on the card). Example: `Sonya Svantesson`
`wallet_id` String	Number of the wallet. Example: `WID301185029011891`
`wallet_owner` String	First and last name of the recipient. Example: `Sonya Svantesson`
`country` String	Code of the recipient's country in the ISO 3166-1 alpha-2 format. Example: `SE`
`address` String	Recipient's address. Example: `Albanovaegen 28`
`city` String	Recipient's city of residence. Example: `Stockholm`
`state` String	Recipient's state. Example: `MN`

To work with COF purchases, you should pass relevant parameters in the recurrentData object of the JetPayPaymentOptions object.

Parameter	Description
`type` String	COF purchase type: `C`—OneClick `U`—autopurchase `R`—regular purchase
`period` String	Debiting period for a regular purchase. Possible values: `D`—daily `W`—weekly `M`—monthly `Q`—quarterly `Y`—yearly
`expiry_day` String	Expiration day of the COF purchase.
`expiry_month` String	Expiration month of the COF purchase.
`expiry_year` Int	Expiration year of the COF purchase.
`scheduled_payment_id` String	Identifier to assign to the COF purchase (for automatic debiting). Parameter must be passed together with the `start_date` parameter.
`start_date` String	Date to perform the first debit in the `dd-mm-yyyy` format. Parameter must be passed together with the `scheduled_payment_id` parameter.
`time` String	Time when to perform a scheduled debit (for regular purchases) in the `hh:mm:ss` format, passed if the `period` parameter is specified as well.
`schedule` Object	Schedule of debits performed as a part of the COF purchase (can be specified by the merchant). Should contain parameters `amount` and `date`.
`amount` Int	The amount to debit in the smallest currency unit.
`date` String	Date to perform the debit in the `dd-mm-yyyy` format.

You can pass the following optional parameters in the JetPayThreeDSecureInfo object.

Parameter	Description
`threeDSecureInfo`—object of the `JetPayThreeDSecureInfo` class containing additional objects and parameters used during the 3‑D Secure 2 authentication
`threeDSecurePaymentInfo`—object of the `JetPayThreeDSecurePaymentInfo` class with information about the purchase details and indication of the preferable authentication flow
`challengeIndicator` String	This parameter indicates whether challenge flow is requested for this payment. Possible values: `01`—no preferences `02`—it is preferable not to use challenge flow `03`—challenge flow preferred `04`—always use challenge flow
`challengeWindow` String	The dimensions of a window in which authentication page opens. Possible values: `01`—250 x 400 px `02`—390 x 400 px `03`—500 x 600 px `04`—600 x 400 px `05`—full screen
`preorderDate` String	The date the preordered merchandise will be available. Format: dd-mm-yyyy.
`preorderPurchase` String	This parameter indicates whether cardholder is placing an order for merchandise with a future availability or release date. Possible values: `01`—merchandise available in stock `02`—future merchandise availability
`reorder` String	This parameter indicates whether the cardholder is reordering previously purchased merchandise. Possible values: `01`—first time order `02`—reorder
`threeDSecureGiftCardInfo`—object of the `JetPayThreeDSecureGiftCardInfo` class with information about payment with prepaid card or gift card.
`amount` Int	Amount of the payment with prepaid or gift card denominated in the smallest currency unit.
`currency` String	Currency code of the payment with prepaid or gift card in the ISO 4217 alpha-3 format, for example GBP.
`count` Int	Total number of individual prepaid or gift cards/codes used in purchase.
`threeDSecureCustomerInfo`—object of the `JetPayThreeDSecureCustomerInfo` class with information about the customer.
`addressMatch` String	The parameter indicates whether the customer billing address matches the address specified in the `threeDSecureShippingInfo` object. Possible values: Y—shipping address is the same as billing address N—shipping address and billing address are not identical
`billingRegionCode` String	State, province, or region code in the ISO 3166-2 format. Example: `DOR` for Dorset.
`homePhone` String	Customer home phone number. Numeric, from 4 to 24 characters. Example: `44991234567`.
`workPhone` String	Customer work phone number. Numeric, from 4 to 24 characters. Example `44997654321`.
`threeDSecureAccountInfo`—object of the `JetPayThreeDSecureAccountInfo` class with information about customer account details on record with the web service
`additional` String	Additional customer account information, for instance arbitrary customer ID. Maximum 64 characters.
`activityDay` Int	Number of card payment attempts in the last 24 hours. Maximum 3 characters (for example, `999`).
`activityYear` Int	Number of card payment attempts in the last 365 days. Maximum 3 characters (for example, `999`).
`ageIndicator` String	Number of days since the customer account was created. Possible values: `01`—guest check-out `02`—customer account was created in this transaction `03`—customer account was created less than 30 days ago `04`—customer account was created 30 to 60 days ago `05`—customer account was created over 60 days ago
`authData` String	Any additional log in information in free text. Maximum 255 characters.
`authMethod` String	Authentication type the customer used to log on to the account when placing the order. Possible values: `01`—no authentication `02`—log on by using authentication data on file with merchant `03`—log on by using federated ID (for example, Google Account or Facebook) `04`—log on by using a FIDO authenticator (Fast IDentity Online)
`authTime` String	Account log on date and time. Format: dd-mm-yyyyhh:mm.
`date` String	Account creation date. Format: dd-mm-yyyy.
`changeDate` String	Last account change date except for password change or password reset. Format: dd-mm-yyyy.
`changeIndicator` String	Number of days since last customer account update, not including password change or reset. Possible values: `01`—updated in this transaction `02`—updated less than 30 days ago `03`—updated 30−60 days ago `04`—updated over 60 days ago
`passChangeDate` String	Last password change or password reset date. Format: dd-mm-yyyy.
`passChangeIndicator` String	Number of days since the last password change or reset. Possible values: `01`—password never changed `02`—changed in this transaction `03`—changed less than 30 days ago `04`—changed 30−60 days ago `05`—changed over 60 days ago
`paymentAge` String	Card record creation date. Format: dd-mm-yyyy.
`paymentAgeIndicator` String	Number of days since the payment card details were saved in a customer account. Possible values: `01`—current payment uses no customer account (guest checkout) `02`—card details were saved today `03`—card details were saved less than 30 days ago `04`—card details were saved 30 to 60 days ago `05`—card details were saved more than 60 days ago
`provisionAttempts` Int	Number of attempts to add card details in customer account in the last 24 hours. Maximum 3 characters (`999`).
`purchaseNumber` Int	Number of purchases with this cardholder account in the previous six months. Maximum 4 characters (`9999`).
`suspiciousActivity` String	Suspicious activity detection result. Possible values: `01`—no suspicious activity detected `02`—suspicious activity detected
`threeDSecureShippingInfo`—object of the `JetPayThreeDSecureShippingInfo` class with shipping details.
`address` String	Shipping address. Maximum 150 characters.
`addressUsage` String	First shipping address usage date. Format: dd-mm-yyyy.
`addressUsageIndicator` String	Number of days since the first time usage of the shipping address. Possible values: `01`—this transaction `02`—less than 30 days ago `03`—30−60 days ago `04`—more than 60 days ago
`city` String	Shipping city. Maximum 50 characters.
`country` String	Shipping country in the ISO 3166-1 alpha-2 format, for example `GB` for United Kingdom of Great Britain and Northern Ireland.
`deliveryEmail` String	The email for the digital content delivery. Maximum 255 characters.
`deliveryTime` String	Shipment terms. Possible values: `01`—digital delivery `02`—same-day delivery `03`—overnight delivery `04`—longer than overnight delivery
`nameIndicator` String	Shipment recipient flag. Possible values: `01`—customer and shipment recipient are the same person `02`—customer and shipment recipient are different persons
`postal` String	Shipping postbox number. Maximum 16 characters.
`regionCode` String	State, province, or region code in the ISO 3166-2 format. Example: `DOR` for Dorset. If you specify this parameter, you need also to specify and populate the `country` parameter in the `threeDSecureShippingInfo` object.
`type` String	Shipment indicator. Possible values: `01`—ship to cardholder billing address `02`—ship to another verified address on file with merchant `03`—ship to address that is different from the cardholder billing address or any verified address on file with merchant `04`—ship to local store `05`—digital goods shipment `06`—no shipment, for instance for travel or event tickets `07`—other, for example gaming or subscriptions
`threeDSecureMpiResultInfo`—object of the `JetPayThreeDSecureMpiResultInfo` class with information about previous customer authentication
`acsOperationId` String	The ID the issuer assigned to the previous customer operation. Maximum 36 characters.
`authenticationFlow` String	The flow the issuer used to authenticate the cardholder in the previous operation. Possible values: `01`—frictionless flow `02`—challenge flow
`authenticationTimestamp` String	Date and time of the previous successful customer authentication