pq-api-matic-sdk 1.0.0

data/lib/pay_quicker_sdk/controllers/client_side_controller.rb

@@ -0,0 +1,237 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # ClientSideController
+  class ClientSideController < BaseController
+    # Generate a token used to reveal [prepaid
+    # card](page:resources/prepaid-cards) information in the form of image data
+    # (base64) or JSON.
+    # @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 [PrepaidCardDataType] format Required parameter: Desired format for
+    # the prepaid card data.
+    # @param [PrepaidCardImageSide] side Optional parameter: Side to specify
+    # when retrieving a prepaid card's image data. *Required if IMAGE format
+    # specified.
+    # @return [PrepaidCardDataTokenResult] Response from the API call.
+    def create_card_data_token(user_token,
+                               destination_token,
+                               format,
+                               side: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/pci',
+                                     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))
+                   .query_param(new_parameter(format, key: 'format')
+                                 .is_required(true))
+                   .query_param(new_parameter(side, key: 'side'))
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardDataTokenResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Return [prepaid card](page:resources/prepaid-cards) data in the form of
+    # image data, text, or both.
+    # @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 [PrepaidCardDataType] format Required parameter: Desired format for
+    # the prepaid card data.
+    # @param [PrepaidCardImageSide] side Optional parameter: Side to specify
+    # when retrieving a prepaid card's image data. *Required if IMAGE format
+    # specified.
+    # @param [RetrieveCardData] body Optional parameter: TODO: type description
+    # here
+    # @return [PrepaidCardDataResult] Response from the API call.
+    def retrieve_card_data(user_token,
+                           destination_token,
+                           format,
+                           side: nil,
+                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/pci',
+                                     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))
+                   .query_param(new_parameter(format, key: 'format')
+                                 .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .query_param(new_parameter(side, key: 'side'))
+                   .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('clientside')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardDataResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve one part of a two-part token required to reveal or set a client
+    # side [prepaid card](page:resources/prepaid-cards) PIN.
+    # @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 [PrepaidCardPinTokenResult] Response from the API call.
+    def create_card_pin_token(user_token,
+                              destination_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/pin',
+                                     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(PrepaidCardPinTokenResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Set a [PIN](#/rest/models/structures/prepaid-card-pin) for a [prepaid
+    # card](page:resources/prepaid-cards), if supported by program.
+    # @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 [UpdateCardPin] body Optional parameter: TODO: type description
+    # here
+    # @return [OperationResult] Response from the API call.
+    def update_card_pin(user_token,
+                        destination_token,
+                        body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/pin',
+                                     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('clientside')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(OperationResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Reveal a [PIN](#/rest/models/structures/prepaid-card-pin) for a [prepaid
+    # card](page:resources/prepaid-cards).
+    # @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 [RetrieveCardPin] body Optional parameter: TODO: type description
+    # here
+    # @return [PrepaidCardPinResult] Response from the API call.
+    def retrieve_card_pin(user_token,
+                          destination_token,
+                          body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/prepaid-cards/{destination-token}/pin',
+                                     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('clientside')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PrepaidCardPinResult.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/compliance_controller.rb

@@ -0,0 +1,77 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # ComplianceController
+  class ComplianceController < BaseController
+    # Retrieve a list of [IDV checks](page:resources/user#list-user-idv-checks)
+    # 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-`.
+    # @return [IdvCheckListResult] Response from the API call.
+    def list_identity_checks(user_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/idv-checks',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-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(IdvCheckListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a list of [IDV
+    # checks](page:resources/user#retrieve-user-idv-check) by IDVC 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 [String] idvc_token Required parameter: Auto-generated unique
+    # identifier representing a user IDV check, prefixed with `idvc-`.
+    # @return [IdvCheckResult] Response from the API call.
+    def retrieve_identity_check(user_token,
+                                idvc_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/idv-checks/{idvc-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(idvc_token, key: 'idvc-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(IdvCheckResult.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/documents_controller.rb

@@ -0,0 +1,233 @@
+# pay_quicker_sdk
+#
+# This file was automatically generated for PayQuicker by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PayQuickerSdk
+  # DocumentsController
+  class DocumentsController < BaseController
+    # Retrieve a list of user [documents](page:resources/documents) 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 [DocumentListResult] Response from the API call.
+    def list_documents(user_token,
+                       page,
+                       page_size,
+                       filter: nil,
+                       sort: nil,
+                       language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/documents',
+                                     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(DocumentListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Upload a user [document](page:resources/documents).
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [CreateOrUpdateDocumentFields] fields Optional parameter: TODO:
+    # type description here
+    # @param [File | UploadIO] upload Optional parameter: Document to be
+    # uploaded
+    # @return [DocumentResult] Response from the API call.
+    def upload_document(user_token,
+                        fields: nil,
+                        upload: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/users/{user-token}/documents',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .multipart_param(new_parameter(StringIO.new(fields.to_json), key: 'fields')
+                                     .default_content_type('application/json'))
+                   .multipart_param(new_parameter(upload, key: 'upload')
+                                     .default_content_type('image/png'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DocumentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Retrieve a single user [document](page:resources/documents) by its
+    # document token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] document_token Required parameter: Auto-generated unique
+    # identifier representing an uploaded document, prefixed with `docu-`.
+    # @return [DocumentResult] Response from the API call.
+    def retrieve_document(user_token,
+                          document_token)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/documents/{document-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(document_token, key: 'document-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(DocumentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Replace the user [documents](page:resources/documents) at the given
+    # document token.
+    # @param [String] user_token Required parameter: Auto-generated unique
+    # identifier representing a user, prefixed with `user-`.
+    # @param [String] document_token Required parameter: Auto-generated unique
+    # identifier representing an uploaded document, prefixed with `docu-`.
+    # @param [CreateOrUpdateDocumentFields] fields Optional parameter: TODO:
+    # type description here
+    # @param [File | UploadIO] upload Optional parameter: Document to be
+    # uploaded
+    # @return [DocumentResult] Response from the API call.
+    def replace_document(user_token,
+                         document_token,
+                         fields: nil,
+                         upload: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/users/{user-token}/documents/{document-token}',
+                                     Server::API)
+                   .template_param(new_parameter(user_token, key: 'user-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(document_token, key: 'document-token')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .multipart_param(new_parameter(StringIO.new(fields.to_json), key: 'fields')
+                                     .default_content_type('application/json'))
+                   .multipart_param(new_parameter(upload, key: 'upload')
+                                     .default_content_type('image/png'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('server')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(DocumentResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+
+    # Returns a list of user documents that the user can provide
+    # @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 [DocumentRequirementsListResult] Response from the API call.
+    def list_user_document_requirements(user_token,
+                                        page,
+                                        page_size,
+                                        filter: nil,
+                                        sort: nil,
+                                        language: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/users/{user-token}/documents/requirements',
+                                     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(DocumentRequirementsListResult.method(:from_hash))
+                    .local_error('400',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('500',
+                                 '',
+                                 ApiErrorResultException)
+                    .local_error('default',
+                                 '',
+                                 ApiErrorResultException))
+        .execute
+    end
+  end
+end