citypay_api_client 1.0.0

data/docs/Ping.md

@@ -0,0 +1,17 @@
+# CityPayApiClient::Ping
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**identifier** | **String** | An identifier of the ping request which will be returned in the response. | [optional] 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::Ping.new(identifier: 95b857a1-5955-4b86-963c-5a6dbfc4fb95)
+```
+
+

data/docs/RegisterCard.md

@@ -0,0 +1,23 @@
+# CityPayApiClient::RegisterCard
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**cardnumber** | **String** | The primary number of the card. | 
+**default** | **Boolean** | Determines whether the card should be the new default card. | [optional] 
+**expmonth** | **Integer** | The expiry month of the card. | 
+**expyear** | **Integer** | The expiry year of the card. | 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::RegisterCard.new(cardnumber: 4000 0000 0000 0002,
+                                 default: null,
+                                 expmonth: 9,
+                                 expyear: 2023)
+```
+
+

data/docs/RequestChallenged.md

@@ -0,0 +1,25 @@
+# CityPayApiClient::RequestChallenged
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**acs_url** | **String** | The url of the Access Control Server (ACS) to forward the user to.  | [optional] 
+**creq** | **String** | The challenge request data which is encoded for usage by the ACS. | [optional] 
+**merchantid** | **Integer** | The merchant id that processed this transaction. | [optional] 
+**three_d_server_trans_id** | **String** | The 3DSv2 trans id reference for the challenge process. | [optional] 
+**transno** | **Integer** | The transaction number for the challenge, ordered incrementally from 1 for every merchant_id.  | [optional] 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::RequestChallenged.new(acs_url: https://acs.cardissuer.com/3dsv1,
+                                 creq: null,
+                                 merchantid: 11223344,
+                                 three_d_server_trans_id: null,
+                                 transno: 78416)
+```
+
+

data/docs/RetrieveRequest.md

@@ -0,0 +1,21 @@
+# CityPayApiClient::RetrieveRequest
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**identifier** | **String** | The identifier of the transaction to retrieve. Optional if a transaction number is provided. | [optional] 
+**merchantid** | **Integer** | The merchant account to retrieve data for. | 
+**transno** | **Integer** | The transaction number of a transaction to retrieve. Optional if an identifier is supplied. | [optional] 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::RetrieveRequest.new(identifier: 95b857a1-5955-4b86-963c-5a6dbfc4fb95,
+                                 merchantid: 11223344,
+                                 transno: 78416)
+```
+
+

data/docs/ThreeDSecure.md

@@ -0,0 +1,25 @@
+# CityPayApiClient::ThreeDSecure
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**accept_headers** | **String** | The content of the HTTP accept header as sent to the merchant from the cardholder's user agent. This value will be validated by the ACS when the card holder authenticates themselves to verify that no intermediary is performing this action. Required for 3DSv1.  | [optional] 
+**downgrade1** | **Boolean** | Where a merchant is configured for 3DSv2, setting this option will attempt to downgrade the transaction to  3DSv1.  | [optional] 
+**merchant_termurl** | **String** | A controller URL for 3D-Secure processing that any response from an authentication request or challenge request should be sent to.  The controller should forward on the response from the URL back via this API for subsequent processing. Required if 3DSv1 or 3DSv2 is required.  | [optional] 
+**tds_policy** | **String** | A policy value which determines whether ThreeDSecure is enforced or bypassed. Note that this will only work for e-commerce transactions and accounts that have 3DSecure enabled and fully registered with Visa, MasterCard or American Express. It is useful when transactions may be wanted to bypass processing rules.  Note that this may affect the liability shift of transactions and may occur a higher fee with the acquiring bank.  Values are  `0` for the default policy (default value if not supplied). Your default values are determined by your account manager on setup of the account.  `1` for an enforced policy. Transactions will be enabled for 3DS processing  `2` to bypass. Transactions that are bypassed will switch off 3DS processing.  | [optional] 
+**user_agent** | **String** | The content of the HTTP user-agent header as sent to the merchant from the cardholder's user agent. This value will be validated by the ACS when the card holder authenticates themselves to verify that no intermediary is performing this action. Required for 3DSv1.  | [optional] 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::ThreeDSecure.new(accept_headers: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9,
+                                 downgrade1: null,
+                                 merchant_termurl: null,
+                                 tds_policy: null,
+                                 user_agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36)
+```
+
+

data/docs/VoidRequest.md

@@ -0,0 +1,23 @@
+# CityPayApiClient::VoidRequest
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**identifier** | **String** | The identifier of the transaction to void. If an empty value is supplied then a `trans_no` value must be supplied. | [optional] 
+**merchantid** | **Integer** | Identifies the merchant account to perform the void for. | 
+**sdk** | **String** | An optional reference value for the calling client such as a version number i.e. | [optional] 
+**transno** | **Integer** | The transaction number of the transaction to look up and void. If an empty value is supplied then an identifier value must be supplied. | [optional] 
+
+## Code Sample
+
+```ruby
+require 'CityPayApiClient'
+
+instance = CityPayApiClient::VoidRequest.new(identifier: 95b857a1-5955-4b86-963c-5a6dbfc4fb95,
+                                 merchantid: 11223344,
+                                 sdk: MyClient 1.3.0,
+                                 transno: 78416)
+```
+
+

data/git_push.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-pestore-perl "minor update" "gitlab.com"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+git_host=$4
+
+if [ "$git_host" = "" ]; then
+    git_host="github.com"
+    echo "[INFO] No command line input provided. Set \$git_host to $git_host"
+fi
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="citypay"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="citypay-api-client-ruby"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="Minor update"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=`git remote`
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+        git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:${GIT_TOKEN}@${git_host}/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'
+

data/lib/citypay_api_client.rb

@@ -0,0 +1,72 @@
+=begin
+#CityPay Payment API
+
+# This CityPay API is a HTTP RESTful payment API used for direct server to server transactional processing. It provides a number of payment mechanisms including: Internet, MOTO, Continuous Authority transaction processing, 3-D Secure decision handling using RFA Secure, Authorisation, Refunding, Pre-Authorisation, Cancellation/Voids and Completion processing. The API is also capable of tokinsed payments using Card Holder Accounts.  ## Compliance and Security <aside class=\"notice\">   Before we begin a reminder that your application will need to adhere to PCI-DSS standards to operate safely   and to meet requirements set out by Visa and MasterCard and the PCI Security Standards Council including: </aside>  * Data must be collected using TLS version 1.2 using [strong cryptography](#enabled-tls-ciphers). We will not accept calls to our API at   lower grade encryption levels. We regularly scan our TLS endpoints for vulnerabilities and perform TLS assessments   as part of our compliance program. * The application must not store sensitive card holder data (CHD) such as the card security code (CSC) or   primary access number (PAN) * The application must not display the full card number on receipts, it is recommended to mask the PAN   and show the last 4 digits. The API will return this for you for ease of receipt creation * If you are developing a website, you will be required to perform regular scans on the network where you host the   application to meet your compliance obligations * You will be required to be PCI Compliant and the application must adhere to the security standard. Further information   is available from [https://www.pcisecuritystandards.org/](https://www.pcisecuritystandards.org/) * The API verifies that the request is for a valid account and originates from a trusted source using the remote IP   address. Our application firewalls analyse data that may be an attempt to break a large number of security common   security vulnerabilities. 
+
+The version of the OpenAPI document: 6.0.0
+Contact: support@citypay.com
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.0-SNAPSHOT
+
+=end
+
+# Common files
+require 'citypay_api_client/api_client'
+require 'citypay_api_client/api_error'
+require 'citypay_api_client/version'
+require 'citypay_api_client/configuration'
+
+# Models
+require 'citypay_api_client/models/account_create'
+require 'citypay_api_client/models/account_status'
+require 'citypay_api_client/models/acknowledgement'
+require 'citypay_api_client/models/airline_advice'
+require 'citypay_api_client/models/airline_segment'
+require 'citypay_api_client/models/auth_reference'
+require 'citypay_api_client/models/auth_references'
+require 'citypay_api_client/models/auth_request'
+require 'citypay_api_client/models/auth_response'
+require 'citypay_api_client/models/authen_required'
+require 'citypay_api_client/models/c_res_auth_request'
+require 'citypay_api_client/models/capture_request'
+require 'citypay_api_client/models/card'
+require 'citypay_api_client/models/card_holder_account'
+require 'citypay_api_client/models/card_status'
+require 'citypay_api_client/models/charge_request'
+require 'citypay_api_client/models/contact_details'
+require 'citypay_api_client/models/decision'
+require 'citypay_api_client/models/error'
+require 'citypay_api_client/models/external_mpi'
+require 'citypay_api_client/models/list_merchants_response'
+require 'citypay_api_client/models/mcc6012'
+require 'citypay_api_client/models/merchant'
+require 'citypay_api_client/models/pa_res_auth_request'
+require 'citypay_api_client/models/ping'
+require 'citypay_api_client/models/register_card'
+require 'citypay_api_client/models/request_challenged'
+require 'citypay_api_client/models/retrieve_request'
+require 'citypay_api_client/models/three_d_secure'
+require 'citypay_api_client/models/void_request'
+
+# APIs
+require 'citypay_api_client/api/card_holder_account_api'
+require 'citypay_api_client/api/operational_api'
+require 'citypay_api_client/api/payment_processing_api'
+
+module CityPayApiClient
+  class << self
+    # Customize default settings for the SDK using block.
+    #   CityPayApiClient.configure do |config|
+    #     config.username = "xxx"
+    #     config.password = "xxx"
+    #   end
+    # If no block given, return the default Configuration object.
+    def configure
+      if block_given?
+        yield(Configuration.default)
+      else
+        Configuration.default
+      end
+    end
+  end
+end

data/lib/citypay_api_client/api/card_holder_account_api.rb

@@ -0,0 +1,628 @@
+=begin
+#CityPay Payment API
+
+# This CityPay API is a HTTP RESTful payment API used for direct server to server transactional processing. It provides a number of payment mechanisms including: Internet, MOTO, Continuous Authority transaction processing, 3-D Secure decision handling using RFA Secure, Authorisation, Refunding, Pre-Authorisation, Cancellation/Voids and Completion processing. The API is also capable of tokinsed payments using Card Holder Accounts.  ## Compliance and Security <aside class=\"notice\">   Before we begin a reminder that your application will need to adhere to PCI-DSS standards to operate safely   and to meet requirements set out by Visa and MasterCard and the PCI Security Standards Council including: </aside>  * Data must be collected using TLS version 1.2 using [strong cryptography](#enabled-tls-ciphers). We will not accept calls to our API at   lower grade encryption levels. We regularly scan our TLS endpoints for vulnerabilities and perform TLS assessments   as part of our compliance program. * The application must not store sensitive card holder data (CHD) such as the card security code (CSC) or   primary access number (PAN) * The application must not display the full card number on receipts, it is recommended to mask the PAN   and show the last 4 digits. The API will return this for you for ease of receipt creation * If you are developing a website, you will be required to perform regular scans on the network where you host the   application to meet your compliance obligations * You will be required to be PCI Compliant and the application must adhere to the security standard. Further information   is available from [https://www.pcisecuritystandards.org/](https://www.pcisecuritystandards.org/) * The API verifies that the request is for a valid account and originates from a trusted source using the remote IP   address. Our application firewalls analyse data that may be an attempt to break a large number of security common   security vulnerabilities. 
+
+The version of the OpenAPI document: 6.0.0
+Contact: support@citypay.com
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.0.0-SNAPSHOT
+
+=end
+
+require 'cgi'
+
+module CityPayApiClient
+  class CardHolderAccountApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.default)
+      @api_client = api_client
+    end
+    # Card Deletion
+    # Deletes a card from the account. The card will be marked for deletion before a subsequent purge will clear the card permanently. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param card_id [String] The id of the card that is presented by a call to retrieve a card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [Acknowledgement]
+    def account_card_delete_request(accountid, card_id, opts = {})
+      data, _status_code, _headers = account_card_delete_request_with_http_info(accountid, card_id, opts)
+      data
+    end
+
+    # Card Deletion
+    # Deletes a card from the account. The card will be marked for deletion before a subsequent purge will clear the card permanently. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param card_id [String] The id of the card that is presented by a call to retrieve a card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Acknowledgement, Integer, Hash)>] Acknowledgement data, response status code and response headers
+    def account_card_delete_request_with_http_info(accountid, card_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_card_delete_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_card_delete_request"
+      end
+      # verify the required parameter 'card_id' is set
+      if @api_client.config.client_side_validation && card_id.nil?
+        fail ArgumentError, "Missing the required parameter 'card_id' when calling CardHolderAccountApi.account_card_delete_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}/card/{cardId}'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s)).sub('{' + 'cardId' + '}', CGI.escape(card_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] 
+
+      # return_type
+      return_type = opts[:return_type] || 'Acknowledgement' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_card_delete_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Card Registration
+    # Allows for a card to be registered for the account. The card will be added for future  processing and will be available as a tokenised value for future processing.  The card will be validated for  0. Being a valid card number (luhn check) 0. Having a valid expiry date 0. Being a valid bin value. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param register_card [RegisterCard] 
+    # @param [Hash] opts the optional parameters
+    # @return [CardHolderAccount]
+    def account_card_register_request(accountid, register_card, opts = {})
+      data, _status_code, _headers = account_card_register_request_with_http_info(accountid, register_card, opts)
+      data
+    end
+
+    # Card Registration
+    # Allows for a card to be registered for the account. The card will be added for future  processing and will be available as a tokenised value for future processing.  The card will be validated for  0. Being a valid card number (luhn check) 0. Having a valid expiry date 0. Being a valid bin value. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param register_card [RegisterCard] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CardHolderAccount, Integer, Hash)>] CardHolderAccount data, response status code and response headers
+    def account_card_register_request_with_http_info(accountid, register_card, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_card_register_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_card_register_request"
+      end
+      # verify the required parameter 'register_card' is set
+      if @api_client.config.client_side_validation && register_card.nil?
+        fail ArgumentError, "Missing the required parameter 'register_card' when calling CardHolderAccountApi.account_card_register_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}/register'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(register_card) 
+
+      # return_type
+      return_type = opts[:return_type] || 'CardHolderAccount' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_card_register_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Card Status
+    # Updates the status of a card for processing. The following values are available  | Status | Description |  |--------|-------------| | Active | The card is active for processing and can be used for charging against with a valid token | | Inactive | The card is inactive for processing and cannot be used for processing, it will require reactivation before being used to charge | | Expired | The card has expired either due to the expiry date no longer being valid or due to a replacement card being issued | 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param card_id [String] The id of the card that is presented by a call to retrieve a card holder account.
+    # @param card_status [CardStatus] 
+    # @param [Hash] opts the optional parameters
+    # @return [Acknowledgement]
+    def account_card_status_request(accountid, card_id, card_status, opts = {})
+      data, _status_code, _headers = account_card_status_request_with_http_info(accountid, card_id, card_status, opts)
+      data
+    end
+
+    # Card Status
+    # Updates the status of a card for processing. The following values are available  | Status | Description |  |--------|-------------| | Active | The card is active for processing and can be used for charging against with a valid token | | Inactive | The card is inactive for processing and cannot be used for processing, it will require reactivation before being used to charge | | Expired | The card has expired either due to the expiry date no longer being valid or due to a replacement card being issued | 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param card_id [String] The id of the card that is presented by a call to retrieve a card holder account.
+    # @param card_status [CardStatus] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Acknowledgement, Integer, Hash)>] Acknowledgement data, response status code and response headers
+    def account_card_status_request_with_http_info(accountid, card_id, card_status, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_card_status_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_card_status_request"
+      end
+      # verify the required parameter 'card_id' is set
+      if @api_client.config.client_side_validation && card_id.nil?
+        fail ArgumentError, "Missing the required parameter 'card_id' when calling CardHolderAccountApi.account_card_status_request"
+      end
+      # verify the required parameter 'card_status' is set
+      if @api_client.config.client_side_validation && card_status.nil?
+        fail ArgumentError, "Missing the required parameter 'card_status' when calling CardHolderAccountApi.account_card_status_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}/card/{cardId}/status'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s)).sub('{' + 'cardId' + '}', CGI.escape(card_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(card_status) 
+
+      # return_type
+      return_type = opts[:return_type] || 'Acknowledgement' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_card_status_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Contact Details Update
+    # Allows for the ability to change the contact details for an account.
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param contact_details [ContactDetails] 
+    # @param [Hash] opts the optional parameters
+    # @return [CardHolderAccount]
+    def account_change_contact_request(accountid, contact_details, opts = {})
+      data, _status_code, _headers = account_change_contact_request_with_http_info(accountid, contact_details, opts)
+      data
+    end
+
+    # Contact Details Update
+    # Allows for the ability to change the contact details for an account.
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param contact_details [ContactDetails] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CardHolderAccount, Integer, Hash)>] CardHolderAccount data, response status code and response headers
+    def account_change_contact_request_with_http_info(accountid, contact_details, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_change_contact_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_change_contact_request"
+      end
+      # verify the required parameter 'contact_details' is set
+      if @api_client.config.client_side_validation && contact_details.nil?
+        fail ArgumentError, "Missing the required parameter 'contact_details' when calling CardHolderAccountApi.account_change_contact_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}/contact'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(contact_details) 
+
+      # return_type
+      return_type = opts[:return_type] || 'CardHolderAccount' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_change_contact_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Account Create
+    # Creates a new card holder account and initialises the account ready for adding cards.
+    # @param account_create [AccountCreate] 
+    # @param [Hash] opts the optional parameters
+    # @return [CardHolderAccount]
+    def account_create(account_create, opts = {})
+      data, _status_code, _headers = account_create_with_http_info(account_create, opts)
+      data
+    end
+
+    # Account Create
+    # Creates a new card holder account and initialises the account ready for adding cards.
+    # @param account_create [AccountCreate] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CardHolderAccount, Integer, Hash)>] CardHolderAccount data, response status code and response headers
+    def account_create_with_http_info(account_create, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_create ...'
+      end
+      # verify the required parameter 'account_create' is set
+      if @api_client.config.client_side_validation && account_create.nil?
+        fail ArgumentError, "Missing the required parameter 'account_create' when calling CardHolderAccountApi.account_create"
+      end
+      # resource path
+      local_var_path = '/account/create'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(account_create) 
+
+      # return_type
+      return_type = opts[:return_type] || 'CardHolderAccount' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Account Deletion
+    # Allows for the deletion of an account. The account will marked for deletion and subsequent purging. No further transactions will be alowed to be processed or actioned against this account. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [Acknowledgement]
+    def account_delete_request(accountid, opts = {})
+      data, _status_code, _headers = account_delete_request_with_http_info(accountid, opts)
+      data
+    end
+
+    # Account Deletion
+    # Allows for the deletion of an account. The account will marked for deletion and subsequent purging. No further transactions will be alowed to be processed or actioned against this account. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Acknowledgement, Integer, Hash)>] Acknowledgement data, response status code and response headers
+    def account_delete_request_with_http_info(accountid, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_delete_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_delete_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] 
+
+      # return_type
+      return_type = opts[:return_type] || 'Acknowledgement' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_delete_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Account Retrieval
+    # Allows for the retrieval of a card holder account for the given `id`. Should duplicate accounts exist for the same `id`, the first account created with that `id` will be returned.  The account can be used for tokenisation processing by listing all cards assigned to the account. The returned cards will include all `active`, `inactive` and `expired` cards. This can be used to  enable a card holder to view their wallet and make constructive choices on which card to use. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [CardHolderAccount]
+    def account_retrieve_request(accountid, opts = {})
+      data, _status_code, _headers = account_retrieve_request_with_http_info(accountid, opts)
+      data
+    end
+
+    # Account Retrieval
+    # Allows for the retrieval of a card holder account for the given &#x60;id&#x60;. Should duplicate accounts exist for the same &#x60;id&#x60;, the first account created with that &#x60;id&#x60; will be returned.  The account can be used for tokenisation processing by listing all cards assigned to the account. The returned cards will include all &#x60;active&#x60;, &#x60;inactive&#x60; and &#x60;expired&#x60; cards. This can be used to  enable a card holder to view their wallet and make constructive choices on which card to use. 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(CardHolderAccount, Integer, Hash)>] CardHolderAccount data, response status code and response headers
+    def account_retrieve_request_with_http_info(accountid, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_retrieve_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_retrieve_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] 
+
+      # return_type
+      return_type = opts[:return_type] || 'CardHolderAccount' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_retrieve_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Account Status
+    # Updates the status of an account. An account can have the following statuses applied  | Status | Description | |--------|-------------| | Active | The account is active for processing | | Disabled | The account has been disabled and cannot be used for processing. The account will require reactivation to continue procesing | 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param account_status [AccountStatus] 
+    # @param [Hash] opts the optional parameters
+    # @return [Acknowledgement]
+    def account_status_request(accountid, account_status, opts = {})
+      data, _status_code, _headers = account_status_request_with_http_info(accountid, account_status, opts)
+      data
+    end
+
+    # Account Status
+    # Updates the status of an account. An account can have the following statuses applied  | Status | Description | |--------|-------------| | Active | The account is active for processing | | Disabled | The account has been disabled and cannot be used for processing. The account will require reactivation to continue procesing | 
+    # @param accountid [String] The account id that refers to the customer&#39;s account no. This value will have been provided when setting up the card holder account.
+    # @param account_status [AccountStatus] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Acknowledgement, Integer, Hash)>] Acknowledgement data, response status code and response headers
+    def account_status_request_with_http_info(accountid, account_status, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.account_status_request ...'
+      end
+      # verify the required parameter 'accountid' is set
+      if @api_client.config.client_side_validation && accountid.nil?
+        fail ArgumentError, "Missing the required parameter 'accountid' when calling CardHolderAccountApi.account_status_request"
+      end
+      # verify the required parameter 'account_status' is set
+      if @api_client.config.client_side_validation && account_status.nil?
+        fail ArgumentError, "Missing the required parameter 'account_status' when calling CardHolderAccountApi.account_status_request"
+      end
+      # resource path
+      local_var_path = '/account/{accountid}/status'.sub('{' + 'accountid' + '}', CGI.escape(accountid.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(account_status) 
+
+      # return_type
+      return_type = opts[:return_type] || 'Acknowledgement' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#account_status_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Charge
+    # A charge process obtains an authorisation using a tokenised value which represents a stored card  on a card holder account.  A card must previously be registered by calling `/account-register-card` with the card details  or retrieved using `/account-retrieve`  Tokens are generated whenever a previously registered list of cards are retrieved. Each token has, by design a  relatively short time to live of 30 minutes. This is both to safe guard the merchant and card holder from  replay attacks. Tokens are also restricted to your account, preventing malicious actors from stealing details for use elsewhere.    If a token is reused after it has expired it will be rejected and a new token will be required.   Tokenisation can be used for   - repeat authorisations on a previously stored card - easy authorisations just requiring CSC values to be entered - can be used for credential on file style payments - can require full 3-D Secure authentication to retain the liability shift - wallet style usage. 
+    # @param charge_request [ChargeRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [Decision]
+    def charge_request(charge_request, opts = {})
+      data, _status_code, _headers = charge_request_with_http_info(charge_request, opts)
+      data
+    end
+
+    # Charge
+    # A charge process obtains an authorisation using a tokenised value which represents a stored card  on a card holder account.  A card must previously be registered by calling &#x60;/account-register-card&#x60; with the card details  or retrieved using &#x60;/account-retrieve&#x60;  Tokens are generated whenever a previously registered list of cards are retrieved. Each token has, by design a  relatively short time to live of 30 minutes. This is both to safe guard the merchant and card holder from  replay attacks. Tokens are also restricted to your account, preventing malicious actors from stealing details for use elsewhere.    If a token is reused after it has expired it will be rejected and a new token will be required.   Tokenisation can be used for   - repeat authorisations on a previously stored card - easy authorisations just requiring CSC values to be entered - can be used for credential on file style payments - can require full 3-D Secure authentication to retain the liability shift - wallet style usage. 
+    # @param charge_request [ChargeRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Decision, Integer, Hash)>] Decision data, response status code and response headers
+    def charge_request_with_http_info(charge_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: CardHolderAccountApi.charge_request ...'
+      end
+      # verify the required parameter 'charge_request' is set
+      if @api_client.config.client_side_validation && charge_request.nil?
+        fail ArgumentError, "Missing the required parameter 'charge_request' when calling CardHolderAccountApi.charge_request"
+      end
+      # resource path
+      local_var_path = '/charge'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'text/xml'])
+      # HTTP header 'Content-Type'
+      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json', 'text/xml'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] || @api_client.object_to_http_body(charge_request) 
+
+      # return_type
+      return_type = opts[:return_type] || 'Decision' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['cp-api-key']
+
+      new_options = opts.merge(
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: CardHolderAccountApi#charge_request\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end