apimatic-greendot-sdk 0.0.1

data/lib/gd_bos_v1/apis/account_api.rb

@@ -0,0 +1,2009 @@
+# gd_bos_v1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module GdBosV1
+  # AccountApi
+  class AccountApi < BaseApi
+    # This endpoint allows the retrieval of detailed information about a
+    # specific account. If the GET request is successful, the following response
+    # message will be returned along with a 200 HTTP status code.
+    # Note:UpgradeKycStateData will be return when customer upgrade their
+    # account to DDA
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] extend Optional parameter: Optional. Set to
+    # "privatePaymentInstrumentData" to include sensitive payment instrument
+    # data.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_account(x_gd_request_id,
+                    program_code,
+                    account_identifier,
+                    extend: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(extend, key: 'extend'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAccountResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAccountResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAccountResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAccountResponseErrorException))
+        .execute
+    end
+
+    # This endpoint can be used to assign account identifiers to customer
+    # accounts or to opt in or out of any terms or agreements that were agreed
+    # to or declined during enrollment
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [UpdateTermsAcceptancesEncryptedRequest] body Optional parameter:
+    # Encrypted request to update terms acceptances. See
+    # Gd.Bos.DataTransfer.Request.UpdateTermsAcceptancesEncryptedRequest for
+    # required fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_account(x_gd_request_id,
+                       program_code,
+                       account_identifier,
+                       body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(UpdateTermsAcceptancesResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateTermsAcceptancesResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateTermsAcceptancesResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateTermsAcceptancesResponseErrorException))
+        .execute
+    end
+
+    # Retrieves account information for display in showcase scenarios. Used for
+    # limited or demo account views.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_account_for_showcase(x_gd_request_id,
+                                 program_code,
+                                 account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/getAccountForShowcase',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetAccountForShowcaseResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAccountForShowcaseResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAccountForShowcaseResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAccountForShowcaseResponseErrorException))
+        .execute
+    end
+
+    # Retrieves detailed information about accounts linked to the specified
+    # account. Optionally includes sensitive payment instrument data and
+    # additional details.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] extend Optional parameter: Optional. Set to
+    # "privatePaymentInstrumentData" to include sensitive payment instrument
+    # data.
+    # @param [TrueClass | FalseClass] include_details Optional parameter: If
+    # true, includes detailed linked account information.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_linked_accounts_info(x_gd_request_id,
+                                 program_code,
+                                 account_identifier,
+                                 extend: nil,
+                                 include_details: false)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/getLinkedAccountsInfo',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(extend, key: 'extend'))
+                   .query_param(new_parameter(include_details, key: 'includeDetails'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetLinkedAccountsInfoResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetLinkedAccountsInfoResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetLinkedAccountsInfoResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetLinkedAccountsInfoResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows the retrieval of a PDF statement for an account and
+    # for a given period. The PDF will be base64 coded and it will return the
+    # transaction details on all transaction types.
+    #  If the GET request is successful, the following response message will be
+    # returned along with a 200 HTTP status code
+    # Programs configured for the Interest Rate feature only:
+    # - The following changes will be made to the eStatement interest details
+    # section:
+    # 	- Interest Paid this Period changed to Interest Earned this Period
+    # 	- Interest Paid Year to Date – Will reflect the posted YTD interest total
+    # amount
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] statement_period Required parameter: Statement period
+    # (e.g., "2024-01").
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [TrueClass | FalseClass] is_cbl Optional parameter: Indicates if
+    # the statement is for a CBL account.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_e_statement(x_gd_request_id,
+                        statement_period,
+                        program_code,
+                        account_identifier,
+                        is_cbl: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/statements/{statementPeriod}',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(statement_period, key: 'statementPeriod')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .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))
+                   .query_param(new_parameter(is_cbl, key: 'isCbl'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetEStatementResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetEStatementResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetEStatementResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetEStatementResponseErrorException))
+        .execute
+    end
+
+    # Structure of API Call: GET
+    # /programs/{programCode}/accounts/{accountIdentifier}/statements
+    # - List Available Statements for an Account This endpoint allows a list of
+    # available statements to be retrieved
+    #  If the GET request is successful, the following response message will be
+    # returned along with a 200 HTTP status code.
+    #  Note: If a statement is not available, and the accountIdentifier exists,
+    # then an empty list will be returned along with the 200 HTTP status code.
+    # If the accountIdentifier does not exist, a 404 HTTP status code will be
+    # returned.
+    #  **eStatements List**
+    #  All available eStatements will be included in the accountholder’s online
+    # Statements list. The Statements list may become long over time, so it is
+    # recommended that Partners:
+    # - Limit the list to 2 years or less
+    # - Implement a hide/unhide tab for accountholders to view eStatements older
+    # than 2 years
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [TrueClass | FalseClass] is_cbl Optional parameter: Indicates if
+    # the statement is for a CBL account.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_list_e_statement(x_gd_request_id,
+                             program_code,
+                             account_identifier,
+                             is_cbl: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/statements',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(is_cbl, key: 'isCbl'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetListEStatementResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetListEStatementResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetListEStatementResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetListEStatementResponseErrorException))
+        .execute
+    end
+
+    # Searches for accounts based on encrypted search criteria. Requires a valid
+    # program code and search details in the request body. Returns a list of
+    # accounts matching the search parameters.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [EncryptedData] body Optional parameter: The encrypted search
+    # criteria for the account. See
+    # Gd.Bos.DataTransfer.Request.SearchAccountRequestUnEncrypted for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def search_account(x_gd_request_id,
+                       program_code,
+                       body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/accounts/search',
+                                     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))
+                   .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(SearchAccountResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 SearchAccountResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 SearchAccountResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 SearchAccountResponseErrorException))
+        .execute
+    end
+
+    # This endpoint provides the ability to close accounts without the
+    # assistance of the Green Dot Care team.
+    # - Close an Account
+    # - To set an account to restricted customer initiated spend down:
+    # 	- Submit a request to close the account by calling PUT
+    # /programs/{programCode}/accounts/{accountIdentifier}/close
+    # 	- Once the request is processed by the system, the partner will receive a
+    # response containing the following account status information:
+    # 		- The account status will be changed to restricted
+    # 		- The account status reason will be customerInitiatedSpendDown
+    # 		- There will not be a kycPendingGate (cure) (i.e. kycPendingGate: none)
+    # 	- All funds currently in the spend purses will be moved back to the
+    # primary purse automatically.
+    # 		- Note: For an account to be closed, it must be set to a restricted
+    # customer initiated spend down state.
+    # 	- The current status of the account must be normal.
+    # 	- An account with a negative balance cannot be closed using the API
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [CloseAccountRequest] body Optional parameter: Request to close the
+    # account. The reason must be 'customerInitiatedSpendDown'.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def close_account(x_gd_request_id,
+                      program_code,
+                      account_identifier,
+                      body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/close',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(CloseAccountResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 CloseAccountResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 CloseAccountResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 CloseAccountResponseErrorException))
+        .execute
+    end
+
+    # Structure of API Call: PUT
+    # /programs/{programCode}/accounts/{accountIdentifier}/status
+    # - Update account status and status reason
+    #  This endpoint allows Partners to update account statuses, account status
+    # reasons, and cures under certain conditions. When a valid request is
+    # submitted and completed successfully, the updated status, status reason,
+    # and kycPendingGate will be returned in GET /accounts/{accountIdentifier}
+    # and GET /enrollments/accounts/{accountIdentifier} responses. An Account
+    # Updated Webhook will also be published.
+    #  Note: This endpoint can only be used if the Partner is configured to
+    # change statuses.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [SetPartnerAccountStatusRequest] body Optional parameter: Request
+    # to update account status and reason. See
+    # Gd.Bos.DataTransfer.Request.SetPartnerAccountStatusRequest for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def set_partner_account_status(x_gd_request_id,
+                                   program_code,
+                                   account_identifier,
+                                   body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/status',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(SetPartnerAccountStatusResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 SetPartnerAccountStatusResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 SetPartnerAccountStatusResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 SetPartnerAccountStatusResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows the retrieval of the users’ profile information,
+    # associated with a specific account.
+    # Request Parameters
+    # - Retrieve profile information for all associated users See Structure of
+    # API Calls for details.
+    #  Response Message
+    # - If the GET request is successful, the following response message will be
+    # returned along with a 200 HTTP status code.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_users(x_gd_request_id,
+                  program_code,
+                  account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetUsersResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetUsersResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetUsersResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetUsersResponseErrorException))
+        .execute
+    end
+
+    # Structure of API Call: PUT
+    # /programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier
+    # }
+    # - Updates Select Properties of a User
+    #  This endpoint gives the partner the ability to update an existing user’s
+    # information.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] user_identifier Required parameter: Unique user identifier
+    # (UID or GUID).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [UpdateUserRequestEncrypted] body Optional parameter: Encrypted
+    # request to update user information. See
+    # Gd.Bos.DataTransfer.Request.UpdateUserRequestEncrypted for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_user_update_user(x_gd_request_id,
+                                account_identifier,
+                                user_identifier,
+                                program_code,
+                                body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier}',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(user_identifier, key: 'userIdentifier')
+                                    .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(UpdateUserResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateUserResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateUserResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateUserResponseErrorException))
+        .execute
+    end
+
+    # Structure of API Call: POST
+    # /accounts/{accountIdentifier}/users/{userIdentifier}/identity
+    #  This endpoint allows an Individual Taxpayer Identification Number (ITIN)
+    # to be added to a customer’s account that originally enrolled using a
+    # Mexican Matricula ID only. This is primarily for U.S. tax purposes.
+    #  ITIN Limits:
+    # - Up to 1 active account with the same ITIN per consumer program is
+    # allowed
+    # - Up to 3 lifetime accounts with the same ITIN per consumer program are
+    # allowed
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] user_identifier Required parameter: Unique user identifier
+    # (UID or GUID).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [UpdateItinResquestEncrypted] body Optional parameter: Encrypted
+    # request to update ITIN. See
+    # Gd.Bos.DataTransfer.Request.UpdateItinResquestEncrypted for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_itin(x_gd_request_id,
+                    account_identifier,
+                    user_identifier,
+                    program_code,
+                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier}/identity',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(user_identifier, key: 'userIdentifier')
+                                    .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(UpdateItinResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateItinResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateItinResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateItinResponseErrorException))
+        .execute
+    end
+
+    # Performs Know Your Customer (KYC) verification for a user on the account.
+    # Requires encrypted KYC details in the request body.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] user_identifier Required parameter: Unique user identifier
+    # (UID or GUID).
+    # @param [String] x_gd_enrollment_request_identifier Optional parameter:
+    # Enrollment request identifier (X-GD-EnrollmentRequestIdentifier header).
+    # @param [FraudKycCureRequest] body Optional parameter: Encrypted KYC
+    # request. See Gd.Bos.DataTransfer.Request.FraudKycCureRequest for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def execute_kyc(x_gd_request_id,
+                    program_code,
+                    account_identifier,
+                    user_identifier,
+                    x_gd_enrollment_request_identifier: nil,
+                    body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier}/kycGates/kyc2',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(user_identifier, key: 'userIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json-patch+json', key: 'Content-Type'))
+                   .header_param(new_parameter(x_gd_enrollment_request_identifier, key: 'X-GD-EnrollmentRequestIdentifier'))
+                   .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(FraudKycCureResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 FraudKycCureResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 FraudKycCureResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 FraudKycCureResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows the retrieval of a list of transfers for an account.
+    #  Note: The maximum number of transfers in a list is 180 per request.
+    #  If the GET request is successful, the following response message will be
+    # returned along with a 200 HTTP status code. Filtering ACH Transfers ACH
+    # transfers can be filtered based on the following ACH Transfer Statuses, so
+    # specific ACH transfers can be viewed by the Partner. If GET /achTransfers
+    # is called and the status provided is one or more of the valid ACH Transfer
+    # Statuses (listed above), then the response will contain the ACH transfers
+    # within the selected (or defaulted) date range that have an ACH Transfer
+    # Status that matches one of the statuses that was provided in the call.
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] start_date Optional parameter: Start date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] end_date Optional parameter: End date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] status Optional parameter: Comma-separated list of ACH
+    # transfer statuses (see ACHTransferStatus enum).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_ach_transfer(program_code,
+                         account_identifier,
+                         x_gd_request_id,
+                         start_date: nil,
+                         end_date: nil,
+                         status: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/ACHTransfers',
+                                     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))
+                   .query_param(new_parameter(start_date, key: 'startDate'))
+                   .query_param(new_parameter(end_date, key: 'endDate'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAchTransfersResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAchTransfersResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAchTransfersResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAchTransfersResponseErrorException))
+        .execute
+    end
+
+    # After a check is submitted and the checkDepositStatus is either pending or
+    # in review, this endpoint forces the customer to either accept or cancel
+    # the check deposit request.
+    # - Accept or Cancel Check Deposit Request
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] transfer_identifier Required parameter: Unique transfer
+    # identifier (UID or GUID).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [UpdateCheckRequest] body Optional parameter: Request to update
+    # check deposit status. See Gd.Bos.DataTransfer.Request.UpdateCheckRequest
+    # for required fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def update_check(x_gd_request_id,
+                     account_identifier,
+                     transfer_identifier,
+                     program_code,
+                     body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PUT,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/{transferIdentifier}/mrdc',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(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(UpdateCheckResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 UpdateCheckResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 UpdateCheckResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 UpdateCheckResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows retrieval of MRDC related transfers, one at a time,
+    # for an account.
+    # - Allows retrieval of MRDC related transfers
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] transfer_identifier Required parameter: Unique transfer
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_mrdc_transfer(x_gd_request_id,
+                          program_code,
+                          account_identifier,
+                          transfer_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/{transferIdentifier}/mrdc',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .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(GetMrdcTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetMrdcTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetMrdcTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetMrdcTransferResponseErrorException))
+        .execute
+    end
+
+    # Get Fund Fulfillment MRDC Transfer
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] transfer_identifier Required parameter: Unique transfer
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_fund_fulfillment_mrdc_transfer(x_gd_request_id,
+                                           program_code,
+                                           account_identifier,
+                                           transfer_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/fundfulfillment/{transferIdentifier}/mrdc',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .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(GetFundFulfillmentMrdcTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetFundFulfillmentMrdcTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetFundFulfillmentMrdcTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetFundFulfillmentMrdcTransferResponseErrorException))
+        .execute
+    end
+
+    # After a check is submitted and the checkDepositStatus is either pending or
+    # in review, this endpoint forces the customer to either accept or cancel
+    # the check deposit request.
+    # - Accept or Cancel Check Deposit Request
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] start_date Optional parameter: Start date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] end_date Optional parameter: End date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] offset Optional parameter: Paging offset for results.
+    # @param [String] limit Optional parameter: Paging limit for results.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_mrdc_transfer_list(x_gd_request_id,
+                               program_code,
+                               account_identifier,
+                               start_date: nil,
+                               end_date: nil,
+                               offset: nil,
+                               limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/mrdc',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(start_date, key: 'startDate'))
+                   .query_param(new_parameter(end_date, key: 'endDate'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetMrdcTransferListResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetMrdcTransferListResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetMrdcTransferListResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetMrdcTransferListResponseErrorException))
+        .execute
+    end
+
+    # Retrieves a paginated list of fund fulfillment MRDC transfers for the
+    # specified account, filtered by date range. Returns transfer details and
+    # status.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] start_date Optional parameter: Start date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] end_date Optional parameter: End date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] offset Optional parameter: Paging offset for results.
+    # @param [String] limit Optional parameter: Paging limit for results.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_fund_fulfillment_mrdc_transfer_list(x_gd_request_id,
+                                                program_code,
+                                                account_identifier,
+                                                start_date: nil,
+                                                end_date: nil,
+                                                offset: nil,
+                                                limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/fundfulfillment/mrdc',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(start_date, key: 'startDate'))
+                   .query_param(new_parameter(end_date, key: 'endDate'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetFundFulfillmentMrdcTransferListResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetFundFulfillmentMrdcTransferListResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetFundFulfillmentMrdcTransferListResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetFundFulfillmentMrdcTransferListResponseErrorException))
+        .execute
+    end
+
+    # Retrieves a full color or grayscale image of a check for a specific MRDC
+    # transfer.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] transfer_identifier Required parameter: Unique transfer
+    # identifier (UID or GUID).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [TrueClass | FalseClass] color_image Optional parameter: If true,
+    # retrieves a full color image of the check.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_check_images(x_gd_request_id,
+                         account_identifier,
+                         transfer_identifier,
+                         program_code,
+                         color_image: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/{transferIdentifier}/mrdc/checkImage',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(x_gd_request_id, key: 'X-GD-RequestId')
+                                  .is_required(true))
+                   .template_param(new_parameter(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(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))
+                   .query_param(new_parameter(color_image, key: 'colorImage'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetCheckImagesResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetCheckImagesResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetCheckImagesResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetCheckImagesResponseErrorException))
+        .execute
+    end
+
+    # Retrieves a list of MRDC (Mobile Remote Deposit Capture) transfers that
+    # are currently on hold for the specified account. Returns transfer details
+    # and status.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_on_hold_transfers(x_gd_request_id,
+                              program_code,
+                              account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/onHold',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetOnHoldTransfersResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetOnHoldTransfersResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetOnHoldTransfersResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetOnHoldTransfersResponseErrorException))
+        .execute
+    end
+
+    # Retrieves details for a specific P2P (peer-to-peer) transfer by transfer
+    # identifier for the given account. Returns transfer status, amount, and
+    # participant information.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] transfer_identifier Required parameter: Unique transfer
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_p2_p_transfer(x_gd_request_id,
+                          program_code,
+                          account_identifier,
+                          transfer_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/{transferIdentifier}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(transfer_identifier, key: 'transferIdentifier')
+                                    .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(GetP2PTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetP2PTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetP2PTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetP2PTransferResponseErrorException))
+        .execute
+    end
+
+    # - Retrieves a list of P2P transfers
+    #  This API is used to retrieve information about P2P requests between two
+    # different account holders within a program. It should be used to retrieve
+    # a list of P2Ps that could still be:
+    # - Accepted by the recipient
+    # - Cancelled by the sender
+    # -  Rejected by the recipient
+    # -  Expired by the system
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] start_date Optional parameter: Start date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] end_date Optional parameter: End date for filtering
+    # transfers (yyyy-MM-dd).
+    # @param [String] transfer_type Optional parameter: Pipe-separated list of
+    # transfer types (see FundTransferType enum).
+    # @param [String] status Optional parameter: Pipe-separated list of transfer
+    # statuses (see FundTransferStatus enum).
+    # @param [TrueClass | FalseClass] is_initiator Optional parameter: If true,
+    # filters transfers where the account is the initiator.
+    # @param [Integer] offset Optional parameter: Paging offset for results.
+    # @param [Integer] limit Optional parameter: Paging limit for results.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_all_p2_p_transfer(x_gd_request_id,
+                              program_code,
+                              account_identifier,
+                              start_date: nil,
+                              end_date: nil,
+                              transfer_type: nil,
+                              status: nil,
+                              is_initiator: nil,
+                              offset: nil,
+                              limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/transfers/p2p',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .query_param(new_parameter(start_date, key: 'startDate'))
+                   .query_param(new_parameter(end_date, key: 'endDate'))
+                   .query_param(new_parameter(transfer_type, key: 'transferType'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .query_param(new_parameter(is_initiator, key: 'isInitiator'))
+                   .query_param(new_parameter(offset, key: 'offset'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('Bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(GetAllP2PTransferResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAllP2PTransferResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAllP2PTransferResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAllP2PTransferResponseErrorException))
+        .execute
+    end
+
+    # Retrieves all external debit or credit cards linked to the specified
+    # account. Returns card details and status for each linked card.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_all_external_cards(x_gd_request_id,
+                               program_code,
+                               account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/externalcards',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetAllExternalCardsResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAllExternalCardsResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAllExternalCardsResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAllExternalCardsResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows a specific external card to be deleted from an
+    # account. Simply call DELETE /externalCards/{cardIdentifier} and include
+    # the accountIdentifier and cardIdentifier
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] card_identifier Required parameter: Unique card identifier
+    # (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def delete_external_card(x_gd_request_id,
+                             program_code,
+                             account_identifier,
+                             card_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::DELETE,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/externalcards/{cardIdentifier}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(card_identifier, key: 'cardIdentifier')
+                                    .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(DeleteExternalCardResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 DeleteExternalCardResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 DeleteExternalCardResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 DeleteExternalCardResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows an account holder to be added to an existing
+    # account.Account must have the ability to be a joint account and not be a
+    # corp account.Account holder must first pass a validation check if
+    # validation check is successful, the account holder will be created and the
+    # request will returned the account holders linked to the account.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [EncryptedAddAccountHolderRequest] body Optional parameter:
+    # Encrypted request to add an account holder. See
+    # Gd.Bos.DataTransfer.Request.EncryptedAddAccountHolderRequest for required
+    # fields.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def add_account_holder(x_gd_request_id,
+                           program_code,
+                           account_identifier,
+                           body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/AccountHolder',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(AddAccountHolderResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 AddAccountHolderResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 AddAccountHolderResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 AddAccountHolderResponseErrorException))
+        .execute
+    end
+
+    # Retrieves all linked accounts for the specified account, including account
+    # link type and status.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_linked_account(x_gd_request_id,
+                           program_code,
+                           account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/getLinkedAccount',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetLinkedAccountResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetLinkedAccountResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetLinkedAccountResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetLinkedAccountResponseErrorException))
+        .execute
+    end
+
+    # Retrieves a Single Sign-On (SSO) token for the specified user on the
+    # account.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] user_identifier Required parameter: Unique user identifier
+    # (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_auth_customer_sso_token(x_gd_request_id,
+                                    program_code,
+                                    account_identifier,
+                                    user_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier}/authCustomerSSOToken',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(user_identifier, key: 'userIdentifier')
+                                    .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(GetAuthCustomerSsoTokenResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAuthCustomerSsoTokenResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAuthCustomerSsoTokenResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAuthCustomerSsoTokenResponseErrorException))
+        .execute
+    end
+
+    # Retrieves the enrollment information for the specified user on the
+    # account.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [String] user_identifier Required parameter: Unique user identifier
+    # (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_auth_customer_enrollment(x_gd_request_id,
+                                     program_code,
+                                     account_identifier,
+                                     user_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/users/{userIdentifier}/getAuthCustomerEnrollment',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(user_identifier, key: 'userIdentifier')
+                                    .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(GetCustomerEnrollmentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetCustomerEnrollmentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetCustomerEnrollmentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetCustomerEnrollmentResponseErrorException))
+        .execute
+    end
+
+    # Performs an overdraft eligibility check for the specified account based on
+    # the inquiry date.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def od_eligibility_check(x_gd_request_id,
+                             program_code,
+                             account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/odEligibilities',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(OdEligibilityCheckResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 OdEligibilityCheckResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 OdEligibilityCheckResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 OdEligibilityCheckResponseErrorException))
+        .execute
+    end
+
+    # - Retrieve an INT-1099 form for a specific year
+    #  This endpoint allows the retrieval of an INT-1099 form for a specific
+    # year. INT-1099 forms are only available for interest-bearing accounts that
+    # earn $10 USD or more in interest per year.
+    #  Note: Contact your Green Dot liaison for assistance with configuration.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [Integer] year Required parameter: Tax year for the document.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_tax_document_no_doc_type(x_gd_request_id,
+                                     program_code,
+                                     account_identifier,
+                                     year)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/taxdocuments/{year}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(year, key: 'year')
+                                    .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(GetDocumentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetDocumentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetDocumentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetDocumentResponseErrorException))
+        .execute
+    end
+
+    # - Retrieve different type form for a specific year
+    # This endpoint allows the retrieval of different type form for a specific
+    # year. Like INT-1099,S-1042 forms,etc.
+    # Note: Contact your Green Dot liaison for assistance with configuration.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [Integer] year Required parameter: Tax year for the document.
+    # @param [Integer] doc_type Required parameter: Document type (see
+    # DocumentRequestType enum).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_tax_document(x_gd_request_id,
+                         program_code,
+                         account_identifier,
+                         year,
+                         doc_type)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/taxdocuments/{docType}/{year}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(year, key: 'year')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(doc_type, key: 'docType')
+                                    .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(GetDocumentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetDocumentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetDocumentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetDocumentResponseErrorException))
+        .execute
+    end
+
+    # - Retrieve an INT-1099 form
+    #  This endpoint allows the retrieval of an INT-1099 form. INT-1099 forms
+    # are only available for interest-bearing accounts that earn $10 USD or more
+    # in interest per year.
+    #  Note: Contact your Green Dot liaison for assistance with configuration.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_list_tax_document_no_doc_type(x_gd_request_id,
+                                          program_code,
+                                          account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/taxdocuments',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetListDocumentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetListDocumentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetListDocumentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetListDocumentResponseErrorException))
+        .execute
+    end
+
+    # - Retrieve tax documents for the account by type
+    #  Note: Contact your Green Dot liaison for assistance with configuration.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @param [Integer] doc_type Required parameter: Document type (see
+    # DocumentRequestType enum).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_list_tax_document(x_gd_request_id,
+                              program_code,
+                              account_identifier,
+                              doc_type)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/taxdocumentsbytype/{docType}',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .template_param(new_parameter(doc_type, key: 'docType')
+                                    .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(GetListDocumentResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetListDocumentResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetListDocumentResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetListDocumentResponseErrorException))
+        .execute
+    end
+
+    # This endpoint allows to retrieve the fee summary of certian account. It
+    # returns the prior month fees and the year-to-date fees in this fee
+    # summary.
+    # **Http Status Codes**
+    #  <table><thead><tr><th>Status Code</th><th>Code</th><th>Sub
+    # Code</th><th>Description</th></tr></thead><tbody><tr><td>200</td><td>0</td
+    # ><td>0</td><td>API operation was
+    # successful.</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized:
+    # authorization prefix none
+    # bearer</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized:
+    # invalid authorization
+    # format</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized:
+    # invalid authorization
+    # token</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized: expired
+    # authorization
+    # token</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized: out of
+    # credential
+    # scopes</td></tr><tr><td>401</td><td></td><td></td><td>Unauthorized:
+    # invalid program
+    # code</td></tr><tr><td>404</td><td>10</td><td>0</td><td>Account Not
+    # Found.</td></tr><tr><td>400</td><td>1000</td><td>0</td><td>The program
+    # code in the API path is
+    # unknown.</td></tr><tr><td>503</td><td>4610</td><td>4611</td><td>PRODUCT_NO
+    # T_SUPPORT_FEE</td></tr></tbody></table>
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_account_fees(x_gd_request_id,
+                         program_code,
+                         account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/feeSummary',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetAccountFeesResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAccountFeesResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAccountFeesResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAccountFeesResponseErrorException))
+        .execute
+    end
+
+    # Retrieves the type of the specified account, such as checking, savings, or
+    # other supported types. Useful for partners to determine account
+    # capabilities.
+    # @param [String] x_gd_request_id Required parameter: Unique request
+    # tracking identifier (X-GD-RequestId header).
+    # @param [String] program_code Required parameter: Partner program code for
+    # the account.
+    # @param [String] account_identifier Required parameter: Unique account
+    # identifier (UID or GUID).
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def get_account_type(x_gd_request_id,
+                         program_code,
+                         account_identifier)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/programs/{programCode}/accounts/{accountIdentifier}/getAccountType',
+                                     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(account_identifier, key: 'accountIdentifier')
+                                    .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(GetAccountTypeResponse.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 APIException)
+                    .local_error('403',
+                                 'Forbidden',
+                                 GetAccountTypeResponseErrorException)
+                    .local_error('500',
+                                 'Internal Server Error',
+                                 GetAccountTypeResponseErrorException)
+                    .local_error('503',
+                                 'Service Unavailable',
+                                 GetAccountTypeResponseErrorException))
+        .execute
+    end
+  end
+end