square.rb 44.2.0.20251016 → 45.0.1.20260122

data/lib/square/labor/client.rb

@@ -3,7 +3,9 @@
 module Square
   module Labor
     class Client
-      # @return [Square::Labor::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
@@ -17,25 +19,35 @@ module Square
       # - `start_at`
       # - `end_at`
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::CreateScheduledShiftRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
       # @return [Square::Types::CreateScheduledShiftResponse]
       def create_scheduled_shift(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/scheduled-shifts",
-          body: params
+          body: Square::Labor::Types::CreateScheduledShiftRequest.new(params).to_h,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::CreateScheduledShiftResponse.load(_response.body)
+          Square::Types::CreateScheduledShiftResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
@@ -46,73 +58,104 @@ module Square
       # The minimum `start_at` and maximum `end_at` timestamps of all shifts in a
       # `BulkPublishScheduledShifts` request must fall within a two-week period.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::BulkPublishScheduledShiftsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
       # @return [Square::Types::BulkPublishScheduledShiftsResponse]
       def bulk_publish_scheduled_shifts(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/scheduled-shifts/bulk-publish",
-          body: params
+          body: Square::Labor::Types::BulkPublishScheduledShiftsRequest.new(params).to_h,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::BulkPublishScheduledShiftsResponse.load(_response.body)
+          Square::Types::BulkPublishScheduledShiftsResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
       # Returns a paginated list of scheduled shifts, with optional filter and sort settings.
       # By default, results are sorted by `start_at` in ascending order.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::SearchScheduledShiftsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
       # @return [Square::Types::SearchScheduledShiftsResponse]
       def search_scheduled_shifts(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/scheduled-shifts/search",
-          body: params
+          body: Square::Labor::Types::SearchScheduledShiftsRequest.new(params).to_h,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::SearchScheduledShiftsResponse.load(_response.body)
+          Square::Types::SearchScheduledShiftsResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
       # Retrieves a scheduled shift by ID.
       #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::RetrieveScheduledShiftResponse]
       def retrieve_scheduled_shift(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "GET",
-          path: "v2/labor/scheduled-shifts/#{params[:id]}"
+          path: "v2/labor/scheduled-shifts/#{params[:id]}",
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::RetrieveScheduledShiftResponse.load(_response.body)
+          Square::Types::RetrieveScheduledShiftResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
@@ -127,54 +170,80 @@ module Square
       # - Change the `is_deleted` field. To delete a scheduled shift, set `is_deleted` to true
       # and then publish the shift.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::UpdateScheduledShiftRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::UpdateScheduledShiftResponse]
       def update_scheduled_shift(request_options: {}, **params)
-        _path_param_names = ["id"]
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request_data = Square::Labor::Types::UpdateScheduledShiftRequest.new(params).to_h
+        non_body_param_names = ["id"]
+        body = request_data.except(*non_body_param_names)
 
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "PUT",
           path: "v2/labor/scheduled-shifts/#{params[:id]}",
-          body: params.except(*_path_param_names)
+          body: body,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::UpdateScheduledShiftResponse.load(_response.body)
+          Square::Types::UpdateScheduledShiftResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
       # Publishes a scheduled shift. When a scheduled shift is published, Square keeps the
       # `draft_shift_details` field as is and copies it to the `published_shift_details` field.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::PublishScheduledShiftRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::PublishScheduledShiftResponse]
       def publish_scheduled_shift(request_options: {}, **params)
-        _path_param_names = ["id"]
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request_data = Square::Labor::Types::PublishScheduledShiftRequest.new(params).to_h
+        non_body_param_names = ["id"]
+        body = request_data.except(*non_body_param_names)
 
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/scheduled-shifts/#{params[:id]}/publish",
-          body: params.except(*_path_param_names)
+          body: body,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::PublishScheduledShiftResponse.load(_response.body)
+          Square::Types::PublishScheduledShiftResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
@@ -197,25 +266,35 @@ module Square
       # is before the `Timecard.start_at`, a break `end_at` is after
       # the `Timecard.end_at`, or both.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::CreateTimecardRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
       # @return [Square::Types::CreateTimecardResponse]
       def create_timecard(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/timecards",
-          body: params
+          body: Square::Labor::Types::CreateTimecardRequest.new(params).to_h,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::CreateTimecardResponse.load(_response.body)
+          Square::Types::CreateTimecardResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
@@ -234,48 +313,69 @@ module Square
       # - `CREATED_AT`
       # - `UPDATED_AT`
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::SearchTimecardsRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
       # @return [Square::Types::SearchTimecardsResponse]
       def search_timecards(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "POST",
           path: "v2/labor/timecards/search",
-          body: params
+          body: Square::Labor::Types::SearchTimecardsRequest.new(params).to_h,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::SearchTimecardsResponse.load(_response.body)
+          Square::Types::SearchTimecardsResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
       # Returns a single `Timecard` specified by `id`.
       #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::RetrieveTimecardResponse]
       def retrieve_timecard(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "GET",
-          path: "v2/labor/timecards/#{params[:id]}"
+          path: "v2/labor/timecards/#{params[:id]}",
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::RetrieveTimecardResponse.load(_response.body)
+          Square::Types::RetrieveTimecardResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
@@ -287,50 +387,74 @@ module Square
       # When closing a `Timecard`, all `Break` instances in the `Timecard` must be complete with `end_at`
       # set on each `Break`.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Labor::Types::UpdateTimecardRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::UpdateTimecardResponse]
       def update_timecard(request_options: {}, **params)
-        _path_param_names = ["id"]
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request_data = Square::Labor::Types::UpdateTimecardRequest.new(params).to_h
+        non_body_param_names = ["id"]
+        body = request_data.except(*non_body_param_names)
 
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "PUT",
           path: "v2/labor/timecards/#{params[:id]}",
-          body: params.except(*_path_param_names)
+          body: body,
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::UpdateTimecardResponse.load(_response.body)
+          Square::Types::UpdateTimecardResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 
       # Deletes a `Timecard`.
       #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :id
+      #
       # @return [Square::Types::DeleteTimecardResponse]
       def delete_timecard(request_options: {}, **params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "DELETE",
-          path: "v2/labor/timecards/#{params[:id]}"
+          path: "v2/labor/timecards/#{params[:id]}",
+          request_options: request_options
         )
         begin
-          _response = @client.send(_request)
+          response = @client.send(request)
         rescue Net::HTTPRequestTimeout
           raise Square::Errors::TimeoutError
         end
-        code = _response.code.to_i
+        code = response.code.to_i
         if code.between?(200, 299)
-          Square::Types::DeleteTimecardResponse.load(_response.body)
+          Square::Types::DeleteTimecardResponse.load(response.body)
         else
           error_class = Square::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(_response.body, code: code)
+          raise error_class.new(response.body, code: code)
         end
       end
 

data/lib/square/labor/employee_wages/client.rb

@@ -4,62 +4,95 @@ module Square
   module Labor
     module EmployeeWages
       class Client
-        # @return [Square::Labor::EmployeeWages::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
 
         # Returns a paginated list of `EmployeeWage` instances for a business.
         #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String, nil] :employee_id
+        # @option params [Integer, nil] :limit
+        # @option params [String, nil] :cursor
+        #
         # @return [Square::Types::ListEmployeeWagesResponse]
         def list(request_options: {}, **params)
-          _query_param_names = [
-            %w[employee_id limit cursor],
-            %i[employee_id limit cursor]
-          ].flatten
-          _query = params.slice(*_query_param_names)
-          params.except(*_query_param_names)
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          query_param_names = %i[employee_id limit cursor]
+          query_params = {}
+          query_params["employee_id"] = params[:employee_id] if params.key?(:employee_id)
+          query_params["limit"] = params[:limit] if params.key?(:limit)
+          query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+          params.except(*query_param_names)
 
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-            method: "GET",
-            path: "v2/labor/employee-wages",
-            query: _query
-          )
-          begin
-            _response = @client.send(_request)
-          rescue Net::HTTPRequestTimeout
-            raise Square::Errors::TimeoutError
-          end
-          code = _response.code.to_i
-          if code.between?(200, 299)
-            Square::Types::ListEmployeeWagesResponse.load(_response.body)
-          else
-            error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+          Square::Internal::CursorItemIterator.new(
+            cursor_field: :cursor,
+            item_field: :employee_wages,
+            initial_cursor: query_params[:cursor]
+          ) do |next_cursor|
+            query_params[:cursor] = next_cursor
+            request = Square::Internal::JSON::Request.new(
+              base_url: request_options[:base_url],
+              method: "GET",
+              path: "v2/labor/employee-wages",
+              query: query_params,
+              request_options: request_options
+            )
+            begin
+              response = @client.send(request)
+            rescue Net::HTTPRequestTimeout
+              raise Square::Errors::TimeoutError
+            end
+            code = response.code.to_i
+            if code.between?(200, 299)
+              Square::Types::ListEmployeeWagesResponse.load(response.body)
+            else
+              error_class = Square::Errors::ResponseError.subclass_for_code(code)
+              raise error_class.new(response.body, code: code)
+            end
           end
         end
 
         # Returns a single `EmployeeWage` specified by `id`.
         #
+        # @param request_options [Hash]
+        # @param params [Hash]
+        # @option request_options [String] :base_url
+        # @option request_options [Hash{String => Object}] :additional_headers
+        # @option request_options [Hash{String => Object}] :additional_query_parameters
+        # @option request_options [Hash{String => Object}] :additional_body_parameters
+        # @option request_options [Integer] :timeout_in_seconds
+        # @option params [String] :id
+        #
         # @return [Square::Types::GetEmployeeWageResponse]
         def get(request_options: {}, **params)
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url],
             method: "GET",
-            path: "v2/labor/employee-wages/#{params[:id]}"
+            path: "v2/labor/employee-wages/#{params[:id]}",
+            request_options: request_options
           )
           begin
-            _response = @client.send(_request)
+            response = @client.send(request)
           rescue Net::HTTPRequestTimeout
             raise Square::Errors::TimeoutError
           end
-          code = _response.code.to_i
+          code = response.code.to_i
           if code.between?(200, 299)
-            Square::Types::GetEmployeeWageResponse.load(_response.body)
+            Square::Types::GetEmployeeWageResponse.load(response.body)
           else
             error_class = Square::Errors::ResponseError.subclass_for_code(code)
-            raise error_class.new(_response.body, code: code)
+            raise error_class.new(response.body, code: code)
           end
         end
       end