> For the complete documentation index, see [llms.txt](https://sandbox-docs.verifone.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://sandbox-docs.verifone.com/s-adk-5.1-programmers-guide/readme/modules.md).

# Modules

Here is a list of all modules:

|                                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 📄 Return Codes                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Synchronous Card Types                                                                                         | Used by crdSync\_PowerUp()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 📄 Handling of tags not defined by EMVCo                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📁General topics                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Additional error information                                                                                 | Filled in case of error, value to describe which error occured                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └──📄 Additional error info exit code                                                                             | Last step performed by EMV ADK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └──📄 Additional error info, status                                                                               | Internal error index                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └─📄 Limitations and sizes                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 ADK return codes                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Common data structures                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Special tag handling                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Handling of tags not defined by EMVCo                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Serialization                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └── 📁BER TLV tags used by EMV framework                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Tags defined by EMVCo                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Propriertary tags used by Visa                                                                             | See \[Visa\_Card], page A-63                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| └───📄 Proprietary tags used by MasterCard                                                                        | See \[MC\_FA], page 7-78                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └─── 📁Verifone internal tags                                                                                     | There are many data objects, which do not have an EMVCo defined tags. For usage of TLV interface it's necessary to define internal tags                                                                                                                                                                                                                                                                                                                                                                              |
| └────📄 Constructed tags                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──── 📁Primitive tags                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─────📄 Tags for callback functions                                                                              | Used in function EMV\_CT\_CALLBACK\_FnT                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └─────📄 3-byte primitive tags                                                                                    | For all unsigned long variables in functional interface, please use 4 byte in the serialization                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └────📄 Tags for L1 status reported in kernel wrapper data                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Tags for transport layer                                                                                    | Used for enclosing TLV container at transport. That's necessary in case EMV ADK and calling application are placed in separated entities. Transport layer (e.g. PINPad ISO2) must have indicators to determine whether data is meant for EMv ADK or not                                                                                                                                                                                                                                                              |
| 📁Initialization                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁EMV ADK functions for initialization                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Options at framework initialisation                                                                         | Flags used in parameter options in EMV\_CT\_Init\_Framework                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Options for Exit Framework                                                                                  | Meaning of TAG\_DF8F0A\_EXIT\_OPTIONS, see also EMV\_CT\_Exit\_Framework\_extended()                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 📁Configuration                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Tags for configuration storage                                                                               | Used for storing the configuration in XML files                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Defines for type of virtual terminal map                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 EMV ADK functions for configuration                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Terminal Data                                                                                                | Definitions used for functions EMV\_CT\_SetTermData(), EMV\_CT\_GetTermData()                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| └──📄 Terminal data: Which data is included                                                                       | Contents of the EMV\_CT\_TERMDATA\_STRUCT::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Terminaltypes (Tag 9F35)                                                                                    | See also \[EMV B4], page 113                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| └─ 📁Application data                                                                                             | Definitions used for functions EMV\_CT\_SetAppliData(), EMV\_CT\_GetAppliData()                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Supported                                                                                                   | Defines for supported EMV Modes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 TAC/IAC DENIAL processing in case of Offline Only terminals                                                 | DF15, ICS feature, for ucAC\_before\_after in EMV\_CT\_TERMDATA\_STRUCT                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Defines for EMVCo checksum calculation                                                                      | Other major terminal parameters actually there are only some of them definedmost of them are hard coded in the lib as actually neededall of them are Yes / No decisions--> whenever there is a need to make this configurable for the checksum there will be another parameter addedIn brackets there is the default value or the currently hard coded valueonly for checksum --> no control on the flow,e.g. Blacklist is controlled per application not per terminal parameters!!! take respect on the default !!! |
| └──📄 Application data: Which data is included                                                                    | Contents of EMV\_CT\_APPLIDATA\_STRUCT::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| └──📄 Byte defines for CVM not supported / CVM not required                                                       | See AIP\_CVM\_not\_supported and EMV\_CT\_APPLIDATA\_STRUCT::CVM\_not\_required                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Defines for Application flow capabilities                                                                   | Application (transaction flow) capabilities (see EMV\_CT\_APPLIDATA\_STRUCT::App\_FlowCap)                                                                                                                                                                                                                                                                                                                                                                                                                           |
| └──📄 CDA modes                                                                                                   | DF3E, CDA mode to be executed for the named AID                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Fallback handling after Final Select                                                                        | DF18, see EMV\_CT\_APPLIDATA\_STRUCT::uc\_FallBack\_Handling                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| └──📄 Defines for type of read application data mode                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Modes of application data and CAP key setting                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Defines for special transaction configuration                                                               | Special transactions, transaction types and flows                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └─ 📁Text data                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Application text IDs                                                                                        | Also see EMV\_ADK\_TXT\_TYPE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| └──📄 Known languages                                                                                             | See EMV\_ADK\_TXT\_TYPE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| 📁Transaction execution                                                                                           | Definitions used for functions EMV\_CT\_StartTransaction(), EMV\_CT\_ContinueOffline(), EMV\_CT\_ContinueOnline()                                                                                                                                                                                                                                                                                                                                                                                                    |
| └─📄 Functions for performing transactions                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Callback functions                                                                                           | Callback function to be implemented in the same entity as EMV ADK                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └── 📁Definitions for PIN Input callback function                                                                 | See EMV\_CT\_CALLBACK\_FnT (TAG\_BF08\_CBK\_PIN)                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └───📄 Input params for PIN entry                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Return values                                                                                              | Return values used by calling application for PIN input callback function                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └──📄 DCC mode                                                                                                    | Used to carry decision given back by EMV\_CT\_CALLBACK\_FnT (TAG\_BF07\_CBK\_DCC)TLV tag TAG\_DF7D\_CBK\_DCC\_CHECK                                                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 Defines for callback function "put merchant information"                                                    | In order to show the merchant additional information on a system with two displays, 'information flashes' can be sent to the terminal during payment processing. This allows the merchant to alert the customer to confirming the amount or entering the PIN as required.see EMV\_CT\_CALLBACK\_FnT (TAG\_BF01\_CBK\_MERCHINFO)                                                                                                                                                                                      |
| └──📄 Defines for callback function "cardholder information"                                                      | In order to show the cardholder additional information, e.g. wrong PIN, last PIN try, another app is selected, ...see EMV\_CT\_CALLBACK\_FnT (TAG\_BF09\_CBK\_CARDHOLDERINFO)                                                                                                                                                                                                                                                                                                                                        |
| └──📄 Types of external application selection                                                                     | Used as input for callback function "Application Selection" --> ReduceCandidateList() (ucSelector)                                                                                                                                                                                                                                                                                                                                                                                                                   |
| └──📄 Modes of domestic application handling                                                                      | Used as return TAG\_DF7E\_CBK\_DOM\_APP\_RES for EMV\_CT\_CALLBACK\_FnT TAG\_BF05\_CBK\_DOM\_APPS                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Domestic callback options                                                                                   | Calling application may set some options for further transaction processing                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Domestic callback information                                                                               | Information flags for TAG\_DF5C\_DOM\_INFO in EMV\_CT\_CALLBACK\_FnT (TAG\_BF06\_CBK\_LOCAL\_CHECKS)                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └──📄 DCC callback information                                                                                    | Information flags for calling application                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └──📄 Constructed tags for CT callback functions                                                                  | Used in EMV\_CT\_CALLBACK\_FnT                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └─ 📁Input data                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Fallback options for magstripe applications                                                                 | For use in ucFallback of EMV\_CT\_FALLBCK\_MSR\_TYPE                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └──📄 Bit field for additional fallback options for magstripe applications (not originating from DC POS tag DF18) | For use in fallbackMsrOptions of EMV\_CT\_SELECT\_TYPE                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| └──📄 Select input: Which data is included                                                                        | Contents of EMV\_CT\_SELECT\_STRUCT::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └──📄 Support of cardholder confirmation                                                                          | DF4D, see ucCardholderConfirmation in EMV\_CT\_SELECT\_TYPE                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Buildlist options for EMV\_CT\_StartTransaction()                                                           | See EMV\_CT\_SELECT\_TYPE::InitTXN\_Buildlist                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| └──📄 Options for transaction processing                                                                          | Defines for EMV\_CT\_SELECT\_STRUCT::TxnOptions, EMV\_CT\_TRANSAC\_STRUCT::TxnOptions, EMV\_CT\_HOST\_STRUCT::TxnOptions                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 Re-entrance options                                                                                         | Defines for EMV\_CT\_SELECT\_TYPE::TxnSteps resp. EMV\_CT\_TRANSAC\_TYPE::TxnSteps                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| └──📄 Amount confirmation before or after CVM processing                                                          | Byte defines for EMV\_CT\_PAYMENT\_STRUCT::uc\_AmountConfirmationonly valid in case no combined amount confirmation configured (see EMV\_CT\_CONF\_AMOUNT\_PIN in Defines for Application flow capabilities)                                                                                                                                                                                                                                                                                                         |
| └──📄 Transaction input: Which data is included                                                                   | Contents of EMV\_CT\_TRANSAC\_TYPE::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 Host data: Which data is included                                                                           | Contents of EMV\_CT\_HOST\_TYPE::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| └──📄 Transaction type (Tag 9C)                                                                                   | According to ISO 8583 - Annex A: Processing Code, Position 1 + 2                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Options for updating TLV data                                                                               | options for EMV\_CT\_updateTxnTags()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └─ 📁Output data                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └── 📁Additional error data                                                                                       | DF62, 15 bytes, error reference                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Position 1: chipcard command where error occurs (2 byte)                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Position 2: status of chipcard communication (2 byte)                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Position 3: activator (1 byte)                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Position 7: error class (1 byte)                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 StartTransaction: Which data was received from the chip                                                     | Contents of EMV\_CT\_SELECTRES\_STRUCT::T\_DF61\_Info\_Received\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| └──📄 ContinueOffline/ContinueOnline: Information which data was provided by the ICC                              | Contents of EMV\_CT\_TRANSRES\_TYPE::T\_DF61\_Info\_Received\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| └──📄 Additional information in cryptogram information (9F27)                                                     | 9F27 (cryptogram information) can carry more information than just AAC, TC, and ARQC. The ICC has the possibility to give back these additional information. Calling application may use these defines to analyse EMV\_CT\_TRANSRES\_STRUCT::T\_9F27\_CryptInfo                                                                                                                                                                                                                                                      |
| └──📄 Status information                                                                                          | Defines for EMV\_CT\_TRANSRES\_STRUCT::StatusInfo                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Options for fetching TLV data                                                                               | options for EMV\_CT\_fetchTxnTags()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 📁ICC Interface                                                                                                   | Definitions used for functions EMV\_CT\_SmartISO(), EMV\_CT\_SmartReset(), EMV\_CT\_SmartPowerOff(), EMV\_CT\_Send\_PIN\_Offline(), EMV\_CT\_SmartDetect()                                                                                                                                                                                                                                                                                                                                                           |
| └─📄 Options for ICC transparent commands                                                                         | Parameter ucOptions in EMV\_CT\_SmartISO(), EMV\_CT\_SmartDetect(), EMV\_CT\_SmartReset()                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └─📄 Smart status                                                                                                 | Return values for functions of group Functions for transparent ICC access                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └─📄 Functions for transparent ICC access                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📁General topics                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Additional error information                                                                                 | Filled in case of error, value to describe which error occured                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └──📄 Additional error info exit code                                                                             | Last step performed by EMV ADK 0 ? 10-27 VK-related 30-4B Amex 50-6x Discover 7 Gemalto 80-8A setup 9 ? A0-B5 common TXN C0-DB MK-related E ? F0-F4 online                                                                                                                                                                                                                                                                                                                                                           |
| └──📄 Additional error info, status                                                                               | Internal error index                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └─📄 Common data structures                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Special tag handling                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Serialization                                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └── 📁BER TLV tags used by EMV ADK                                                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Tags defined by EMVCo                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Propriertary tags used by Visa                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Proprietary tags used by MasterCard                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Proprietary tags used by JCB                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Proprietary tags used by Interac (Canada)                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Proprietary tags used by Amex                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 Proprietary tags used by Gemalto/Pure                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─── 📁Verifone internal tags                                                                                     | There are many data objects, which do not have an EMVCo defined tags. For usage of TLV interface it's necessary to define internal tags                                                                                                                                                                                                                                                                                                                                                                              |
| └──── 📁Constructed tags                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─────📄 Card Transaction Log dump (China union pay)                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─────📄 Constructed tags for new scheme specific config interface                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──── 📁Primitive tags                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───── 📁TLV tags for callback functions                                                                          | Used in function EMV\_CallbackFunction()                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──────📄 LED callback: Additional information                                                                    | Additional information for LED switching, used for TAG\_DF8F60\_LED\_ADD\_INFO                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └─────📄 Primitive tags for new scheme specific config interface                                                  | Used in functions EMV\_CTLS\_SetAppliDataSchemeSpecific()/EMV\_CTLS\_GetAppliDataSchemeSpecific                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └────📄 Three-byte-tags                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └────📄 Tags for Transaction Log subfields                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └────📄 Tags for L1 status reported in kernel wrapper data                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Tags for transport layer                                                                                    | Used for enclosing TLV container at transport. That's necessary in case EMV ADK and calling application are placed in separated entities. Transport layer (e.g. PINPad ISO2) must have indicators to determine whether data is meant for EMV ADK or not                                                                                                                                                                                                                                                              |
| 📁Initialization                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁EMV ADK functions for initialization                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Options for Exit Framework                                                                                  | Meaning of TAG\_DF8F0A\_EXIT\_OPTIONS, see also EMV\_CTLS\_Exit\_Framework\_extended()                                                                                                                                                                                                                                                                                                                                                                                                                               |
| └──📄 Options for End Transaction                                                                                 | Meaning of TAG\_DF8F0A\_EXIT\_OPTIONS, see also EMV\_CTLS\_EndTransaction()                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Options at framework initialisation                                                                         | Flags used in EMV\_CTLS\_Init\_Framework                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 📁Configuration                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Tags for configuration storage                                                                               | Used for storing the configuration in XML files                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 EMV ADK functions for configuration                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Terminal Data                                                                                                | Definitions used for functions EMV\_CTLS\_SetTermData(), EMV\_CTLS\_GetTermData()                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Terminal data: Which data is valid                                                                          | Contents of the EMV\_CTLS\_TERMDATA\_STRUCT::Info\_Included\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Terminal configuration: Collection of flow options                                                          | Contents of the EMV\_CTLS\_TERMDATA\_STRUCT::FlowOptions                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └─ 📁Application data                                                                                             | Definitions used for functions EMV\_CTLS\_SetAppliData(), EMV\_CTLS\_GetAppliData()                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 VISA terminal transaction qualifier                                                                         | Possible values for EMV\_CTLS\_APPLIDATA\_VK\_STRUCT::TerminalTransactionQualifier\_9F66                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 Common Terminal Transaction Qualifier                                                                       | TTQ bits as defined \[EMV-A] section 5.7                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └── 📁Dynamic reader limits                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └───📄 DRL feature switching                                                                                      | Values for VISA and Amex DRL features which can be switched on and off                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| └───📄 Number of DRL entries for Amex                                                                             | For Amex: How many DRL entries are possible                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Options how to apply configuration                                                                          | Options for EMV\_CTLS\_ApplyConfiguration()                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| └──📄 Contactless Kernel Ids                                                                                      | Short or Extended Kernel Id as integer                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| └──📄 technologies used in TecSupport\_DFAB30                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 used in EMV\_CTLS\_APPLIDATA\_MK\_STRUCT::KernelConfiguration\_DF811B                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 used in EMV\_CTLS\_APPLIDATA\_RK\_STRUCT::KernelConfiguration\_DF811B                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Application flow capabilities for all schemes                                                               | Contents of EMV\_CTLS\_APPLIDATA\_SCHEME\_SPECIFIC\_STRUCT::AppFlowCap\_DFAB03                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └──📄 Application flow capabilities for PayPass (MasterCard)                                                      | Contents of EMV\_CTLS\_APPLIDATA\_MK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for payWave (Visa)                                                            | Contents of EMV\_CTLS\_APPLIDATA\_VK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for ExpressPay (Amex)                                                         | Contents of EMV\_CTLS\_APPLIDATA\_AK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for JCB                                                                       | Contents of EMV\_CTLS\_APPLIDATA\_JK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for Discover/Diners                                                           | Contents of EMV\_CTLS\_APPLIDATA\_DK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for Interac                                                                   | Contents of EMV\_CTLS\_APPLIDATA\_IK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for EPAL                                                                      | Contents of EMV\_CTLS\_APPLIDATA\_EK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for China Union Pay                                                           | Contents of EMV\_CTLS\_APPLIDATA\_CK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Gemalto/Pure: Application flow capabilities                                                                 | Defines for EMV\_CTLS\_APPLIDATA\_GK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for RuPay                                                                     | Contents of EMV\_CTLS\_APPLIDATA\_RK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for SIBS                                                                      | Contents of EMV\_CTLS\_APPLIDATA\_SK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for PagoBancomat                                                              | Contents of EMV\_CTLS\_APPLIDATA\_PB\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for WISE                                                                      | Contents of EMV\_CTLS\_APPLIDATA\_WK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for CPACE                                                                     | Contents of EMV\_CTLS\_APPLIDATA\_BK\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Application flow capabilities for MIR                                                                       | Contents of EMV\_CTLS\_APPLIDATA\_MR\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Appli data scheme specific - MasterCard - Availability bits                                                 | Contents of the input in EMV\_CTLS\_APPLIDATA\_MK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 PayPass ProceedToFirstWriteFlag\_DF8110 values                                                              | Well-known values for PayPass flag ProceedToFirstWriteFlag('DF1810') in EMV\_CTLS\_APPLIDATA\_MK\_STRUCT::Scheme.MK.ProceedToFirstWriteFlag\_DF8110                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 Appli data scheme specific - Visa - Availability bits                                                       | Contents of the input in EMV\_CTLS\_APPLIDATA\_VK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Amex - Availability bits                                                       | Contents of the input in EMV\_CTLS\_APPLIDATA\_AK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - JCB - Avaiability bits                                                         | Contents of the input in EMV\_CTLS\_APPLIDATA\_JK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Discover - Availability bits                                                   | Contents of the input in EMV\_CTLS\_APPLIDATA\_DK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Interac - Availability bits                                                    | Contents of the input in EMV\_CTLS\_APPLIDATA\_IK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Epal - Availability bits                                                       | Contents of the input in EMV\_CTLS\_APPLIDATA\_EK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - China Union Pay - Avaialability bits                                           | Contents of the input in EMV\_CTLS\_APPLIDATA\_CK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Gemalto Pure - Availability bits                                               | Contents of the input in EMV\_CTLS\_APPLIDATA\_GK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - RuPay - Availability bits                                                      | Contents of the input in EMV\_CTLS\_APPLIDATA\_RK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - SIBS - Avaiability bits                                                        | Contents of the input in EMV\_CTLS\_APPLIDATA\_SK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - PagoBancomat - Availability bits                                               | Contents of the input in EMV\_CTLS\_APPLIDATA\_PB\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - Wise - Availability bits                                                       | Contents of the input in EMV\_CTLS\_APPLIDATA\_WK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - CPACE - Availability bits                                                      | Contents of the input in EMV\_CTLS\_APPLIDATA\_BK\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Appli data scheme specific - MIR - Availability bits                                                        | Contents of the input in EMV\_CTLS\_APPLIDATA\_MIR\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 Appli data scheme specific - domestic kernel - Availability bits                                            | Contents of the input in EMV\_CTLS\_APPLIDATA\_DOM\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 application flow capabilities for domestic applications                                                     | Contents of EMV\_CTLS\_APPLIDATA\_DOM\_STRUCT::AppFlowCap\_DFAB31                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Appli data scheme specific - global part - Availability bits                                                | Contents of the input in EMV\_CTLS\_APPLIDATA\_SCHEME\_SPECIFIC\_STRUCT::IncludedData                                                                                                                                                                                                                                                                                                                                                                                                                                |
| └─📄 Text data                                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📁Transaction execution                                                                                           | Definitions used for functions EMV\_CTLS\_SetupTransaction(), EMV\_CTLS\_ContinueOffline(), EMV\_CTLS\_ContinueOnline()                                                                                                                                                                                                                                                                                                                                                                                              |
| └─📄 Functions for performing transactions                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Callback functions                                                                                           | Callback function to be implemented in the same entity as EMV ADK                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └──📄 Options for DataExchange request                                                                            | Used in EMV\_CTLS\_CALLBACK\_FnT, TAG\_BF0E\_CBK\_DATA\_EXCHANGE, TAG\_DF8F58\_DE\_REQUEST                                                                                                                                                                                                                                                                                                                                                                                                                           |
| └──📄 Options for DataExchange state                                                                              | Used in EMV\_CTLS\_CALLBACK\_FnT, TAG\_BF0E\_CBK\_DATA\_EXCHANGE, TAG\_DF8F59\_DE\_STATE                                                                                                                                                                                                                                                                                                                                                                                                                             |
| └──📄 Options for DataExchange mode                                                                               | Used in EMV\_CTLS\_CALLBACK\_FnT, TAG\_BF0E\_CBK\_DATA\_EXCHANGE, TAG\_DF8F5A\_DE\_MODE                                                                                                                                                                                                                                                                                                                                                                                                                              |
| └──📄 Constructed tags for CTLS callback functions                                                                | Used in EMV\_CTLS\_CALLBACK\_FnT                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| └──📄 Buzzer handling                                                                                             | Defines given in callback TAG\_BF19\_CTLS\_CBK\_BEEP                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| └─ 📁Input data                                                                                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Options for contactless transaction processing                                                              | Defines for EMV\_CTLS\_START\_TYPE::TxnOptions                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| └──📄 Scheme specific transaction types                                                                           | Defines for EMV\_CTLS\_START\_TYPE::TransType                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| └──📄 EMV\_CTLS\_SetupTransaction: Which data is included in input struct                                         | Contents of the input in EMV\_CTLS\_START\_STRUCT::Info\_Included\_Data, EMV\_CTLS\_SetupTransaction()                                                                                                                                                                                                                                                                                                                                                                                                               |
| └──📄 EMV\_CTLS\_ContinueOnline: Which data is included                                                           | Contents of the input in EMV\_CTLS\_HOST\_STRUCT::Info\_Included\_Data, EMV\_CTLS\_ContinueOnline()                                                                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 EMV\_CTLS\_ContinueOfflineExt(): Which data is included                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 Options for contactless transaction processing at EMV\_CTLS\_ContinueOfflineExt()                           | Defines for EMV\_CTLS\_CONT\_OFFL\_STRUCT::options                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| └──📄 Support of cardholder confirmation                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─ 📁Output data                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └──📄 CTLS card types                                                                                             | Defines for EMV\_CTLS\_TRANSRES\_TYPE::ctlsCardType                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 Bitstring with information about the outcome of EMV\_CTLS\_SetupTransaction()                               | Contents of EMV\_CTLS\_STARTRES\_STRUCT::TxnInformation, EMV\_CTLS\_SetupTransaction()                                                                                                                                                                                                                                                                                                                                                                                                                               |
| └──📄 EMV\_CTLS\_SetupTransaction: Which data is included in result struct                                        | Contents of the output in EMV\_CTLS\_STARTRES\_STRUCT::T\_DF61\_Info\_Received\_Data, EMV\_CTLS\_SetupTransaction()                                                                                                                                                                                                                                                                                                                                                                                                  |
| └──📄 Information which data was provided by the ICC                                                              | Contents of EMV\_CTLS\_TRANSRES\_STRUCT::T\_DF61\_Info\_Received\_Data                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 📁ICC Interface                                                                                                   | Definitions used for functions EMV\_CTLS\_SmartISO(), EMV\_CTLS\_SmartReset(), EMV\_CTLS\_SmartPowerOff()                                                                                                                                                                                                                                                                                                                                                                                                            |
| └─📄 Options for ICC access                                                                                       | Options for ICC access, e.g. for EMV\_CTLS\_SmartISO(), EMV\_CTLS\_SmartReset(), EMV\_CTLS\_SmartPowerOff()                                                                                                                                                                                                                                                                                                                                                                                                          |
| └─📄 Functions for transparent ICC access                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📁LED control                                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Defines for LED IDs                                                                                          | LED numbers in EMV\_CTLS\_LED()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Defines for LED states                                                                                       | LED states to be used in EMV\_CTLS\_LED()                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| └─📄 Defines for LED modes                                                                                        | LED modes to be used in EMV\_CTLS\_LED\_SetMode()                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| └─📄 Defines for LED handling                                                                                     | LED numbers and modes to be used in EMV\_CT\_LED()                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 📁Import/Export Utility                                                                                           | Allows configurable data translation from a file into a database and vice versa                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| └─📄 Public API                                                                                                   | API for the users of the library                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 📄 Property Database API                                                                                          | Allows for easy to use hierarchical key/value storage                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 📄 Multi Application Controller functions                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Error codes                                                                                                    | These error codes are returned by the various libmsr functions                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 📄 Status code                                                                                                    | These values indicate the status of each read track                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 📄 Card Type Code                                                                                                 | These values indicate the type of msr read                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 📄 Track Type Code                                                                                                | These values indicate the type of track data                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 📄 Options bitmask                                                                                                | These options configure the behavior of magnetic card reader library, set by MSR\_SetOptions(). A combination is possible using \| operator                                                                                                                                                                                                                                                                                                                                                                          |
| 📄 LED states                                                                                                     | These are the states of the three MSR LEDs which can be set by MSR\_SwitchLeds(). On devices that don't have multicolored LEDs, all "color defines" are equivalent and imply "LED on". As there is currently no device with multicolored LEDs, multicolor feature is not implemented yet                                                                                                                                                                                                                             |
| 📄 management functions                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Tag fetching options                                                                                           | Options for SDI\_fetchTxnTags() The searched data base is ADK and L2 kernel excluding kernel private tags ( "readHypTag")                                                                                                                                                                                                                                                                                                                                                                                            |
| 📄 Dialog invocation return values                                                                                | Return values from display(), secureInput(), htmlDialog(), menu(), requestCard() and captureSignature() are defined as integer values according to html/gui\_error.h to be able to return a positive value for the selected menu item                                                                                                                                                                                                                                                                                |
| 📄 Dialog options                                                                                                 | Bit mask values for dialog options set with setOptions() (DFA13D)                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| 📄 Menu options                                                                                                   | Bit mask values for menu options set with setOptions() (DFA13D)                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI Protocol Error Codes                                                                                       | SDI protocol error codes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 📄 SDI Protocol Initialization Options                                                                            | SDI protocol configuration flags                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 📄 System LED functions                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Netloader                                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 System statusbar functions                                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Low level system power management functions. Please use vfisyspm.h instead.                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 System beep functions                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 System property functions                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 System property functions                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 installation functions                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Utility functions                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 zontalk protocal APIs                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 PED return codes                                                                                               | These return codes are returned by the ped functions                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 📄 PED status codes                                                                                               | These codes are set by ped\_Pairing()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| 📄 Notification callback types                                                                                    | These callbacks can be set by cts\_SetNotificationCallback()                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 📄 TEC technology code                                                                                            | These codes are used to specify supported technologies. A combination is possible using \| operator                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 📄 TEC return codes                                                                                               | These return codes are returned by the various libtec functions                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 TEC start options                                                                                              | These options configure the behavior of technology selection, set by cts\_StartSelection(). A combination is possible using \| operator                                                                                                                                                                                                                                                                                                                                                                              |
| 📄 TEC result data tags                                                                                           | These tags are used in dataBuffer of cts\_WaitSelection() if CTS\_DATA\_TLV is set in usedTechnology                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 📄 TEC option tags                                                                                                | These options can be set by cts\_SetOptions()                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| 📄 Graphical User Interface                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Printing functions                                                                                             |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 inter process communication                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 TLVLite                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI client setup                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Low level message interface                                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 System interface                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Display interface                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Printer interface                                                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 MSR interface                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Card reader interface                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 PIN entry interface                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Crypto interface                                                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Data interface                                                                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 VCL interface                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 EMV contact interface                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 EMV contactless interface                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI client NFC interface                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI client VAS interface                                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI and EMV callbacks                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 SDI plugin commands                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Com\_verifone\_seccmd                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Config                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 📄 Vss                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://sandbox-docs.verifone.com/s-adk-5.1-programmers-guide/readme/modules.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.