=begin
#The Plaid API

#The Plaid REST API. Please see https://plaid.com/docs/api for more details.

The version of the OpenAPI document: 2020-09-14_1.46.1

Generated by: https://openapi-generator.tech
OpenAPI Generator version: 5.1.0

=end

require 'cgi'

module Plaid
  class PlaidApi
    attr_accessor :api_client

    def initialize(api_client = ApiClient.default)
      @api_client = api_client
    end
    # Retrieve real-time balance data
    # The `/accounts/balance/get` endpoint returns the real-time balance for each of an Item's accounts. While other endpoints may return a balance object, only `/accounts/balance/get` forces the available and current balance fields to be refreshed rather than cached. This endpoint can be used for existing Items that were added via any of Plaid’s other products. This endpoint can be used as long as Link has been initialized with any other product, `balance` itself is not a product that can be used to initialize Link.
    # @param accounts_balance_get_request [AccountsBalanceGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AccountsGetResponse]
    def accounts_balance_get(accounts_balance_get_request, opts = {})
      data, _status_code, _headers = accounts_balance_get_with_http_info(accounts_balance_get_request, opts)
      data
    end

    # Retrieve real-time balance data
    # The `/accounts/balance/get` endpoint returns the real-time balance for each of an Item's accounts. While other endpoints may return a balance object, only `/accounts/balance/get` forces the available and current balance fields to be refreshed rather than cached. This endpoint can be used for existing Items that were added via any of Plaid’s other products. This endpoint can be used as long as Link has been initialized with any other product, `balance` itself is not a product that can be used to initialize Link.
    # @param accounts_balance_get_request [AccountsBalanceGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AccountsGetResponse, Integer, Hash)>] AccountsGetResponse data, response status code and response headers
    def accounts_balance_get_with_http_info(accounts_balance_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.accounts_balance_get ...'
      end
      # verify the required parameter 'accounts_balance_get_request' is set
      if @api_client.config.client_side_validation && accounts_balance_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'accounts_balance_get_request' when calling PlaidApi.accounts_balance_get"
      end
      # resource path
      local_var_path = '/accounts/balance/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(accounts_balance_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AccountsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.accounts_balance_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#accounts_balance_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve accounts
    # The `/accounts/get`  endpoint can be used to retrieve information for any linked Item. Note that some information is nullable. Plaid will only return active bank accounts, i.e. accounts that are not closed and are capable of carrying a balance.  This endpoint retrieves cached information, rather than extracting fresh information from the institution. As a result, balances returned may not be up-to-date; for realtime balance information, use `/accounts/balance/get` instead.
    # @param accounts_get_request [AccountsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AccountsGetResponse]
    def accounts_get(accounts_get_request, opts = {})
      data, _status_code, _headers = accounts_get_with_http_info(accounts_get_request, opts)
      data
    end

    # Retrieve accounts
    # The &#x60;/accounts/get&#x60;  endpoint can be used to retrieve information for any linked Item. Note that some information is nullable. Plaid will only return active bank accounts, i.e. accounts that are not closed and are capable of carrying a balance.  This endpoint retrieves cached information, rather than extracting fresh information from the institution. As a result, balances returned may not be up-to-date; for realtime balance information, use &#x60;/accounts/balance/get&#x60; instead.
    # @param accounts_get_request [AccountsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AccountsGetResponse, Integer, Hash)>] AccountsGetResponse data, response status code and response headers
    def accounts_get_with_http_info(accounts_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.accounts_get ...'
      end
      # verify the required parameter 'accounts_get_request' is set
      if @api_client.config.client_side_validation && accounts_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'accounts_get_request' when calling PlaidApi.accounts_get"
      end
      # resource path
      local_var_path = '/accounts/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(accounts_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AccountsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.accounts_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#accounts_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve information about a Plaid application
    # Allows financial institutions to retrieve information about Plaid clients for the purpose of building control-tower experiences
    # @param application_get_request [ApplicationGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ApplicationGetResponse]
    def application_get(application_get_request, opts = {})
      data, _status_code, _headers = application_get_with_http_info(application_get_request, opts)
      data
    end

    # Retrieve information about a Plaid application
    # Allows financial institutions to retrieve information about Plaid clients for the purpose of building control-tower experiences
    # @param application_get_request [ApplicationGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ApplicationGetResponse, Integer, Hash)>] ApplicationGetResponse data, response status code and response headers
    def application_get_with_http_info(application_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.application_get ...'
      end
      # verify the required parameter 'application_get_request' is set
      if @api_client.config.client_side_validation && application_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'application_get_request' when calling PlaidApi.application_get"
      end
      # resource path
      local_var_path = '/application/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(application_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ApplicationGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.application_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#application_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Asset Report Audit Copy
    # Plaid can provide an Audit Copy of any Asset Report directly to a participating third party on your behalf. For example, Plaid can supply an Audit Copy directly to Fannie Mae on your behalf if you participate in the Day 1 Certainty™ program. An Audit Copy contains the same underlying data as the Asset Report.  To grant access to an Audit Copy, use the `/asset_report/audit_copy/create` endpoint to create an `audit_copy_token` and then pass that token to the third party who needs access. Each third party has its own `auditor_id`, for example `fannie_mae`. You’ll need to create a separate Audit Copy for each third party to whom you want to grant access to the Report.
    # @param asset_report_audit_copy_create_request [AssetReportAuditCopyCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportAuditCopyCreateResponse]
    def asset_report_audit_copy_create(asset_report_audit_copy_create_request, opts = {})
      data, _status_code, _headers = asset_report_audit_copy_create_with_http_info(asset_report_audit_copy_create_request, opts)
      data
    end

    # Create Asset Report Audit Copy
    # Plaid can provide an Audit Copy of any Asset Report directly to a participating third party on your behalf. For example, Plaid can supply an Audit Copy directly to Fannie Mae on your behalf if you participate in the Day 1 Certainty™ program. An Audit Copy contains the same underlying data as the Asset Report.  To grant access to an Audit Copy, use the &#x60;/asset_report/audit_copy/create&#x60; endpoint to create an &#x60;audit_copy_token&#x60; and then pass that token to the third party who needs access. Each third party has its own &#x60;auditor_id&#x60;, for example &#x60;fannie_mae&#x60;. You’ll need to create a separate Audit Copy for each third party to whom you want to grant access to the Report.
    # @param asset_report_audit_copy_create_request [AssetReportAuditCopyCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportAuditCopyCreateResponse, Integer, Hash)>] AssetReportAuditCopyCreateResponse data, response status code and response headers
    def asset_report_audit_copy_create_with_http_info(asset_report_audit_copy_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_audit_copy_create ...'
      end
      # verify the required parameter 'asset_report_audit_copy_create_request' is set
      if @api_client.config.client_side_validation && asset_report_audit_copy_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_audit_copy_create_request' when calling PlaidApi.asset_report_audit_copy_create"
      end
      # resource path
      local_var_path = '/asset_report/audit_copy/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_audit_copy_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportAuditCopyCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_audit_copy_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_audit_copy_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve an Asset Report Audit Copy
    # `/asset_report/audit_copy/get` allows auditors to get a copy of an Asset Report that was previously shared via the `/asset_report/audit_copy/create` endpoint.  The caller of `/asset_report/audit_copy/create` must provide the `audit_copy_token` to the auditor.  This token can then be used to call `/asset_report/audit_copy/create`.
    # @param asset_report_audit_copy_get_request [AssetReportAuditCopyGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportGetResponse]
    def asset_report_audit_copy_get(asset_report_audit_copy_get_request, opts = {})
      data, _status_code, _headers = asset_report_audit_copy_get_with_http_info(asset_report_audit_copy_get_request, opts)
      data
    end

    # Retrieve an Asset Report Audit Copy
    # &#x60;/asset_report/audit_copy/get&#x60; allows auditors to get a copy of an Asset Report that was previously shared via the &#x60;/asset_report/audit_copy/create&#x60; endpoint.  The caller of &#x60;/asset_report/audit_copy/create&#x60; must provide the &#x60;audit_copy_token&#x60; to the auditor.  This token can then be used to call &#x60;/asset_report/audit_copy/create&#x60;.
    # @param asset_report_audit_copy_get_request [AssetReportAuditCopyGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportGetResponse, Integer, Hash)>] AssetReportGetResponse data, response status code and response headers
    def asset_report_audit_copy_get_with_http_info(asset_report_audit_copy_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_audit_copy_get ...'
      end
      # verify the required parameter 'asset_report_audit_copy_get_request' is set
      if @api_client.config.client_side_validation && asset_report_audit_copy_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_audit_copy_get_request' when calling PlaidApi.asset_report_audit_copy_get"
      end
      # resource path
      local_var_path = '/asset_report/audit_copy/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_audit_copy_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_audit_copy_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_audit_copy_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Remove Asset Report Audit Copy
    # The `/asset_report/audit_copy/remove` endpoint allows you to remove an Audit Copy. Removing an Audit Copy invalidates the `audit_copy_token` associated with it, meaning both you and any third parties holding the token will no longer be able to use it to access Report data. Items associated with the Asset Report, the Asset Report itself and other Audit Copies of it are not affected and will remain accessible after removing the given Audit Copy.
    # @param asset_report_audit_copy_remove_request [AssetReportAuditCopyRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportAuditCopyRemoveResponse]
    def asset_report_audit_copy_remove(asset_report_audit_copy_remove_request, opts = {})
      data, _status_code, _headers = asset_report_audit_copy_remove_with_http_info(asset_report_audit_copy_remove_request, opts)
      data
    end

    # Remove Asset Report Audit Copy
    # The &#x60;/asset_report/audit_copy/remove&#x60; endpoint allows you to remove an Audit Copy. Removing an Audit Copy invalidates the &#x60;audit_copy_token&#x60; associated with it, meaning both you and any third parties holding the token will no longer be able to use it to access Report data. Items associated with the Asset Report, the Asset Report itself and other Audit Copies of it are not affected and will remain accessible after removing the given Audit Copy.
    # @param asset_report_audit_copy_remove_request [AssetReportAuditCopyRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportAuditCopyRemoveResponse, Integer, Hash)>] AssetReportAuditCopyRemoveResponse data, response status code and response headers
    def asset_report_audit_copy_remove_with_http_info(asset_report_audit_copy_remove_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_audit_copy_remove ...'
      end
      # verify the required parameter 'asset_report_audit_copy_remove_request' is set
      if @api_client.config.client_side_validation && asset_report_audit_copy_remove_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_audit_copy_remove_request' when calling PlaidApi.asset_report_audit_copy_remove"
      end
      # resource path
      local_var_path = '/asset_report/audit_copy/remove'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_audit_copy_remove_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportAuditCopyRemoveResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_audit_copy_remove",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_audit_copy_remove\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create an Asset Report
    # The `/asset_report/create` endpoint initiates the process of creating an Asset Report, which can then be retrieved by passing the `asset_report_token` return value to the `/asset_report/get` or `/asset_report/pdf/get` endpoints.  The Asset Report takes some time to be created and is not available immediately after calling `/asset_report/create`. When the Asset Report is ready to be retrieved using `/asset_report/get` or `/asset_report/pdf/get`, Plaid will fire a `PRODUCT_READY` webhook. For full details of the webhook schema, see [Asset Report webhooks](https://plaid.com/docs/api/webhooks/#Assets-webhooks).  The `/asset_report/create` endpoint creates an Asset Report at a moment in time. Asset Reports are immutable. To get an updated Asset Report, use the `/asset_report/refresh` endpoint.
    # @param asset_report_create_request [AssetReportCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportCreateResponse]
    def asset_report_create(asset_report_create_request, opts = {})
      data, _status_code, _headers = asset_report_create_with_http_info(asset_report_create_request, opts)
      data
    end

    # Create an Asset Report
    # The &#x60;/asset_report/create&#x60; endpoint initiates the process of creating an Asset Report, which can then be retrieved by passing the &#x60;asset_report_token&#x60; return value to the &#x60;/asset_report/get&#x60; or &#x60;/asset_report/pdf/get&#x60; endpoints.  The Asset Report takes some time to be created and is not available immediately after calling &#x60;/asset_report/create&#x60;. When the Asset Report is ready to be retrieved using &#x60;/asset_report/get&#x60; or &#x60;/asset_report/pdf/get&#x60;, Plaid will fire a &#x60;PRODUCT_READY&#x60; webhook. For full details of the webhook schema, see [Asset Report webhooks](https://plaid.com/docs/api/webhooks/#Assets-webhooks).  The &#x60;/asset_report/create&#x60; endpoint creates an Asset Report at a moment in time. Asset Reports are immutable. To get an updated Asset Report, use the &#x60;/asset_report/refresh&#x60; endpoint.
    # @param asset_report_create_request [AssetReportCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportCreateResponse, Integer, Hash)>] AssetReportCreateResponse data, response status code and response headers
    def asset_report_create_with_http_info(asset_report_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_create ...'
      end
      # verify the required parameter 'asset_report_create_request' is set
      if @api_client.config.client_side_validation && asset_report_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_create_request' when calling PlaidApi.asset_report_create"
      end
      # resource path
      local_var_path = '/asset_report/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Filter Asset Report
    # By default, an Asset Report will contain all of the accounts on a given Item. In some cases, you may not want the Asset Report to contain all accounts. For example, you might have the end user choose which accounts are relevant in Link using the Account Select view, which you can enable in the dashboard. Or, you might always exclude certain account types or subtypes, which you can identify by using the `/accounts/get` endpoint. To narrow an Asset Report to only a subset of accounts, use the `/asset_report/filter` endpoint.  To exclude certain Accounts from an Asset Report, first use the `/asset_report/create` endpoint to create the report, then send the `asset_report_token` along with a list of `account_ids` to exclude to the `/asset_report/filter` endpoint, to create a new Asset Report which contains only a subset of the original Asset Report's data.  Because Asset Reports are immutable, calling `/asset_report/filter` does not alter the original Asset Report in any way; rather, `/asset_report/filter` creates a new Asset Report with a new token and id. Asset Reports created via `/asset_report/filter` do not contain new Asset data, and are not billed.  Plaid will fire a [`PRODUCT_READY`](https://plaid.com/docs/api/webhooks) webhook once generation of the filtered Asset Report has completed.
    # @param asset_report_filter_request [AssetReportFilterRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportFilterResponse]
    def asset_report_filter(asset_report_filter_request, opts = {})
      data, _status_code, _headers = asset_report_filter_with_http_info(asset_report_filter_request, opts)
      data
    end

    # Filter Asset Report
    # By default, an Asset Report will contain all of the accounts on a given Item. In some cases, you may not want the Asset Report to contain all accounts. For example, you might have the end user choose which accounts are relevant in Link using the Account Select view, which you can enable in the dashboard. Or, you might always exclude certain account types or subtypes, which you can identify by using the &#x60;/accounts/get&#x60; endpoint. To narrow an Asset Report to only a subset of accounts, use the &#x60;/asset_report/filter&#x60; endpoint.  To exclude certain Accounts from an Asset Report, first use the &#x60;/asset_report/create&#x60; endpoint to create the report, then send the &#x60;asset_report_token&#x60; along with a list of &#x60;account_ids&#x60; to exclude to the &#x60;/asset_report/filter&#x60; endpoint, to create a new Asset Report which contains only a subset of the original Asset Report&#39;s data.  Because Asset Reports are immutable, calling &#x60;/asset_report/filter&#x60; does not alter the original Asset Report in any way; rather, &#x60;/asset_report/filter&#x60; creates a new Asset Report with a new token and id. Asset Reports created via &#x60;/asset_report/filter&#x60; do not contain new Asset data, and are not billed.  Plaid will fire a [&#x60;PRODUCT_READY&#x60;](https://plaid.com/docs/api/webhooks) webhook once generation of the filtered Asset Report has completed.
    # @param asset_report_filter_request [AssetReportFilterRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportFilterResponse, Integer, Hash)>] AssetReportFilterResponse data, response status code and response headers
    def asset_report_filter_with_http_info(asset_report_filter_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_filter ...'
      end
      # verify the required parameter 'asset_report_filter_request' is set
      if @api_client.config.client_side_validation && asset_report_filter_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_filter_request' when calling PlaidApi.asset_report_filter"
      end
      # resource path
      local_var_path = '/asset_report/filter'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_filter_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportFilterResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_filter",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_filter\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve an Asset Report
    # The `/asset_report/get` endpoint retrieves the Asset Report in JSON format. Before calling `/asset_report/get`, you must first create the Asset Report using `/asset_report/create` (or filter an Asset Report using `/asset_report/filter`) and then wait for the [`PRODUCT_READY`](https://plaid.com/docs/api/webhooks) webhook to fire, indicating that the Report is ready to be retrieved.  By default, an Asset Report includes transaction descriptions as returned by the bank, as opposed to parsed and categorized by Plaid. You can also receive cleaned and categorized transactions, as well as additional insights like merchant name or location information. We call this an Asset Report with Insights. An Asset Report with Insights provides transaction category, location, and merchant information in addition to the transaction strings provided in a standard Asset Report.  To retrieve an Asset Report with Insights, call the `/asset_report/get` endpoint with `include_insights` set to `true`.
    # @param asset_report_get_request [AssetReportGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportGetResponse]
    def asset_report_get(asset_report_get_request, opts = {})
      data, _status_code, _headers = asset_report_get_with_http_info(asset_report_get_request, opts)
      data
    end

    # Retrieve an Asset Report
    # The &#x60;/asset_report/get&#x60; endpoint retrieves the Asset Report in JSON format. Before calling &#x60;/asset_report/get&#x60;, you must first create the Asset Report using &#x60;/asset_report/create&#x60; (or filter an Asset Report using &#x60;/asset_report/filter&#x60;) and then wait for the [&#x60;PRODUCT_READY&#x60;](https://plaid.com/docs/api/webhooks) webhook to fire, indicating that the Report is ready to be retrieved.  By default, an Asset Report includes transaction descriptions as returned by the bank, as opposed to parsed and categorized by Plaid. You can also receive cleaned and categorized transactions, as well as additional insights like merchant name or location information. We call this an Asset Report with Insights. An Asset Report with Insights provides transaction category, location, and merchant information in addition to the transaction strings provided in a standard Asset Report.  To retrieve an Asset Report with Insights, call the &#x60;/asset_report/get&#x60; endpoint with &#x60;include_insights&#x60; set to &#x60;true&#x60;.
    # @param asset_report_get_request [AssetReportGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportGetResponse, Integer, Hash)>] AssetReportGetResponse data, response status code and response headers
    def asset_report_get_with_http_info(asset_report_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_get ...'
      end
      # verify the required parameter 'asset_report_get_request' is set
      if @api_client.config.client_side_validation && asset_report_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_get_request' when calling PlaidApi.asset_report_get"
      end
      # resource path
      local_var_path = '/asset_report/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a PDF Asset Report
    # The `/asset_report/pdf/get` endpoint retrieves the Asset Report in PDF format. Before calling `/asset_report/pdf/get`, you must first create the Asset Report using `/asset_report/create` (or filter an Asset Report using `/asset_report/filter`) and then wait for the [`PRODUCT_READY`](https://plaid.com/docs/api/webhooks) webhook to fire, indicating that the Report is ready to be retrieved.  The response to `/asset_report/pdf/get` is the PDF binary data. The `request_id`  is returned in the `Plaid-Request-ID` header.  [View a sample PDF Asset Report](https://plaid.com/documents/sample-asset-report.pdf).
    # @param asset_report_pdf_get_request [AssetReportPDFGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [File]
    def asset_report_pdf_get(asset_report_pdf_get_request, opts = {})
      data, _status_code, _headers = asset_report_pdf_get_with_http_info(asset_report_pdf_get_request, opts)
      data
    end

    # Retrieve a PDF Asset Report
    # The &#x60;/asset_report/pdf/get&#x60; endpoint retrieves the Asset Report in PDF format. Before calling &#x60;/asset_report/pdf/get&#x60;, you must first create the Asset Report using &#x60;/asset_report/create&#x60; (or filter an Asset Report using &#x60;/asset_report/filter&#x60;) and then wait for the [&#x60;PRODUCT_READY&#x60;](https://plaid.com/docs/api/webhooks) webhook to fire, indicating that the Report is ready to be retrieved.  The response to &#x60;/asset_report/pdf/get&#x60; is the PDF binary data. The &#x60;request_id&#x60;  is returned in the &#x60;Plaid-Request-ID&#x60; header.  [View a sample PDF Asset Report](https://plaid.com/documents/sample-asset-report.pdf).
    # @param asset_report_pdf_get_request [AssetReportPDFGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def asset_report_pdf_get_with_http_info(asset_report_pdf_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_pdf_get ...'
      end
      # verify the required parameter 'asset_report_pdf_get_request' is set
      if @api_client.config.client_side_validation && asset_report_pdf_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_pdf_get_request' when calling PlaidApi.asset_report_pdf_get"
      end
      # resource path
      local_var_path = '/asset_report/pdf/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/pdf'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_pdf_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_pdf_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_pdf_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Refresh an Asset Report
    # An Asset Report is an immutable snapshot of a user's assets. In order to \"refresh\" an Asset Report you created previously, you can use the `/asset_report/refresh` endpoint to create a new Asset Report based on the old one, but with the most recent data available.  The new Asset Report will contain the same Items as the original Report, as well as the same filters applied by any call to `/asset_report/filter`. By default, the new Asset Report will also use the same parameters you submitted with your original `/asset_report/create` request, but the original `days_requested` value and the values of any parameters in the `options` object can be overridden with new values. To change these arguments, simply supply new values for them in your request to `/asset_report/refresh`. Submit an empty string (\"\") for any previously-populated fields you would like set as empty.
    # @param asset_report_refresh_request [AssetReportRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportRefreshResponse]
    def asset_report_refresh(asset_report_refresh_request, opts = {})
      data, _status_code, _headers = asset_report_refresh_with_http_info(asset_report_refresh_request, opts)
      data
    end

    # Refresh an Asset Report
    # An Asset Report is an immutable snapshot of a user&#39;s assets. In order to \&quot;refresh\&quot; an Asset Report you created previously, you can use the &#x60;/asset_report/refresh&#x60; endpoint to create a new Asset Report based on the old one, but with the most recent data available.  The new Asset Report will contain the same Items as the original Report, as well as the same filters applied by any call to &#x60;/asset_report/filter&#x60;. By default, the new Asset Report will also use the same parameters you submitted with your original &#x60;/asset_report/create&#x60; request, but the original &#x60;days_requested&#x60; value and the values of any parameters in the &#x60;options&#x60; object can be overridden with new values. To change these arguments, simply supply new values for them in your request to &#x60;/asset_report/refresh&#x60;. Submit an empty string (\&quot;\&quot;) for any previously-populated fields you would like set as empty.
    # @param asset_report_refresh_request [AssetReportRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportRefreshResponse, Integer, Hash)>] AssetReportRefreshResponse data, response status code and response headers
    def asset_report_refresh_with_http_info(asset_report_refresh_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_refresh ...'
      end
      # verify the required parameter 'asset_report_refresh_request' is set
      if @api_client.config.client_side_validation && asset_report_refresh_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_refresh_request' when calling PlaidApi.asset_report_refresh"
      end
      # resource path
      local_var_path = '/asset_report/refresh'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_refresh_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportRefreshResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_refresh",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_refresh\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Delete an Asset Report
    # The `/item/remove` endpoint allows you to invalidate an `access_token`, meaning you will not be able to create new Asset Reports with it. Removing an Item does not affect any Asset Reports or Audit Copies you have already created, which will remain accessible until you remove them specifically.  The `/asset_report/remove` endpoint allows you to remove an Asset Report. Removing an Asset Report invalidates its `asset_report_token`, meaning you will no longer be able to use it to access Report data or create new Audit Copies. Removing an Asset Report does not affect the underlying Items, but does invalidate any `audit_copy_tokens` associated with the Asset Report.
    # @param asset_report_remove_request [AssetReportRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AssetReportRemoveResponse]
    def asset_report_remove(asset_report_remove_request, opts = {})
      data, _status_code, _headers = asset_report_remove_with_http_info(asset_report_remove_request, opts)
      data
    end

    # Delete an Asset Report
    # The &#x60;/item/remove&#x60; endpoint allows you to invalidate an &#x60;access_token&#x60;, meaning you will not be able to create new Asset Reports with it. Removing an Item does not affect any Asset Reports or Audit Copies you have already created, which will remain accessible until you remove them specifically.  The &#x60;/asset_report/remove&#x60; endpoint allows you to remove an Asset Report. Removing an Asset Report invalidates its &#x60;asset_report_token&#x60;, meaning you will no longer be able to use it to access Report data or create new Audit Copies. Removing an Asset Report does not affect the underlying Items, but does invalidate any &#x60;audit_copy_tokens&#x60; associated with the Asset Report.
    # @param asset_report_remove_request [AssetReportRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AssetReportRemoveResponse, Integer, Hash)>] AssetReportRemoveResponse data, response status code and response headers
    def asset_report_remove_with_http_info(asset_report_remove_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.asset_report_remove ...'
      end
      # verify the required parameter 'asset_report_remove_request' is set
      if @api_client.config.client_side_validation && asset_report_remove_request.nil?
        fail ArgumentError, "Missing the required parameter 'asset_report_remove_request' when calling PlaidApi.asset_report_remove"
      end
      # resource path
      local_var_path = '/asset_report/remove'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(asset_report_remove_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AssetReportRemoveResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.asset_report_remove",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#asset_report_remove\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve auth data
    # The `/auth/get` endpoint returns the bank account and bank identification numbers (such as routing numbers, for US accounts) associated with an Item's checking and savings accounts, along with high-level account data and balances when available.  Note: This request may take some time to complete if `auth` was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the data.  Also note that `/auth/get` will not return data for any new accounts opened after the Item was created. To obtain data for new accounts, create a new Item.
    # @param auth_get_request [AuthGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [AuthGetResponse]
    def auth_get(auth_get_request, opts = {})
      data, _status_code, _headers = auth_get_with_http_info(auth_get_request, opts)
      data
    end

    # Retrieve auth data
    # The &#x60;/auth/get&#x60; endpoint returns the bank account and bank identification numbers (such as routing numbers, for US accounts) associated with an Item&#39;s checking and savings accounts, along with high-level account data and balances when available.  Note: This request may take some time to complete if &#x60;auth&#x60; was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the data.  Also note that &#x60;/auth/get&#x60; will not return data for any new accounts opened after the Item was created. To obtain data for new accounts, create a new Item.
    # @param auth_get_request [AuthGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(AuthGetResponse, Integer, Hash)>] AuthGetResponse data, response status code and response headers
    def auth_get_with_http_info(auth_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.auth_get ...'
      end
      # verify the required parameter 'auth_get_request' is set
      if @api_client.config.client_side_validation && auth_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'auth_get_request' when calling PlaidApi.auth_get"
      end
      # resource path
      local_var_path = '/auth/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(auth_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'AuthGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.auth_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#auth_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get balance of your Bank Transfer account
    # Use the `/bank_transfer/balance/get` endpoint to see the available balance in your bank transfer account. Debit transfers increase this balance once their status is posted. Credit transfers decrease this balance when they are created.  The transactable balance shows the amount in your account that you are able to use for transfers, and is essentially your available balance minus your minimum balance.  Note that this endpoint can only be used with FBO accounts, when using Bank Transfers in the Full Service configuration. It cannot be used on your own account when using Bank Transfers in the BTS Platform configuration.
    # @param bank_transfer_balance_get_request [BankTransferBalanceGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferBalanceGetResponse]
    def bank_transfer_balance_get(bank_transfer_balance_get_request, opts = {})
      data, _status_code, _headers = bank_transfer_balance_get_with_http_info(bank_transfer_balance_get_request, opts)
      data
    end

    # Get balance of your Bank Transfer account
    # Use the &#x60;/bank_transfer/balance/get&#x60; endpoint to see the available balance in your bank transfer account. Debit transfers increase this balance once their status is posted. Credit transfers decrease this balance when they are created.  The transactable balance shows the amount in your account that you are able to use for transfers, and is essentially your available balance minus your minimum balance.  Note that this endpoint can only be used with FBO accounts, when using Bank Transfers in the Full Service configuration. It cannot be used on your own account when using Bank Transfers in the BTS Platform configuration.
    # @param bank_transfer_balance_get_request [BankTransferBalanceGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferBalanceGetResponse, Integer, Hash)>] BankTransferBalanceGetResponse data, response status code and response headers
    def bank_transfer_balance_get_with_http_info(bank_transfer_balance_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_balance_get ...'
      end
      # verify the required parameter 'bank_transfer_balance_get_request' is set
      if @api_client.config.client_side_validation && bank_transfer_balance_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_balance_get_request' when calling PlaidApi.bank_transfer_balance_get"
      end
      # resource path
      local_var_path = '/bank_transfer/balance/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_balance_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferBalanceGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_balance_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_balance_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Cancel a bank transfer
    # Use the `/bank_transfer/cancel` endpoint to cancel a bank transfer.  A transfer is eligible for cancelation if the `cancellable` property returned by `/bank_transfer/get` is `true`.
    # @param bank_transfer_cancel_request [BankTransferCancelRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferCancelResponse]
    def bank_transfer_cancel(bank_transfer_cancel_request, opts = {})
      data, _status_code, _headers = bank_transfer_cancel_with_http_info(bank_transfer_cancel_request, opts)
      data
    end

    # Cancel a bank transfer
    # Use the &#x60;/bank_transfer/cancel&#x60; endpoint to cancel a bank transfer.  A transfer is eligible for cancelation if the &#x60;cancellable&#x60; property returned by &#x60;/bank_transfer/get&#x60; is &#x60;true&#x60;.
    # @param bank_transfer_cancel_request [BankTransferCancelRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferCancelResponse, Integer, Hash)>] BankTransferCancelResponse data, response status code and response headers
    def bank_transfer_cancel_with_http_info(bank_transfer_cancel_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_cancel ...'
      end
      # verify the required parameter 'bank_transfer_cancel_request' is set
      if @api_client.config.client_side_validation && bank_transfer_cancel_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_cancel_request' when calling PlaidApi.bank_transfer_cancel"
      end
      # resource path
      local_var_path = '/bank_transfer/cancel'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_cancel_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferCancelResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_cancel",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_cancel\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a bank transfer
    # Use the `/bank_transfer/create` endpoint to initiate a new bank transfer.
    # @param bank_transfer_create_request [BankTransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferCreateResponse]
    def bank_transfer_create(bank_transfer_create_request, opts = {})
      data, _status_code, _headers = bank_transfer_create_with_http_info(bank_transfer_create_request, opts)
      data
    end

    # Create a bank transfer
    # Use the &#x60;/bank_transfer/create&#x60; endpoint to initiate a new bank transfer.
    # @param bank_transfer_create_request [BankTransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferCreateResponse, Integer, Hash)>] BankTransferCreateResponse data, response status code and response headers
    def bank_transfer_create_with_http_info(bank_transfer_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_create ...'
      end
      # verify the required parameter 'bank_transfer_create_request' is set
      if @api_client.config.client_side_validation && bank_transfer_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_create_request' when calling PlaidApi.bank_transfer_create"
      end
      # resource path
      local_var_path = '/bank_transfer/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List bank transfer events
    # Use the `/bank_transfer/event/list` endpoint to get a list of bank transfer events based on specified filter criteria.
    # @param bank_transfer_event_list_request [BankTransferEventListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferEventListResponse]
    def bank_transfer_event_list(bank_transfer_event_list_request, opts = {})
      data, _status_code, _headers = bank_transfer_event_list_with_http_info(bank_transfer_event_list_request, opts)
      data
    end

    # List bank transfer events
    # Use the &#x60;/bank_transfer/event/list&#x60; endpoint to get a list of bank transfer events based on specified filter criteria.
    # @param bank_transfer_event_list_request [BankTransferEventListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferEventListResponse, Integer, Hash)>] BankTransferEventListResponse data, response status code and response headers
    def bank_transfer_event_list_with_http_info(bank_transfer_event_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_event_list ...'
      end
      # verify the required parameter 'bank_transfer_event_list_request' is set
      if @api_client.config.client_side_validation && bank_transfer_event_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_event_list_request' when calling PlaidApi.bank_transfer_event_list"
      end
      # resource path
      local_var_path = '/bank_transfer/event/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_event_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferEventListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_event_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_event_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Sync bank transfer events
    # `/bank_transfer/event/sync` allows you to request up to the next 25 bank transfer events that happened after a specific `event_id`. Use the `/bank_transfer/event/sync` endpoint to guarantee you have seen all bank transfer events.
    # @param bank_transfer_event_sync_request [BankTransferEventSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferEventSyncResponse]
    def bank_transfer_event_sync(bank_transfer_event_sync_request, opts = {})
      data, _status_code, _headers = bank_transfer_event_sync_with_http_info(bank_transfer_event_sync_request, opts)
      data
    end

    # Sync bank transfer events
    # &#x60;/bank_transfer/event/sync&#x60; allows you to request up to the next 25 bank transfer events that happened after a specific &#x60;event_id&#x60;. Use the &#x60;/bank_transfer/event/sync&#x60; endpoint to guarantee you have seen all bank transfer events.
    # @param bank_transfer_event_sync_request [BankTransferEventSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferEventSyncResponse, Integer, Hash)>] BankTransferEventSyncResponse data, response status code and response headers
    def bank_transfer_event_sync_with_http_info(bank_transfer_event_sync_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_event_sync ...'
      end
      # verify the required parameter 'bank_transfer_event_sync_request' is set
      if @api_client.config.client_side_validation && bank_transfer_event_sync_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_event_sync_request' when calling PlaidApi.bank_transfer_event_sync"
      end
      # resource path
      local_var_path = '/bank_transfer/event/sync'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_event_sync_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferEventSyncResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_event_sync",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_event_sync\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a bank transfer
    # The `/bank_transfer/get` fetches information about the bank transfer corresponding to the given `bank_transfer_id`.
    # @param bank_transfer_get_request [BankTransferGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferGetResponse]
    def bank_transfer_get(bank_transfer_get_request, opts = {})
      data, _status_code, _headers = bank_transfer_get_with_http_info(bank_transfer_get_request, opts)
      data
    end

    # Retrieve a bank transfer
    # The &#x60;/bank_transfer/get&#x60; fetches information about the bank transfer corresponding to the given &#x60;bank_transfer_id&#x60;.
    # @param bank_transfer_get_request [BankTransferGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferGetResponse, Integer, Hash)>] BankTransferGetResponse data, response status code and response headers
    def bank_transfer_get_with_http_info(bank_transfer_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_get ...'
      end
      # verify the required parameter 'bank_transfer_get_request' is set
      if @api_client.config.client_side_validation && bank_transfer_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_get_request' when calling PlaidApi.bank_transfer_get"
      end
      # resource path
      local_var_path = '/bank_transfer/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List bank transfers
    # Use the `/bank_transfer/list` endpoint to see a list of all your bank transfers and their statuses. Results are paginated; use the `count` and `offset` query parameters to retrieve the desired bank transfers. 
    # @param bank_transfer_list_request [BankTransferListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferListResponse]
    def bank_transfer_list(bank_transfer_list_request, opts = {})
      data, _status_code, _headers = bank_transfer_list_with_http_info(bank_transfer_list_request, opts)
      data
    end

    # List bank transfers
    # Use the &#x60;/bank_transfer/list&#x60; endpoint to see a list of all your bank transfers and their statuses. Results are paginated; use the &#x60;count&#x60; and &#x60;offset&#x60; query parameters to retrieve the desired bank transfers. 
    # @param bank_transfer_list_request [BankTransferListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferListResponse, Integer, Hash)>] BankTransferListResponse data, response status code and response headers
    def bank_transfer_list_with_http_info(bank_transfer_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_list ...'
      end
      # verify the required parameter 'bank_transfer_list_request' is set
      if @api_client.config.client_side_validation && bank_transfer_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_list_request' when calling PlaidApi.bank_transfer_list"
      end
      # resource path
      local_var_path = '/bank_transfer/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Migrate account into Bank Transfers
    # As an alternative to adding Items via Link, you can also use the `/bank_transfer/migrate_account` endpoint to migrate known account and routing numbers to Plaid Items.  Note that Items created in this way are not compatible with endpoints for other products, such as `/accounts/balance/get`, and can only be used with Bank Transfer endpoints.  If you require access to other endpoints, create the Item through Link instead.  Access to `/bank_transfer/migrate_account` is not enabled by default; to obtain access, contact your Plaid Account Manager.
    # @param bank_transfer_migrate_account_request [BankTransferMigrateAccountRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferMigrateAccountResponse]
    def bank_transfer_migrate_account(bank_transfer_migrate_account_request, opts = {})
      data, _status_code, _headers = bank_transfer_migrate_account_with_http_info(bank_transfer_migrate_account_request, opts)
      data
    end

    # Migrate account into Bank Transfers
    # As an alternative to adding Items via Link, you can also use the &#x60;/bank_transfer/migrate_account&#x60; endpoint to migrate known account and routing numbers to Plaid Items.  Note that Items created in this way are not compatible with endpoints for other products, such as &#x60;/accounts/balance/get&#x60;, and can only be used with Bank Transfer endpoints.  If you require access to other endpoints, create the Item through Link instead.  Access to &#x60;/bank_transfer/migrate_account&#x60; is not enabled by default; to obtain access, contact your Plaid Account Manager.
    # @param bank_transfer_migrate_account_request [BankTransferMigrateAccountRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferMigrateAccountResponse, Integer, Hash)>] BankTransferMigrateAccountResponse data, response status code and response headers
    def bank_transfer_migrate_account_with_http_info(bank_transfer_migrate_account_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_migrate_account ...'
      end
      # verify the required parameter 'bank_transfer_migrate_account_request' is set
      if @api_client.config.client_side_validation && bank_transfer_migrate_account_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_migrate_account_request' when calling PlaidApi.bank_transfer_migrate_account"
      end
      # resource path
      local_var_path = '/bank_transfer/migrate_account'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_migrate_account_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferMigrateAccountResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_migrate_account",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_migrate_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a sweep
    # The `/bank_transfer/sweep/get` endpoint fetches information about the sweep corresponding to the given `sweep_id`.
    # @param bank_transfer_sweep_get_request [BankTransferSweepGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferSweepGetResponse]
    def bank_transfer_sweep_get(bank_transfer_sweep_get_request, opts = {})
      data, _status_code, _headers = bank_transfer_sweep_get_with_http_info(bank_transfer_sweep_get_request, opts)
      data
    end

    # Retrieve a sweep
    # The &#x60;/bank_transfer/sweep/get&#x60; endpoint fetches information about the sweep corresponding to the given &#x60;sweep_id&#x60;.
    # @param bank_transfer_sweep_get_request [BankTransferSweepGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferSweepGetResponse, Integer, Hash)>] BankTransferSweepGetResponse data, response status code and response headers
    def bank_transfer_sweep_get_with_http_info(bank_transfer_sweep_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_sweep_get ...'
      end
      # verify the required parameter 'bank_transfer_sweep_get_request' is set
      if @api_client.config.client_side_validation && bank_transfer_sweep_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_sweep_get_request' when calling PlaidApi.bank_transfer_sweep_get"
      end
      # resource path
      local_var_path = '/bank_transfer/sweep/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_sweep_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferSweepGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_sweep_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_sweep_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List sweeps
    # The `/bank_transfer/sweep/list` endpoint fetches information about the sweeps matching the given filters.
    # @param bank_transfer_sweep_list_request [BankTransferSweepListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [BankTransferSweepListResponse]
    def bank_transfer_sweep_list(bank_transfer_sweep_list_request, opts = {})
      data, _status_code, _headers = bank_transfer_sweep_list_with_http_info(bank_transfer_sweep_list_request, opts)
      data
    end

    # List sweeps
    # The &#x60;/bank_transfer/sweep/list&#x60; endpoint fetches information about the sweeps matching the given filters.
    # @param bank_transfer_sweep_list_request [BankTransferSweepListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(BankTransferSweepListResponse, Integer, Hash)>] BankTransferSweepListResponse data, response status code and response headers
    def bank_transfer_sweep_list_with_http_info(bank_transfer_sweep_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.bank_transfer_sweep_list ...'
      end
      # verify the required parameter 'bank_transfer_sweep_list_request' is set
      if @api_client.config.client_side_validation && bank_transfer_sweep_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'bank_transfer_sweep_list_request' when calling PlaidApi.bank_transfer_sweep_list"
      end
      # resource path
      local_var_path = '/bank_transfer/sweep/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(bank_transfer_sweep_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'BankTransferSweepListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.bank_transfer_sweep_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#bank_transfer_sweep_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get Categories
    # Send a request to the `/categories/get`  endpoint to get detailed information on categories returned by Plaid. This endpoint does not require authentication.
    # @param body [Object] 
    # @param [Hash] opts the optional parameters
    # @return [CategoriesGetResponse]
    def categories_get(body, opts = {})
      data, _status_code, _headers = categories_get_with_http_info(body, opts)
      data
    end

    # Get Categories
    # Send a request to the &#x60;/categories/get&#x60;  endpoint to get detailed information on categories returned by Plaid. This endpoint does not require authentication.
    # @param body [Object] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(CategoriesGetResponse, Integer, Hash)>] CategoriesGetResponse data, response status code and response headers
    def categories_get_with_http_info(body, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.categories_get ...'
      end
      # verify the required parameter 'body' is set
      if @api_client.config.client_side_validation && body.nil?
        fail ArgumentError, "Missing the required parameter 'body' when calling PlaidApi.categories_get"
      end
      # resource path
      local_var_path = '/categories/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(body)

      # return_type
      return_type = opts[:debug_return_type] || 'CategoriesGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || []

      new_options = opts.merge(
        :operation => :"PlaidApi.categories_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#categories_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create payment token
    # The `/payment_initiation/payment/token/create` endpoint has been deprecated. New Plaid customers will be unable to use this endpoint, and existing customers are encouraged to migrate to the newer, `link_token`-based flow. The recommended flow is to provide the `payment_id` to `/link/token/create`, which returns a `link_token` used to initialize Link.  The `/payment_initiation/payment/token/create` is used to create a `payment_token`, which can then be used in Link initialization to enter a payment initiation flow. You can only use a `payment_token` once. If this attempt fails, the end user aborts the flow, or the token expires, you will need to create a new payment token. Creating a new payment token does not require end user input.
    # @param payment_initiation_payment_token_create_request [PaymentInitiationPaymentTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationPaymentTokenCreateResponse]
    def create_payment_token(payment_initiation_payment_token_create_request, opts = {})
      data, _status_code, _headers = create_payment_token_with_http_info(payment_initiation_payment_token_create_request, opts)
      data
    end

    # Create payment token
    # The &#x60;/payment_initiation/payment/token/create&#x60; endpoint has been deprecated. New Plaid customers will be unable to use this endpoint, and existing customers are encouraged to migrate to the newer, &#x60;link_token&#x60;-based flow. The recommended flow is to provide the &#x60;payment_id&#x60; to &#x60;/link/token/create&#x60;, which returns a &#x60;link_token&#x60; used to initialize Link.  The &#x60;/payment_initiation/payment/token/create&#x60; is used to create a &#x60;payment_token&#x60;, which can then be used in Link initialization to enter a payment initiation flow. You can only use a &#x60;payment_token&#x60; once. If this attempt fails, the end user aborts the flow, or the token expires, you will need to create a new payment token. Creating a new payment token does not require end user input.
    # @param payment_initiation_payment_token_create_request [PaymentInitiationPaymentTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationPaymentTokenCreateResponse, Integer, Hash)>] PaymentInitiationPaymentTokenCreateResponse data, response status code and response headers
    def create_payment_token_with_http_info(payment_initiation_payment_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.create_payment_token ...'
      end
      # verify the required parameter 'payment_initiation_payment_token_create_request' is set
      if @api_client.config.client_side_validation && payment_initiation_payment_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_payment_token_create_request' when calling PlaidApi.create_payment_token"
      end
      # resource path
      local_var_path = '/payment_initiation/payment/token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_payment_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationPaymentTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.create_payment_token",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#create_payment_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a deposit switch without using Plaid Exchange
    # This endpoint provides an alternative to `/deposit_switch/create` for customers who have not yet fully integrated with Plaid Exchange. Like `/deposit_switch/create`, it creates a deposit switch entity that will be persisted throughout the lifecycle of the switch.
    # @param deposit_switch_alt_create_request [DepositSwitchAltCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [DepositSwitchAltCreateResponse]
    def deposit_switch_alt_create(deposit_switch_alt_create_request, opts = {})
      data, _status_code, _headers = deposit_switch_alt_create_with_http_info(deposit_switch_alt_create_request, opts)
      data
    end

    # Create a deposit switch without using Plaid Exchange
    # This endpoint provides an alternative to &#x60;/deposit_switch/create&#x60; for customers who have not yet fully integrated with Plaid Exchange. Like &#x60;/deposit_switch/create&#x60;, it creates a deposit switch entity that will be persisted throughout the lifecycle of the switch.
    # @param deposit_switch_alt_create_request [DepositSwitchAltCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(DepositSwitchAltCreateResponse, Integer, Hash)>] DepositSwitchAltCreateResponse data, response status code and response headers
    def deposit_switch_alt_create_with_http_info(deposit_switch_alt_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.deposit_switch_alt_create ...'
      end
      # verify the required parameter 'deposit_switch_alt_create_request' is set
      if @api_client.config.client_side_validation && deposit_switch_alt_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'deposit_switch_alt_create_request' when calling PlaidApi.deposit_switch_alt_create"
      end
      # resource path
      local_var_path = '/deposit_switch/alt/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(deposit_switch_alt_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'DepositSwitchAltCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.deposit_switch_alt_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#deposit_switch_alt_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a deposit switch
    # This endpoint creates a deposit switch entity that will be persisted throughout the lifecycle of the switch.
    # @param deposit_switch_create_request [DepositSwitchCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [DepositSwitchCreateResponse]
    def deposit_switch_create(deposit_switch_create_request, opts = {})
      data, _status_code, _headers = deposit_switch_create_with_http_info(deposit_switch_create_request, opts)
      data
    end

    # Create a deposit switch
    # This endpoint creates a deposit switch entity that will be persisted throughout the lifecycle of the switch.
    # @param deposit_switch_create_request [DepositSwitchCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(DepositSwitchCreateResponse, Integer, Hash)>] DepositSwitchCreateResponse data, response status code and response headers
    def deposit_switch_create_with_http_info(deposit_switch_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.deposit_switch_create ...'
      end
      # verify the required parameter 'deposit_switch_create_request' is set
      if @api_client.config.client_side_validation && deposit_switch_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'deposit_switch_create_request' when calling PlaidApi.deposit_switch_create"
      end
      # resource path
      local_var_path = '/deposit_switch/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(deposit_switch_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'DepositSwitchCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.deposit_switch_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#deposit_switch_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a deposit switch
    # This endpoint returns information related to how the user has configured their payroll allocation and the state of the switch. You can use this information to build logic related to the user's direct deposit allocation preferences.
    # @param deposit_switch_get_request [DepositSwitchGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [DepositSwitchGetResponse]
    def deposit_switch_get(deposit_switch_get_request, opts = {})
      data, _status_code, _headers = deposit_switch_get_with_http_info(deposit_switch_get_request, opts)
      data
    end

    # Retrieve a deposit switch
    # This endpoint returns information related to how the user has configured their payroll allocation and the state of the switch. You can use this information to build logic related to the user&#39;s direct deposit allocation preferences.
    # @param deposit_switch_get_request [DepositSwitchGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(DepositSwitchGetResponse, Integer, Hash)>] DepositSwitchGetResponse data, response status code and response headers
    def deposit_switch_get_with_http_info(deposit_switch_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.deposit_switch_get ...'
      end
      # verify the required parameter 'deposit_switch_get_request' is set
      if @api_client.config.client_side_validation && deposit_switch_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'deposit_switch_get_request' when calling PlaidApi.deposit_switch_get"
      end
      # resource path
      local_var_path = '/deposit_switch/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(deposit_switch_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'DepositSwitchGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.deposit_switch_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#deposit_switch_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a deposit switch token
    # In order for the end user to take action, you will need to create a public token representing the deposit switch. This token is used to initialize Link. It can be used one time and expires after 30 minutes. 
    # @param deposit_switch_token_create_request [DepositSwitchTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [DepositSwitchTokenCreateResponse]
    def deposit_switch_token_create(deposit_switch_token_create_request, opts = {})
      data, _status_code, _headers = deposit_switch_token_create_with_http_info(deposit_switch_token_create_request, opts)
      data
    end

    # Create a deposit switch token
    # In order for the end user to take action, you will need to create a public token representing the deposit switch. This token is used to initialize Link. It can be used one time and expires after 30 minutes. 
    # @param deposit_switch_token_create_request [DepositSwitchTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(DepositSwitchTokenCreateResponse, Integer, Hash)>] DepositSwitchTokenCreateResponse data, response status code and response headers
    def deposit_switch_token_create_with_http_info(deposit_switch_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.deposit_switch_token_create ...'
      end
      # verify the required parameter 'deposit_switch_token_create_request' is set
      if @api_client.config.client_side_validation && deposit_switch_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'deposit_switch_token_create_request' when calling PlaidApi.deposit_switch_token_create"
      end
      # resource path
      local_var_path = '/deposit_switch/token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(deposit_switch_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'DepositSwitchTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.deposit_switch_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#deposit_switch_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Search employer database
    # `/employers/search` allows you the ability to search Plaid’s database of known employers, for use with Deposit Switch. You can use this endpoint to look up a user's employer in order to confirm that they are supported. Users with non-supported employers can then be routed out of the Deposit Switch flow.  The data in the employer database is currently limited. As the Deposit Switch and Income products progress through their respective beta periods, more employers are being regularly added. Because the employer database is frequently updated, we recommend that you do not cache or store data from this endpoint for more than a day.
    # @param employers_search_request [EmployersSearchRequest] 
    # @param [Hash] opts the optional parameters
    # @return [EmployersSearchResponse]
    def employers_search(employers_search_request, opts = {})
      data, _status_code, _headers = employers_search_with_http_info(employers_search_request, opts)
      data
    end

    # Search employer database
    # &#x60;/employers/search&#x60; allows you the ability to search Plaid’s database of known employers, for use with Deposit Switch. You can use this endpoint to look up a user&#39;s employer in order to confirm that they are supported. Users with non-supported employers can then be routed out of the Deposit Switch flow.  The data in the employer database is currently limited. As the Deposit Switch and Income products progress through their respective beta periods, more employers are being regularly added. Because the employer database is frequently updated, we recommend that you do not cache or store data from this endpoint for more than a day.
    # @param employers_search_request [EmployersSearchRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmployersSearchResponse, Integer, Hash)>] EmployersSearchResponse data, response status code and response headers
    def employers_search_with_http_info(employers_search_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.employers_search ...'
      end
      # verify the required parameter 'employers_search_request' is set
      if @api_client.config.client_side_validation && employers_search_request.nil?
        fail ArgumentError, "Missing the required parameter 'employers_search_request' when calling PlaidApi.employers_search"
      end
      # resource path
      local_var_path = '/employers/search'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(employers_search_request)

      # return_type
      return_type = opts[:debug_return_type] || 'EmployersSearchResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.employers_search",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#employers_search\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a summary of an individual's employment information.
    # `/employment/verification/get` returns a list of employments through a user payroll that was verified by an end user.
    # @param employment_verification_get_request [EmploymentVerificationGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [EmploymentVerificationGetResponse]
    def employment_verification_get(employment_verification_get_request, opts = {})
      data, _status_code, _headers = employment_verification_get_with_http_info(employment_verification_get_request, opts)
      data
    end

    # Retrieve a summary of an individual&#39;s employment information.
    # &#x60;/employment/verification/get&#x60; returns a list of employments through a user payroll that was verified by an end user.
    # @param employment_verification_get_request [EmploymentVerificationGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(EmploymentVerificationGetResponse, Integer, Hash)>] EmploymentVerificationGetResponse data, response status code and response headers
    def employment_verification_get_with_http_info(employment_verification_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.employment_verification_get ...'
      end
      # verify the required parameter 'employment_verification_get_request' is set
      if @api_client.config.client_side_validation && employment_verification_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'employment_verification_get_request' when calling PlaidApi.employment_verification_get"
      end
      # resource path
      local_var_path = '/employment/verification/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(employment_verification_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'EmploymentVerificationGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.employment_verification_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#employment_verification_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve identity data
    # The `/identity/get` endpoint allows you to retrieve various account holder information on file with the financial institution, including names, emails, phone numbers, and addresses. Only name data is guaranteed to be returned; other fields will be empty arrays if not provided by the institution.  Note: This request may take some time to complete if identity was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the data.
    # @param identity_get_request [IdentityGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IdentityGetResponse]
    def identity_get(identity_get_request, opts = {})
      data, _status_code, _headers = identity_get_with_http_info(identity_get_request, opts)
      data
    end

    # Retrieve identity data
    # The &#x60;/identity/get&#x60; endpoint allows you to retrieve various account holder information on file with the financial institution, including names, emails, phone numbers, and addresses. Only name data is guaranteed to be returned; other fields will be empty arrays if not provided by the institution.  Note: This request may take some time to complete if identity was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the data.
    # @param identity_get_request [IdentityGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IdentityGetResponse, Integer, Hash)>] IdentityGetResponse data, response status code and response headers
    def identity_get_with_http_info(identity_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.identity_get ...'
      end
      # verify the required parameter 'identity_get_request' is set
      if @api_client.config.client_side_validation && identity_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'identity_get_request' when calling PlaidApi.identity_get"
      end
      # resource path
      local_var_path = '/identity/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(identity_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IdentityGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.identity_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#identity_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # (Deprecated) Create an income verification instance
    # `/income/verification/create` begins the income verification process by returning an `income_verification_id`. You can then provide the `income_verification_id` to `/link/token/create` under the `income_verification` parameter in order to create a Link instance that will prompt the user to go through the income verification flow. Plaid will fire an `INCOME` webhook once the user completes the Payroll Income flow, or when the uploaded documents in the Document Income flow have finished processing. 
    # @param income_verification_create_request [IncomeVerificationCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationCreateResponse]
    def income_verification_create(income_verification_create_request, opts = {})
      data, _status_code, _headers = income_verification_create_with_http_info(income_verification_create_request, opts)
      data
    end

    # (Deprecated) Create an income verification instance
    # &#x60;/income/verification/create&#x60; begins the income verification process by returning an &#x60;income_verification_id&#x60;. You can then provide the &#x60;income_verification_id&#x60; to &#x60;/link/token/create&#x60; under the &#x60;income_verification&#x60; parameter in order to create a Link instance that will prompt the user to go through the income verification flow. Plaid will fire an &#x60;INCOME&#x60; webhook once the user completes the Payroll Income flow, or when the uploaded documents in the Document Income flow have finished processing. 
    # @param income_verification_create_request [IncomeVerificationCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationCreateResponse, Integer, Hash)>] IncomeVerificationCreateResponse data, response status code and response headers
    def income_verification_create_with_http_info(income_verification_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_create ...'
      end
      # verify the required parameter 'income_verification_create_request' is set
      if @api_client.config.client_side_validation && income_verification_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_create_request' when calling PlaidApi.income_verification_create"
      end
      # resource path
      local_var_path = '/income/verification/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Download the original documents used for income verification
    # `/income/verification/documents/download` provides the ability to download the source documents associated with the verification.  If Document Income was used, the documents will be those the user provided in Link. For Payroll Income, the most recent files available for download from the payroll provider will be available from this endpoint.  The response to `/income/verification/documents/download` is ZIP file in binary data. If a document_id is passed, a single document will be contained in this file. If not, the response will contain all documents associated with the verification.  The `request_id` is returned in the `Plaid-Request-ID` header.
    # @param income_verification_documents_download_request [IncomeVerificationDocumentsDownloadRequest] 
    # @param [Hash] opts the optional parameters
    # @return [File]
    def income_verification_documents_download(income_verification_documents_download_request, opts = {})
      data, _status_code, _headers = income_verification_documents_download_with_http_info(income_verification_documents_download_request, opts)
      data
    end

    # Download the original documents used for income verification
    # &#x60;/income/verification/documents/download&#x60; provides the ability to download the source documents associated with the verification.  If Document Income was used, the documents will be those the user provided in Link. For Payroll Income, the most recent files available for download from the payroll provider will be available from this endpoint.  The response to &#x60;/income/verification/documents/download&#x60; is ZIP file in binary data. If a document_id is passed, a single document will be contained in this file. If not, the response will contain all documents associated with the verification.  The &#x60;request_id&#x60; is returned in the &#x60;Plaid-Request-ID&#x60; header.
    # @param income_verification_documents_download_request [IncomeVerificationDocumentsDownloadRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(File, Integer, Hash)>] File data, response status code and response headers
    def income_verification_documents_download_with_http_info(income_verification_documents_download_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_documents_download ...'
      end
      # verify the required parameter 'income_verification_documents_download_request' is set
      if @api_client.config.client_side_validation && income_verification_documents_download_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_documents_download_request' when calling PlaidApi.income_verification_documents_download"
      end
      # resource path
      local_var_path = '/income/verification/documents/download'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/zip'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_documents_download_request)

      # return_type
      return_type = opts[:debug_return_type] || 'File'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_documents_download",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_documents_download\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # (Deprecated) Retrieve information from a single paystub used for income verification
    # @param income_verification_paystub_get_request [IncomeVerificationPaystubGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationPaystubGetResponse]
    def income_verification_paystub_get(income_verification_paystub_get_request, opts = {})
      data, _status_code, _headers = income_verification_paystub_get_with_http_info(income_verification_paystub_get_request, opts)
      data
    end

    # (Deprecated) Retrieve information from a single paystub used for income verification
    # @param income_verification_paystub_get_request [IncomeVerificationPaystubGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationPaystubGetResponse, Integer, Hash)>] IncomeVerificationPaystubGetResponse data, response status code and response headers
    def income_verification_paystub_get_with_http_info(income_verification_paystub_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_paystub_get ...'
      end
      # verify the required parameter 'income_verification_paystub_get_request' is set
      if @api_client.config.client_side_validation && income_verification_paystub_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_paystub_get_request' when calling PlaidApi.income_verification_paystub_get"
      end
      # resource path
      local_var_path = '/income/verification/paystub/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_paystub_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationPaystubGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_paystub_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_paystub_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve information from the paystubs used for income verification
    # `/income/verification/paystubs/get` returns the information collected from the paystubs that were used to verify an end user's income. It can be called once the status of the verification has been set to `VERIFICATION_STATUS_PROCESSING_COMPLETE`, as reported by the `INCOME: verification_status` webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param income_verification_paystubs_get_request [IncomeVerificationPaystubsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationPaystubsGetResponse]
    def income_verification_paystubs_get(income_verification_paystubs_get_request, opts = {})
      data, _status_code, _headers = income_verification_paystubs_get_with_http_info(income_verification_paystubs_get_request, opts)
      data
    end

    # Retrieve information from the paystubs used for income verification
    # &#x60;/income/verification/paystubs/get&#x60; returns the information collected from the paystubs that were used to verify an end user&#39;s income. It can be called once the status of the verification has been set to &#x60;VERIFICATION_STATUS_PROCESSING_COMPLETE&#x60;, as reported by the &#x60;INCOME: verification_status&#x60; webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param income_verification_paystubs_get_request [IncomeVerificationPaystubsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationPaystubsGetResponse, Integer, Hash)>] IncomeVerificationPaystubsGetResponse data, response status code and response headers
    def income_verification_paystubs_get_with_http_info(income_verification_paystubs_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_paystubs_get ...'
      end
      # verify the required parameter 'income_verification_paystubs_get_request' is set
      if @api_client.config.client_side_validation && income_verification_paystubs_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_paystubs_get_request' when calling PlaidApi.income_verification_paystubs_get"
      end
      # resource path
      local_var_path = '/income/verification/paystubs/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_paystubs_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationPaystubsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_paystubs_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_paystubs_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Check a user's eligibility for the income verification product
    # `/income/verification/precheck` returns whether a given user is supportable by the income product
    # @param income_verification_precheck_request [IncomeVerificationPrecheckRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationPrecheckResponse]
    def income_verification_precheck(income_verification_precheck_request, opts = {})
      data, _status_code, _headers = income_verification_precheck_with_http_info(income_verification_precheck_request, opts)
      data
    end

    # Check a user&#39;s eligibility for the income verification product
    # &#x60;/income/verification/precheck&#x60; returns whether a given user is supportable by the income product
    # @param income_verification_precheck_request [IncomeVerificationPrecheckRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationPrecheckResponse, Integer, Hash)>] IncomeVerificationPrecheckResponse data, response status code and response headers
    def income_verification_precheck_with_http_info(income_verification_precheck_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_precheck ...'
      end
      # verify the required parameter 'income_verification_precheck_request' is set
      if @api_client.config.client_side_validation && income_verification_precheck_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_precheck_request' when calling PlaidApi.income_verification_precheck"
      end
      # resource path
      local_var_path = '/income/verification/precheck'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_precheck_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationPrecheckResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_precheck",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_precheck\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Refresh an income verification
    # `/income/verification/refresh` refreshes a given income verification.
    # @param income_verification_refresh_request [IncomeVerificationRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationRefreshResponse]
    def income_verification_refresh(income_verification_refresh_request, opts = {})
      data, _status_code, _headers = income_verification_refresh_with_http_info(income_verification_refresh_request, opts)
      data
    end

    # Refresh an income verification
    # &#x60;/income/verification/refresh&#x60; refreshes a given income verification.
    # @param income_verification_refresh_request [IncomeVerificationRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationRefreshResponse, Integer, Hash)>] IncomeVerificationRefreshResponse data, response status code and response headers
    def income_verification_refresh_with_http_info(income_verification_refresh_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_refresh ...'
      end
      # verify the required parameter 'income_verification_refresh_request' is set
      if @api_client.config.client_side_validation && income_verification_refresh_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_refresh_request' when calling PlaidApi.income_verification_refresh"
      end
      # resource path
      local_var_path = '/income/verification/refresh'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_refresh_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationRefreshResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_refresh",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_refresh\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # (Deprecated) Retrieve a summary of information derived from income verification
    # `/income/verification/summary/get` returns a verification summary for the income that was verified for an end user. It can be called once the status of the verification has been set to `VERIFICATION_STATUS_PROCESSING_COMPLETE`, as reported by the `INCOME: verification_status` webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param income_verification_summary_get_request [IncomeVerificationSummaryGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationSummaryGetResponse]
    def income_verification_summary_get(income_verification_summary_get_request, opts = {})
      data, _status_code, _headers = income_verification_summary_get_with_http_info(income_verification_summary_get_request, opts)
      data
    end

    # (Deprecated) Retrieve a summary of information derived from income verification
    # &#x60;/income/verification/summary/get&#x60; returns a verification summary for the income that was verified for an end user. It can be called once the status of the verification has been set to &#x60;VERIFICATION_STATUS_PROCESSING_COMPLETE&#x60;, as reported by the &#x60;INCOME: verification_status&#x60; webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param income_verification_summary_get_request [IncomeVerificationSummaryGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationSummaryGetResponse, Integer, Hash)>] IncomeVerificationSummaryGetResponse data, response status code and response headers
    def income_verification_summary_get_with_http_info(income_verification_summary_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_summary_get ...'
      end
      # verify the required parameter 'income_verification_summary_get_request' is set
      if @api_client.config.client_side_validation && income_verification_summary_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'income_verification_summary_get_request' when calling PlaidApi.income_verification_summary_get"
      end
      # resource path
      local_var_path = '/income/verification/summary/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(income_verification_summary_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationSummaryGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_summary_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_summary_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve information from the tax documents used for income verification
    # `/income/verification/taxforms/get` returns the information collected from taxforms that were used to verify an end user's income. It can be called once the status of the verification has been set to `VERIFICATION_STATUS_PROCESSING_COMPLETE`, as reported by the `INCOME: verification_status` webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param request_body [Hash<String, Object>] 
    # @param [Hash] opts the optional parameters
    # @return [IncomeVerificationTaxformsGetResponse]
    def income_verification_taxforms_get(request_body, opts = {})
      data, _status_code, _headers = income_verification_taxforms_get_with_http_info(request_body, opts)
      data
    end

    # Retrieve information from the tax documents used for income verification
    # &#x60;/income/verification/taxforms/get&#x60; returns the information collected from taxforms that were used to verify an end user&#39;s income. It can be called once the status of the verification has been set to &#x60;VERIFICATION_STATUS_PROCESSING_COMPLETE&#x60;, as reported by the &#x60;INCOME: verification_status&#x60; webhook. Attempting to call the endpoint before verification has been completed will result in an error.
    # @param request_body [Hash<String, Object>] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(IncomeVerificationTaxformsGetResponse, Integer, Hash)>] IncomeVerificationTaxformsGetResponse data, response status code and response headers
    def income_verification_taxforms_get_with_http_info(request_body, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.income_verification_taxforms_get ...'
      end
      # verify the required parameter 'request_body' is set
      if @api_client.config.client_side_validation && request_body.nil?
        fail ArgumentError, "Missing the required parameter 'request_body' when calling PlaidApi.income_verification_taxforms_get"
      end
      # resource path
      local_var_path = '/income/verification/taxforms/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(request_body)

      # return_type
      return_type = opts[:debug_return_type] || 'IncomeVerificationTaxformsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.income_verification_taxforms_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#income_verification_taxforms_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get details of all supported institutions
    # Returns a JSON response containing details on all financial institutions currently supported by Plaid. Because Plaid supports thousands of institutions, results are paginated.  If there is no overlap between an institution’s enabled products and a client’s enabled products, then the institution will be filtered out from the response. As a result, the number of institutions returned may not match the count specified in the call.
    # @param institutions_get_request [InstitutionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [InstitutionsGetResponse]
    def institutions_get(institutions_get_request, opts = {})
      data, _status_code, _headers = institutions_get_with_http_info(institutions_get_request, opts)
      data
    end

    # Get details of all supported institutions
    # Returns a JSON response containing details on all financial institutions currently supported by Plaid. Because Plaid supports thousands of institutions, results are paginated.  If there is no overlap between an institution’s enabled products and a client’s enabled products, then the institution will be filtered out from the response. As a result, the number of institutions returned may not match the count specified in the call.
    # @param institutions_get_request [InstitutionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(InstitutionsGetResponse, Integer, Hash)>] InstitutionsGetResponse data, response status code and response headers
    def institutions_get_with_http_info(institutions_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.institutions_get ...'
      end
      # verify the required parameter 'institutions_get_request' is set
      if @api_client.config.client_side_validation && institutions_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'institutions_get_request' when calling PlaidApi.institutions_get"
      end
      # resource path
      local_var_path = '/institutions/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(institutions_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'InstitutionsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.institutions_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#institutions_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get details of an institution
    # Returns a JSON response containing details on a specified financial institution currently supported by Plaid.
    # @param institutions_get_by_id_request [InstitutionsGetByIdRequest] 
    # @param [Hash] opts the optional parameters
    # @return [InstitutionsGetByIdResponse]
    def institutions_get_by_id(institutions_get_by_id_request, opts = {})
      data, _status_code, _headers = institutions_get_by_id_with_http_info(institutions_get_by_id_request, opts)
      data
    end

    # Get details of an institution
    # Returns a JSON response containing details on a specified financial institution currently supported by Plaid.
    # @param institutions_get_by_id_request [InstitutionsGetByIdRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(InstitutionsGetByIdResponse, Integer, Hash)>] InstitutionsGetByIdResponse data, response status code and response headers
    def institutions_get_by_id_with_http_info(institutions_get_by_id_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.institutions_get_by_id ...'
      end
      # verify the required parameter 'institutions_get_by_id_request' is set
      if @api_client.config.client_side_validation && institutions_get_by_id_request.nil?
        fail ArgumentError, "Missing the required parameter 'institutions_get_by_id_request' when calling PlaidApi.institutions_get_by_id"
      end
      # resource path
      local_var_path = '/institutions/get_by_id'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(institutions_get_by_id_request)

      # return_type
      return_type = opts[:debug_return_type] || 'InstitutionsGetByIdResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.institutions_get_by_id",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#institutions_get_by_id\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Search institutions
    # Returns a JSON response containing details for institutions that match the query parameters, up to a maximum of ten institutions per query.
    # @param institutions_search_request [InstitutionsSearchRequest] 
    # @param [Hash] opts the optional parameters
    # @return [InstitutionsSearchResponse]
    def institutions_search(institutions_search_request, opts = {})
      data, _status_code, _headers = institutions_search_with_http_info(institutions_search_request, opts)
      data
    end

    # Search institutions
    # Returns a JSON response containing details for institutions that match the query parameters, up to a maximum of ten institutions per query.
    # @param institutions_search_request [InstitutionsSearchRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(InstitutionsSearchResponse, Integer, Hash)>] InstitutionsSearchResponse data, response status code and response headers
    def institutions_search_with_http_info(institutions_search_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.institutions_search ...'
      end
      # verify the required parameter 'institutions_search_request' is set
      if @api_client.config.client_side_validation && institutions_search_request.nil?
        fail ArgumentError, "Missing the required parameter 'institutions_search_request' when calling PlaidApi.institutions_search"
      end
      # resource path
      local_var_path = '/institutions/search'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(institutions_search_request)

      # return_type
      return_type = opts[:debug_return_type] || 'InstitutionsSearchResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.institutions_search",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#institutions_search\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get Investment holdings
    # The `/investments/holdings/get` endpoint allows developers to receive user-authorized stock position data for `investment`-type accounts.
    # @param investments_holdings_get_request [InvestmentsHoldingsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [InvestmentsHoldingsGetResponse]
    def investments_holdings_get(investments_holdings_get_request, opts = {})
      data, _status_code, _headers = investments_holdings_get_with_http_info(investments_holdings_get_request, opts)
      data
    end

    # Get Investment holdings
    # The &#x60;/investments/holdings/get&#x60; endpoint allows developers to receive user-authorized stock position data for &#x60;investment&#x60;-type accounts.
    # @param investments_holdings_get_request [InvestmentsHoldingsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(InvestmentsHoldingsGetResponse, Integer, Hash)>] InvestmentsHoldingsGetResponse data, response status code and response headers
    def investments_holdings_get_with_http_info(investments_holdings_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.investments_holdings_get ...'
      end
      # verify the required parameter 'investments_holdings_get_request' is set
      if @api_client.config.client_side_validation && investments_holdings_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'investments_holdings_get_request' when calling PlaidApi.investments_holdings_get"
      end
      # resource path
      local_var_path = '/investments/holdings/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(investments_holdings_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'InvestmentsHoldingsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.investments_holdings_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#investments_holdings_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get investment transactions
    # The `/investments/transactions/get` endpoint allows developers to retrieve user-authorized transaction data for investment accounts.  Transactions are returned in reverse-chronological order, and the sequence of transaction ordering is stable and will not shift.  Due to the potentially large number of investment transactions associated with an Item, results are paginated. Manipulate the count and offset parameters in conjunction with the `total_investment_transactions` response body field to fetch all available investment transactions.
    # @param investments_transactions_get_request [InvestmentsTransactionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [InvestmentsTransactionsGetResponse]
    def investments_transactions_get(investments_transactions_get_request, opts = {})
      data, _status_code, _headers = investments_transactions_get_with_http_info(investments_transactions_get_request, opts)
      data
    end

    # Get investment transactions
    # The &#x60;/investments/transactions/get&#x60; endpoint allows developers to retrieve user-authorized transaction data for investment accounts.  Transactions are returned in reverse-chronological order, and the sequence of transaction ordering is stable and will not shift.  Due to the potentially large number of investment transactions associated with an Item, results are paginated. Manipulate the count and offset parameters in conjunction with the &#x60;total_investment_transactions&#x60; response body field to fetch all available investment transactions.
    # @param investments_transactions_get_request [InvestmentsTransactionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(InvestmentsTransactionsGetResponse, Integer, Hash)>] InvestmentsTransactionsGetResponse data, response status code and response headers
    def investments_transactions_get_with_http_info(investments_transactions_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.investments_transactions_get ...'
      end
      # verify the required parameter 'investments_transactions_get_request' is set
      if @api_client.config.client_side_validation && investments_transactions_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'investments_transactions_get_request' when calling PlaidApi.investments_transactions_get"
      end
      # resource path
      local_var_path = '/investments/transactions/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(investments_transactions_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'InvestmentsTransactionsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.investments_transactions_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#investments_transactions_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Invalidate access_token
    # By default, the `access_token` associated with an Item does not expire and should be stored in a persistent, secure manner.  You can use the `/item/access_token/invalidate` endpoint to rotate the `access_token` associated with an Item. The endpoint returns a new `access_token` and immediately invalidates the previous `access_token`. 
    # @param item_access_token_invalidate_request [ItemAccessTokenInvalidateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemAccessTokenInvalidateResponse]
    def item_access_token_invalidate(item_access_token_invalidate_request, opts = {})
      data, _status_code, _headers = item_access_token_invalidate_with_http_info(item_access_token_invalidate_request, opts)
      data
    end

    # Invalidate access_token
    # By default, the &#x60;access_token&#x60; associated with an Item does not expire and should be stored in a persistent, secure manner.  You can use the &#x60;/item/access_token/invalidate&#x60; endpoint to rotate the &#x60;access_token&#x60; associated with an Item. The endpoint returns a new &#x60;access_token&#x60; and immediately invalidates the previous &#x60;access_token&#x60;. 
    # @param item_access_token_invalidate_request [ItemAccessTokenInvalidateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemAccessTokenInvalidateResponse, Integer, Hash)>] ItemAccessTokenInvalidateResponse data, response status code and response headers
    def item_access_token_invalidate_with_http_info(item_access_token_invalidate_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_access_token_invalidate ...'
      end
      # verify the required parameter 'item_access_token_invalidate_request' is set
      if @api_client.config.client_side_validation && item_access_token_invalidate_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_access_token_invalidate_request' when calling PlaidApi.item_access_token_invalidate"
      end
      # resource path
      local_var_path = '/item/access_token/invalidate'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_access_token_invalidate_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemAccessTokenInvalidateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_access_token_invalidate",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_access_token_invalidate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List a user’s connected applications
    # List a user’s connected applications
    # @param item_application_list_request [ItemApplicationListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemApplicationListResponse]
    def item_application_list(item_application_list_request, opts = {})
      data, _status_code, _headers = item_application_list_with_http_info(item_application_list_request, opts)
      data
    end

    # List a user’s connected applications
    # List a user’s connected applications
    # @param item_application_list_request [ItemApplicationListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemApplicationListResponse, Integer, Hash)>] ItemApplicationListResponse data, response status code and response headers
    def item_application_list_with_http_info(item_application_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_application_list ...'
      end
      # verify the required parameter 'item_application_list_request' is set
      if @api_client.config.client_side_validation && item_application_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_application_list_request' when calling PlaidApi.item_application_list"
      end
      # resource path
      local_var_path = '/item/application/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_application_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemApplicationListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_application_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_application_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update the scopes of access for a particular application
    # Enable consumers to update product access on selected accounts for an application.
    # @param item_application_scopes_update_request [ItemApplicationScopesUpdateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemApplicationScopesUpdateResponse]
    def item_application_scopes_update(item_application_scopes_update_request, opts = {})
      data, _status_code, _headers = item_application_scopes_update_with_http_info(item_application_scopes_update_request, opts)
      data
    end

    # Update the scopes of access for a particular application
    # Enable consumers to update product access on selected accounts for an application.
    # @param item_application_scopes_update_request [ItemApplicationScopesUpdateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemApplicationScopesUpdateResponse, Integer, Hash)>] ItemApplicationScopesUpdateResponse data, response status code and response headers
    def item_application_scopes_update_with_http_info(item_application_scopes_update_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_application_scopes_update ...'
      end
      # verify the required parameter 'item_application_scopes_update_request' is set
      if @api_client.config.client_side_validation && item_application_scopes_update_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_application_scopes_update_request' when calling PlaidApi.item_application_scopes_update"
      end
      # resource path
      local_var_path = '/item/application/scopes/update'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_application_scopes_update_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemApplicationScopesUpdateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_application_scopes_update",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_application_scopes_update\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create public token
    # Note: As of July 2020, the `/item/public_token/create` endpoint is deprecated. Instead, use `/link/token/create` with an `access_token` to create a Link token for use with [update mode](https://plaid.com/docs/link/update-mode).  If you need your user to take action to restore or resolve an error associated with an Item, generate a public token with the `/item/public_token/create` endpoint and then initialize Link with that `public_token`.  A `public_token` is one-time use and expires after 30 minutes. You use a `public_token` to initialize Link in [update mode](https://plaid.com/docs/link/update-mode) for a particular Item. You can generate a `public_token` for an Item even if you did not use Link to create the Item originally.  The `/item/public_token/create` endpoint is **not** used to create your initial `public_token`. If you have not already received an `access_token` for a specific Item, use Link to obtain your `public_token` instead. See the [Quickstart](https://plaid.com/docs/quickstart) for more information.
    # @param item_public_token_create_request [ItemPublicTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemPublicTokenCreateResponse]
    def item_create_public_token(item_public_token_create_request, opts = {})
      data, _status_code, _headers = item_create_public_token_with_http_info(item_public_token_create_request, opts)
      data
    end

    # Create public token
    # Note: As of July 2020, the &#x60;/item/public_token/create&#x60; endpoint is deprecated. Instead, use &#x60;/link/token/create&#x60; with an &#x60;access_token&#x60; to create a Link token for use with [update mode](https://plaid.com/docs/link/update-mode).  If you need your user to take action to restore or resolve an error associated with an Item, generate a public token with the &#x60;/item/public_token/create&#x60; endpoint and then initialize Link with that &#x60;public_token&#x60;.  A &#x60;public_token&#x60; is one-time use and expires after 30 minutes. You use a &#x60;public_token&#x60; to initialize Link in [update mode](https://plaid.com/docs/link/update-mode) for a particular Item. You can generate a &#x60;public_token&#x60; for an Item even if you did not use Link to create the Item originally.  The &#x60;/item/public_token/create&#x60; endpoint is **not** used to create your initial &#x60;public_token&#x60;. If you have not already received an &#x60;access_token&#x60; for a specific Item, use Link to obtain your &#x60;public_token&#x60; instead. See the [Quickstart](https://plaid.com/docs/quickstart) for more information.
    # @param item_public_token_create_request [ItemPublicTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemPublicTokenCreateResponse, Integer, Hash)>] ItemPublicTokenCreateResponse data, response status code and response headers
    def item_create_public_token_with_http_info(item_public_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_create_public_token ...'
      end
      # verify the required parameter 'item_public_token_create_request' is set
      if @api_client.config.client_side_validation && item_public_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_public_token_create_request' when calling PlaidApi.item_create_public_token"
      end
      # resource path
      local_var_path = '/item/public_token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_public_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemPublicTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_create_public_token",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_create_public_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve an Item
    # Returns information about the status of an Item.
    # @param item_get_request [ItemGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemGetResponse]
    def item_get(item_get_request, opts = {})
      data, _status_code, _headers = item_get_with_http_info(item_get_request, opts)
      data
    end

    # Retrieve an Item
    # Returns information about the status of an Item.
    # @param item_get_request [ItemGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemGetResponse, Integer, Hash)>] ItemGetResponse data, response status code and response headers
    def item_get_with_http_info(item_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_get ...'
      end
      # verify the required parameter 'item_get_request' is set
      if @api_client.config.client_side_validation && item_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_get_request' when calling PlaidApi.item_get"
      end
      # resource path
      local_var_path = '/item/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Import Item
    # `/item/import` creates an Item via your Plaid Exchange Integration and returns an `access_token`. As part of an `/item/import` request, you will include a User ID (`user_auth.user_id`) and Authentication Token (`user_auth.auth_token`) that enable data aggregation through your Plaid Exchange API endpoints. These authentication principals are to be chosen by you.  Upon creating an Item via `/item/import`, Plaid will automatically begin an extraction of that Item through the Plaid Exchange infrastructure you have already integrated. This will automatically generate the Plaid native account ID for the account the user will switch their direct deposit to (`target_account_id`).
    # @param item_import_request [ItemImportRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemImportResponse]
    def item_import(item_import_request, opts = {})
      data, _status_code, _headers = item_import_with_http_info(item_import_request, opts)
      data
    end

    # Import Item
    # &#x60;/item/import&#x60; creates an Item via your Plaid Exchange Integration and returns an &#x60;access_token&#x60;. As part of an &#x60;/item/import&#x60; request, you will include a User ID (&#x60;user_auth.user_id&#x60;) and Authentication Token (&#x60;user_auth.auth_token&#x60;) that enable data aggregation through your Plaid Exchange API endpoints. These authentication principals are to be chosen by you.  Upon creating an Item via &#x60;/item/import&#x60;, Plaid will automatically begin an extraction of that Item through the Plaid Exchange infrastructure you have already integrated. This will automatically generate the Plaid native account ID for the account the user will switch their direct deposit to (&#x60;target_account_id&#x60;).
    # @param item_import_request [ItemImportRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemImportResponse, Integer, Hash)>] ItemImportResponse data, response status code and response headers
    def item_import_with_http_info(item_import_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_import ...'
      end
      # verify the required parameter 'item_import_request' is set
      if @api_client.config.client_side_validation && item_import_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_import_request' when calling PlaidApi.item_import"
      end
      # resource path
      local_var_path = '/item/import'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_import_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemImportResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_import",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_import\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Exchange public token for an access token
    # Exchange a Link `public_token` for an API `access_token`. Link hands off the `public_token` client-side via the `onSuccess` callback once a user has successfully created an Item. The `public_token` is ephemeral and expires after 30 minutes.  The response also includes an `item_id` that should be stored with the `access_token`. The `item_id` is used to identify an Item in a webhook. The `item_id` can also be retrieved by making an `/item/get` request.
    # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemPublicTokenExchangeResponse]
    def item_public_token_exchange(item_public_token_exchange_request, opts = {})
      data, _status_code, _headers = item_public_token_exchange_with_http_info(item_public_token_exchange_request, opts)
      data
    end

    # Exchange public token for an access token
    # Exchange a Link &#x60;public_token&#x60; for an API &#x60;access_token&#x60;. Link hands off the &#x60;public_token&#x60; client-side via the &#x60;onSuccess&#x60; callback once a user has successfully created an Item. The &#x60;public_token&#x60; is ephemeral and expires after 30 minutes.  The response also includes an &#x60;item_id&#x60; that should be stored with the &#x60;access_token&#x60;. The &#x60;item_id&#x60; is used to identify an Item in a webhook. The &#x60;item_id&#x60; can also be retrieved by making an &#x60;/item/get&#x60; request.
    # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemPublicTokenExchangeResponse, Integer, Hash)>] ItemPublicTokenExchangeResponse data, response status code and response headers
    def item_public_token_exchange_with_http_info(item_public_token_exchange_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_public_token_exchange ...'
      end
      # verify the required parameter 'item_public_token_exchange_request' is set
      if @api_client.config.client_side_validation && item_public_token_exchange_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_public_token_exchange_request' when calling PlaidApi.item_public_token_exchange"
      end
      # resource path
      local_var_path = '/item/public_token/exchange'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_public_token_exchange_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemPublicTokenExchangeResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_public_token_exchange",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_public_token_exchange\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Remove an Item
    # The `/item/remove`  endpoint allows you to remove an Item. Once removed, the `access_token`  associated with the Item is no longer valid and cannot be used to access any data that was associated with the Item.  Note that in the Development environment, issuing an `/item/remove`  request will not decrement your live credential count. To increase your credential account in Development, contact Support.  Also note that for certain OAuth-based institutions, an Item removed via `/item/remove` may still show as an active connection in the institution's OAuth permission manager.
    # @param item_remove_request [ItemRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemRemoveResponse]
    def item_remove(item_remove_request, opts = {})
      data, _status_code, _headers = item_remove_with_http_info(item_remove_request, opts)
      data
    end

    # Remove an Item
    # The &#x60;/item/remove&#x60;  endpoint allows you to remove an Item. Once removed, the &#x60;access_token&#x60;  associated with the Item is no longer valid and cannot be used to access any data that was associated with the Item.  Note that in the Development environment, issuing an &#x60;/item/remove&#x60;  request will not decrement your live credential count. To increase your credential account in Development, contact Support.  Also note that for certain OAuth-based institutions, an Item removed via &#x60;/item/remove&#x60; may still show as an active connection in the institution&#39;s OAuth permission manager.
    # @param item_remove_request [ItemRemoveRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemRemoveResponse, Integer, Hash)>] ItemRemoveResponse data, response status code and response headers
    def item_remove_with_http_info(item_remove_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_remove ...'
      end
      # verify the required parameter 'item_remove_request' is set
      if @api_client.config.client_side_validation && item_remove_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_remove_request' when calling PlaidApi.item_remove"
      end
      # resource path
      local_var_path = '/item/remove'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_remove_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemRemoveResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_remove",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_remove\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Update Webhook URL
    # The POST `/item/webhook/update` allows you to update the webhook URL associated with an Item. This request triggers a [`WEBHOOK_UPDATE_ACKNOWLEDGED`](https://plaid.com/docs/api/webhooks/#item-webhook-url-updated) webhook to the newly specified webhook URL.
    # @param item_webhook_update_request [ItemWebhookUpdateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ItemWebhookUpdateResponse]
    def item_webhook_update(item_webhook_update_request, opts = {})
      data, _status_code, _headers = item_webhook_update_with_http_info(item_webhook_update_request, opts)
      data
    end

    # Update Webhook URL
    # The POST &#x60;/item/webhook/update&#x60; allows you to update the webhook URL associated with an Item. This request triggers a [&#x60;WEBHOOK_UPDATE_ACKNOWLEDGED&#x60;](https://plaid.com/docs/api/webhooks/#item-webhook-url-updated) webhook to the newly specified webhook URL.
    # @param item_webhook_update_request [ItemWebhookUpdateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ItemWebhookUpdateResponse, Integer, Hash)>] ItemWebhookUpdateResponse data, response status code and response headers
    def item_webhook_update_with_http_info(item_webhook_update_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.item_webhook_update ...'
      end
      # verify the required parameter 'item_webhook_update_request' is set
      if @api_client.config.client_side_validation && item_webhook_update_request.nil?
        fail ArgumentError, "Missing the required parameter 'item_webhook_update_request' when calling PlaidApi.item_webhook_update"
      end
      # resource path
      local_var_path = '/item/webhook/update'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(item_webhook_update_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ItemWebhookUpdateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.item_webhook_update",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#item_webhook_update\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Liabilities data
    # The `/liabilities/get` endpoint returns various details about an Item with loan or credit accounts. Liabilities data is available primarily for US financial institutions, with some limited coverage of Canadian institutions. Currently supported account types are account type `credit` with account subtype `credit card` or `paypal`, and account type `loan` with account subtype `student` or `mortgage`. To limit accounts listed in Link to types and subtypes supported by Liabilities, you can use the `account_filters` parameter when [creating a Link token](https://plaid.com/docs/api/tokens/#linktokencreate).  The types of information returned by Liabilities can include balances and due dates, loan terms, and account details such as original loan amount and guarantor. Data is refreshed approximately once per day; the latest data can be retrieved by calling `/liabilities/get`.  Note: This request may take some time to complete if `liabilities` was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the additional data.
    # @param liabilities_get_request [LiabilitiesGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [LiabilitiesGetResponse]
    def liabilities_get(liabilities_get_request, opts = {})
      data, _status_code, _headers = liabilities_get_with_http_info(liabilities_get_request, opts)
      data
    end

    # Retrieve Liabilities data
    # The &#x60;/liabilities/get&#x60; endpoint returns various details about an Item with loan or credit accounts. Liabilities data is available primarily for US financial institutions, with some limited coverage of Canadian institutions. Currently supported account types are account type &#x60;credit&#x60; with account subtype &#x60;credit card&#x60; or &#x60;paypal&#x60;, and account type &#x60;loan&#x60; with account subtype &#x60;student&#x60; or &#x60;mortgage&#x60;. To limit accounts listed in Link to types and subtypes supported by Liabilities, you can use the &#x60;account_filters&#x60; parameter when [creating a Link token](https://plaid.com/docs/api/tokens/#linktokencreate).  The types of information returned by Liabilities can include balances and due dates, loan terms, and account details such as original loan amount and guarantor. Data is refreshed approximately once per day; the latest data can be retrieved by calling &#x60;/liabilities/get&#x60;.  Note: This request may take some time to complete if &#x60;liabilities&#x60; was not specified as an initial product when creating the Item. This is because Plaid must communicate directly with the institution to retrieve the additional data.
    # @param liabilities_get_request [LiabilitiesGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(LiabilitiesGetResponse, Integer, Hash)>] LiabilitiesGetResponse data, response status code and response headers
    def liabilities_get_with_http_info(liabilities_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.liabilities_get ...'
      end
      # verify the required parameter 'liabilities_get_request' is set
      if @api_client.config.client_side_validation && liabilities_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'liabilities_get_request' when calling PlaidApi.liabilities_get"
      end
      # resource path
      local_var_path = '/liabilities/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(liabilities_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'LiabilitiesGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.liabilities_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#liabilities_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Link Token
    # The `/link/token/create` endpoint creates a `link_token`, which is required as a parameter when initializing Link. Once Link has been initialized, it returns a `public_token`, which can then be exchanged for an `access_token` via `/item/public_token/exchange` as part of the main Link flow.  A `link_token` generated by `/link/token/create` is also used to initialize other Link flows, such as the update mode flow for tokens with expired credentials, or the Payment Initiation (Europe) flow.
    # @param link_token_create_request [LinkTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [LinkTokenCreateResponse]
    def link_token_create(link_token_create_request, opts = {})
      data, _status_code, _headers = link_token_create_with_http_info(link_token_create_request, opts)
      data
    end

    # Create Link Token
    # The &#x60;/link/token/create&#x60; endpoint creates a &#x60;link_token&#x60;, which is required as a parameter when initializing Link. Once Link has been initialized, it returns a &#x60;public_token&#x60;, which can then be exchanged for an &#x60;access_token&#x60; via &#x60;/item/public_token/exchange&#x60; as part of the main Link flow.  A &#x60;link_token&#x60; generated by &#x60;/link/token/create&#x60; is also used to initialize other Link flows, such as the update mode flow for tokens with expired credentials, or the Payment Initiation (Europe) flow.
    # @param link_token_create_request [LinkTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(LinkTokenCreateResponse, Integer, Hash)>] LinkTokenCreateResponse data, response status code and response headers
    def link_token_create_with_http_info(link_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.link_token_create ...'
      end
      # verify the required parameter 'link_token_create_request' is set
      if @api_client.config.client_side_validation && link_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'link_token_create_request' when calling PlaidApi.link_token_create"
      end
      # resource path
      local_var_path = '/link/token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(link_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'LinkTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.link_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#link_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get Link Token
    # The `/link/token/get` endpoint gets information about a previously-created `link_token` using the `/link/token/create` endpoint. It can be useful for debugging purposes.
    # @param link_token_get_request [LinkTokenGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [LinkTokenGetResponse]
    def link_token_get(link_token_get_request, opts = {})
      data, _status_code, _headers = link_token_get_with_http_info(link_token_get_request, opts)
      data
    end

    # Get Link Token
    # The &#x60;/link/token/get&#x60; endpoint gets information about a previously-created &#x60;link_token&#x60; using the &#x60;/link/token/create&#x60; endpoint. It can be useful for debugging purposes.
    # @param link_token_get_request [LinkTokenGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(LinkTokenGetResponse, Integer, Hash)>] LinkTokenGetResponse data, response status code and response headers
    def link_token_get_with_http_info(link_token_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.link_token_get ...'
      end
      # verify the required parameter 'link_token_get_request' is set
      if @api_client.config.client_side_validation && link_token_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'link_token_get_request' when calling PlaidApi.link_token_get"
      end
      # resource path
      local_var_path = '/link/token/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(link_token_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'LinkTokenGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.link_token_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#link_token_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a payment
    # After creating a payment recipient, you can use the `/payment_initiation/payment/create` endpoint to create a payment to that recipient.  Payments can be one-time or standing order (recurring) and can be denominated in either EUR or GBP.  If making domestic GBP-denominated payments, your recipient must have been created with BACS numbers. In general, EUR-denominated payments will be sent via SEPA Credit Transfer and GBP-denominated payments will be sent via the Faster Payments network, but the payment network used will be determined by the institution. Payments sent via Faster Payments will typically arrive immediately, while payments sent via SEPA Credit Transfer will typically arrive in one business day.  Standing orders (recurring payments) must be denominated in GBP and can only be sent to recipients in the UK. Once created, standing order payments cannot be modified or canceled via the API. An end user can cancel or modify a standing order directly on their banking application or website, or by contacting the bank. Standing orders will follow the payment rules of the underlying rails (Faster Payments in UK). Payments can be sent Monday to Friday, excluding bank holidays. If the pre-arranged date falls on a weekend or bank holiday, the payment is made on the next working day. It is not possible to guarantee the exact time the payment will reach the recipient’s account, although at least 90% of standing order payments are sent by 6am.  In the Development environment, payments must be below 5 GBP / EUR. For details on any payment limits in Production, contact your Plaid Account Manager.
    # @param payment_initiation_payment_create_request [PaymentInitiationPaymentCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationPaymentCreateResponse]
    def payment_initiation_payment_create(payment_initiation_payment_create_request, opts = {})
      data, _status_code, _headers = payment_initiation_payment_create_with_http_info(payment_initiation_payment_create_request, opts)
      data
    end

    # Create a payment
    # After creating a payment recipient, you can use the &#x60;/payment_initiation/payment/create&#x60; endpoint to create a payment to that recipient.  Payments can be one-time or standing order (recurring) and can be denominated in either EUR or GBP.  If making domestic GBP-denominated payments, your recipient must have been created with BACS numbers. In general, EUR-denominated payments will be sent via SEPA Credit Transfer and GBP-denominated payments will be sent via the Faster Payments network, but the payment network used will be determined by the institution. Payments sent via Faster Payments will typically arrive immediately, while payments sent via SEPA Credit Transfer will typically arrive in one business day.  Standing orders (recurring payments) must be denominated in GBP and can only be sent to recipients in the UK. Once created, standing order payments cannot be modified or canceled via the API. An end user can cancel or modify a standing order directly on their banking application or website, or by contacting the bank. Standing orders will follow the payment rules of the underlying rails (Faster Payments in UK). Payments can be sent Monday to Friday, excluding bank holidays. If the pre-arranged date falls on a weekend or bank holiday, the payment is made on the next working day. It is not possible to guarantee the exact time the payment will reach the recipient’s account, although at least 90% of standing order payments are sent by 6am.  In the Development environment, payments must be below 5 GBP / EUR. For details on any payment limits in Production, contact your Plaid Account Manager.
    # @param payment_initiation_payment_create_request [PaymentInitiationPaymentCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationPaymentCreateResponse, Integer, Hash)>] PaymentInitiationPaymentCreateResponse data, response status code and response headers
    def payment_initiation_payment_create_with_http_info(payment_initiation_payment_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_payment_create ...'
      end
      # verify the required parameter 'payment_initiation_payment_create_request' is set
      if @api_client.config.client_side_validation && payment_initiation_payment_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_payment_create_request' when calling PlaidApi.payment_initiation_payment_create"
      end
      # resource path
      local_var_path = '/payment_initiation/payment/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_payment_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationPaymentCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_payment_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_payment_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get payment details
    # The `/payment_initiation/payment/get` endpoint can be used to check the status of a payment, as well as to receive basic information such as recipient and payment amount. In the case of standing orders, the `/payment_initiation/payment/get` endpoint will provide information about the status of the overall standing order itself; the API cannot be used to retrieve payment status for individual payments within a standing order.
    # @param payment_initiation_payment_get_request [PaymentInitiationPaymentGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationPaymentGetResponse]
    def payment_initiation_payment_get(payment_initiation_payment_get_request, opts = {})
      data, _status_code, _headers = payment_initiation_payment_get_with_http_info(payment_initiation_payment_get_request, opts)
      data
    end

    # Get payment details
    # The &#x60;/payment_initiation/payment/get&#x60; endpoint can be used to check the status of a payment, as well as to receive basic information such as recipient and payment amount. In the case of standing orders, the &#x60;/payment_initiation/payment/get&#x60; endpoint will provide information about the status of the overall standing order itself; the API cannot be used to retrieve payment status for individual payments within a standing order.
    # @param payment_initiation_payment_get_request [PaymentInitiationPaymentGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationPaymentGetResponse, Integer, Hash)>] PaymentInitiationPaymentGetResponse data, response status code and response headers
    def payment_initiation_payment_get_with_http_info(payment_initiation_payment_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_payment_get ...'
      end
      # verify the required parameter 'payment_initiation_payment_get_request' is set
      if @api_client.config.client_side_validation && payment_initiation_payment_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_payment_get_request' when calling PlaidApi.payment_initiation_payment_get"
      end
      # resource path
      local_var_path = '/payment_initiation/payment/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_payment_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationPaymentGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_payment_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_payment_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List payments
    # The `/payment_initiation/payment/list` endpoint can be used to retrieve all created payments. By default, the 10 most recent payments are returned. You can request more payments and paginate through the results using the optional `count` and `cursor` parameters.
    # @param payment_initiation_payment_list_request [PaymentInitiationPaymentListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationPaymentListResponse]
    def payment_initiation_payment_list(payment_initiation_payment_list_request, opts = {})
      data, _status_code, _headers = payment_initiation_payment_list_with_http_info(payment_initiation_payment_list_request, opts)
      data
    end

    # List payments
    # The &#x60;/payment_initiation/payment/list&#x60; endpoint can be used to retrieve all created payments. By default, the 10 most recent payments are returned. You can request more payments and paginate through the results using the optional &#x60;count&#x60; and &#x60;cursor&#x60; parameters.
    # @param payment_initiation_payment_list_request [PaymentInitiationPaymentListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationPaymentListResponse, Integer, Hash)>] PaymentInitiationPaymentListResponse data, response status code and response headers
    def payment_initiation_payment_list_with_http_info(payment_initiation_payment_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_payment_list ...'
      end
      # verify the required parameter 'payment_initiation_payment_list_request' is set
      if @api_client.config.client_side_validation && payment_initiation_payment_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_payment_list_request' when calling PlaidApi.payment_initiation_payment_list"
      end
      # resource path
      local_var_path = '/payment_initiation/payment/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_payment_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationPaymentListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_payment_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_payment_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Reverse an existing payment
    # Reverse a previously initiated payment.  A payment can only be reversed once and will be refunded to the original sender's account. 
    # @param payment_initiation_payment_reverse_request [PaymentInitiationPaymentReverseRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationPaymentReverseResponse]
    def payment_initiation_payment_reverse(payment_initiation_payment_reverse_request, opts = {})
      data, _status_code, _headers = payment_initiation_payment_reverse_with_http_info(payment_initiation_payment_reverse_request, opts)
      data
    end

    # Reverse an existing payment
    # Reverse a previously initiated payment.  A payment can only be reversed once and will be refunded to the original sender&#39;s account. 
    # @param payment_initiation_payment_reverse_request [PaymentInitiationPaymentReverseRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationPaymentReverseResponse, Integer, Hash)>] PaymentInitiationPaymentReverseResponse data, response status code and response headers
    def payment_initiation_payment_reverse_with_http_info(payment_initiation_payment_reverse_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_payment_reverse ...'
      end
      # verify the required parameter 'payment_initiation_payment_reverse_request' is set
      if @api_client.config.client_side_validation && payment_initiation_payment_reverse_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_payment_reverse_request' when calling PlaidApi.payment_initiation_payment_reverse"
      end
      # resource path
      local_var_path = '/payment_initiation/payment/reverse'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_payment_reverse_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationPaymentReverseResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_payment_reverse",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_payment_reverse\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create payment recipient
    # Create a payment recipient for payment initiation.  The recipient must be in Europe, within a country that is a member of the Single Euro Payment Area (SEPA).  For a standing order (recurring) payment, the recipient must be in the UK.  The endpoint is idempotent: if a developer has already made a request with the same payment details, Plaid will return the same `recipient_id`. 
    # @param payment_initiation_recipient_create_request [PaymentInitiationRecipientCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationRecipientCreateResponse]
    def payment_initiation_recipient_create(payment_initiation_recipient_create_request, opts = {})
      data, _status_code, _headers = payment_initiation_recipient_create_with_http_info(payment_initiation_recipient_create_request, opts)
      data
    end

    # Create payment recipient
    # Create a payment recipient for payment initiation.  The recipient must be in Europe, within a country that is a member of the Single Euro Payment Area (SEPA).  For a standing order (recurring) payment, the recipient must be in the UK.  The endpoint is idempotent: if a developer has already made a request with the same payment details, Plaid will return the same &#x60;recipient_id&#x60;. 
    # @param payment_initiation_recipient_create_request [PaymentInitiationRecipientCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationRecipientCreateResponse, Integer, Hash)>] PaymentInitiationRecipientCreateResponse data, response status code and response headers
    def payment_initiation_recipient_create_with_http_info(payment_initiation_recipient_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_recipient_create ...'
      end
      # verify the required parameter 'payment_initiation_recipient_create_request' is set
      if @api_client.config.client_side_validation && payment_initiation_recipient_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_recipient_create_request' when calling PlaidApi.payment_initiation_recipient_create"
      end
      # resource path
      local_var_path = '/payment_initiation/recipient/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_recipient_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationRecipientCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_recipient_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_recipient_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get payment recipient
    # Get details about a payment recipient you have previously created.
    # @param payment_initiation_recipient_get_request [PaymentInitiationRecipientGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationRecipientGetResponse]
    def payment_initiation_recipient_get(payment_initiation_recipient_get_request, opts = {})
      data, _status_code, _headers = payment_initiation_recipient_get_with_http_info(payment_initiation_recipient_get_request, opts)
      data
    end

    # Get payment recipient
    # Get details about a payment recipient you have previously created.
    # @param payment_initiation_recipient_get_request [PaymentInitiationRecipientGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationRecipientGetResponse, Integer, Hash)>] PaymentInitiationRecipientGetResponse data, response status code and response headers
    def payment_initiation_recipient_get_with_http_info(payment_initiation_recipient_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_recipient_get ...'
      end
      # verify the required parameter 'payment_initiation_recipient_get_request' is set
      if @api_client.config.client_side_validation && payment_initiation_recipient_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_recipient_get_request' when calling PlaidApi.payment_initiation_recipient_get"
      end
      # resource path
      local_var_path = '/payment_initiation/recipient/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_recipient_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationRecipientGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_recipient_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_recipient_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List payment recipients
    # The `/payment_initiation/recipient/list` endpoint list the payment recipients that you have previously created.
    # @param payment_initiation_recipient_list_request [PaymentInitiationRecipientListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [PaymentInitiationRecipientListResponse]
    def payment_initiation_recipient_list(payment_initiation_recipient_list_request, opts = {})
      data, _status_code, _headers = payment_initiation_recipient_list_with_http_info(payment_initiation_recipient_list_request, opts)
      data
    end

    # List payment recipients
    # The &#x60;/payment_initiation/recipient/list&#x60; endpoint list the payment recipients that you have previously created.
    # @param payment_initiation_recipient_list_request [PaymentInitiationRecipientListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(PaymentInitiationRecipientListResponse, Integer, Hash)>] PaymentInitiationRecipientListResponse data, response status code and response headers
    def payment_initiation_recipient_list_with_http_info(payment_initiation_recipient_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.payment_initiation_recipient_list ...'
      end
      # verify the required parameter 'payment_initiation_recipient_list_request' is set
      if @api_client.config.client_side_validation && payment_initiation_recipient_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'payment_initiation_recipient_list_request' when calling PlaidApi.payment_initiation_recipient_list"
      end
      # resource path
      local_var_path = '/payment_initiation/recipient/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_initiation_recipient_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'PaymentInitiationRecipientListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.payment_initiation_recipient_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#payment_initiation_recipient_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Apex bank account token
    # Used to create a token suitable for sending to Apex to enable Plaid-Apex integrations.
    # @param processor_apex_processor_token_create_request [ProcessorApexProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorTokenCreateResponse]
    def processor_apex_processor_token_create(processor_apex_processor_token_create_request, opts = {})
      data, _status_code, _headers = processor_apex_processor_token_create_with_http_info(processor_apex_processor_token_create_request, opts)
      data
    end

    # Create Apex bank account token
    # Used to create a token suitable for sending to Apex to enable Plaid-Apex integrations.
    # @param processor_apex_processor_token_create_request [ProcessorApexProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorTokenCreateResponse, Integer, Hash)>] ProcessorTokenCreateResponse data, response status code and response headers
    def processor_apex_processor_token_create_with_http_info(processor_apex_processor_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_apex_processor_token_create ...'
      end
      # verify the required parameter 'processor_apex_processor_token_create_request' is set
      if @api_client.config.client_side_validation && processor_apex_processor_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_apex_processor_token_create_request' when calling PlaidApi.processor_apex_processor_token_create"
      end
      # resource path
      local_var_path = '/processor/apex/processor_token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_apex_processor_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_apex_processor_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_apex_processor_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Auth data
    # The `/processor/auth/get` endpoint returns the bank account and bank identification number (such as the routing number, for US accounts), for a checking or savings account that's associated with a given `processor_token`. The endpoint also returns high-level account data and balances when available.
    # @param processor_auth_get_request [ProcessorAuthGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorAuthGetResponse]
    def processor_auth_get(processor_auth_get_request, opts = {})
      data, _status_code, _headers = processor_auth_get_with_http_info(processor_auth_get_request, opts)
      data
    end

    # Retrieve Auth data
    # The &#x60;/processor/auth/get&#x60; endpoint returns the bank account and bank identification number (such as the routing number, for US accounts), for a checking or savings account that&#39;s associated with a given &#x60;processor_token&#x60;. The endpoint also returns high-level account data and balances when available.
    # @param processor_auth_get_request [ProcessorAuthGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorAuthGetResponse, Integer, Hash)>] ProcessorAuthGetResponse data, response status code and response headers
    def processor_auth_get_with_http_info(processor_auth_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_auth_get ...'
      end
      # verify the required parameter 'processor_auth_get_request' is set
      if @api_client.config.client_side_validation && processor_auth_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_auth_get_request' when calling PlaidApi.processor_auth_get"
      end
      # resource path
      local_var_path = '/processor/auth/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_auth_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorAuthGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_auth_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_auth_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Balance data
    # The `/processor/balance/get` endpoint returns the real-time balance for each of an Item's accounts. While other endpoints may return a balance object, only `/processor/balance/get` forces the available and current balance fields to be refreshed rather than cached. 
    # @param processor_balance_get_request [ProcessorBalanceGetRequest] The &#x60;/processor/balance/get&#x60; endpoint returns the real-time balance for the account associated with a given &#x60;processor_token&#x60;.  The current balance is the total amount of funds in the account. The available balance is the current balance less any outstanding holds or debits that have not yet posted to the account.  Note that not all institutions calculate the available balance. In the event that available balance is unavailable from the institution, Plaid will return an available balance value of &#x60;null&#x60;.
    # @param [Hash] opts the optional parameters
    # @return [ProcessorBalanceGetResponse]
    def processor_balance_get(processor_balance_get_request, opts = {})
      data, _status_code, _headers = processor_balance_get_with_http_info(processor_balance_get_request, opts)
      data
    end

    # Retrieve Balance data
    # The &#x60;/processor/balance/get&#x60; endpoint returns the real-time balance for each of an Item&#39;s accounts. While other endpoints may return a balance object, only &#x60;/processor/balance/get&#x60; forces the available and current balance fields to be refreshed rather than cached. 
    # @param processor_balance_get_request [ProcessorBalanceGetRequest] The &#x60;/processor/balance/get&#x60; endpoint returns the real-time balance for the account associated with a given &#x60;processor_token&#x60;.  The current balance is the total amount of funds in the account. The available balance is the current balance less any outstanding holds or debits that have not yet posted to the account.  Note that not all institutions calculate the available balance. In the event that available balance is unavailable from the institution, Plaid will return an available balance value of &#x60;null&#x60;.
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorBalanceGetResponse, Integer, Hash)>] ProcessorBalanceGetResponse data, response status code and response headers
    def processor_balance_get_with_http_info(processor_balance_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_balance_get ...'
      end
      # verify the required parameter 'processor_balance_get_request' is set
      if @api_client.config.client_side_validation && processor_balance_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_balance_get_request' when calling PlaidApi.processor_balance_get"
      end
      # resource path
      local_var_path = '/processor/balance/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_balance_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorBalanceGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_balance_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_balance_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a bank transfer as a processor
    # Use the `/processor/bank_transfer/create` endpoint to initiate a new bank transfer as a processor
    # @param processor_bank_transfer_create_request [ProcessorBankTransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorBankTransferCreateResponse]
    def processor_bank_transfer_create(processor_bank_transfer_create_request, opts = {})
      data, _status_code, _headers = processor_bank_transfer_create_with_http_info(processor_bank_transfer_create_request, opts)
      data
    end

    # Create a bank transfer as a processor
    # Use the &#x60;/processor/bank_transfer/create&#x60; endpoint to initiate a new bank transfer as a processor
    # @param processor_bank_transfer_create_request [ProcessorBankTransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorBankTransferCreateResponse, Integer, Hash)>] ProcessorBankTransferCreateResponse data, response status code and response headers
    def processor_bank_transfer_create_with_http_info(processor_bank_transfer_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_bank_transfer_create ...'
      end
      # verify the required parameter 'processor_bank_transfer_create_request' is set
      if @api_client.config.client_side_validation && processor_bank_transfer_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_bank_transfer_create_request' when calling PlaidApi.processor_bank_transfer_create"
      end
      # resource path
      local_var_path = '/processor/bank_transfer/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_bank_transfer_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorBankTransferCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_bank_transfer_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_bank_transfer_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve Identity data
    # The `/processor/identity/get` endpoint allows you to retrieve various account holder information on file with the financial institution, including names, emails, phone numbers, and addresses.
    # @param processor_identity_get_request [ProcessorIdentityGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorIdentityGetResponse]
    def processor_identity_get(processor_identity_get_request, opts = {})
      data, _status_code, _headers = processor_identity_get_with_http_info(processor_identity_get_request, opts)
      data
    end

    # Retrieve Identity data
    # The &#x60;/processor/identity/get&#x60; endpoint allows you to retrieve various account holder information on file with the financial institution, including names, emails, phone numbers, and addresses.
    # @param processor_identity_get_request [ProcessorIdentityGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorIdentityGetResponse, Integer, Hash)>] ProcessorIdentityGetResponse data, response status code and response headers
    def processor_identity_get_with_http_info(processor_identity_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_identity_get ...'
      end
      # verify the required parameter 'processor_identity_get_request' is set
      if @api_client.config.client_side_validation && processor_identity_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_identity_get_request' when calling PlaidApi.processor_identity_get"
      end
      # resource path
      local_var_path = '/processor/identity/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_identity_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorIdentityGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_identity_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_identity_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create Stripe bank account token
    # Used to create a token suitable for sending to Stripe to enable Plaid-Stripe integrations. For a detailed guide on integrating Stripe, see [Add Stripe to your app](https://plaid.com/docs/auth/partnerships/stripe/).
    # @param processor_stripe_bank_account_token_create_request [ProcessorStripeBankAccountTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorStripeBankAccountTokenCreateResponse]
    def processor_stripe_bank_account_token_create(processor_stripe_bank_account_token_create_request, opts = {})
      data, _status_code, _headers = processor_stripe_bank_account_token_create_with_http_info(processor_stripe_bank_account_token_create_request, opts)
      data
    end

    # Create Stripe bank account token
    # Used to create a token suitable for sending to Stripe to enable Plaid-Stripe integrations. For a detailed guide on integrating Stripe, see [Add Stripe to your app](https://plaid.com/docs/auth/partnerships/stripe/).
    # @param processor_stripe_bank_account_token_create_request [ProcessorStripeBankAccountTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorStripeBankAccountTokenCreateResponse, Integer, Hash)>] ProcessorStripeBankAccountTokenCreateResponse data, response status code and response headers
    def processor_stripe_bank_account_token_create_with_http_info(processor_stripe_bank_account_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_stripe_bank_account_token_create ...'
      end
      # verify the required parameter 'processor_stripe_bank_account_token_create_request' is set
      if @api_client.config.client_side_validation && processor_stripe_bank_account_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_stripe_bank_account_token_create_request' when calling PlaidApi.processor_stripe_bank_account_token_create"
      end
      # resource path
      local_var_path = '/processor/stripe/bank_account_token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_stripe_bank_account_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorStripeBankAccountTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_stripe_bank_account_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_stripe_bank_account_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create processor token
    # Used to create a token suitable for sending to one of Plaid's partners to enable integrations. Note that Stripe partnerships use bank account tokens instead; see `/processor/stripe/bank_account_token/create` for creating tokens for use with Stripe integrations.
    # @param processor_token_create_request [ProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [ProcessorTokenCreateResponse]
    def processor_token_create(processor_token_create_request, opts = {})
      data, _status_code, _headers = processor_token_create_with_http_info(processor_token_create_request, opts)
      data
    end

    # Create processor token
    # Used to create a token suitable for sending to one of Plaid&#39;s partners to enable integrations. Note that Stripe partnerships use bank account tokens instead; see &#x60;/processor/stripe/bank_account_token/create&#x60; for creating tokens for use with Stripe integrations.
    # @param processor_token_create_request [ProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(ProcessorTokenCreateResponse, Integer, Hash)>] ProcessorTokenCreateResponse data, response status code and response headers
    def processor_token_create_with_http_info(processor_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.processor_token_create ...'
      end
      # verify the required parameter 'processor_token_create_request' is set
      if @api_client.config.client_side_validation && processor_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'processor_token_create_request' when calling PlaidApi.processor_token_create"
      end
      # resource path
      local_var_path = '/processor/token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(processor_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'ProcessorTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.processor_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#processor_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Manually fire a Bank Transfer webhook
    # Use the `/sandbox/bank_transfer/fire_webhook` endpoint to manually trigger a Bank Transfers webhook in the Sandbox environment.
    # @param sandbox_bank_transfer_fire_webhook_request [SandboxBankTransferFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxBankTransferFireWebhookResponse]
    def sandbox_bank_transfer_fire_webhook(sandbox_bank_transfer_fire_webhook_request, opts = {})
      data, _status_code, _headers = sandbox_bank_transfer_fire_webhook_with_http_info(sandbox_bank_transfer_fire_webhook_request, opts)
      data
    end

    # Manually fire a Bank Transfer webhook
    # Use the &#x60;/sandbox/bank_transfer/fire_webhook&#x60; endpoint to manually trigger a Bank Transfers webhook in the Sandbox environment.
    # @param sandbox_bank_transfer_fire_webhook_request [SandboxBankTransferFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxBankTransferFireWebhookResponse, Integer, Hash)>] SandboxBankTransferFireWebhookResponse data, response status code and response headers
    def sandbox_bank_transfer_fire_webhook_with_http_info(sandbox_bank_transfer_fire_webhook_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_bank_transfer_fire_webhook ...'
      end
      # verify the required parameter 'sandbox_bank_transfer_fire_webhook_request' is set
      if @api_client.config.client_side_validation && sandbox_bank_transfer_fire_webhook_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_bank_transfer_fire_webhook_request' when calling PlaidApi.sandbox_bank_transfer_fire_webhook"
      end
      # resource path
      local_var_path = '/sandbox/bank_transfer/fire_webhook'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_bank_transfer_fire_webhook_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxBankTransferFireWebhookResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_bank_transfer_fire_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_bank_transfer_fire_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Simulate a bank transfer event in Sandbox
    # Use the `/sandbox/bank_transfer/simulate` endpoint to simulate a bank transfer event in the Sandbox environment.  Note that while an event will be simulated and will appear when using endpoints such as `/bank_transfer/event/sync` or `/bank_transfer/event/list`, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.
    # @param sandbox_bank_transfer_simulate_request [SandboxBankTransferSimulateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxBankTransferSimulateResponse]
    def sandbox_bank_transfer_simulate(sandbox_bank_transfer_simulate_request, opts = {})
      data, _status_code, _headers = sandbox_bank_transfer_simulate_with_http_info(sandbox_bank_transfer_simulate_request, opts)
      data
    end

    # Simulate a bank transfer event in Sandbox
    # Use the &#x60;/sandbox/bank_transfer/simulate&#x60; endpoint to simulate a bank transfer event in the Sandbox environment.  Note that while an event will be simulated and will appear when using endpoints such as &#x60;/bank_transfer/event/sync&#x60; or &#x60;/bank_transfer/event/list&#x60;, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.
    # @param sandbox_bank_transfer_simulate_request [SandboxBankTransferSimulateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxBankTransferSimulateResponse, Integer, Hash)>] SandboxBankTransferSimulateResponse data, response status code and response headers
    def sandbox_bank_transfer_simulate_with_http_info(sandbox_bank_transfer_simulate_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_bank_transfer_simulate ...'
      end
      # verify the required parameter 'sandbox_bank_transfer_simulate_request' is set
      if @api_client.config.client_side_validation && sandbox_bank_transfer_simulate_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_bank_transfer_simulate_request' when calling PlaidApi.sandbox_bank_transfer_simulate"
      end
      # resource path
      local_var_path = '/sandbox/bank_transfer/simulate'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_bank_transfer_simulate_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxBankTransferSimulateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_bank_transfer_simulate",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_bank_transfer_simulate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Manually fire an Income webhook
    # Use the `/sandbox/income/fire_webhook` endpoint to manually trigger an Income webhook in the Sandbox environment.
    # @param sandbox_income_fire_webhook_request [SandboxIncomeFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxIncomeFireWebhookResponse]
    def sandbox_income_fire_webhook(sandbox_income_fire_webhook_request, opts = {})
      data, _status_code, _headers = sandbox_income_fire_webhook_with_http_info(sandbox_income_fire_webhook_request, opts)
      data
    end

    # Manually fire an Income webhook
    # Use the &#x60;/sandbox/income/fire_webhook&#x60; endpoint to manually trigger an Income webhook in the Sandbox environment.
    # @param sandbox_income_fire_webhook_request [SandboxIncomeFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxIncomeFireWebhookResponse, Integer, Hash)>] SandboxIncomeFireWebhookResponse data, response status code and response headers
    def sandbox_income_fire_webhook_with_http_info(sandbox_income_fire_webhook_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_income_fire_webhook ...'
      end
      # verify the required parameter 'sandbox_income_fire_webhook_request' is set
      if @api_client.config.client_side_validation && sandbox_income_fire_webhook_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_income_fire_webhook_request' when calling PlaidApi.sandbox_income_fire_webhook"
      end
      # resource path
      local_var_path = '/sandbox/income/fire_webhook'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_income_fire_webhook_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxIncomeFireWebhookResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_income_fire_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_income_fire_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Fire a test webhook
    # The `/sandbox/item/fire_webhook` endpoint is used to test that code correctly handles webhooks. Calling this endpoint triggers a Transactions `DEFAULT_UPDATE` webhook to be fired for a given Sandbox Item. If the Item does not support Transactions, a `SANDBOX_PRODUCT_NOT_ENABLED` error will result.
    # @param sandbox_item_fire_webhook_request [SandboxItemFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxItemFireWebhookResponse]
    def sandbox_item_fire_webhook(sandbox_item_fire_webhook_request, opts = {})
      data, _status_code, _headers = sandbox_item_fire_webhook_with_http_info(sandbox_item_fire_webhook_request, opts)
      data
    end

    # Fire a test webhook
    # The &#x60;/sandbox/item/fire_webhook&#x60; endpoint is used to test that code correctly handles webhooks. Calling this endpoint triggers a Transactions &#x60;DEFAULT_UPDATE&#x60; webhook to be fired for a given Sandbox Item. If the Item does not support Transactions, a &#x60;SANDBOX_PRODUCT_NOT_ENABLED&#x60; error will result.
    # @param sandbox_item_fire_webhook_request [SandboxItemFireWebhookRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxItemFireWebhookResponse, Integer, Hash)>] SandboxItemFireWebhookResponse data, response status code and response headers
    def sandbox_item_fire_webhook_with_http_info(sandbox_item_fire_webhook_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_item_fire_webhook ...'
      end
      # verify the required parameter 'sandbox_item_fire_webhook_request' is set
      if @api_client.config.client_side_validation && sandbox_item_fire_webhook_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_item_fire_webhook_request' when calling PlaidApi.sandbox_item_fire_webhook"
      end
      # resource path
      local_var_path = '/sandbox/item/fire_webhook'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_item_fire_webhook_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxItemFireWebhookResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_item_fire_webhook",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_item_fire_webhook\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Force a Sandbox Item into an error state
    # `/sandbox/item/reset_login/` forces an Item into an `ITEM_LOGIN_REQUIRED` state in order to simulate an Item whose login is no longer valid. This makes it easy to test Link's [update mode](https://plaid.com/docs/link/update-mode) flow in the Sandbox environment.  After calling `/sandbox/item/reset_login`, You can then use Plaid Link update mode to restore the Item to a good state. An `ITEM_LOGIN_REQUIRED` webhook will also be fired after a call to this endpoint, if one is associated with the Item.   In the Sandbox, Items will transition to an `ITEM_LOGIN_REQUIRED` error state automatically after 30 days, even if this endpoint is not called.
    # @param sandbox_item_reset_login_request [SandboxItemResetLoginRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxItemResetLoginResponse]
    def sandbox_item_reset_login(sandbox_item_reset_login_request, opts = {})
      data, _status_code, _headers = sandbox_item_reset_login_with_http_info(sandbox_item_reset_login_request, opts)
      data
    end

    # Force a Sandbox Item into an error state
    # &#x60;/sandbox/item/reset_login/&#x60; forces an Item into an &#x60;ITEM_LOGIN_REQUIRED&#x60; state in order to simulate an Item whose login is no longer valid. This makes it easy to test Link&#39;s [update mode](https://plaid.com/docs/link/update-mode) flow in the Sandbox environment.  After calling &#x60;/sandbox/item/reset_login&#x60;, You can then use Plaid Link update mode to restore the Item to a good state. An &#x60;ITEM_LOGIN_REQUIRED&#x60; webhook will also be fired after a call to this endpoint, if one is associated with the Item.   In the Sandbox, Items will transition to an &#x60;ITEM_LOGIN_REQUIRED&#x60; error state automatically after 30 days, even if this endpoint is not called.
    # @param sandbox_item_reset_login_request [SandboxItemResetLoginRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxItemResetLoginResponse, Integer, Hash)>] SandboxItemResetLoginResponse data, response status code and response headers
    def sandbox_item_reset_login_with_http_info(sandbox_item_reset_login_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_item_reset_login ...'
      end
      # verify the required parameter 'sandbox_item_reset_login_request' is set
      if @api_client.config.client_side_validation && sandbox_item_reset_login_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_item_reset_login_request' when calling PlaidApi.sandbox_item_reset_login"
      end
      # resource path
      local_var_path = '/sandbox/item/reset_login'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_item_reset_login_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxItemResetLoginResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_item_reset_login",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_item_reset_login\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Set verification status for Sandbox account
    # The `/sandbox/item/set_verification_status` endpoint can be used to change the verification status of an Item in in the Sandbox in order to simulate the Automated Micro-deposit flow.  Note that not all Plaid developer accounts are enabled for micro-deposit based verification by default. Your account must be enabled for this feature in order to test it in Sandbox. To enable this features or check your status, contact your account manager or [submit a product access Support ticket](https://dashboard.plaid.com/support/new/product-and-development/product-troubleshooting/request-product-access).  For more information on testing Automated Micro-deposits in Sandbox, see [Auth full coverage testing](https://plaid.com/docs/auth/coverage/testing#).
    # @param sandbox_item_set_verification_status_request [SandboxItemSetVerificationStatusRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxItemSetVerificationStatusResponse]
    def sandbox_item_set_verification_status(sandbox_item_set_verification_status_request, opts = {})
      data, _status_code, _headers = sandbox_item_set_verification_status_with_http_info(sandbox_item_set_verification_status_request, opts)
      data
    end

    # Set verification status for Sandbox account
    # The &#x60;/sandbox/item/set_verification_status&#x60; endpoint can be used to change the verification status of an Item in in the Sandbox in order to simulate the Automated Micro-deposit flow.  Note that not all Plaid developer accounts are enabled for micro-deposit based verification by default. Your account must be enabled for this feature in order to test it in Sandbox. To enable this features or check your status, contact your account manager or [submit a product access Support ticket](https://dashboard.plaid.com/support/new/product-and-development/product-troubleshooting/request-product-access).  For more information on testing Automated Micro-deposits in Sandbox, see [Auth full coverage testing](https://plaid.com/docs/auth/coverage/testing#).
    # @param sandbox_item_set_verification_status_request [SandboxItemSetVerificationStatusRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxItemSetVerificationStatusResponse, Integer, Hash)>] SandboxItemSetVerificationStatusResponse data, response status code and response headers
    def sandbox_item_set_verification_status_with_http_info(sandbox_item_set_verification_status_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_item_set_verification_status ...'
      end
      # verify the required parameter 'sandbox_item_set_verification_status_request' is set
      if @api_client.config.client_side_validation && sandbox_item_set_verification_status_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_item_set_verification_status_request' when calling PlaidApi.sandbox_item_set_verification_status"
      end
      # resource path
      local_var_path = '/sandbox/item/set_verification_status'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_item_set_verification_status_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxItemSetVerificationStatusResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_item_set_verification_status",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_item_set_verification_status\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Save the selected accounts when connecting to the Platypus Oauth institution
    # @param sandbox_oauth_select_accounts_request [SandboxOauthSelectAccountsRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Object]
    def sandbox_oauth_select_accounts(sandbox_oauth_select_accounts_request, opts = {})
      data, _status_code, _headers = sandbox_oauth_select_accounts_with_http_info(sandbox_oauth_select_accounts_request, opts)
      data
    end

    # Save the selected accounts when connecting to the Platypus Oauth institution
    # @param sandbox_oauth_select_accounts_request [SandboxOauthSelectAccountsRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(Object, Integer, Hash)>] Object data, response status code and response headers
    def sandbox_oauth_select_accounts_with_http_info(sandbox_oauth_select_accounts_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_oauth_select_accounts ...'
      end
      # verify the required parameter 'sandbox_oauth_select_accounts_request' is set
      if @api_client.config.client_side_validation && sandbox_oauth_select_accounts_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_oauth_select_accounts_request' when calling PlaidApi.sandbox_oauth_select_accounts"
      end
      # resource path
      local_var_path = '/sandbox/oauth/select_accounts'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_oauth_select_accounts_request)

      # return_type
      return_type = opts[:debug_return_type] || 'Object'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_oauth_select_accounts",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_oauth_select_accounts\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a test Item and processor token
    # Use the `/sandbox/processor_token/create` endpoint to create a valid `processor_token` for an arbitrary institution ID and test credentials. The created `processor_token` corresponds to a new Sandbox Item. You can then use this `processor_token` with the `/processor/` API endpoints in Sandbox. You can also use `/sandbox/processor_token/create` with the [`user_custom` test username](https://plaid.com/docs/sandbox/user-custom) to generate a test account with custom data.
    # @param sandbox_processor_token_create_request [SandboxProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxProcessorTokenCreateResponse]
    def sandbox_processor_token_create(sandbox_processor_token_create_request, opts = {})
      data, _status_code, _headers = sandbox_processor_token_create_with_http_info(sandbox_processor_token_create_request, opts)
      data
    end

    # Create a test Item and processor token
    # Use the &#x60;/sandbox/processor_token/create&#x60; endpoint to create a valid &#x60;processor_token&#x60; for an arbitrary institution ID and test credentials. The created &#x60;processor_token&#x60; corresponds to a new Sandbox Item. You can then use this &#x60;processor_token&#x60; with the &#x60;/processor/&#x60; API endpoints in Sandbox. You can also use &#x60;/sandbox/processor_token/create&#x60; with the [&#x60;user_custom&#x60; test username](https://plaid.com/docs/sandbox/user-custom) to generate a test account with custom data.
    # @param sandbox_processor_token_create_request [SandboxProcessorTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxProcessorTokenCreateResponse, Integer, Hash)>] SandboxProcessorTokenCreateResponse data, response status code and response headers
    def sandbox_processor_token_create_with_http_info(sandbox_processor_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_processor_token_create ...'
      end
      # verify the required parameter 'sandbox_processor_token_create_request' is set
      if @api_client.config.client_side_validation && sandbox_processor_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_processor_token_create_request' when calling PlaidApi.sandbox_processor_token_create"
      end
      # resource path
      local_var_path = '/sandbox/processor_token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_processor_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxProcessorTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_processor_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_processor_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a test Item
    # Use the `/sandbox/public_token/create` endpoint to create a valid `public_token`  for an arbitrary institution ID, initial products, and test credentials. The created `public_token` maps to a new Sandbox Item. You can then call `/item/public_token/exchange` to exchange the `public_token` for an `access_token` and perform all API actions. `/sandbox/public_token/create` can also be used with the [`user_custom` test username](https://plaid.com/docs/sandbox/user-custom) to generate a test account with custom data. `/sandbox/public_token/create` cannot be used with OAuth institutions.
    # @param sandbox_public_token_create_request [SandboxPublicTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxPublicTokenCreateResponse]
    def sandbox_public_token_create(sandbox_public_token_create_request, opts = {})
      data, _status_code, _headers = sandbox_public_token_create_with_http_info(sandbox_public_token_create_request, opts)
      data
    end

    # Create a test Item
    # Use the &#x60;/sandbox/public_token/create&#x60; endpoint to create a valid &#x60;public_token&#x60;  for an arbitrary institution ID, initial products, and test credentials. The created &#x60;public_token&#x60; maps to a new Sandbox Item. You can then call &#x60;/item/public_token/exchange&#x60; to exchange the &#x60;public_token&#x60; for an &#x60;access_token&#x60; and perform all API actions. &#x60;/sandbox/public_token/create&#x60; can also be used with the [&#x60;user_custom&#x60; test username](https://plaid.com/docs/sandbox/user-custom) to generate a test account with custom data. &#x60;/sandbox/public_token/create&#x60; cannot be used with OAuth institutions.
    # @param sandbox_public_token_create_request [SandboxPublicTokenCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxPublicTokenCreateResponse, Integer, Hash)>] SandboxPublicTokenCreateResponse data, response status code and response headers
    def sandbox_public_token_create_with_http_info(sandbox_public_token_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_public_token_create ...'
      end
      # verify the required parameter 'sandbox_public_token_create_request' is set
      if @api_client.config.client_side_validation && sandbox_public_token_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_public_token_create_request' when calling PlaidApi.sandbox_public_token_create"
      end
      # resource path
      local_var_path = '/sandbox/public_token/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_public_token_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxPublicTokenCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_public_token_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_public_token_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Simulate a transfer event in Sandbox
    # Use the `/sandbox/transfer/simulate` endpoint to simulate a transfer event in the Sandbox environment.  Note that while an event will be simulated and will appear when using endpoints such as `/transfer/event/sync` or `/transfer/event/list`, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.
    # @param sandbox_transfer_simulate_request [SandboxTransferSimulateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SandboxTransferSimulateResponse]
    def sandbox_transfer_simulate(sandbox_transfer_simulate_request, opts = {})
      data, _status_code, _headers = sandbox_transfer_simulate_with_http_info(sandbox_transfer_simulate_request, opts)
      data
    end

    # Simulate a transfer event in Sandbox
    # Use the &#x60;/sandbox/transfer/simulate&#x60; endpoint to simulate a transfer event in the Sandbox environment.  Note that while an event will be simulated and will appear when using endpoints such as &#x60;/transfer/event/sync&#x60; or &#x60;/transfer/event/list&#x60;, no transactions will actually take place and funds will not move between accounts, even within the Sandbox.
    # @param sandbox_transfer_simulate_request [SandboxTransferSimulateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SandboxTransferSimulateResponse, Integer, Hash)>] SandboxTransferSimulateResponse data, response status code and response headers
    def sandbox_transfer_simulate_with_http_info(sandbox_transfer_simulate_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.sandbox_transfer_simulate ...'
      end
      # verify the required parameter 'sandbox_transfer_simulate_request' is set
      if @api_client.config.client_side_validation && sandbox_transfer_simulate_request.nil?
        fail ArgumentError, "Missing the required parameter 'sandbox_transfer_simulate_request' when calling PlaidApi.sandbox_transfer_simulate"
      end
      # resource path
      local_var_path = '/sandbox/transfer/simulate'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(sandbox_transfer_simulate_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SandboxTransferSimulateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.sandbox_transfer_simulate",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#sandbox_transfer_simulate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Report whether you initiated an ACH transaction
    # After calling `/signal/evaluate`, call `/signal/decision/report` to report whether the transaction was initiated. This endpoint will return an `INVALID_REQUEST` error if called a second time with a different value for `initiated`.
    # @param signal_decision_report_request [SignalDecisionReportRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SignalDecisionReportResponse]
    def signal_decision_report(signal_decision_report_request, opts = {})
      data, _status_code, _headers = signal_decision_report_with_http_info(signal_decision_report_request, opts)
      data
    end

    # Report whether you initiated an ACH transaction
    # After calling &#x60;/signal/evaluate&#x60;, call &#x60;/signal/decision/report&#x60; to report whether the transaction was initiated. This endpoint will return an &#x60;INVALID_REQUEST&#x60; error if called a second time with a different value for &#x60;initiated&#x60;.
    # @param signal_decision_report_request [SignalDecisionReportRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SignalDecisionReportResponse, Integer, Hash)>] SignalDecisionReportResponse data, response status code and response headers
    def signal_decision_report_with_http_info(signal_decision_report_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.signal_decision_report ...'
      end
      # verify the required parameter 'signal_decision_report_request' is set
      if @api_client.config.client_side_validation && signal_decision_report_request.nil?
        fail ArgumentError, "Missing the required parameter 'signal_decision_report_request' when calling PlaidApi.signal_decision_report"
      end
      # resource path
      local_var_path = '/signal/decision/report'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(signal_decision_report_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SignalDecisionReportResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.signal_decision_report",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#signal_decision_report\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Evaluate a planned ACH transaction
    # Use `/signal/evaluate` to evaluate a planned ACH transaction to get a return risk assessment (such as a risk score and risk tier) and additional risk signals.  In order to obtain a valid score for an ACH transaction, Plaid must have an access token for the account, and the Item must be healthy (receiving product updates) or have recently been in a healthy state. If the transaction does not meet eligibility requirements, an error will be returned corresponding to the underlying cause. If `/signal/evaluate` is called on the same transaction multiple times within a 24-hour period, cached results may be returned.
    # @param signal_evaluate_request [SignalEvaluateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [SignalEvaluateResponse]
    def signal_evaluate(signal_evaluate_request, opts = {})
      data, _status_code, _headers = signal_evaluate_with_http_info(signal_evaluate_request, opts)
      data
    end

    # Evaluate a planned ACH transaction
    # Use &#x60;/signal/evaluate&#x60; to evaluate a planned ACH transaction to get a return risk assessment (such as a risk score and risk tier) and additional risk signals.  In order to obtain a valid score for an ACH transaction, Plaid must have an access token for the account, and the Item must be healthy (receiving product updates) or have recently been in a healthy state. If the transaction does not meet eligibility requirements, an error will be returned corresponding to the underlying cause. If &#x60;/signal/evaluate&#x60; is called on the same transaction multiple times within a 24-hour period, cached results may be returned.
    # @param signal_evaluate_request [SignalEvaluateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SignalEvaluateResponse, Integer, Hash)>] SignalEvaluateResponse data, response status code and response headers
    def signal_evaluate_with_http_info(signal_evaluate_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.signal_evaluate ...'
      end
      # verify the required parameter 'signal_evaluate_request' is set
      if @api_client.config.client_side_validation && signal_evaluate_request.nil?
        fail ArgumentError, "Missing the required parameter 'signal_evaluate_request' when calling PlaidApi.signal_evaluate"
      end
      # resource path
      local_var_path = '/signal/evaluate'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(signal_evaluate_request)

      # return_type
      return_type = opts[:debug_return_type] || 'SignalEvaluateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.signal_evaluate",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#signal_evaluate\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Report a return for an ACH transaction
    # Call the `/signal/return/report` endpoint to report a returned transaction that was previously sent to the `/signal/evaluate` endpoint. Your feedback will be used by the model to incorporate the latest risk trend in your portfolio.
    # @param request_body [Hash<String, Object>] 
    # @param [Hash] opts the optional parameters
    # @return [SignalReturnReportResponse]
    def signal_return_report(request_body, opts = {})
      data, _status_code, _headers = signal_return_report_with_http_info(request_body, opts)
      data
    end

    # Report a return for an ACH transaction
    # Call the &#x60;/signal/return/report&#x60; endpoint to report a returned transaction that was previously sent to the &#x60;/signal/evaluate&#x60; endpoint. Your feedback will be used by the model to incorporate the latest risk trend in your portfolio.
    # @param request_body [Hash<String, Object>] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(SignalReturnReportResponse, Integer, Hash)>] SignalReturnReportResponse data, response status code and response headers
    def signal_return_report_with_http_info(request_body, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.signal_return_report ...'
      end
      # verify the required parameter 'request_body' is set
      if @api_client.config.client_side_validation && request_body.nil?
        fail ArgumentError, "Missing the required parameter 'request_body' when calling PlaidApi.signal_return_report"
      end
      # resource path
      local_var_path = '/signal/return/report'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(request_body)

      # return_type
      return_type = opts[:debug_return_type] || 'SignalReturnReportResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.signal_return_report",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#signal_return_report\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get transaction data
    # The `/transactions/get` endpoint allows developers to receive user-authorized transaction data for credit, depository, and some loan-type accounts (only those with account subtype `student`; coverage may be limited). For transaction history from investments accounts, use the [Investments endpoint](https://plaid.com/docs/api/products#investments) instead. Transaction data is standardized across financial institutions, and in many cases transactions are linked to a clean name, entity type, location, and category. Similarly, account data is standardized and returned with a clean name, number, balance, and other meta information where available.  Transactions are returned in reverse-chronological order, and the sequence of transaction ordering is stable and will not shift.  Transactions are not immutable and can also be removed altogether by the institution; a removed transaction will no longer appear in `/transactions/get`.  For more details, see [Pending and posted transactions](https://plaid.com/docs/transactions/transactions-data/#pending-and-posted-transactions).  Due to the potentially large number of transactions associated with an Item, results are paginated. Manipulate the `count` and `offset` parameters in conjunction with the `total_transactions` response body field to fetch all available transactions.  Data returned by `/transactions/get` will be the data available for the Item as of the most recent successful check for new transactions. Plaid typically checks for new data multiple times a day, but these checks may occur less frequently, such as once a day, depending on the institution. An Item's `status.transactions.last_successful_update` field will show the timestamp of the most recent successful update. To force Plaid to check for new transactions, you can use the `/transactions/refresh` endpoint.  Note that data may not be immediately available to `/transactions/get`. Plaid will begin to prepare transactions data upon Item link, if Link was initialized with `transactions`, or upon the first call to `/transactions/get`, if it wasn't. To be alerted when transaction data is ready to be fetched, listen for the [`INITIAL_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-initial_update) and [`HISTORICAL_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-historical_update) webhooks. If no transaction history is ready when `/transactions/get` is called, it will return a `PRODUCT_NOT_READY` error.
    # @param transactions_get_request [TransactionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransactionsGetResponse]
    def transactions_get(transactions_get_request, opts = {})
      data, _status_code, _headers = transactions_get_with_http_info(transactions_get_request, opts)
      data
    end

    # Get transaction data
    # The &#x60;/transactions/get&#x60; endpoint allows developers to receive user-authorized transaction data for credit, depository, and some loan-type accounts (only those with account subtype &#x60;student&#x60;; coverage may be limited). For transaction history from investments accounts, use the [Investments endpoint](https://plaid.com/docs/api/products#investments) instead. Transaction data is standardized across financial institutions, and in many cases transactions are linked to a clean name, entity type, location, and category. Similarly, account data is standardized and returned with a clean name, number, balance, and other meta information where available.  Transactions are returned in reverse-chronological order, and the sequence of transaction ordering is stable and will not shift.  Transactions are not immutable and can also be removed altogether by the institution; a removed transaction will no longer appear in &#x60;/transactions/get&#x60;.  For more details, see [Pending and posted transactions](https://plaid.com/docs/transactions/transactions-data/#pending-and-posted-transactions).  Due to the potentially large number of transactions associated with an Item, results are paginated. Manipulate the &#x60;count&#x60; and &#x60;offset&#x60; parameters in conjunction with the &#x60;total_transactions&#x60; response body field to fetch all available transactions.  Data returned by &#x60;/transactions/get&#x60; will be the data available for the Item as of the most recent successful check for new transactions. Plaid typically checks for new data multiple times a day, but these checks may occur less frequently, such as once a day, depending on the institution. An Item&#39;s &#x60;status.transactions.last_successful_update&#x60; field will show the timestamp of the most recent successful update. To force Plaid to check for new transactions, you can use the &#x60;/transactions/refresh&#x60; endpoint.  Note that data may not be immediately available to &#x60;/transactions/get&#x60;. Plaid will begin to prepare transactions data upon Item link, if Link was initialized with &#x60;transactions&#x60;, or upon the first call to &#x60;/transactions/get&#x60;, if it wasn&#39;t. To be alerted when transaction data is ready to be fetched, listen for the [&#x60;INITIAL_UPDATE&#x60;](https://plaid.com/docs/api/webhooks#transactions-initial_update) and [&#x60;HISTORICAL_UPDATE&#x60;](https://plaid.com/docs/api/webhooks#transactions-historical_update) webhooks. If no transaction history is ready when &#x60;/transactions/get&#x60; is called, it will return a &#x60;PRODUCT_NOT_READY&#x60; error.
    # @param transactions_get_request [TransactionsGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransactionsGetResponse, Integer, Hash)>] TransactionsGetResponse data, response status code and response headers
    def transactions_get_with_http_info(transactions_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_get ...'
      end
      # verify the required parameter 'transactions_get_request' is set
      if @api_client.config.client_side_validation && transactions_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'transactions_get_request' when calling PlaidApi.transactions_get"
      end
      # resource path
      local_var_path = '/transactions/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transactions_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransactionsGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transactions_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transactions_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get streams of recurring transactions
    # The `/transactions/recurring/get` endpoint identifies and returns groups of transactions that occur on a regular basis for the inputted Item and accounts.  The product is currently in beta. To request access, contact transactions-feedback@plaid.com.
    # @param transactions_recurring_get_request [TransactionsRecurringGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransactionsRecurringGetResponse]
    def transactions_recurring_get(transactions_recurring_get_request, opts = {})
      data, _status_code, _headers = transactions_recurring_get_with_http_info(transactions_recurring_get_request, opts)
      data
    end

    # Get streams of recurring transactions
    # The &#x60;/transactions/recurring/get&#x60; endpoint identifies and returns groups of transactions that occur on a regular basis for the inputted Item and accounts.  The product is currently in beta. To request access, contact transactions-feedback@plaid.com.
    # @param transactions_recurring_get_request [TransactionsRecurringGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransactionsRecurringGetResponse, Integer, Hash)>] TransactionsRecurringGetResponse data, response status code and response headers
    def transactions_recurring_get_with_http_info(transactions_recurring_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_recurring_get ...'
      end
      # verify the required parameter 'transactions_recurring_get_request' is set
      if @api_client.config.client_side_validation && transactions_recurring_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'transactions_recurring_get_request' when calling PlaidApi.transactions_recurring_get"
      end
      # resource path
      local_var_path = '/transactions/recurring/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transactions_recurring_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransactionsRecurringGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transactions_recurring_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transactions_recurring_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Refresh transaction data
    # `/transactions/refresh` is an optional endpoint for users of the Transactions product. It initiates an on-demand extraction to fetch the newest transactions for an Item. This on-demand extraction takes place in addition to the periodic extractions that automatically occur multiple times a day for any Transactions-enabled Item. If changes to transactions are discovered after calling `/transactions/refresh`, Plaid will fire a webhook: [`TRANSACTIONS_REMOVED`](https://plaid.com/docs/api/webhooks#deleted-transactions-detected) will be fired if any removed transactions are detected, and [`DEFAULT_UPDATE`](https://plaid.com/docs/api/webhooks#transactions-default_update) will be fired if any new transactions are detected. New transactions can be fetched by calling `/transactions/get`.  Access to `/transactions/refresh` in Production is specific to certain pricing plans. If you cannot access `/transactions/refresh` in Production, [contact Sales](https://www.plaid.com/contact) for assistance.
    # @param transactions_refresh_request [TransactionsRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransactionsRefreshResponse]
    def transactions_refresh(transactions_refresh_request, opts = {})
      data, _status_code, _headers = transactions_refresh_with_http_info(transactions_refresh_request, opts)
      data
    end

    # Refresh transaction data
    # &#x60;/transactions/refresh&#x60; is an optional endpoint for users of the Transactions product. It initiates an on-demand extraction to fetch the newest transactions for an Item. This on-demand extraction takes place in addition to the periodic extractions that automatically occur multiple times a day for any Transactions-enabled Item. If changes to transactions are discovered after calling &#x60;/transactions/refresh&#x60;, Plaid will fire a webhook: [&#x60;TRANSACTIONS_REMOVED&#x60;](https://plaid.com/docs/api/webhooks#deleted-transactions-detected) will be fired if any removed transactions are detected, and [&#x60;DEFAULT_UPDATE&#x60;](https://plaid.com/docs/api/webhooks#transactions-default_update) will be fired if any new transactions are detected. New transactions can be fetched by calling &#x60;/transactions/get&#x60;.  Access to &#x60;/transactions/refresh&#x60; in Production is specific to certain pricing plans. If you cannot access &#x60;/transactions/refresh&#x60; in Production, [contact Sales](https://www.plaid.com/contact) for assistance.
    # @param transactions_refresh_request [TransactionsRefreshRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransactionsRefreshResponse, Integer, Hash)>] TransactionsRefreshResponse data, response status code and response headers
    def transactions_refresh_with_http_info(transactions_refresh_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_refresh ...'
      end
      # verify the required parameter 'transactions_refresh_request' is set
      if @api_client.config.client_side_validation && transactions_refresh_request.nil?
        fail ArgumentError, "Missing the required parameter 'transactions_refresh_request' when calling PlaidApi.transactions_refresh"
      end
      # resource path
      local_var_path = '/transactions/refresh'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transactions_refresh_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransactionsRefreshResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transactions_refresh",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transactions_refresh\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get incremental transaction updates on an item
    # The `/transactions/sync` endpoint returns item transactions as a set of delta updates. Subsequent calls to the endpoint using the cursor returned in the response will return new added, modified, and removed transactions since the last call to the endpoint  The product is currently in beta. To request access, contact transactions-feedback@plaid.com.
    # @param transactions_sync_request [TransactionsSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransactionsSyncResponse]
    def transactions_sync(transactions_sync_request, opts = {})
      data, _status_code, _headers = transactions_sync_with_http_info(transactions_sync_request, opts)
      data
    end

    # Get incremental transaction updates on an item
    # The &#x60;/transactions/sync&#x60; endpoint returns item transactions as a set of delta updates. Subsequent calls to the endpoint using the cursor returned in the response will return new added, modified, and removed transactions since the last call to the endpoint  The product is currently in beta. To request access, contact transactions-feedback@plaid.com.
    # @param transactions_sync_request [TransactionsSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransactionsSyncResponse, Integer, Hash)>] TransactionsSyncResponse data, response status code and response headers
    def transactions_sync_with_http_info(transactions_sync_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_sync ...'
      end
      # verify the required parameter 'transactions_sync_request' is set
      if @api_client.config.client_side_validation && transactions_sync_request.nil?
        fail ArgumentError, "Missing the required parameter 'transactions_sync_request' when calling PlaidApi.transactions_sync"
      end
      # resource path
      local_var_path = '/transactions/sync'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transactions_sync_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransactionsSyncResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transactions_sync",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transactions_sync\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a transfer authorization
    # Use the `/transfer/authorization/create` endpoint to determine transfer failure risk.  In Plaid's sandbox environment the decisions will be returned as follows:    - To approve a transfer, make an authorization request with an `amount` less than the available balance in the account.    - To decline a transfer with the rationale code `NSF`, the available balance on the account must be less than the authorization `amount`. See [Create Sandbox test data](https://plaid.com/docs/sandbox/user-custom/) for details on how to customize data in Sandbox.    - To decline a transfer with the rationale code `RISK`, the available balance on the account must be exactly $0. See [Create Sandbox test data](https://plaid.com/docs/sandbox/user-custom/) for details on how to customize data in Sandbox.    - To permit a transfer with the rationale code `MANUALLY_VERIFIED_ITEM`, create an Item in Link through the [Same Day Micro-deposits flow](https://plaid.com/docs/auth/coverage/testing/#testing-same-day-micro-deposits).    - To permit a transfer with the rationale code `LOGIN_REQUIRED`, [reset the login for an Item](https://plaid.com/docs/sandbox/#item_login_required).  All username/password combinations other than the ones listed above will result in a decision of permitted and rationale code `ERROR`.
    # @param transfer_authorization_create_request [TransferAuthorizationCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferAuthorizationCreateResponse]
    def transfer_authorization_create(transfer_authorization_create_request, opts = {})
      data, _status_code, _headers = transfer_authorization_create_with_http_info(transfer_authorization_create_request, opts)
      data
    end

    # Create a transfer authorization
    # Use the &#x60;/transfer/authorization/create&#x60; endpoint to determine transfer failure risk.  In Plaid&#39;s sandbox environment the decisions will be returned as follows:    - To approve a transfer, make an authorization request with an &#x60;amount&#x60; less than the available balance in the account.    - To decline a transfer with the rationale code &#x60;NSF&#x60;, the available balance on the account must be less than the authorization &#x60;amount&#x60;. See [Create Sandbox test data](https://plaid.com/docs/sandbox/user-custom/) for details on how to customize data in Sandbox.    - To decline a transfer with the rationale code &#x60;RISK&#x60;, the available balance on the account must be exactly $0. See [Create Sandbox test data](https://plaid.com/docs/sandbox/user-custom/) for details on how to customize data in Sandbox.    - To permit a transfer with the rationale code &#x60;MANUALLY_VERIFIED_ITEM&#x60;, create an Item in Link through the [Same Day Micro-deposits flow](https://plaid.com/docs/auth/coverage/testing/#testing-same-day-micro-deposits).    - To permit a transfer with the rationale code &#x60;LOGIN_REQUIRED&#x60;, [reset the login for an Item](https://plaid.com/docs/sandbox/#item_login_required).  All username/password combinations other than the ones listed above will result in a decision of permitted and rationale code &#x60;ERROR&#x60;.
    # @param transfer_authorization_create_request [TransferAuthorizationCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferAuthorizationCreateResponse, Integer, Hash)>] TransferAuthorizationCreateResponse data, response status code and response headers
    def transfer_authorization_create_with_http_info(transfer_authorization_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_authorization_create ...'
      end
      # verify the required parameter 'transfer_authorization_create_request' is set
      if @api_client.config.client_side_validation && transfer_authorization_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_authorization_create_request' when calling PlaidApi.transfer_authorization_create"
      end
      # resource path
      local_var_path = '/transfer/authorization/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_authorization_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferAuthorizationCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_authorization_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_authorization_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Cancel a transfer
    # Use the `/transfer/cancel` endpoint to cancel a transfer.  A transfer is eligible for cancelation if the `cancellable` property returned by `/transfer/get` is `true`.
    # @param transfer_cancel_request [TransferCancelRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferCancelResponse]
    def transfer_cancel(transfer_cancel_request, opts = {})
      data, _status_code, _headers = transfer_cancel_with_http_info(transfer_cancel_request, opts)
      data
    end

    # Cancel a transfer
    # Use the &#x60;/transfer/cancel&#x60; endpoint to cancel a transfer.  A transfer is eligible for cancelation if the &#x60;cancellable&#x60; property returned by &#x60;/transfer/get&#x60; is &#x60;true&#x60;.
    # @param transfer_cancel_request [TransferCancelRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferCancelResponse, Integer, Hash)>] TransferCancelResponse data, response status code and response headers
    def transfer_cancel_with_http_info(transfer_cancel_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_cancel ...'
      end
      # verify the required parameter 'transfer_cancel_request' is set
      if @api_client.config.client_side_validation && transfer_cancel_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_cancel_request' when calling PlaidApi.transfer_cancel"
      end
      # resource path
      local_var_path = '/transfer/cancel'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_cancel_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferCancelResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_cancel",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_cancel\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Create a transfer
    # Use the `/transfer/create` endpoint to initiate a new transfer.
    # @param transfer_create_request [TransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferCreateResponse]
    def transfer_create(transfer_create_request, opts = {})
      data, _status_code, _headers = transfer_create_with_http_info(transfer_create_request, opts)
      data
    end

    # Create a transfer
    # Use the &#x60;/transfer/create&#x60; endpoint to initiate a new transfer.
    # @param transfer_create_request [TransferCreateRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferCreateResponse, Integer, Hash)>] TransferCreateResponse data, response status code and response headers
    def transfer_create_with_http_info(transfer_create_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_create ...'
      end
      # verify the required parameter 'transfer_create_request' is set
      if @api_client.config.client_side_validation && transfer_create_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_create_request' when calling PlaidApi.transfer_create"
      end
      # resource path
      local_var_path = '/transfer/create'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_create_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferCreateResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_create",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_create\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List transfer events
    # Use the `/transfer/event/list` endpoint to get a list of transfer events based on specified filter criteria.
    # @param transfer_event_list_request [TransferEventListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferEventListResponse]
    def transfer_event_list(transfer_event_list_request, opts = {})
      data, _status_code, _headers = transfer_event_list_with_http_info(transfer_event_list_request, opts)
      data
    end

    # List transfer events
    # Use the &#x60;/transfer/event/list&#x60; endpoint to get a list of transfer events based on specified filter criteria.
    # @param transfer_event_list_request [TransferEventListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferEventListResponse, Integer, Hash)>] TransferEventListResponse data, response status code and response headers
    def transfer_event_list_with_http_info(transfer_event_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_event_list ...'
      end
      # verify the required parameter 'transfer_event_list_request' is set
      if @api_client.config.client_side_validation && transfer_event_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_event_list_request' when calling PlaidApi.transfer_event_list"
      end
      # resource path
      local_var_path = '/transfer/event/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_event_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferEventListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_event_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_event_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Sync transfer events
    # `/transfer/event/sync` allows you to request up to the next 25 transfer events that happened after a specific `event_id`. Use the `/transfer/event/sync` endpoint to guarantee you have seen all transfer events.
    # @param transfer_event_sync_request [TransferEventSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferEventSyncResponse]
    def transfer_event_sync(transfer_event_sync_request, opts = {})
      data, _status_code, _headers = transfer_event_sync_with_http_info(transfer_event_sync_request, opts)
      data
    end

    # Sync transfer events
    # &#x60;/transfer/event/sync&#x60; allows you to request up to the next 25 transfer events that happened after a specific &#x60;event_id&#x60;. Use the &#x60;/transfer/event/sync&#x60; endpoint to guarantee you have seen all transfer events.
    # @param transfer_event_sync_request [TransferEventSyncRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferEventSyncResponse, Integer, Hash)>] TransferEventSyncResponse data, response status code and response headers
    def transfer_event_sync_with_http_info(transfer_event_sync_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_event_sync ...'
      end
      # verify the required parameter 'transfer_event_sync_request' is set
      if @api_client.config.client_side_validation && transfer_event_sync_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_event_sync_request' when calling PlaidApi.transfer_event_sync"
      end
      # resource path
      local_var_path = '/transfer/event/sync'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_event_sync_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferEventSyncResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_event_sync",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_event_sync\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Retrieve a transfer
    # The `/transfer/get` fetches information about the transfer corresponding to the given `transfer_id`.
    # @param transfer_get_request [TransferGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferGetResponse]
    def transfer_get(transfer_get_request, opts = {})
      data, _status_code, _headers = transfer_get_with_http_info(transfer_get_request, opts)
      data
    end

    # Retrieve a transfer
    # The &#x60;/transfer/get&#x60; fetches information about the transfer corresponding to the given &#x60;transfer_id&#x60;.
    # @param transfer_get_request [TransferGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferGetResponse, Integer, Hash)>] TransferGetResponse data, response status code and response headers
    def transfer_get_with_http_info(transfer_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_get ...'
      end
      # verify the required parameter 'transfer_get_request' is set
      if @api_client.config.client_side_validation && transfer_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_get_request' when calling PlaidApi.transfer_get"
      end
      # resource path
      local_var_path = '/transfer/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # List transfers
    # Use the `/transfer/list` endpoint to see a list of all your transfers and their statuses. Results are paginated; use the `count` and `offset` query parameters to retrieve the desired transfers. 
    # @param transfer_list_request [TransferListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [TransferListResponse]
    def transfer_list(transfer_list_request, opts = {})
      data, _status_code, _headers = transfer_list_with_http_info(transfer_list_request, opts)
      data
    end

    # List transfers
    # Use the &#x60;/transfer/list&#x60; endpoint to see a list of all your transfers and their statuses. Results are paginated; use the &#x60;count&#x60; and &#x60;offset&#x60; query parameters to retrieve the desired transfers. 
    # @param transfer_list_request [TransferListRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(TransferListResponse, Integer, Hash)>] TransferListResponse data, response status code and response headers
    def transfer_list_with_http_info(transfer_list_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.transfer_list ...'
      end
      # verify the required parameter 'transfer_list_request' is set
      if @api_client.config.client_side_validation && transfer_list_request.nil?
        fail ArgumentError, "Missing the required parameter 'transfer_list_request' when calling PlaidApi.transfer_list"
      end
      # resource path
      local_var_path = '/transfer/list'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(transfer_list_request)

      # return_type
      return_type = opts[:debug_return_type] || 'TransferListResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.transfer_list",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#transfer_list\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end

    # Get webhook verification key
    # Plaid signs all outgoing webhooks and provides JSON Web Tokens (JWTs) so that you can verify the authenticity of any incoming webhooks to your application. A message signature is included in the `Plaid-Verification` header.  The `/webhook_verification_key/get` endpoint provides a JSON Web Key (JWK) that can be used to verify a JWT.
    # @param webhook_verification_key_get_request [WebhookVerificationKeyGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [WebhookVerificationKeyGetResponse]
    def webhook_verification_key_get(webhook_verification_key_get_request, opts = {})
      data, _status_code, _headers = webhook_verification_key_get_with_http_info(webhook_verification_key_get_request, opts)
      data
    end

    # Get webhook verification key
    # Plaid signs all outgoing webhooks and provides JSON Web Tokens (JWTs) so that you can verify the authenticity of any incoming webhooks to your application. A message signature is included in the &#x60;Plaid-Verification&#x60; header.  The &#x60;/webhook_verification_key/get&#x60; endpoint provides a JSON Web Key (JWK) that can be used to verify a JWT.
    # @param webhook_verification_key_get_request [WebhookVerificationKeyGetRequest] 
    # @param [Hash] opts the optional parameters
    # @return [Array<(WebhookVerificationKeyGetResponse, Integer, Hash)>] WebhookVerificationKeyGetResponse data, response status code and response headers
    def webhook_verification_key_get_with_http_info(webhook_verification_key_get_request, opts = {})
      if @api_client.config.debugging
        @api_client.config.logger.debug 'Calling API: PlaidApi.webhook_verification_key_get ...'
      end
      # verify the required parameter 'webhook_verification_key_get_request' is set
      if @api_client.config.client_side_validation && webhook_verification_key_get_request.nil?
        fail ArgumentError, "Missing the required parameter 'webhook_verification_key_get_request' when calling PlaidApi.webhook_verification_key_get"
      end
      # resource path
      local_var_path = '/webhook_verification_key/get'

      # query parameters
      query_params = opts[:query_params] || {}

      # header parameters
      header_params = opts[:header_params] || {}
      # HTTP header 'Accept' (if needed)
      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
      # HTTP header 'Content-Type'
      header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])

      # form parameters
      form_params = opts[:form_params] || {}

      # http body (model)
      post_body = opts[:debug_body] || @api_client.object_to_http_body(webhook_verification_key_get_request)

      # return_type
      return_type = opts[:debug_return_type] || 'WebhookVerificationKeyGetResponse'

      # auth_names
      auth_names = opts[:debug_auth_names] || ['clientId', 'plaidVersion', 'secret']

      new_options = opts.merge(
        :operation => :"PlaidApi.webhook_verification_key_get",
        :header_params => header_params,
        :query_params => query_params,
        :form_params => form_params,
        :body => post_body,
        :auth_names => auth_names,
        :return_type => return_type
      )

      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
      if @api_client.config.debugging
        @api_client.config.logger.debug "API called: PlaidApi#webhook_verification_key_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
      end
      return data, status_code, headers
    end
  end
end