card-management-sdk 1.0.0

data/lib/shell_card_management_ap_is/controllers/card_controller.rb

@@ -0,0 +1,1047 @@
+# shell_card_management_ap_is
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module ShellCardManagementApIs
+  # CardController
+  class CardController < BaseController
+    # This API allows to search for Shell Cards in the Shell Card Platform. It
+    # provides flexible search criteria and supports paging.
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * New parameters have been added in the response. Below are the list of
+    # parameters added
+    #       * IsEMVContact
+    #       * IsEMVContactless
+    #       * IsRFID
+    #       * RFIDUID
+    #       * EMAID
+    #       * EVPrintedNumber
+    #       * CardMediaCode
+    # #### Supported operations
+    #   * Search cards by card id or PAN
+    #   * Search cards by card status
+    #   * Search cards by excluding card status
+    #   * Search cards by date fields
+    #   * Search cards by embossed fields
+    #   * Search cards by card configuration fields
+    #   * Search cards by included/excluded list of cards
+    #   * Search cards by excluding card bundle Id
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [SearchCardRequest] body Optional parameter: requestbody
+    # @return [CardSearchResponse] response from the API call
+    def search_card(request_id,
+                    body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/search',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(CardSearchResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows to search for fuel cards in the Shell Card Platform and
+    # returns a high-level summary count. It provides flexible search criteria.
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * Minor change in response structure with addition of Status parameter
+    # 
+    # #### Supported operations
+    #   * Search cards by card id or PAN
+    #   * Search cards by card status
+    #   * Search cards by excluding card status
+    #   * Search cards by date fields
+    #   * Search cards by embossed fields
+    #   * Search cards by card configuration fields
+    #   * Search cards by included/excluded list of cards
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [CardSummaryRequest] body Optional parameter: summary request
+    # body
+    # @return [CardSummaryResponse] response from the API call
+    def card_summary(request_id,
+                     body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/summary',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(CardSummaryResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows ordering one or more fuel cards (up to 50). If the API
+    # call succeeds, the API will return a reference number and queue the
+    # request for asynchronous processing.
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * New parameters have been added in the response for the new PIN
+    # management changes. Below parameters needs to be derived from the new PIN
+    # encryption method explained in our Mobility Card PIN Management product.
+    #       * SelfSelectedEncryptedPIN
+    #       * SelfSelectedPINKeyID
+    #       * SelfSelectedPINSessionKey
+    #   * New parameters have been added in the response for card and pin
+    # delivery mechanism which gives the opportunity to deliver card & pin by
+    # email, SMS or post.
+    #     Also the possibility to deliver card and pin to different address if
+    # the use case demands.
+    #       * CardDeliveryType
+    #       * PINDeliveryAddressType
+    #       * PINAdviceType
+    #       * PINContact
+    #       * CardContact
+    # #### Supported operations
+    #   * Order one or more cards (up to 50)
+    #   * Order card with self selected PIN
+    #   * Order card with vehicle registration number
+    #   * Order card and add to new or exisitng card group
+    #   * Order card and enable fleetId or odemeter input
+    #   * Order card and specify product groups
+    # #### Validation rules
+    # * Number of cards per request does not exceed 50
+    # #### API response
+    # * A main reference number for the API request (**OrderReference**)
+    # * Individual reference numbers (**OrderCardReference**) for each new card
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [OrderCardRequest] body Optional parameter: Order card request
+    # body
+    # @return [OrderCardResponse] response from the API call
+    def order_card(request_id,
+                   body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/ordercard',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(OrderCardResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API retrieves the card order status from the Shell Card Platform
+    # based on the given reference numbers.
+    #   #### New version updates
+    #     * Oauth authentication to access the API
+    #     * Minor change in response structure with addition of Status parameter
+    #   #### Supported operations
+    #     * Get order status by Bulk Card Order Reference
+    #     * Get order status by Order Reference (main reference for the order)
+    #     * Get order status by Card Reference (individual card reference
+    # belonging to an order reference)
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [OrderCardEnquiryRequest] body Optional parameter: Order Card
+    # Enquiry request body
+    # @return [OrderCardEnquiryResponse] response from the API call
+    def order_card_enquiry(request_id,
+                           body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/ordercardenquiry',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(OrderCardEnquiryResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows cancelling one or multiple cards (up to 500) within a
+    # single API call. This API allows updating of
+    #   the card to the following status-
+    # *  Block (Cancelled)
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * Change in the request body
+    #     * PIN delivery address details have been added along with Email and
+    # Phone number for card and PIN delivery.
+    # Requests that passed the below validations are queued-
+    #   * All Mandatory fields are passed.
+    #   *  Card is present in the Shell Card Platform.
+    #   *  Only one matching card is available in the cards platform for the
+    # given PAN and expiry date for Block requests.
+    #   *  Card is allowed to be moved to proposed state as per the card status
+    # transition configuration in cards platform.
+    #   *  A valid Reason Id or Reason Text is provided. The reason for card
+    # cancellation can be “Damaged” or “NoLongerRequired”.
+    #   *  For the given card, there is no Cancel request already submitted via
+    # this API and is being processed.
+    #   *  ‘IsReplacementChargeable’ is set to ‘False’ only to the configured
+    # customer, other customers need to set it as ‘True’ only. If other
+    # customers pass this value as ‘False’.
+    #   Note- Shell Card Platform will maintain the list of   customers, to whom
+    # ‘IsReplacementChargeable’ can be set as ‘False’.
+    # If all validations are passed, the request will be accepted and the API
+    # will return reference numbers for tracking purpose. If any of the
+    # validations fail, the API will return the appropriate error details on
+    # response.  The API response will include-
+    #   *  A main reference number for the API request.
+    #   *  A list of successfully validated and accepted cards along with the
+    # individual reference numbers for each of the successful requests.
+    #   *  A list of cards for which at least validation has failed along with
+    # the appropriate error code and details.
+    #   A permanent block (cancelled) request for the card will be queued in
+    # Shell Card Platform after the configured damaged card active period
+    # (configured as number of days).
+    # 
+    #   When a card is requested to be Blocked permanently (cancelled) for which
+    # a request has already been submitted to report as Damaged and the damaged
+    # card active period is not yet completed, the damaged card request will be
+    # marked as superseded and the new Block (cancelled) request will be
+    # processed.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [CancelCardRequest] body Optional parameter: Update status request
+    # body
+    # @return [CancelCardResponse] response from the API call
+    def card_cancel(request_id,
+                    body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/cancel',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(CancelCardResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows updating of the card status for one or more cards (up to
+    # 500) within a single API call.  If the API call succeeds, the API will
+    # return a reference number and queue the request for asynchronous
+    # processing.
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * Change in the request body
+    #     * Pin change related parameters - SelfSelectedEncryptedPIN,
+    # SelfSelectedPINKeyID, SelfSelectedPINSessionKey
+    #     * PIN delivery address details have been added along with Email and
+    # Phone number for card and PIN delivery.
+    #     * SaveForPINReminder - The given address will be used for sending PIN
+    # reminders in future when requested.
+    #     * SaveForCardReissue - If this is specified, the contact address will
+    # be saved in cards platform for card reissue processing.
+    # #### Supported operations
+    #   * Updating a card status to Temporary block, Unblock, Block (Cancelled)
+    #     or Damaged
+    #   * Requesting a replacement card when status is set to Block or Damaged
+    # #### Validation rules
+    #   * Number of cards per request does not exceed 500
+    #   * A card can be changed to proposed status as per the card status
+    # transition configuration in the Shell Card Platform
+    #   * Locating a card -
+    #     * If target status set to **TemporaryBlock**, then only one matching
+    # active card should exist in the Shell Card Platform for the given **PAN**
+    # and **CardExpiryDate**
+    #     * If target status set to **Unblock** or **Block**, then only one
+    # matching card should exist in the Shell Card Platform for the given
+    # **PAN** and **CardExpiryDate**
+    #   * A valid Reason Id or Reason Text is provided
+    #     * If target status set to **Block** or **Damaged** and a
+    # **ReasonText** is provided, the value must be from the fixed list -
+    # *'Lost'*, *'Stolen'* or *'Card no longer required'*
+    #   * For the given card, there is no Status Update request already
+    # submitted via this API and is being processed
+    #   * The **OrderReplacementCard** field is set to True only for cards with
+    # a target status set to Block or Damaged
+    # #### API response
+    #   * A main reference number for the API request
+    # (**OrderReplacementReference**)
+    #   * A list of successfully validated and accepted cards along with the
+    # individual reference numbers (**UpdateCardReference**) for each of the
+    # successful  request
+    #   * A list of cards (**ErrorCards**) that failed validation along with the
+    # appropriate error code and message
+    # #### Asynchronous processing of valid API request
+    #   * Replacement cards
+    #     * Request for a replacement card will be placed only when the Block
+    # card or Block damaged card request is successfully placed.
+    #     * The Replacement card request will be processed only when the
+    # permanent Block card request is successfully processed. In case of damaged
+    # card request, the replacement card request will be processed immediately.
+    #   * Damaged cards
+    #     * Setting a card to Damaged will automatically trigger a request to
+    # permanently block the card. This will only take effect once the ‘Damaged
+    # Active’ period has passed.
+    #     * The Damaged card active period is the number of days after which a
+    # "Damaged" card request will be processed. This value is configured at
+    # ColCo level.
+    #     * If a card is reported as damaged at 10pm local time on 1st Nov and
+    # the damaged card period is set to 10 days, then the block request will be
+    # submitted to the Shell Card Platform on 11th Nov 00-01 local time.
+    #     * If during the damage card active period another request is made to
+    # set the card to Temporarily Blocked or Blocked permanently (cancelled),
+    # then the damaged card request will be marked as superseded and the new
+    # Temporary Block or Block (cancelled) will be processed.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [UpdateCardStatusRequest] body Optional parameter: Update status
+    # request body
+    # @return [UpdateCardStatusResponse] response from the API call
+    def card_update_status(request_id,
+                           body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/updatestatus',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(UpdateCardStatusResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API will allow querying the purchase categories of Card
+    #  for the given country and/or card type.
+    #   It will also include the below data associated with each of the purchase
+    # categories on it’s response.
+    #   *  List of fuel and non-fuel product sets associated.
+    #   *  List of products configured in each product set
+    # @param [String] apikey Required parameter: This is the API key of the
+    # specific environment which needs to be passed by the client.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [PurchaseCategoryRequest] body Optional parameter: PurchaseCategory
+    # request body
+    # @return [PurchaseCategoryResponse] response from the API call
+    def purchase_category(apikey,
+                          request_id,
+                          body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/fleetmanagement/v1/master/purchasecategory',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(apikey, key: 'apikey'))
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BasicAuth')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PurchaseCategoryResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request  due to'\
+                                 ' something that is perceived to be a client\r\n error (e.g.,'\
+                                 ' malformed request syntax, invalid \r\n request message framing,'\
+                                 ' or deceptive request routing).",
+                                DefaultErrorException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                DefaultErrorException)
+                   .local_error('403',
+                                "The server understood the request but refuses to authorize it.'\
+                                 '\r\n",
+                                ErrorUserAccessError1Exception)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                DefaultErrorException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition the prevented it'\
+                                 ' from fulfilling the request.\r\n",
+                                DefaultErrorException))
+        .execute
+    end
+
+    # This API allows to fetch details of a single fuel card from the Shell Card
+    # Platform. If a **CardId** request parameter is provided, this will return
+    # a single card.  If a **PAN** request parameter is provided, this may
+    # result in multiple fuel cards matching the search criteria. The card
+    # details of the most recently issued card will be returned.
+    #   #### Supported operations
+    #   * Get card by card id or PAN
+    # @param [String] apikey Required parameter: This is the API key of the
+    # specific environment which needs to be passed by the client.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [CardDetailsRequest] body Optional parameter: Card details request
+    # body
+    # @return [CardDetailsResponse] response from the API call
+    def card_details(apikey,
+                     request_id,
+                     body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/fleetmanagement/v1/card/card',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(apikey, key: 'apikey'))
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BasicAuth')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(CardDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request  due to'\
+                                 ' something that is perceived to be a client\r\n error (e.g.,'\
+                                 ' malformed request syntax, invalid \r\n request message framing,'\
+                                 ' or deceptive request routing).",
+                                DefaultErrorException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                DefaultErrorException)
+                   .local_error('403',
+                                "The server understood the request but refuses to authorize it.'\
+                                 '\r\n",
+                                ErrorUserAccessError1Exception)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                DefaultErrorException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition the prevented it'\
+                                 ' from fulfilling the request.\r\n",
+                                DefaultErrorException))
+        .execute
+    end
+
+    # This API allows to move one or more fuel cards (up to 500) across card
+    # groups within a single account or across accounts under the same payer. If
+    # the API call succeeds, the API will return a reference number and queue
+    # the request for asynchronous processing.
+    # #### Supported operations
+    #   * Moving card to exisitng card group
+    #   * Moving card to new card group
+    #   * Removing a card from a card group
+    # #### Validation rules
+    #   * Number of cards per request does not exceed 500
+    #   * Given **PAN** for a card matches with only one card
+    #   * A card is allowed to be moved to the **TargetCardGroupId** or
+    # **TargetAccountNumber**
+    #   * A pending move request does not exist in the queue for a card
+    # submitted on the same date (customers local)
+    #   * A card has not been moved as part of a previous request on the same
+    # date (customers local)
+    # #### API response
+    #   * A main reference number for the API request
+    # (**MoveCardRequestReference**)
+    #   * Individual reference numbers (**MoveCardReference**) for each card
+    # move request that passes validation
+    #   * A list of cards (**ErrorCards**) that failed validation along with the
+    # appropriate error code and message
+    # #### Asynchronous processing of valid API request
+    #   * Move card requests that have been submitted and processed will be
+    # reflected after midnight according to the customers local date
+    # @param [String] apikey Required parameter: This is the API key of the
+    # specific environment which needs to be passed by the client.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [CardMoveRequest] body Optional parameter: Move cards request
+    # body.
+    # @return [CardMoveResponse] response from the API call
+    def card_move(apikey,
+                  request_id,
+                  body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/fleetmanagement/v1/card/move',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(apikey, key: 'apikey'))
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BasicAuth')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(CardMoveResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request  due to'\
+                                 ' something that is perceived to be a client\r\n error (e.g.,'\
+                                 ' malformed request syntax, invalid \r\n request message framing,'\
+                                 ' or deceptive request routing).",
+                                DefaultErrorException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                DefaultErrorException)
+                   .local_error('403',
+                                "The server understood the request but refuses to authorize it.'\
+                                 '\r\n",
+                                ErrorUserAccessError1Exception)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                DefaultErrorException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition the prevented it'\
+                                 ' from fulfilling the request.\r\n",
+                                DefaultErrorException))
+        .execute
+    end
+
+    # This API allows requesting a PIN reminder for a fuel card. If the API call
+    # succeeds, the API will return a reference number and queue the request for
+    # asynchronous processing.
+    # #### New version updates
+    #   * Oauth authentication to access the API
+    #   * Change in request body where PIN delivery type can be requested via
+    # Email, SMS or Post. PIN delivery contact can be set to different values
+    # based on previous contact details of card or pin delivery or can set
+    # specific contact details for this request.
+    #     * PINAdviceType
+    #     * PINContactType
+    #     * PINDeliverTo
+    #   * Please note that we have a **savePINReminder** parameter in order to
+    # save the contact details for future such requests.
+    #   * Change in response body where Card details are also provided along
+    # with expiry date and PAN details.
+    # #### Supported operations
+    #   * Request a pin reminder by card Id or PAN
+    # #### Validation rules
+    #   * Given **PAN** or **CardId** is active
+    #   * Given **PAN** matches only one active card
+    #   * Requested card has PIN
+    #   * There is no pending PIN Reminder request in the queue awaiting to be
+    # processed for the card
+    #   * A PIN reminder request has not been successfully processed in the last
+    # 48 hours for the card
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [PINReminderRequest] body Optional parameter: PIN reminder request
+    # body
+    # @return [PINReminderResponse] response from the API call
+    def card_pin_reminder(request_id,
+                          body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/pinreminder',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PINReminderResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\r\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\r\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows scheduling Card Block / Unblock requests for one or
+    # multiple cards (up to 500 (configurable)) within a single API call. This
+    # API is used to perform the following Actions:
+    # >
+    #    *  AddOrUpdate (Schedule a new request or update an existing
+    # scheduled request for the overlapping period.
+    #    *  AddAndOverwriteAll (all the existing requests of the given card will
+    # be removed and a new request with the specified FromDate and ToDate will
+    # be added.)
+    #    *  Delete (Deletes the scheduled request for the same From and To date)
+    #    *  DeleteAll (Deletes all the scheduled requests for the given card)
+    # > Requests that passed the below validations are queue:
+    # *  All Mandatory fields are passed in the request.
+    # *  Card is present in the Shell Card Platform. Only one matching card is
+    # available in the cards platform for the given PAN and expiry date for the
+    # requests
+    # *  The scheduled period start date or end date should be later than or
+    # equal to the current date.
+    # > If all validations are passed, the request will be accepted and saved in
+    # the intermediate queue  and the API will return reference numbers for
+    # tracking purpose.
+    # > A background service will execute the block/unblock requests on a daily
+    # basis, based on the scheduled block or unblock date.
+    # 
+    #   *  The newly added block/unblock request will have a status ‘A’ when it
+    # is yet to be moved to the actual queue.
+    #   *  When the request is moved to the actual queue table, the status will
+    # be updated as ‘P’ if the request has a value for ‘ToDate’, else, the
+    # status will be updated as ‘S’ or ‘F’ based on whether the request has been
+    # successfully moved to the actual queue table or if an error is encountered
+    # during processing.
+    # 
+    #   *  When the unblock request is moved to the actual queue table, the
+    # status of the request will be changed from ‘P’ to ‘S’ or ‘F’ based on
+    # whether the request has been successfully moved to the actual queue table
+    # or if an error has occurred during processing.
+    # > If any of the validations fail, the API will return the appropriate
+    # error details in the response.
+    # > The API response will include:
+    #   *  An error entity holding the details of any error encountered.
+    #   * A list of submitted cards along with the individual reference numbers
+    # for each of the request.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [ScheduleCardBlockRequest] body Optional parameter: request body
+    # @return [ScheduleCardBlockResponse] response from the API call
+    def schedule_card_block(request_id,
+                            body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/schedulecardblock',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ScheduleCardBlockResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This API allows to update the reissue indicator of a single card. If the
+    # API call succeeds, the API will return a reference number for tracking
+    # purposes and queue the request for asynchronous processing.
+    # #### Supported operations
+    #   * Update the reissue indicator of a card to enable auto renewal
+    #   * Update the reissue indicator of a card to disable auto renewal
+    # #### Validation rules
+    #   * Card status must be either Active, Temporary Block (Customer),
+    # Temporary Block (Shell) or Pending Renewal, otherwise an error code 9016
+    # is returned
+    # 
+    # #### API response
+    #   * Returns a reference number for the API request
+    # (**AutoRenewReference**)
+    # #### Asynchronous processing of valid API request
+    #   * If the provided card is superseded i.e. a replacement/new card is
+    # already issued, then the latest card's reissue indicator should be updated
+    # in the Shell Card Platform.
+    #   * Providing a **PAN** request paramter may result in multiple fuel cards
+    # being located in the Shell Card Platform. The card details of the most
+    # recently issued card will be considered.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [AutoRenewCardRequest] body Optional parameter: Auto renew request
+    # body
+    # @return [AutoRenewCardResponse] response from the API call
+    def auto_renew(request_id,
+                   body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/autorenew',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(AutoRenewCardResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # This operation allows  update the approval status of Mobile Payment
+    # Registration requests requiring for Fleet Manager approval.
+    # If the approval status is:
+    # *	“Approved” then the request status will be changed to Pending for
+    # processing.
+    # *	“Rejected” then status will be updated to “CI” (Failed) with appropriate
+    # error message.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [UpdateMPayRegStatusRequest] body Optional parameter: Request
+    # body
+    # @return [UpdateMPayRegStatusResponse] response from the API call
+    def update_mobile_payment_registration_status(request_id,
+                                                  body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/card-management/v1/updatemobilepaymentregistrationstatus',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(UpdateMPayRegStatusResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request due to'\
+                                 ' something that is perceived to be a client error (e.g.,'\
+                                 ' malformed request syntax, invalid request message framing, or'\
+                                 ' deceptive request routing).\n",
+                                ErrorObjectException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\n",
+                                ErrorObjectException)
+                   .local_error('403',
+                                'Forbidden',
+                                ErrorObjectException)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\n",
+                                ErrorObjectException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition that  prevented'\
+                                 ' it from fulfilling the request.\n",
+                                ErrorObjectException))
+        .execute
+    end
+
+    # Get a new public key that will be used to encrypt data for selected PIN
+    # process when ordering new Shell Card. This encrypted data is used for
+    # further processing.
+    # @param [String] request_id Required parameter: Mandatory UUID (according
+    # to RFC 4122 standards) for requests and responses. This will be played
+    # back in the response from the request.
+    # @param [TrueClass | FalseClass] fleet Optional parameter: If the public
+    # key will be used a long time for multiple files this parameter will be
+    # true. If the parameter is true then public Key will be valid for 90 days.
+    # If the parameter is false then the key will be valid for one time. default
+    # value will be false.
+    # @return [GeneratePINKeyResponse] response from the API call
+    def get_key(request_id,
+                fleet: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/pin-management/v1/generatepinkeys',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(request_id, key: 'RequestId'))
+                   .query_param(new_parameter(fleet, key: 'fleet'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('BearerToken')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(GeneratePINKeyResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request  due to'\
+                                 ' something that is perceived to be a client\r\n error (e.g.,'\
+                                 ' malformed request syntax, invalid \r\n request message framing,'\
+                                 ' or deceptive request routing).",
+                                DefaultErrorException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                DefaultErrorException)
+                   .local_error('403',
+                                "The server understood the request but refuses to authorize it.'\
+                                 '\r\n",
+                                ErrorUserAccessError1Exception)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                DefaultErrorException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition the prevented it'\
+                                 ' from fulfilling the request.\r\n",
+                                DefaultErrorException))
+        .execute
+    end
+
+    # This API allows users to update the card’s delivery addresses (card
+    # delivery address used for card re-issue and PIN delivery address used when
+    # PIN reminder is requested)
+    # #### Supported operations
+    #   * card delivery address update
+    # @param [String] apikey Required parameter: This is the API key of the
+    # specific environment which needs to be passed by the client.
+    # @param [DeliveryAddressUpdateRequest] body Optional parameter: Delivery
+    # Address Update Request Body
+    # @return [DeliveryAddressUpdateResponse] response from the API call
+    def delivery_address_update(apikey,
+                                body: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/fleetmanagement/v1/card/deliveryaddressupdate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(apikey, key: 'apikey'))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('BasicAuth')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(DeliveryAddressUpdateResponse.method(:from_hash))
+                   .local_error('400',
+                                "The server cannot or will not process the request  due to'\
+                                 ' something that is perceived to be a client\r\n error (e.g.,'\
+                                 ' malformed request syntax, invalid \r\n request message framing,'\
+                                 ' or deceptive request routing).",
+                                DefaultErrorException)
+                   .local_error('401',
+                                "The request has not been applied because it lacks valid '\
+                                 ' authentication credentials for the target resource.\r\n",
+                                DefaultErrorException)
+                   .local_error('403',
+                                "The server understood the request but refuses to authorize it.'\
+                                 '\r\n",
+                                ErrorUserAccessError1Exception)
+                   .local_error('404',
+                                "The origin server did not find a current representation  for'\
+                                 ' the target resource or is not willing to disclose  that one'\
+                                 ' exists.\r\n",
+                                DefaultErrorException)
+                   .local_error('500',
+                                "The server encountered an unexpected condition the prevented it'\
+                                 ' from fulfilling the request.\r\n",
+                                DefaultErrorException))
+        .execute
+    end
+  end
+end