square.rb 44.2.0.20251016 → 45.0.1.20260122

data/lib/square/employees/client.rb

@@ -3,58 +3,93 @@
 module Square
   module Employees
     class Client
-      # @return [Square::Employees::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
 
+      # @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] :location_id
+      # @option params [Square::Types::EmployeeStatus, nil] :status
+      # @option params [Integer, nil] :limit
+      # @option params [String, nil] :cursor
+      #
       # @return [Square::Types::ListEmployeesResponse]
       def list(request_options: {}, **params)
-        _query_param_names = [
-          %w[location_id status limit cursor],
-          %i[location_id status 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[location_id status limit cursor]
+        query_params = {}
+        query_params["location_id"] = params[:location_id] if params.key?(:location_id)
+        query_params["status"] = params[:status] if params.key?(:status)
+        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/employees",
-          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::ListEmployeesResponse.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: :employees,
+          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/employees",
+            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::ListEmployeesResponse.load(response.body)
+          else
+            error_class = Square::Errors::ResponseError.subclass_for_code(code)
+            raise error_class.new(response.body, code: code)
+          end
         end
       end
 
+      # @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::GetEmployeeResponse]
       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/employees/#{params[:id]}"
+          path: "v2/employees/#{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::GetEmployeeResponse.load(_response.body)
+          Square::Types::GetEmployeeResponse.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/events/client.rb

@@ -3,111 +3,153 @@
 module Square
   module Events
     class Client
-      # @return [Square::Events::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
 
       # Search for Square API events that occur within a 28-day timeframe.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Events::Types::SearchEventsRequest]
+      # @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::SearchEventsResponse]
       def search_events(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/events",
-          body: params
+          body: Square::Events::Types::SearchEventsRequest.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::SearchEventsResponse.load(_response.body)
+          Square::Types::SearchEventsResponse.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
 
       # Disables events to prevent them from being searchable.
       # All events are disabled by default. You must enable events to make them searchable.
-      # Disabling events for a specific time period prevents them from being searchable, even if you re-enable them later.
+      # Disabling events for a specific time period prevents them from being searchable, even if you re-enable them
+      # later.
+      #
+      # @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
       #
       # @return [Square::Types::DisableEventsResponse]
-      def disable_events(request_options: {}, **_params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+      def disable_events(request_options: {}, **params)
+        Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "PUT",
-          path: "v2/events/disable"
+          path: "v2/events/disable",
+          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::DisableEventsResponse.load(_response.body)
+          Square::Types::DisableEventsResponse.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
 
       # Enables events to make them searchable. Only events that occur while in the enabled state are searchable.
       #
+      # @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
+      #
       # @return [Square::Types::EnableEventsResponse]
-      def enable_events(request_options: {}, **_params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+      def enable_events(request_options: {}, **params)
+        Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "PUT",
-          path: "v2/events/enable"
+          path: "v2/events/enable",
+          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::EnableEventsResponse.load(_response.body)
+          Square::Types::EnableEventsResponse.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
 
       # Lists all event types that you can subscribe to as webhooks or query using the Events API.
       #
+      # @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] :api_version
+      #
       # @return [Square::Types::ListEventTypesResponse]
       def list_event_types(request_options: {}, **params)
-        _query_param_names = [
-          ["api_version"],
-          %i[api_version]
-        ].flatten
-        _query = params.slice(*_query_param_names)
-        params.except(*_query_param_names)
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[api_version]
+        query_params = {}
+        query_params["api_version"] = params[:api_version] if params.key?(:api_version)
+        params.except(*query_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: "GET",
           path: "v2/events/types",
-          query: _query
+          query: query_params,
+          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::ListEventTypesResponse.load(_response.body)
+          Square::Types::ListEventTypesResponse.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/file_param.rb

@@ -1,83 +1,83 @@
 # frozen_string_literal: true
 
 module Square
-    # FileParam is a utility class for handling files in multipart form data.
+  # FileParam is a utility class for handling files in multipart form data.
+  #
+  # @attr_reader [IO] io The readable object
+  # @attr_reader [String, nil] filename The filename
+  # @attr_reader [String, nil] content_type The content type
+  class FileParam
+    attr_reader :io, :filename, :content_type
+
+    # Create a new file parameter.
     #
-    # @attr_reader [IO] io The readable object
-    # @attr_reader [String, nil] filename The filename
-    # @attr_reader [String, nil] content_type The content type
-    class FileParam
-      attr_reader :io, :filename, :content_type
-  
-      # Create a new file parameter.
-      #
-      # @param io [#read] A readable object (File, StringIO, etc.)
-      # @param filename [String, nil] Optional filename
-      # @param content_type [String, nil] Optional content type
-      def initialize(io:, filename: nil, content_type: nil)
-        @io = io
-        @filename = filename
-        @content_type = content_type
-      end
-  
-      # Creates a FileParam instance from a filepath.
-      #
-      # @param filepath [String] Path to the file
-      # @param filename [String, nil] Optional filename (defaults to basename of filepath)
-      # @param content_type [String, nil] Optional content type
-      # @return [FileParam] A new FileParam instance
-      # @raise [StandardError] If the file cannot be opened or read
-      def self.from_filepath(filepath:, filename: nil, content_type: nil)
-        begin
-          file = File.open(filepath, "rb")
-        rescue StandardError => e
-          raise "Unable to open file #{filepath}: #{e.message}"
-        end
-  
-        new(
-          io: file,
-          filename: filename || File.basename(filepath),
-          content_type: content_type
-        )
-      end
-  
-      # Creates a FileParam instance from a string.
-      #
-      # @param content [String] The content string
-      # @param filename [String, nil] Required filename
-      # @param content_type [String, nil] Optional content type
-      # @return [FileParam] A new FileParam instance
-      def self.from_string(content:, filename:, content_type: nil)
-        new(
-          io: StringIO.new(content),
-          filename: filename,
-          content_type: content_type
-        )
-      end
-  
-      # Maps this FileParam to a FormDataPart.
-      #
-      # @param name [String] The name of the form field
-      # @param content_type [String, nil] Overrides the content type, if provided
-      # @return [Square::Internal::Multipart::FormDataPart] A multipart form data part representing this file
-      def to_form_data_part(name:, content_type: nil)
-        content_type ||= @content_type
-        headers = content_type ? { "Content-Type" => content_type } : nil
-  
-        Square::Internal::Multipart::FormDataPart.new(
-          name: name,
-          value: @io,
-          filename: @filename,
-          headers: headers
-        )
-      end
-  
-      # Closes the file IO if it responds to close.
-      #
-      # @return [nil]
-      def close
-        @io.close if @io.respond_to?(:close)
-        nil
+    # @param io [#read] A readable object (File, StringIO, etc.)
+    # @param filename [String, nil] Optional filename
+    # @param content_type [String, nil] Optional content type
+    def initialize(io:, filename: nil, content_type: nil)
+      @io = io
+      @filename = filename
+      @content_type = content_type
+    end
+
+    # Creates a FileParam instance from a filepath.
+    #
+    # @param filepath [String] Path to the file
+    # @param filename [String, nil] Optional filename (defaults to basename of filepath)
+    # @param content_type [String, nil] Optional content type
+    # @return [FileParam] A new FileParam instance
+    # @raise [StandardError] If the file cannot be opened or read
+    def self.from_filepath(filepath:, filename: nil, content_type: nil)
+      begin
+        file = File.open(filepath, "rb")
+      rescue StandardError => e
+        raise "Unable to open file #{filepath}: #{e.message}"
       end
+
+      new(
+        io: file,
+        filename: filename || File.basename(filepath),
+        content_type: content_type
+      )
+    end
+
+    # Creates a FileParam instance from a string.
+    #
+    # @param content [String] The content string
+    # @param filename [String, nil] Required filename
+    # @param content_type [String, nil] Optional content type
+    # @return [FileParam] A new FileParam instance
+    def self.from_string(content:, filename:, content_type: nil)
+      new(
+        io: StringIO.new(content),
+        filename: filename,
+        content_type: content_type
+      )
+    end
+
+    # Maps this FileParam to a FormDataPart.
+    #
+    # @param name [String] The name of the form field
+    # @param content_type [String, nil] Overrides the content type, if provided
+    # @return [Square::Internal::Multipart::FormDataPart] A multipart form data part representing this file
+    def to_form_data_part(name:, content_type: nil)
+      content_type ||= @content_type
+      headers = content_type ? { "Content-Type" => content_type } : nil
+
+      Square::Internal::Multipart::FormDataPart.new(
+        name: name,
+        value: @io,
+        filename: @filename,
+        headers: headers
+      )
+    end
+
+    # Closes the file IO if it responds to close.
+    #
+    # @return [nil]
+    def close
+      @io.close if @io.respond_to?(:close)
+      nil
     end
-  end
+  end
+end

data/lib/square/gift_cards/activities/client.rb

@@ -4,7 +4,9 @@ module Square
   module GiftCards
     module Activities
       class Client
-        # @return [Square::GiftCards::Activities::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
@@ -14,57 +16,97 @@ module Square
         # filter the list. For example, you can get a list of gift card activities for a gift card,
         # for all gift cards in a specific region, or for activities within a time window.
         #
+        # @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] :gift_card_id
+        # @option params [String, nil] :type
+        # @option params [String, nil] :location_id
+        # @option params [String, nil] :begin_time
+        # @option params [String, nil] :end_time
+        # @option params [Integer, nil] :limit
+        # @option params [String, nil] :cursor
+        # @option params [String, nil] :sort_order
+        #
         # @return [Square::Types::ListGiftCardActivitiesResponse]
         def list(request_options: {}, **params)
-          _query_param_names = [
-            %w[gift_card_id type location_id begin_time end_time limit cursor sort_order],
-            %i[gift_card_id type location_id begin_time end_time limit cursor sort_order]
-          ].flatten
-          _query = params.slice(*_query_param_names)
-          params.except(*_query_param_names)
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          query_param_names = %i[gift_card_id type location_id begin_time end_time limit cursor sort_order]
+          query_params = {}
+          query_params["gift_card_id"] = params[:gift_card_id] if params.key?(:gift_card_id)
+          query_params["type"] = params[:type] if params.key?(:type)
+          query_params["location_id"] = params[:location_id] if params.key?(:location_id)
+          query_params["begin_time"] = params[:begin_time] if params.key?(:begin_time)
+          query_params["end_time"] = params[:end_time] if params.key?(:end_time)
+          query_params["limit"] = params[:limit] if params.key?(:limit)
+          query_params["cursor"] = params[:cursor] if params.key?(:cursor)
+          query_params["sort_order"] = params[:sort_order] if params.key?(:sort_order)
+          params.except(*query_param_names)
 
-          _request = Square::Internal::JSON::Request.new(
-            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
-            method: "GET",
-            path: "v2/gift-cards/activities",
-            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::ListGiftCardActivitiesResponse.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: :gift_card_activities,
+            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/gift-cards/activities",
+              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::ListGiftCardActivitiesResponse.load(response.body)
+            else
+              error_class = Square::Errors::ResponseError.subclass_for_code(code)
+              raise error_class.new(response.body, code: code)
+            end
           end
         end
 
         # Creates a gift card activity to manage the balance or state of a [gift card](entity:GiftCard).
         # For example, create an `ACTIVATE` activity to activate a gift card with an initial balance before first use.
         #
+        # @param request_options [Hash]
+        # @param params [Square::GiftCards::Activities::Types::CreateGiftCardActivityRequest]
+        # @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::CreateGiftCardActivityResponse]
         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/gift-cards/activities",
-            body: params
+            body: Square::GiftCards::Activities::Types::CreateGiftCardActivityRequest.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::CreateGiftCardActivityResponse.load(_response.body)
+            Square::Types::CreateGiftCardActivityResponse.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