moneykit 0.0.3 → 0.0.5

data/lib/plaid_compatible/money_kit_plaid_compatible/api/plaid_api.rb

@@ -12,729 +12,734 @@ require 'cgi'
 
 module MoneyKit
   module PlaidCompatible
-  class PlaidApi
-    attr_accessor :api_client
+    class PlaidApi
+      attr_accessor :api_client
 
-    def initialize(api_client = ApiClient.default)
-      @api_client = api_client
-    end
-
-    # /accounts/get
-    # @param accounts_get_request [AccountsGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [AccountsGetResponse]
-    def accounts_get(accounts_get_request, opts = {})
-      data, _status_code, _headers = accounts_get_with_http_info(accounts_get_request, opts)
-      data
-    end
-
-    # /accounts/get
-    # @param accounts_get_request [AccountsGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(AccountsGetResponse, Integer, Hash)>] AccountsGetResponse data, response status code and response headers
-    def accounts_get_with_http_info(accounts_get_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.accounts_get ...' if @api_client.config.debugging
-      # verify the required parameter 'accounts_get_request' is set
-      if @api_client.config.client_side_validation && accounts_get_request.nil?
-        raise ArgumentError, "Missing the required parameter 'accounts_get_request' when calling PlaidApi.accounts_get"
+      def initialize(api_client = ApiClient.default)
+        @api_client = api_client
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /accounts/get
+      # @param accounts_get_request [AccountsGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [AccountsGetResponse]
+      def accounts_get(accounts_get_request, opts = {})
+        data, _status_code, _headers = accounts_get_with_http_info(accounts_get_request, opts)
+        data
       end
-      [data, status_code, headers]
-    end
 
-    # /auth/get
-    # @param auth_get_request [AuthGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [AuthGetResponse]
-    def auth_get(auth_get_request, opts = {})
-      data, _status_code, _headers = auth_get_with_http_info(auth_get_request, opts)
-      data
-    end
-
-    # /auth/get
-    # @param auth_get_request [AuthGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(AuthGetResponse, Integer, Hash)>] AuthGetResponse data, response status code and response headers
-    def auth_get_with_http_info(auth_get_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.auth_get ...' if @api_client.config.debugging
-      # verify the required parameter 'auth_get_request' is set
-      if @api_client.config.client_side_validation && auth_get_request.nil?
-        raise ArgumentError, "Missing the required parameter 'auth_get_request' when calling PlaidApi.auth_get"
+      # /accounts/get
+      # @param accounts_get_request [AccountsGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(AccountsGetResponse, Integer, Hash)>] AccountsGetResponse data, response status code and response headers
+      def accounts_get_with_http_info(accounts_get_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.accounts_get ...' if @api_client.config.debugging
+        # verify the required parameter 'accounts_get_request' is set
+        if @api_client.config.client_side_validation && accounts_get_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /auth/get
+      # @param auth_get_request [AuthGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [AuthGetResponse]
+      def auth_get(auth_get_request, opts = {})
+        data, _status_code, _headers = auth_get_with_http_info(auth_get_request, opts)
+        data
       end
-      [data, status_code, headers]
-    end
-
-    # /identity/get
-    # @param identity_get_request [IdentityGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [IdentityGetResponse]
-    def identity_get(identity_get_request, opts = {})
-      data, _status_code, _headers = identity_get_with_http_info(identity_get_request, opts)
-      data
-    end
 
-    # /identity/get
-    # @param identity_get_request [IdentityGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(IdentityGetResponse, Integer, Hash)>] IdentityGetResponse data, response status code and response headers
-    def identity_get_with_http_info(identity_get_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.identity_get ...' if @api_client.config.debugging
-      # verify the required parameter 'identity_get_request' is set
-      if @api_client.config.client_side_validation && identity_get_request.nil?
-        raise ArgumentError, "Missing the required parameter 'identity_get_request' when calling PlaidApi.identity_get"
+      # /auth/get
+      # @param auth_get_request [AuthGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(AuthGetResponse, Integer, Hash)>] AuthGetResponse data, response status code and response headers
+      def auth_get_with_http_info(auth_get_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.auth_get ...' if @api_client.config.debugging
+        # verify the required parameter 'auth_get_request' is set
+        if @api_client.config.client_side_validation && auth_get_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /identity/get
+      # @param identity_get_request [IdentityGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [IdentityGetResponse]
+      def identity_get(identity_get_request, opts = {})
+        data, _status_code, _headers = identity_get_with_http_info(identity_get_request, opts)
+        data
       end
-      [data, status_code, headers]
-    end
 
-    # /institutions/get_by_id
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @option opts [InstitutionsGetByIdRequest] :institutions_get_by_id_request
-    # @return [InstitutionsGetByIdResponse]
-    def institutions_get_by_id(opts = {})
-      data, _status_code, _headers = institutions_get_by_id_with_http_info(opts)
-      data
-    end
-
-    # /institutions/get_by_id
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @option opts [InstitutionsGetByIdRequest] :institutions_get_by_id_request
-    # @return [Array<(InstitutionsGetByIdResponse, Integer, Hash)>] InstitutionsGetByIdResponse data, response status code and response headers
-    def institutions_get_by_id_with_http_info(opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.institutions_get_by_id ...' if @api_client.config.debugging
-      # 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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # form parameters
-      form_params = opts[:form_params] || {}
-
-      # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:institutions_get_by_id_request])
-
-      # return_type
-      return_type = opts[:debug_return_type] || 'InstitutionsGetByIdResponse'
-
-      # auth_names
-      auth_names = opts[:debug_auth_names] || %w[clientId 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}"
+      # /identity/get
+      # @param identity_get_request [IdentityGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(IdentityGetResponse, Integer, Hash)>] IdentityGetResponse data, response status code and response headers
+      def identity_get_with_http_info(identity_get_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.identity_get ...' if @api_client.config.debugging
+        # verify the required parameter 'identity_get_request' is set
+        if @api_client.config.client_side_validation && identity_get_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
 
-    # /item/get
-    # @param item_get_request [ItemGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [ItemGetResponse]
-    def item_get(item_get_request, opts = {})
-      data, _status_code, _headers = item_get_with_http_info(item_get_request, opts)
-      data
-    end
-
-    # /item/get
-    # @param item_get_request [ItemGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(ItemGetResponse, Integer, Hash)>] ItemGetResponse data, response status code and response headers
-    def item_get_with_http_info(item_get_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.item_get ...' if @api_client.config.debugging
-      # verify the required parameter 'item_get_request' is set
-      if @api_client.config.client_side_validation && item_get_request.nil?
-        raise ArgumentError, "Missing the required parameter 'item_get_request' when calling PlaidApi.item_get"
+      # /institutions/get_by_id
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @option opts [InstitutionsGetByIdRequest] :institutions_get_by_id_request
+      # @return [InstitutionsGetByIdResponse]
+      def institutions_get_by_id(opts = {})
+        data, _status_code, _headers = institutions_get_by_id_with_http_info(opts)
+        data
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /institutions/get_by_id
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @option opts [InstitutionsGetByIdRequest] :institutions_get_by_id_request
+      # @return [Array<(InstitutionsGetByIdResponse, Integer, Hash)>] InstitutionsGetByIdResponse data, response status code and response headers
+      def institutions_get_by_id_with_http_info(opts = {})
+        if @api_client.config.debugging
+          @api_client.config.logger.debug 'Calling API: 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # form parameters
+        form_params = opts[:form_params] || {}
+
+        # http body (model)
+        post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:institutions_get_by_id_request])
+
+        # return_type
+        return_type = opts[:debug_return_type] || 'InstitutionsGetByIdResponse'
+
+        # auth_names
+        auth_names = opts[:debug_auth_names] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
-
-    # /item/public_token/exchange
-    # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @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
 
-    # /item/public_token/exchange
-    # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @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?
-        raise ArgumentError,
-              "Missing the required parameter 'item_public_token_exchange_request' when calling PlaidApi.item_public_token_exchange"
+      # /item/get
+      # @param item_get_request [ItemGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [ItemGetResponse]
+      def item_get(item_get_request, opts = {})
+        data, _status_code, _headers = item_get_with_http_info(item_get_request, opts)
+        data
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /item/get
+      # @param item_get_request [ItemGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(ItemGetResponse, Integer, Hash)>] ItemGetResponse data, response status code and response headers
+      def item_get_with_http_info(item_get_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.item_get ...' if @api_client.config.debugging
+        # verify the required parameter 'item_get_request' is set
+        if @api_client.config.client_side_validation && item_get_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
-
-    # /item/remove
-    # @param item_remove_request [ItemRemoveRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [ItemRemoveResponse]
-    def item_remove(item_remove_request, opts = {})
-      data, _status_code, _headers = item_remove_with_http_info(item_remove_request, opts)
-      data
-    end
 
-    # /item/remove
-    # @param item_remove_request [ItemRemoveRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(ItemRemoveResponse, Integer, Hash)>] ItemRemoveResponse data, response status code and response headers
-    def item_remove_with_http_info(item_remove_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.item_remove ...' if @api_client.config.debugging
-      # verify the required parameter 'item_remove_request' is set
-      if @api_client.config.client_side_validation && item_remove_request.nil?
-        raise ArgumentError, "Missing the required parameter 'item_remove_request' when calling PlaidApi.item_remove"
+      # /item/public_token/exchange
+      # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @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
 
-      # 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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /item/public_token/exchange
+      # @param item_public_token_exchange_request [ItemPublicTokenExchangeRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @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?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
-
-    # /link/token/create
-    # @param link_token_create_request [LinkTokenCreateRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @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
 
-    # /link/token/create
-    # @param link_token_create_request [LinkTokenCreateRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @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 = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.link_token_create ...' if @api_client.config.debugging
-      # verify the required parameter 'link_token_create_request' is set
-      if @api_client.config.client_side_validation && link_token_create_request.nil?
-        raise ArgumentError,
-              "Missing the required parameter 'link_token_create_request' when calling PlaidApi.link_token_create"
+      # /item/remove
+      # @param item_remove_request [ItemRemoveRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [ItemRemoveResponse]
+      def item_remove(item_remove_request, opts = {})
+        data, _status_code, _headers = item_remove_with_http_info(item_remove_request, opts)
+        data
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /item/remove
+      # @param item_remove_request [ItemRemoveRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(ItemRemoveResponse, Integer, Hash)>] ItemRemoveResponse data, response status code and response headers
+      def item_remove_with_http_info(item_remove_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.item_remove ...' if @api_client.config.debugging
+        # verify the required parameter 'item_remove_request' is set
+        if @api_client.config.client_side_validation && item_remove_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
 
-    # /transactions/get
-    # @param transactions_get_request [TransactionsGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [TransactionsGetResponse]
-    def transactions_get(transactions_get_request, opts = {})
-      data, _status_code, _headers = transactions_get_with_http_info(transactions_get_request, opts)
-      data
-    end
-
-    # /transactions/get
-    # @param transactions_get_request [TransactionsGetRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(TransactionsGetResponse, Integer, Hash)>] TransactionsGetResponse data, response status code and response headers
-    def transactions_get_with_http_info(transactions_get_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_get ...' if @api_client.config.debugging
-      # verify the required parameter 'transactions_get_request' is set
-      if @api_client.config.client_side_validation && transactions_get_request.nil?
-        raise ArgumentError,
-              "Missing the required parameter 'transactions_get_request' when calling PlaidApi.transactions_get"
+      # /link/token/create
+      # @param link_token_create_request [LinkTokenCreateRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @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
 
-      # 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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /link/token/create
+      # @param link_token_create_request [LinkTokenCreateRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @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 = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.link_token_create ...' if @api_client.config.debugging
+        # verify the required parameter 'link_token_create_request' is set
+        if @api_client.config.client_side_validation && link_token_create_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
-    end
 
-    # /transactions/refresh
-    # @param transactions_refresh_request [TransactionsRefreshRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [TransactionsRefreshResponse]
-    def transactions_refresh(transactions_refresh_request, opts = {})
-      data, _status_code, _headers = transactions_refresh_with_http_info(transactions_refresh_request, opts)
-      data
-    end
+      # /transactions/get
+      # @param transactions_get_request [TransactionsGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [TransactionsGetResponse]
+      def transactions_get(transactions_get_request, opts = {})
+        data, _status_code, _headers = transactions_get_with_http_info(transactions_get_request, opts)
+        data
+      end
 
-    # /transactions/refresh
-    # @param transactions_refresh_request [TransactionsRefreshRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(TransactionsRefreshResponse, Integer, Hash)>] TransactionsRefreshResponse data, response status code and response headers
-    def transactions_refresh_with_http_info(transactions_refresh_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_refresh ...' if @api_client.config.debugging
-      # verify the required parameter 'transactions_refresh_request' is set
-      if @api_client.config.client_side_validation && transactions_refresh_request.nil?
-        raise ArgumentError,
-              "Missing the required parameter 'transactions_refresh_request' when calling PlaidApi.transactions_refresh"
+      # /transactions/get
+      # @param transactions_get_request [TransactionsGetRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(TransactionsGetResponse, Integer, Hash)>] TransactionsGetResponse data, response status code and response headers
+      def transactions_get_with_http_info(transactions_get_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_get ...' if @api_client.config.debugging
+        # verify the required parameter 'transactions_get_request' is set
+        if @api_client.config.client_side_validation && transactions_get_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /transactions/refresh
+      # @param transactions_refresh_request [TransactionsRefreshRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [TransactionsRefreshResponse]
+      def transactions_refresh(transactions_refresh_request, opts = {})
+        data, _status_code, _headers = transactions_refresh_with_http_info(transactions_refresh_request, opts)
+        data
       end
-      [data, status_code, headers]
-    end
 
-    # /transactions/sync
-    # @param transactions_sync_request [TransactionsSyncRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [TransactionsSyncResponse]
-    def transactions_sync(transactions_sync_request, opts = {})
-      data, _status_code, _headers = transactions_sync_with_http_info(transactions_sync_request, opts)
-      data
-    end
+      # /transactions/refresh
+      # @param transactions_refresh_request [TransactionsRefreshRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(TransactionsRefreshResponse, Integer, Hash)>] TransactionsRefreshResponse data, response status code and response headers
+      def transactions_refresh_with_http_info(transactions_refresh_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_refresh ...' if @api_client.config.debugging
+        # verify the required parameter 'transactions_refresh_request' is set
+        if @api_client.config.client_side_validation && transactions_refresh_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
+      end
 
-    # /transactions/sync
-    # @param transactions_sync_request [TransactionsSyncRequest]
-    # @param [Hash] opts the optional parameters
-    # @option opts [String] :plaid_version
-    # @return [Array<(TransactionsSyncResponse, Integer, Hash)>] TransactionsSyncResponse data, response status code and response headers
-    def transactions_sync_with_http_info(transactions_sync_request, opts = {})
-      @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_sync ...' if @api_client.config.debugging
-      # verify the required parameter 'transactions_sync_request' is set
-      if @api_client.config.client_side_validation && transactions_sync_request.nil?
-        raise ArgumentError,
-              "Missing the required parameter 'transactions_sync_request' when calling PlaidApi.transactions_sync"
+      # /transactions/sync
+      # @param transactions_sync_request [TransactionsSyncRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [TransactionsSyncResponse]
+      def transactions_sync(transactions_sync_request, opts = {})
+        data, _status_code, _headers = transactions_sync_with_http_info(transactions_sync_request, opts)
+        data
       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'])
-      header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
-
-      # 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] || %w[clientId 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}"
+      # /transactions/sync
+      # @param transactions_sync_request [TransactionsSyncRequest]
+      # @param [Hash] opts the optional parameters
+      # @option opts [String] :plaid_version
+      # @return [Array<(TransactionsSyncResponse, Integer, Hash)>] TransactionsSyncResponse data, response status code and response headers
+      def transactions_sync_with_http_info(transactions_sync_request, opts = {})
+        @api_client.config.logger.debug 'Calling API: PlaidApi.transactions_sync ...' if @api_client.config.debugging
+        # verify the required parameter 'transactions_sync_request' is set
+        if @api_client.config.client_side_validation && transactions_sync_request.nil?
+          raise 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'])
+        header_params[:'Plaid-Version'] = opts[:plaid_version] unless opts[:plaid_version].nil?
+
+        # 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] || %w[clientId 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
+        [data, status_code, headers]
       end
-      [data, status_code, headers]
     end
   end
-  end
 end