pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/controllers/jobs_controller.rb

@@ -0,0 +1,154 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # JobsController
+  class JobsController < BaseController
+    # Retrieve a list of [jobs](page:resources/jobs) that supports filtering,
+    # sorting, and pagination through existing mechanisms.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [PaymentJobListResult] Response from the API call.
+    def list_payment_jobs(page,
+                          page_size,
+                          filter: nil,
+                          sort: nil,
+                          language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/jobs',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentJobListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a [payment](page:resources/jobs).
+    # @param [GatewayPaymentJob | PortalPaymentJob | nil] body Optional
+    # parameter: TODO: type description here
+    # @return [PaymentJobResult] Response from the API call.
+    def create_payment_job(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/jobs',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .validator(proc do |value|
+                                  UnionTypeLookUp.get(:PaymentJob)
+                                                 .validate(value)
+                                end))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(APIHelper.method(:json_serialize))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentJobResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single payment [job](page:resources/jobs).
+    # @param [String] job_token Required parameter: Auto-generated unique
+    # identifier representing a job, prefixed with `jobs-`.
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [PaymentJobResult] Response from the API call.
+    def retrieve_payment_job(job_token,
+                             filter: nil,
+                             language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/jobs/{job-token}',
+                                     Server::API)
+                   .template_param(new_parameter(job_token, key: 'job-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentJobResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Cancel an submitted payment [job](page:resources/jobs).
+    # @param [String] job_token Required parameter: Auto-generated unique
+    # identifier representing a job, prefixed with `jobs-`.
+    # @return [PaymentJobResult] Response from the API call.
+    def cancel_payment_job(job_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/payments/jobs/{job-token}',
+                                     Server::API)
+                   .template_param(new_parameter(job_token, key: 'job-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentJobResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/o_auth_authorization_controller.rb

@@ -0,0 +1,43 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # OAuthAuthorizationController
+  class OAuthAuthorizationController < BaseController
+    # Create a new OAuth 2 token.
+    # @param [String] authorization Required parameter: Authorization header in
+    # Basic auth format
+    # @param [String] scope Optional parameter: Requested scopes as a
+    # space-delimited list.
+    # @param [Hash] _field_parameters Additional optional form parameters are
+    # supported by this endpoint.
+    # @return [OAuthToken] Response from the API call.
+    def request_token_server(authorization,
+                             scope: nil,
+                             _field_parameters: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/auth/connect/token',
+                                     Server::API)
+                   .form_param(new_parameter('client_credentials', key: 'grant_type'))
+                   .header_param(new_parameter(authorization, key: 'Authorization')
+                                  .is_required(true))
+                   .form_param(new_parameter(scope, key: 'scope'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .additional_form_params(_field_parameters))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OAuthToken.method(:from_hash))
+                    .local_error('400',
+                                 'OAuth 2 provider returned an error.',
+                                 OAuthProviderException)
+                    .local_error('401',
+                                 'OAuth 2 provider says client authentication failed.',
+                                 OAuthProviderException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/payments_controller.rb

@@ -0,0 +1,217 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # PaymentsController
+  class PaymentsController < BaseController
+    # Retrieve a list of [payments](page:resources/payments) that supports
+    # filtering, sorting, and pagination through existing mechanisms.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [PaymentListResult] Response from the API call.
+    def list_payments(page,
+                      page_size,
+                      filter: nil,
+                      sort: nil,
+                      language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments',
+                                     Server::API)
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Create a [payment](page:resources/payments) quote.
+    # @param [GatewayPaymentQuote | PortalPaymentQuote | nil] body Optional
+    # parameter: TODO: type description here
+    # @return [PaymentResult] Response from the API call.
+    def create_payment_quote(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments',
+                                     Server::API)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .validator(proc do |value|
+                                  UnionTypeLookUp.get(:PaymentQuote)
+                                                 .validate(value)
+                                end))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(APIHelper.method(:json_serialize))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single [payment](page:resources/payments).
+    # @param [String] payment_token Required parameter: Auto-generated unique
+    # identifier representing an individual payment transaction and quote,
+    # prefixed with `pmnt-`.
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [PaymentResult] Response from the API call.
+    def retrieve_payment(payment_token,
+                         filter: nil,
+                         language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/{payment-token}',
+                                     Server::API)
+                   .template_param(new_parameter(payment_token, key: 'payment-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Accept an open [payment](page:resources/payments) quote.
+    # @param [String] payment_token Required parameter: Auto-generated unique
+    # identifier representing an individual payment transaction and quote,
+    # prefixed with `pmnt-`.
+    # @return [PaymentResult] Response from the API call.
+    def accept_payment_quote(payment_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{payment-token}',
+                                     Server::API)
+                   .template_param(new_parameter(payment_token, key: 'payment-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Cancel an open [payment](page:resources/payments) quote.
+    # @param [String] payment_token Required parameter: Auto-generated unique
+    # identifier representing an individual payment transaction and quote,
+    # prefixed with `pmnt-`.
+    # @return [PaymentResult] Response from the API call.
+    def cancel_payment_quote(payment_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/payments/{payment-token}',
+                                     Server::API)
+                   .template_param(new_parameter(payment_token, key: 'payment-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Perform a [payment](page:resources/payments) retraction for the full
+    # payment amount.
+    # @param [String] payment_token Required parameter: Auto-generated unique
+    # identifier representing an individual payment transaction and quote,
+    # prefixed with `pmnt-`.
+    # @return [PaymentResult] Response from the API call.
+    def retract_payment(payment_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/payments/{payment-token}/retract',
+                                     Server::API)
+                   .template_param(new_parameter(payment_token, key: 'payment-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end

data/lib/pay_quicker_sdk/controllers/prepaid_cards_controller.rb

@@ -0,0 +1,262 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # PrepaidCardsController
+  class PrepaidCardsController < BaseController
+    # Retrieve a list of [prepaid cards](page:resources/prepaid-cards) by user
+    # token that supports filtering, sorting, and pagination through existing
+    # mechanisms.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [Integer] page Required parameter: Page number of specific page to
+    # return
+    # @param [Integer] page_size Required parameter: Number of items to be
+    # displayed per page
+    # @param [String] filter Optional parameter: Filter request results by
+    # specific criteria.
+    # @param [String] sort Optional parameter: Sort request results by specific
+    # attribute.
+    # @param [Languages] language Optional parameter: Filter results by language
+    # type.
+    # @return [PrepaidCardListResult] Response from the API call.
+    def list_prepaid_cards(user_token,
+                           page,
+                           page_size,
+                           filter: nil,
+                           sort: nil,
+                           language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(page, key: 'page')
+                                 .is_required(true))
+                   .query_param(new_parameter(page_size, key: 'pageSize')
+                                 .is_required(true))
+                   .query_param(new_parameter(filter, key: 'filter'))
+                   .query_param(new_parameter(sort, key: 'sort'))
+                   .query_param(new_parameter(language, key: 'language'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Order a [prepaid card](page:resources/prepaid-cards) for the user by
+    # specifying a cardPackage.
+    # Assign a prepaid card to a user when a program token and card reference
+    # number are supplied.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [OrderPrepaidCard] body Optional parameter: TODO: type description
+    # here
+    # @return [PrepaidCardResult] Response from the API call.
+    def order_prepaid_card(user_token,
+                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/prepaid-cards',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Replace a [prepaid card](page:resources/prepaid-cards) by destination
+    # token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [ReplacePrepaidCard] body Optional parameter: TODO: type
+    # description here
+    # @return [PrepaidCardResult] Response from the API call.
+    def replace_prepaid_card(user_token,
+                             destination_token,
+                             body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve [prepaid card](page:resources/prepaid-cards) details by
+    # destination token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @return [PrepaidCardResult] Response from the API call.
+    def retrieve_prepaid_card(user_token,
+                              destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Partial [prepaid card](page:resources/prepaid-cards) update.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @param [UpdatePrepaidCard] body Optional parameter: TODO: type description
+    # here
+    # @return [PrepaidCardResult] Response from the API call.
+    def update_prepaid_card(user_token,
+                            destination_token,
+                            body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # TODO
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] destination_token Required parameter: Auto-generated
+    # unique identifier representing a transfer destination, including prepaid
+    # cards, bank accounts, paper checks, and other users, prefixed with
+    # `dest-`.
+    # @return [AuthorizationListResult] Response from the API call.
+    def list_card_authorizations(user_token,
+                                 destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/authorizations',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(destination_token, key: 'destination-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AuthorizationListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end