apimatic-greendot-sdk 0.0.1

data/lib/gd_bos_v1/apis/transfers_api.rb

@@ -0,0 +1,1053 @@
+# gd_bos_v1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module GdBosV1
+  # TransfersApi
+  class TransfersApi < BaseApi
+    # Creates a new ACH Out or ACH Pull transfer to move funds between a Green
+    # Dot account and an external bank account. Supports daily limits for ACH
+    # Out transfers. On success, returns details of the created ACH transfer.
+    # Refer to the API documentation for event types and webhook behavior.
+    # @param [String] program_code Required parameter: The program code
+    # associated with the partner implementation. This identifies the specific
+    # partner or program for which the transfer is being created.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request across multiple components. Must be
+    # provided for each new request.
+    # @param [CreateAchRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.CreateACHRequest object containing details for
+    # the ACH transfer, including source and destination account information,
+    # amount, and transfer type.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_ach_transfer(program_code,
+                            x_gd_request_id,
+                            body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/ach',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateAchResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 CreateAchResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 CreateAchResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 CreateAchResponseErrorException))
+        .execute
+    end
+
+    # Retrieves the expected funding date and time (achDeliveryDate) for ACH
+    # Pull transfers. Requires transfer type, optional schedule date, and
+    # delivery type. Returns the expected funding date for the transfer.
+    # @param [String] program_code Required parameter: The program code
+    # associated with the partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] ach_transfer_type Optional parameter: The ACH transfer
+    # type. "1" for achOut, "2" for achPull.
+    # @param [String] schedule_date Optional parameter: The scheduled date for
+    # the transfer (optional, format: yyyy-MM-dd).
+    # @param [String] ach_delivery_type Optional parameter: The ACH delivery
+    # type. "0"=Default, "1"=Same Day, "2"=Next Day, "3"=Three Business Days.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_ach_delivery_date(program_code,
+                              x_gd_request_id,
+                              ach_transfer_type: nil,
+                              schedule_date: nil,
+                              ach_delivery_type: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/DeliveryDate',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .query_param(new_parameter(ach_transfer_type, key: 'achTransferType'))
+                   .query_param(new_parameter(schedule_date, key: 'scheduleDate'))
+                   .query_param(new_parameter(ach_delivery_type, key: 'achDeliveryType'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAchDeliveryDateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAchDeliveryDateResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAchDeliveryDateResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAchDeliveryDateResponseErrorException))
+        .execute
+    end
+
+    # Creates a new Mobile Remote Deposit Capture (MRDC) transfer and runs check
+    # deposits through a pre-validation process. User must accept the 'Funds
+    # Available Date' or a 'Manual Review'.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [CreateMrdcTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.CreateMrdcTransferRequest containing check
+    # deposit and account details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_mrdc_transfer(program_code,
+                             x_gd_request_id,
+                             body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/mrdc',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateMrdcTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 CreateMrdcTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 CreateMrdcTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 CreateMrdcTransferResponseErrorException))
+        .execute
+    end
+
+    # Checks if the account meets eligibility requirements for submitting a
+    # check via MRDC. Returns any unmet prerequisites required for MRDC check
+    # submission.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [AssessMrdcTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.AssessMrdcTransferRequest containing account
+    # and check details for eligibility assessment.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def assess_mrdc_transfer(program_code,
+                             x_gd_request_id,
+                             body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/assessment/mrdc',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateMrdcAssessmentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 CreateMrdcAssessmentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 CreateMrdcAssessmentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 CreateMrdcAssessmentResponseErrorException))
+        .execute
+    end
+
+    # Modifies the funding date of a specific MRDC transaction. The new date
+    # must be a business day between the current and scheduled funding dates.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] transfer_identifier Required parameter: The unique
+    # identifier for the MRDC transfer to update.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [UpdateFundsAvailableDateRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.UpdateFundsAvailableDateRequest containing the
+    # new funding date.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_mrdc_funds_available_date(x_gd_request_id,
+                                         transfer_identifier,
+                                         program_code,
+                                         body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/transfers/{transferIdentifier}/mrdc/fundingDate',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateFundsAvailableDateResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateFundsAvailableDateResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateFundsAvailableDateResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateFundsAvailableDateResponseErrorException))
+        .execute
+    end
+
+    # Transfers funds from a program funding source to a consumer account. The
+    # transferType differentiates B2C, A2A, or P2P transactions. Returns details
+    # of the created transfer.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] x_gd_call_mode Optional parameter: The call mode for AB
+    # testing or routing (optional).
+    # @param [String] x_gd_max_retry_duration Optional parameter: The maximum
+    # retry duration for the transfer (optional).
+    # @param [TransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.TransferRequest containing transfer details,
+    # including source, target, and transfer type.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def transfer_create_transfer_b2_ca2_a(program_code,
+                                          x_gd_request_id,
+                                          x_gd_call_mode: nil,
+                                          x_gd_max_retry_duration: nil,
+                                          body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+json', key: 'Content-Type'))
+                   .header_param(new_parameter(x_gd_call_mode, key: 'X-GD-CallMode'))
+                   .header_param(new_parameter(x_gd_max_retry_duration, key: 'X-GD-MaxRetryDuration'))
+                   .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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ResponseDetailErrorException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 TransferResponseErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 ResponseDetailErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ResponseDetailErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 TransferResponseErrorException))
+        .execute
+    end
+
+    # Assesses if the required prerequisites are met for various transfer types
+    # (P2P, ACH Out, IFT). Verifies user identity and returns any unmet
+    # requirements.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [AssessTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.AssessTransferRequest containing transfer type
+    # and account details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def assess_transfer(program_code,
+                        x_gd_request_id,
+                        body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/assessment',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AssessTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 AssessTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 AssessTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 AssessTransferResponseErrorException))
+        .execute
+    end
+
+    # Verifies ACH Pull limits, frequency, delivery type, and bank account
+    # verification method for ACH authorization. Returns assessment results and
+    # any unmet requirements.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [AssessAchRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.AssessACHRequest containing ACH transfer
+    # details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def assess_ach_transfer(program_code,
+                            x_gd_request_id,
+                            body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/assessment/ach',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AssessTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 AssessTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 AssessTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 AssessTransferResponseErrorException))
+        .execute
+    end
+
+    # Assesses the prerequisites and eligibility for updating an existing
+    # transfer. Returns assessment results and any unmet requirements.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] transfer_identifier Required parameter: The unique
+    # identifier for the transfer to assess.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [AssessUpdateTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.AssessUpdateTransferRequest containing update
+    # details for the transfer.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def assess_update_transfer(program_code,
+                               transfer_identifier,
+                               x_gd_request_id,
+                               body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/transfers/{transferIdentifier}/assessment',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AssessUpdateTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 AssessUpdateTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 AssessUpdateTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 AssessUpdateTransferResponseErrorException))
+        .execute
+    end
+
+    # Updates an existing transfer, including reversals. Reversals are subject
+    # to account status and balance requirements. Returns updated transfer
+    # details.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] transfer_identifier Required parameter: The unique
+    # identifier for the transfer to update.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [UpdateTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.UpdateTransferRequest containing updated
+    # transfer details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_transfer_update_existing_transfer(program_code,
+                                                 transfer_identifier,
+                                                 x_gd_request_id,
+                                                 body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/transfers/{transferIdentifier}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateTransferResponseErrorException))
+        .execute
+    end
+
+    # This new endpoint allows Partners to wire out transactions and testing in
+    # PIE.
+    # Note: This feature must be explicitly requested and configured on a per
+    # partner basis. Contact your Green Dot Account Liaison for assistance.
+    # How it works: Call POST …/accounts/{accountIdentifier}/wires and include
+    # the following information:
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] account_identifier Required parameter: The unique
+    # identifier for the account from which the wire will be sent.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [WireOutRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.WireOutRequest containing wire transfer
+    # details, including beneficiary and bank information.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_wire_out(program_code,
+                        account_identifier,
+                        x_gd_request_id,
+                        body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/wires',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(WireOutResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 WireOutResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 WireOutResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 WireOutResponseErrorException))
+        .execute
+    end
+
+    # Links one or more external bank accounts to a specified account using ACH.
+    # Requires selected bank account tokens and provider information. Returns
+    # reference IDs for linked accounts.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] account_identifier Required parameter: The unique
+    # identifier for the account to link the external bank account to.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [AchLinkExternalAccountRequest] body Optional parameter: The
+    # M:Gd.Bos.Controllers.TransfersController.AchLinkExternalAccountRequest(Sys
+    # tem.String,System.String,Gd.Bos.DataTransfer.Request.AchLinkExternalAccoun
+    # tRequest,System.String) containing selected external bank accounts and
+    # provider information.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def ach_link_external_account_request(program_code,
+                                          account_identifier,
+                                          x_gd_request_id,
+                                          body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/account/{accountIdentifier}/externalbankaccount',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AchLinkExternalAccountResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 AchLinkExternalAccountResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 AchLinkExternalAccountResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 AchLinkExternalAccountResponseErrorException))
+        .execute
+    end
+
+    # Retrieves transfer details using a guest checkout token. Allows partners
+    # to access transfer information for users without authentication.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] transfer_token Required parameter: The unique token
+    # identifying the transfer for guest checkout.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [GetTransferByTokenRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.GetTransferByTokenRequest containing
+    # additional request details.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_transfer_by_token(program_code,
+                              transfer_token,
+                              x_gd_request_id,
+                              body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/{transferToken}/guestcheckout',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_token, key: 'transferToken')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetTransferByTokenResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetTransferByTokenResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetTransferByTokenResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetTransferByTokenResponseErrorException))
+        .execute
+    end
+
+    # Retrieves the bank name associated with a specific routing number.
+    # Partners can use this to validate or display bank information for
+    # user-entered routing numbers.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] routing_number Optional parameter: The routing number for
+    # which to retrieve the bank name.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_bank_name(x_gd_request_id,
+                      program_code,
+                      routing_number: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/bankNames',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(routing_number, key: 'routingNumber'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetBankNameResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetBankNameResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetBankNameResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetBankNameResponseErrorException))
+        .execute
+    end
+
+    # Checks if a bank, identified by its routing number, is eligible for ACH or
+    # other transfer types. Returns eligibility status and related information.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] routing_number Required parameter: The routing number for
+    # which to check eligibility.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_bank_eligibility(x_gd_request_id,
+                             program_code,
+                             routing_number)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/transfers/routingNumbers/{routingNumber}',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(routing_number, key: 'routingNumber')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetBankEligibilityResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetBankEligibilityResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetBankEligibilityResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetBankEligibilityResponseErrorException))
+        .execute
+    end
+
+    # Get GFT Transfer Fees and Limits
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] transfer_types Optional parameter: The transfer types.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_transfer_limits_and_fee_rates_v2(x_gd_request_id,
+                                             program_code,
+                                             transfer_types: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/transfers/gft/feesandlimits',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(transfer_types, key: 'transferTypes'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetFeesAndLimitsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetFeesAndLimitsResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetFeesAndLimitsResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetFeesAndLimitsResponseErrorException))
+        .execute
+    end
+
+    # Submits a check for Mobile Remote Deposit Capture (MRDC) processing.
+    # Requires check and account details. Returns the result of the check
+    # submission.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [MrdcPartialTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.MrdcPartialTransferRequest containing check
+    # and account details for MRDC submission.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def submit_check(program_code,
+                     x_gd_request_id,
+                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/fundfulfillment/mrdc',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(MrdcPartialTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 MrdcPartialTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 MrdcPartialTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 MrdcPartialTransferResponseErrorException))
+        .execute
+    end
+
+    # Generates a secure link token for connecting an external bank account
+    # using a third-party provider. Returns the generated link token for use in
+    # account linking flows.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] account_identifier Required parameter: The unique
+    # identifier for the account to link.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [ExternalAccountLinkTokenRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.ExternalAccountLinkTokenRequest containing
+    # provider information for token creation.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def create_external_account_link_token(program_code,
+                                           account_identifier,
+                                           x_gd_request_id,
+                                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/account/{accountIdentifier}/token/create',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(ExternalAccountLinkTokenResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 ExternalAccountLinkTokenResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ExternalAccountLinkTokenResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 ExternalAccountLinkTokenResponseErrorException))
+        .execute
+    end
+
+    # Executes a single-commit funds transfer in one step, using encrypted
+    # transfer route details. Returns the created transfer details, including
+    # identifier, status, and related accounts.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation. Identifies the specific program for which the
+    # transfer is being created.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [SingleCommitTransferRequestEncrypted] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.SingleCommitTransferRequestEncrypted
+    # containing all required information for executing a single-commit
+    # transfer, including encrypted transfer route details (source, target, and
+    # transaction amount).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def single_commit(program_code,
+                      x_gd_request_id,
+                      body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/singlecommit',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(TransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 TransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 TransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 TransferResponseErrorException))
+        .execute
+    end
+
+    # TODO: type endpoint description here
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation. Identifies the specific program whose Single
+    # Commit health is being checked.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def single_commit_health_check(program_code,
+                                   x_gd_request_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/transfers/singlecommit/healthcheck',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(SingleCommitHealthCheckResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 SingleCommitHealthCheckResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 SingleCommitHealthCheckResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 SingleCommitHealthCheckResponseErrorException))
+        .execute
+    end
+
+    # Creates a global fund transfer (GFT) from a partner to a user. Supports
+    # B2C, A2A, and partner account transfers. Returns the created transfer
+    # details.
+    # @param [String] program_code Required parameter: The program code for the
+    # partner implementation.
+    # @param [String] x_gd_request_id Required parameter: A unique identifier
+    # (GUID) for tracking the request.
+    # @param [GftTransferRequest] body Optional parameter: The
+    # Gd.Bos.DataTransfer.Request.GFTTransferRequest containing transfer details
+    # for a global fund transfer.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def gft_transfer(program_code,
+                     x_gd_request_id,
+                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/transfers/gft',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(program_code, key: 'programCode')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json-patch+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('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 ResponseDetailErrorException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetTransferResponseErrorException)
+                    .local_error('404',
+                                 'Not Found',
+                                 ResponseDetailErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 ResponseDetailErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetTransferResponseErrorException))
+        .execute
+    end
+  end
+end