packageruby 1.1.1

data/lib/form3_public_api/controllers/payments_controller.rb

@@ -0,0 +1,1255 @@
+# form3_public_api
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Form3PublicApi
+  # PaymentsController
+  class PaymentsController < BaseController
+    # List Positions
+    # @return [PositionDetailsListResponse] response from the API call
+    def list_positions
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/organisation/positions',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PositionDetailsListResponse.method(:from_hash)))
+        .execute
+    end
+
+    # List payments
+    # @param [String] page_number Optional parameter: Which page to select
+    # @param [Integer] page_size Optional parameter: Number of items to select
+    # @param [String] page_before Optional parameter: Cursor for previous page
+    # (this is a base64-encoded UUID continuation token returned from the
+    # application and should not be manually generated, unless requesting the
+    # last page, where the value should be set to "end").
+    # @param [String] page_after Optional parameter: Cursor for next page (this
+    # is a base64-encoded UUID continuation token returned from the application
+    # and should not be manually generated, unless requesting the first page,
+    # where the value should be set to "start").
+    # @param [Array[UUID | String]] filter_organisation_id Optional parameter:
+    # Filter by organisation id
+    # @param [String] filter_debtor_party_account_number Optional parameter:
+    # Example:
+    # @param [String] filter_debtor_party_account_name Optional parameter:
+    # Example:
+    # @param [String] filter_debtor_party_bank_id Optional parameter: Example:
+    # @param [String] filter_beneficiary_party_account_number Optional
+    # parameter: Example:
+    # @param [String] filter_beneficiary_party_account_name Optional parameter:
+    # Example:
+    # @param [String] filter_beneficiary_party_bank_id Optional parameter:
+    # Example:
+    # @param [String] filter_currency Optional parameter: Example:
+    # @param [String] filter_end_to_end_reference Optional parameter: Example:
+    # @param [String] filter_return_unique_scheme_id Optional parameter:
+    # Example:
+    # @param [String] filter_scheme_transaction_id Optional parameter:
+    # Example:
+    # @param [String] filter_payment_scheme Optional parameter: Example:
+    # @param [String] filter_payment_type Optional parameter: Example:
+    # @param [Date] filter_processing_date_from Optional parameter: Example:
+    # @param [Date] filter_processing_date_to Optional parameter: Example:
+    # @param [String] filter_unique_scheme_id Optional parameter: Example:
+    # @param [String] filter_amount Optional parameter: Example:
+    # @param [String] filter_reference Optional parameter: Example:
+    # @param [String] filter_route Optional parameter: Example:
+    # @param [DateTime] filter_submission_submission_date_from Optional
+    # parameter: Example:
+    # @param [DateTime] filter_submission_submission_date_to Optional parameter:
+    # Example:
+    # @param [String] filter_submission_status Optional parameter: Filter by
+    # submission status
+    # @param [String] filter_submission_scheme_status_code Optional parameter:
+    # Filter by submission scheme status code
+    # @param [DateTime] filter_return_submission_submission_date_from Optional
+    # parameter: Example:
+    # @param [DateTime] filter_return_submission_submission_date_to Optional
+    # parameter: Example:
+    # @param [String] filter_return_submission_status Optional parameter: Filter
+    # by return submission status
+    # @param [DateTime] filter_admission_admission_date_from Optional parameter:
+    # Example:
+    # @param [DateTime] filter_admission_admission_date_to Optional parameter:
+    # Example:
+    # @param [String] filter_admission_status Optional parameter: Filter by
+    # admission status
+    # @param [String] filter_admission_scheme_status_code Optional parameter:
+    # Filter by admission scheme status code
+    # @param [Array[FilterRelationships1Enum]] filter_relationships Optional
+    # parameter: Filter for payments containing all of the requested
+    # relationships
+    # @param [Array[FilterNotRelationships1Enum]] filter_not_relationships
+    # Optional parameter: Filter for payments containing none of the requested
+    # relationships
+    # @return [PaymentDetailsListResponse] response from the API call
+    def list_payments(page_number: nil,
+                      page_size: nil,
+                      page_before: nil,
+                      page_after: nil,
+                      filter_organisation_id: nil,
+                      filter_debtor_party_account_number: nil,
+                      filter_debtor_party_account_name: nil,
+                      filter_debtor_party_bank_id: nil,
+                      filter_beneficiary_party_account_number: nil,
+                      filter_beneficiary_party_account_name: nil,
+                      filter_beneficiary_party_bank_id: nil,
+                      filter_currency: nil,
+                      filter_end_to_end_reference: nil,
+                      filter_return_unique_scheme_id: nil,
+                      filter_scheme_transaction_id: nil,
+                      filter_payment_scheme: nil,
+                      filter_payment_type: nil,
+                      filter_processing_date_from: nil,
+                      filter_processing_date_to: nil,
+                      filter_unique_scheme_id: nil,
+                      filter_amount: nil,
+                      filter_reference: nil,
+                      filter_route: nil,
+                      filter_submission_submission_date_from: nil,
+                      filter_submission_submission_date_to: nil,
+                      filter_submission_status: nil,
+                      filter_submission_scheme_status_code: nil,
+                      filter_return_submission_submission_date_from: nil,
+                      filter_return_submission_submission_date_to: nil,
+                      filter_return_submission_status: nil,
+                      filter_admission_admission_date_from: nil,
+                      filter_admission_admission_date_to: nil,
+                      filter_admission_status: nil,
+                      filter_admission_scheme_status_code: nil,
+                      filter_relationships: nil,
+                      filter_not_relationships: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(page_number, key: 'page[number]'))
+                   .query_param(new_parameter(page_size, key: 'page[size]'))
+                   .query_param(new_parameter(page_before, key: 'page[before]'))
+                   .query_param(new_parameter(page_after, key: 'page[after]'))
+                   .query_param(new_parameter(filter_organisation_id, key: 'filter[organisation_id]'))
+                   .query_param(new_parameter(filter_debtor_party_account_number, key: 'filter[debtor_party.account_number]'))
+                   .query_param(new_parameter(filter_debtor_party_account_name, key: 'filter[debtor_party.account_name]'))
+                   .query_param(new_parameter(filter_debtor_party_bank_id, key: 'filter[debtor_party.bank_id]'))
+                   .query_param(new_parameter(filter_beneficiary_party_account_number, key: 'filter[beneficiary_party.account_number]'))
+                   .query_param(new_parameter(filter_beneficiary_party_account_name, key: 'filter[beneficiary_party.account_name]'))
+                   .query_param(new_parameter(filter_beneficiary_party_bank_id, key: 'filter[beneficiary_party.bank_id]'))
+                   .query_param(new_parameter(filter_currency, key: 'filter[currency]'))
+                   .query_param(new_parameter(filter_end_to_end_reference, key: 'filter[end_to_end_reference]'))
+                   .query_param(new_parameter(filter_return_unique_scheme_id, key: 'filter[return.unique_scheme_id]'))
+                   .query_param(new_parameter(filter_scheme_transaction_id, key: 'filter[scheme_transaction_id]'))
+                   .query_param(new_parameter(filter_payment_scheme, key: 'filter[payment_scheme]'))
+                   .query_param(new_parameter(filter_payment_type, key: 'filter[payment_type]'))
+                   .query_param(new_parameter(filter_processing_date_from, key: 'filter[processing_date_from]'))
+                   .query_param(new_parameter(filter_processing_date_to, key: 'filter[processing_date_to]'))
+                   .query_param(new_parameter(filter_unique_scheme_id, key: 'filter[unique_scheme_id]'))
+                   .query_param(new_parameter(filter_amount, key: 'filter[amount]'))
+                   .query_param(new_parameter(filter_reference, key: 'filter[reference]'))
+                   .query_param(new_parameter(filter_route, key: 'filter[route]'))
+                   .query_param(new_parameter(filter_submission_submission_date_from, key: 'filter[submission.submission_date_from]'))
+                   .query_param(new_parameter(filter_submission_submission_date_to, key: 'filter[submission.submission_date_to]'))
+                   .query_param(new_parameter(filter_submission_status, key: 'filter[submission.status]'))
+                   .query_param(new_parameter(filter_submission_scheme_status_code, key: 'filter[submission.scheme_status_code]'))
+                   .query_param(new_parameter(filter_return_submission_submission_date_from, key: 'filter[return_submission.submission_date_from]'))
+                   .query_param(new_parameter(filter_return_submission_submission_date_to, key: 'filter[return_submission.submission_date_to]'))
+                   .query_param(new_parameter(filter_return_submission_status, key: 'filter[return_submission.status]'))
+                   .query_param(new_parameter(filter_admission_admission_date_from, key: 'filter[admission.admission_date_from]'))
+                   .query_param(new_parameter(filter_admission_admission_date_to, key: 'filter[admission.admission_date_to]'))
+                   .query_param(new_parameter(filter_admission_status, key: 'filter[admission.status]'))
+                   .query_param(new_parameter(filter_admission_scheme_status_code, key: 'filter[admission.scheme_status_code]'))
+                   .query_param(new_parameter(filter_relationships, key: 'filter[relationships]'))
+                   .query_param(new_parameter(filter_not_relationships, key: 'filter[not_relationships]'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentDetailsListResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create payment
+    # @param [PaymentCreation] payment_creation_request Optional parameter:
+    # Example:
+    # @return [PaymentCreationResponse] response from the API call
+    def create_payment(payment_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(payment_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Payment creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch payment
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @return [PaymentDetailsResponse] response from the API call
+    def fetch_payment(id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [PaymentAdmissionDetailsResponse] response from the API call
+    def fetch_admission(id,
+                        admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # List tasks
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [PaymentAdmissionTaskListResponse] response from the API call
+    def list_tasks(id,
+                   admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/admissions/{admissionId}/tasks',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentAdmissionTaskListResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Get Payment Admission Task By ID
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @param [UUID | String] task_id Required parameter: Payment Admission Task
+    # Id
+    # @return [PaymentAdmissionTaskDetailsResponse] response from the API call
+    def get_payment_admission_task_by_id(id,
+                                         admission_id,
+                                         task_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/admissions/{admissionId}/tasks/{taskId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(task_id, key: 'taskId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentAdmissionTaskDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Patch Payment Admission Task
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @param [UUID | String] task_id Required parameter: Payment Admission Task
+    # Id
+    # @param [PaymentAdmissionTaskAmendment]
+    # payment_admission_task_patch_request Optional parameter: Example:
+    # @return [PaymentAdmissionTaskDetailsResponse] response from the API call
+    def patch_payment_admission_task(id,
+                                     admission_id,
+                                     task_id,
+                                     payment_admission_task_patch_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/transaction/payments/{id}/admissions/{admissionId}/tasks/{taskId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(task_id, key: 'taskId')
+                                    .should_encode(true))
+                   .body_param(new_parameter(payment_admission_task_patch_request))
+                   .header_param(new_parameter('application/json; charset=utf-8', key: 'content-type'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentAdmissionTaskDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Error',
+                                ApiErrorException)
+                   .local_error('409',
+                                'Conflict',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Create advice
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [AdviceCreation] advice_creation_request Optional parameter:
+    # Example:
+    # @return [AdviceCreationResponse] response from the API call
+    def create_advice(id,
+                      advice_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/advices',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(advice_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(AdviceCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Advice creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch advice
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] advice_id Required parameter: Advice Id
+    # @return [AdviceDetailsResponse] response from the API call
+    def fetch_advice(id,
+                     advice_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/advices/{adviceId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(advice_id, key: 'adviceId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(AdviceDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # create advice submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] advice_id Required parameter: Advice Id
+    # @param [AdviceSubmissionCreation] advice_submission_creation_request
+    # Optional parameter: Example:
+    # @return [AdviceSubmissionCreationResponse] response from the API call
+    def create_advice_submission(id,
+                                 advice_id,
+                                 advice_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/advices/{adviceId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(advice_id, key: 'adviceId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(advice_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(AdviceSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Advice submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch advice submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] advice_id Required parameter: Advice Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [AdviceSubmissionDetailsResponse] response from the API call
+    def fetch_advice_submission(id,
+                                advice_id,
+                                submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/advices/{adviceId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(advice_id, key: 'adviceId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(AdviceSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create recall
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [RecallCreation] recall_creation_request Optional parameter:
+    # Example:
+    # @return [RecallCreationResponse] response from the API call
+    def create_recall(id,
+                      recall_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/recalls',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(recall_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Recall creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch recall
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @return [RecallDetailsResponse] response from the API call
+    def fetch_recall(id,
+                     recall_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch recall admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [RecallAdmissionDetailsResponse] response from the API call
+    def fetch_recall_admission(id,
+                               recall_id,
+                               admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create recall decision
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [RecallDecisionCreation] recall_decision_creation_request Optional
+    # parameter: Example:
+    # @return [RecallDecisionCreationResponse] response from the API call
+    def create_recall_decision(id,
+                               recall_id,
+                               recall_decision_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/recalls/{recallId}/decisions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(recall_decision_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDecisionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Recall decision creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch recall decision
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] decision_id Required parameter: Decision Id
+    # @return [RecallDecisionDetailsResponse] response from the API call
+    def fetch_recall_decision(id,
+                              recall_id,
+                              decision_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/decisions/{decisionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(decision_id, key: 'decisionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDecisionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch recall decision admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] decision_id Required parameter: Decision Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [RecallDecisionAdmissionDetailsResponse] response from the API call
+    def fetch_recall_decision_admission(id,
+                                        recall_id,
+                                        decision_id,
+                                        admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/decisions/{decisionId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(decision_id, key: 'decisionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDecisionAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # create recall decision submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] decision_id Required parameter: Decision Id
+    # @param [RecallDecisionSubmissionCreation]
+    # recall_decision_submission_creation_request Optional parameter: Example:
+    # @return [RecallDecisionSubmissionCreationResponse] response from the API call
+    def create_recall_decision_submission(id,
+                                          recall_id,
+                                          decision_id,
+                                          recall_decision_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/recalls/{recallId}/decisions/{decisionId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(decision_id, key: 'decisionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(recall_decision_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDecisionSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Recall decision submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch recall decision submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] decision_id Required parameter: Decision Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [RecallDecisionSubmissionDetailsResponse] response from the API call
+    def fetch_recall_decision_submission(id,
+                                         recall_id,
+                                         decision_id,
+                                         submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/decisions/{decisionId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(decision_id, key: 'decisionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallDecisionSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch recall reversal
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @return [RecallReversalDetailsResponse] response from the API call
+    def fetch_recall_reversal(id,
+                              recall_id,
+                              reversal_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/reversals/{reversalId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallReversalDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch recall reversal admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [RecallReversalAdmissionDetailsResponse] response from the API call
+    def fetch_recall_reversal_admission(id,
+                                        recall_id,
+                                        reversal_id,
+                                        admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/reversals/{reversalId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallReversalAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # create recall submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [RecallSubmissionCreation] recall_submission_creation_request
+    # Optional parameter: Example:
+    # @return [RecallSubmissionCreationResponse] response from the API call
+    def create_recall_submission(id,
+                                 recall_id,
+                                 recall_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/recalls/{recallId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(recall_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Recall submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch recall submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] recall_id Required parameter: Recall Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [RecallSubmissionDetailsResponse] response from the API call
+    def fetch_recall_submission(id,
+                                recall_id,
+                                submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/recalls/{recallId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(recall_id, key: 'recallId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(RecallSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create return
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [ReturnCreation] return_creation_request Optional parameter:
+    # Example:
+    # @return [ReturnCreationResponse] response from the API call
+    def create_return(id,
+                      return_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/returns',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Return creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch return
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @return [ReturnDetailsResponse] response from the API call
+    def fetch_return(id,
+                     return_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/returns/{returnId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch return admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [ReturnAdmissionFetchResponse] response from the API call
+    def fetch_return_admission(id,
+                               return_id,
+                               admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/returns/{returnId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnAdmissionFetchResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create return reversal
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [ReturnReversalCreation] return_reversal_creation_request Optional
+    # parameter: Example:
+    # @return [ReturnReversalCreationResponse] response from the API call
+    def create_return_reversal(id,
+                               return_id,
+                               return_reversal_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/returns/{returnId}/reversals',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_reversal_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnReversalCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Reversal creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch return reversal
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @return [ReturnReversalDetailsResponse] response from the API call
+    def fetch_return_reversal(id,
+                              return_id,
+                              reversal_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/returns/{returnId}/reversals/{reversalId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnReversalDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch return reversal admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [ReturnReversalAdmissionDetailsResponse] response from the API call
+    def fetch_return_reversal_admission(id,
+                                        return_id,
+                                        reversal_id,
+                                        admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/returns/{returnId}/reversals/{reversalId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnReversalAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # create return submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [ReturnSubmissionCreation] return_submission_creation_request
+    # Optional parameter: Example:
+    # @return [ReturnSubmissionCreationResponse] response from the API call
+    def create_return_submission(id,
+                                 return_id,
+                                 return_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/returns/{returnId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Return submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch return submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] return_id Required parameter: Return Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [ReturnSubmissionDetailsResponse] response from the API call
+    def fetch_return_submission(id,
+                                return_id,
+                                submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/returns/{returnId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create reversal
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [ReversalCreation] reversal_creation_request Optional parameter:
+    # Example:
+    # @return [ReversalCreationResponse] response from the API call
+    def create_reversal(id,
+                        reversal_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/reversals',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(reversal_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReversalCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Reversal creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch reversal
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @return [ReversalDetailsResponse] response from the API call
+    def fetch_reversal(id,
+                       reversal_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/reversals/{reversalId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReversalDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Fetch reversal admission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @param [UUID | String] admission_id Required parameter: Admission Id
+    # @return [ReversalAdmissionDetailsResponse] response from the API call
+    def fetch_reversal_admission(id,
+                                 reversal_id,
+                                 admission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/reversals/{reversalId}/admissions/{admissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(admission_id, key: 'admissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReversalAdmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Create reversal submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @param [ReversalSubmissionCreation] reversal_submission_creation_request
+    # Optional parameter: Example:
+    # @return [ReversalSubmissionCreationResponse] response from the API call
+    def create_reversal_submission(id,
+                                   reversal_id,
+                                   reversal_submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/reversals/{reversalId}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnc.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(reversal_submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReversalSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Reversal submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch reversal submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] reversal_id Required parameter: Reversal Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [ReversalSubmissionDetailsResponse] response from the API call
+    def fetch_reversal_submission(id,
+                                  reversal_id,
+                                  submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/reversals/{reversalId}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(reversal_id, key: 'reversalId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReversalSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # create submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [PaymentSubmissionCreation] submission_creation_request Optional
+    # parameter: Example:
+    # @return [PaymentSubmissionCreationResponse] response from the API call
+    def create_submission(id,
+                          submission_creation_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/transaction/payments/{id}/submissions',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(submission_creation_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentSubmissionCreationResponse.method(:from_hash))
+                   .local_error('400',
+                                'Submission creation error',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Fetch submission
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @return [PaymentSubmissionDetailsResponse] response from the API call
+    def fetch_submission(id,
+                         submission_id)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/transaction/payments/{id}/submissions/{submissionId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentSubmissionDetailsResponse.method(:from_hash)))
+        .execute
+    end
+
+    # Patch Payment Submission Task
+    # @param [UUID | String] id Required parameter: Payment Id
+    # @param [UUID | String] submission_id Required parameter: Submission Id
+    # @param [UUID | String] task_id Required parameter: Payment Submission Task
+    # Id
+    # @param [PaymentSubmissionTaskAmendment]
+    # payment_submission_task_patch_request Optional parameter: Example:
+    # @return [PaymentSubmissionTaskDetailsResponse] response from the API call
+    def patch_payment_submission_task(id,
+                                      submission_id,
+                                      task_id,
+                                      payment_submission_task_patch_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/transaction/payments/{id}/submissions/{submissionId}/tasks/{taskId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(submission_id, key: 'submissionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(task_id, key: 'taskId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(payment_submission_task_patch_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(PaymentSubmissionTaskDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Error',
+                                ApiErrorException)
+                   .local_error('409',
+                                'Conflict',
+                                ApiErrorException))
+        .execute
+    end
+
+    # Patch Return Submission Task
+    # @param [UUID | String] payment_id Required parameter: Payment ID
+    # @param [UUID | String] return_id Required parameter: Return ID
+    # @param [UUID | String] return_submission_id Required parameter: Return
+    # Submission ID
+    # @param [UUID | String] task_id Required parameter: Return Submission Task
+    # Id
+    # @param [ReturnSubmissionTaskAmendment]
+    # return_submission_task_patch_request Optional parameter: Example:
+    # @return [ReturnSubmissionTaskDetailsResponse] response from the API call
+    def patch_return_submission_task(payment_id,
+                                     return_id,
+                                     return_submission_id,
+                                     task_id,
+                                     return_submission_task_patch_request: nil)
+      new_api_call_builder
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/transaction/payments/{paymentId}/returns/{returnId}/submissions/{returnSubmissionId}/tasks/{taskId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_id, key: 'paymentId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_id, key: 'returnId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(return_submission_id, key: 'returnSubmissionId')
+                                    .should_encode(true))
+                   .template_param(new_parameter(task_id, key: 'taskId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/vnd.api+json', key: 'Content-Type'))
+                   .body_param(new_parameter(return_submission_task_patch_request))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('OAuth2')))
+        .response(new_response_handler
+                   .deserializer(APIHelper.method(:custom_type_deserializer))
+                   .deserialize_into(ReturnSubmissionTaskDetailsResponse.method(:from_hash))
+                   .local_error('400',
+                                'Error',
+                                ApiErrorException)
+                   .local_error('409',
+                                'Conflict',
+                                ApiErrorException))
+        .execute
+    end
+  end
+end