square.rb 44.2.0.20251016 → 45.0.1.20260122

data/lib/square/customers/groups/client.rb

@@ -4,39 +4,59 @@ module Square
   module Customers
     module Groups
       class Client
-        # @return [Square::Customers::Groups::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
 
         # Retrieves the list of customer groups of 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] :cursor
+        # @option params [Integer, nil] :limit
+        #
         # @return [Square::Types::ListCustomerGroupsResponse]
         def list(request_options: {}, **params)
-          _query_param_names = [
-            %w[cursor limit],
-            %i[cursor limit]
-          ].flatten
-          _query = params.slice(*_query_param_names)
-          params.except(*_query_param_names)
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          query_param_names = %i[cursor limit]
+          query_params = {}
+          query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+          query_params["limit"] = params[:limit] if params.key?(:limit)
+          params.except(*query_param_names)
 
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-            method: "GET",
-            path: "v2/customers/groups",
-            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::ListCustomerGroupsResponse.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: :groups,
+            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/customers/groups",
+              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::ListCustomerGroupsResponse.load(response.body)
+            else
+              error_class = Square::Errors::ResponseError.subclass_for_code(code)
+              raise error_class.new(response.body, code: code)
+            end
           end
         end
 
@@ -44,97 +64,142 @@ module Square
         #
         # The request must include the `name` value of the group.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Customers::Groups::Types::CreateCustomerGroupRequest]
+        # @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::CreateCustomerGroupResponse]
         def create(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/customers/groups",
-            body: params
+            body: Square::Customers::Groups::Types::CreateCustomerGroupRequest.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::CreateCustomerGroupResponse.load(_response.body)
+            Square::Types::CreateCustomerGroupResponse.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 specific customer group as identified by the `group_id` value.
         #
+        # @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] :group_id
+        #
         # @return [Square::Types::GetCustomerGroupResponse]
         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/customers/groups/#{params[:group_id]}"
+            path: "v2/customers/groups/#{params[:group_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::GetCustomerGroupResponse.load(_response.body)
+            Square::Types::GetCustomerGroupResponse.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
 
         # Updates a customer group as identified by the `group_id` value.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Customers::Groups::Types::UpdateCustomerGroupRequest]
+        # @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] :group_id
+        #
         # @return [Square::Types::UpdateCustomerGroupResponse]
         def update(request_options: {}, **params)
-          _path_param_names = ["group_id"]
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          request_data = Square::Customers::Groups::Types::UpdateCustomerGroupRequest.new(params).to_h
+          non_body_param_names = ["group_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/customers/groups/#{params[:group_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::UpdateCustomerGroupResponse.load(_response.body)
+            Square::Types::UpdateCustomerGroupResponse.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 customer group as identified by the `group_id` value.
         #
+        # @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] :group_id
+        #
         # @return [Square::Types::DeleteCustomerGroupResponse]
         def delete(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/customers/groups/#{params[:group_id]}"
+            path: "v2/customers/groups/#{params[:group_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::DeleteCustomerGroupResponse.load(_response.body)
+            Square::Types::DeleteCustomerGroupResponse.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
 
@@ -143,24 +208,36 @@ module Square
         # The customer is identified by the `customer_id` value
         # and the customer group is identified by the `group_id` value.
         #
+        # @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] :customer_id
+        # @option params [String] :group_id
+        #
         # @return [Square::Types::AddGroupToCustomerResponse]
         def add(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: "PUT",
-            path: "v2/customers/#{params[:customer_id]}/groups/#{params[:group_id]}"
+            path: "v2/customers/#{params[:customer_id]}/groups/#{params[:group_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::AddGroupToCustomerResponse.load(_response.body)
+            Square::Types::AddGroupToCustomerResponse.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
 
@@ -169,24 +246,36 @@ module Square
         # The customer is identified by the `customer_id` value
         # and the customer group is identified by the `group_id` value.
         #
+        # @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] :customer_id
+        # @option params [String] :group_id
+        #
         # @return [Square::Types::RemoveGroupFromCustomerResponse]
         def remove(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/customers/#{params[:customer_id]}/groups/#{params[:group_id]}"
+            path: "v2/customers/#{params[:customer_id]}/groups/#{params[:group_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::RemoveGroupFromCustomerResponse.load(_response.body)
+            Square::Types::RemoveGroupFromCustomerResponse.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

data/lib/square/customers/segments/client.rb

@@ -4,62 +4,93 @@ module Square
   module Customers
     module Segments
       class Client
-        # @return [Square::Customers::Segments::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
 
         # Retrieves the list of customer segments of 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] :cursor
+        # @option params [Integer, nil] :limit
+        #
         # @return [Square::Types::ListCustomerSegmentsResponse]
         def list(request_options: {}, **params)
-          _query_param_names = [
-            %w[cursor limit],
-            %i[cursor limit]
-          ].flatten
-          _query = params.slice(*_query_param_names)
-          params.except(*_query_param_names)
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          query_param_names = %i[cursor limit]
+          query_params = {}
+          query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+          query_params["limit"] = params[:limit] if params.key?(:limit)
+          params.except(*query_param_names)
 
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-            method: "GET",
-            path: "v2/customers/segments",
-            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::ListCustomerSegmentsResponse.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: :segments,
+            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/customers/segments",
+              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::ListCustomerSegmentsResponse.load(response.body)
+            else
+              error_class = Square::Errors::ResponseError.subclass_for_code(code)
+              raise error_class.new(response.body, code: code)
+            end
           end
         end
 
         # Retrieves a specific customer segment as identified by the `segment_id` value.
         #
+        # @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] :segment_id
+        #
         # @return [Square::Types::GetCustomerSegmentResponse]
         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/customers/segments/#{params[:segment_id]}"
+            path: "v2/customers/segments/#{params[:segment_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::GetCustomerSegmentResponse.load(_response.body)
+            Square::Types::GetCustomerSegmentResponse.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

data/lib/square/customers/types/bulk_create_customers_request.rb

@@ -4,9 +4,7 @@ module Square
   module Customers
     module Types
       class BulkCreateCustomersRequest < Internal::Types::Model
-        field :customers, lambda {
-          Internal::Types::Hash[String, Square::Types::BulkCreateCustomerData]
-        }, optional: false, nullable: false
+        field :customers, -> { Internal::Types::Hash[String, Square::Types::BulkCreateCustomerData] }, optional: false, nullable: false
       end
     end
   end

data/lib/square/customers/types/bulk_update_customers_request.rb

@@ -4,9 +4,7 @@ module Square
   module Customers
     module Types
       class BulkUpdateCustomersRequest < Internal::Types::Model
-        field :customers, lambda {
-          Internal::Types::Hash[String, Square::Types::BulkUpdateCustomerData]
-        }, optional: false, nullable: false
+        field :customers, -> { Internal::Types::Hash[String, Square::Types::BulkUpdateCustomerData] }, optional: false, nullable: false
       end
     end
   end

data/lib/square/devices/client.rb

@@ -3,7 +3,9 @@
 module Square
   module Devices
     class Client
-      # @return [Square::Devices::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
@@ -11,55 +13,88 @@ module Square
       # List devices associated with the merchant. Currently, only Terminal API
       # devices are supported.
       #
+      # @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] :cursor
+      # @option params [Square::Types::SortOrder, nil] :sort_order
+      # @option params [Integer, nil] :limit
+      # @option params [String, nil] :location_id
+      #
       # @return [Square::Types::ListDevicesResponse]
       def list(request_options: {}, **params)
-        _query_param_names = [
-          %w[cursor sort_order limit location_id],
-          %i[cursor sort_order limit location_id]
-        ].flatten
-        _query = params.slice(*_query_param_names)
-        params.except(*_query_param_names)
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[cursor sort_order limit location_id]
+        query_params = {}
+        query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+        query_params["sort_order"] = params[:sort_order] if params.key?(:sort_order)
+        query_params["limit"] = params[:limit] if params.key?(:limit)
+        query_params["location_id"] = params[:location_id] if params.key?(:location_id)
+        params.except(*query_param_names)
 
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-          method: "GET",
-          path: "v2/devices",
-          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::ListDevicesResponse.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: :devices,
+          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/devices",
+            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::ListDevicesResponse.load(response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
         end
       end
 
       # Retrieves Device with the associated `device_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] :device_id
+      #
       # @return [Square::Types::GetDeviceResponse]
       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/devices/#{params[:device_id]}"
+          path: "v2/devices/#{params[:device_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::GetDeviceResponse.load(_response.body)
+          Square::Types::GetDeviceResponse.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