square.rb 44.2.0.20251016 → 45.0.1.20260122

data/lib/square/catalog/object/client.rb

@@ -4,7 +4,9 @@ module Square
   module Catalog
     module Object_
       class Client
-        # @return [Square::Catalog::Object_::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
@@ -15,25 +17,35 @@ module Square
         # While one (batch or non-batch) update request is being processed, other (batched and non-batched)
         # update requests are rejected with the `429` error code.
         #
+        # @param request_options [Hash]
+        # @param params [Square::Catalog::Object_::Types::UpsertCatalogObjectRequest]
+        # @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::UpsertCatalogObjectResponse]
         def upsert(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/catalog/object",
-            body: params
+            body: Square::Catalog::Object_::Types::UpsertCatalogObjectRequest.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::UpsertCatalogObjectResponse.load(_response.body)
+            Square::Types::UpsertCatalogObjectResponse.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
 
@@ -45,32 +57,46 @@ module Square
         # [CatalogModifierList](entity:CatalogModifierList) objects, and the ids of
         # any [CatalogTax](entity:CatalogTax) objects that apply to it.
         #
+        # @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] :object_id_
+        # @option params [Boolean, nil] :include_related_objects
+        # @option params [Integer, nil] :catalog_version
+        # @option params [Boolean, nil] :include_category_path_to_root
+        #
         # @return [Square::Types::GetCatalogObjectResponse]
         def get(request_options: {}, **params)
-          _query_param_names = [
-            %w[include_related_objects catalog_version include_category_path_to_root],
-            %i[include_related_objects catalog_version include_category_path_to_root]
-          ].flatten
-          _query = params.slice(*_query_param_names)
-          params = params.except(*_query_param_names)
+          params = Square::Internal::Types::Utils.normalize_keys(params)
+          query_param_names = %i[include_related_objects catalog_version include_category_path_to_root]
+          query_params = {}
+          query_params["include_related_objects"] = params[:include_related_objects] if params.key?(:include_related_objects)
+          query_params["catalog_version"] = params[:catalog_version] if params.key?(:catalog_version)
+          query_params["include_category_path_to_root"] = params[:include_category_path_to_root] if params.key?(:include_category_path_to_root)
+          params = 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/catalog/object/#{params[:object_id]}",
-            query: _query
+            path: "v2/catalog/object/#{params[:object_id_]}",
+            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::GetCatalogObjectResponse.load(_response.body)
+            Square::Types::GetCatalogObjectResponse.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
 
@@ -85,24 +111,35 @@ module Square
         # While one (batch or non-batch) delete request is being processed, other (batched and non-batched)
         # delete requests are rejected with the `429` error code.
         #
+        # @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] :object_id_
+        #
         # @return [Square::Types::DeleteCatalogObjectResponse]
         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/catalog/object/#{params[:object_id]}"
+            path: "v2/catalog/object/#{params[:object_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::DeleteCatalogObjectResponse.load(_response.body)
+            Square::Types::DeleteCatalogObjectResponse.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/catalog/object/types/delete_object_request.rb

@@ -5,7 +5,7 @@ module Square
     module Object_
       module Types
         class DeleteObjectRequest < Internal::Types::Model
-          field :object_id_, -> { String }, optional: false, nullable: false
+          field :object_id_, -> { String }, optional: false, nullable: false, api_name: "object_id"
         end
       end
     end

data/lib/square/catalog/object/types/get_object_request.rb

@@ -5,7 +5,7 @@ module Square
     module Object_
       module Types
         class GetObjectRequest < Internal::Types::Model
-          field :object_id_, -> { String }, optional: false, nullable: false
+          field :object_id_, -> { String }, optional: false, nullable: false, api_name: "object_id"
           field :include_related_objects, -> { Internal::Types::Boolean }, optional: true, nullable: false
           field :catalog_version, -> { Integer }, optional: true, nullable: false
           field :include_category_path_to_root, -> { Internal::Types::Boolean }, optional: true, nullable: false

data/lib/square/catalog/types/batch_upsert_catalog_objects_request.rb

@@ -5,9 +5,7 @@ module Square
     module Types
       class BatchUpsertCatalogObjectsRequest < Internal::Types::Model
         field :idempotency_key, -> { String }, optional: false, nullable: false
-        field :batches, lambda {
-          Internal::Types::Array[Square::Types::CatalogObjectBatch]
-        }, optional: false, nullable: false
+        field :batches, -> { Internal::Types::Array[Square::Types::CatalogObjectBatch] }, optional: false, nullable: false
       end
     end
   end

data/lib/square/catalog/types/search_catalog_items_request.rb

@@ -6,19 +6,13 @@ module Square
       class SearchCatalogItemsRequest < Internal::Types::Model
         field :text_filter, -> { String }, optional: true, nullable: false
         field :category_ids, -> { Internal::Types::Array[String] }, optional: true, nullable: false
-        field :stock_levels, lambda {
-          Internal::Types::Array[Square::Types::SearchCatalogItemsRequestStockLevel]
-        }, optional: true, nullable: false
+        field :stock_levels, -> { Internal::Types::Array[Square::Types::SearchCatalogItemsRequestStockLevel] }, optional: true, nullable: false
         field :enabled_location_ids, -> { Internal::Types::Array[String] }, optional: true, nullable: false
         field :cursor, -> { String }, optional: true, nullable: false
         field :limit, -> { Integer }, optional: true, nullable: false
         field :sort_order, -> { Square::Types::SortOrder }, optional: true, nullable: false
-        field :product_types, lambda {
-          Internal::Types::Array[Square::Types::CatalogItemProductType]
-        }, optional: true, nullable: false
-        field :custom_attribute_filters, lambda {
-          Internal::Types::Array[Square::Types::CustomAttributeFilter]
-        }, optional: true, nullable: false
+        field :product_types, -> { Internal::Types::Array[Square::Types::CatalogItemProductType] }, optional: true, nullable: false
+        field :custom_attribute_filters, -> { Internal::Types::Array[Square::Types::CustomAttributeFilter] }, optional: true, nullable: false
         field :archived_state, -> { Square::Types::ArchivedState }, optional: true, nullable: false
       end
     end

data/lib/square/catalog/types/search_catalog_objects_request.rb

@@ -5,9 +5,7 @@ module Square
     module Types
       class SearchCatalogObjectsRequest < Internal::Types::Model
         field :cursor, -> { String }, optional: true, nullable: false
-        field :object_types, lambda {
-          Internal::Types::Array[Square::Types::CatalogObjectType]
-        }, optional: true, nullable: false
+        field :object_types, -> { Internal::Types::Array[Square::Types::CatalogObjectType] }, optional: true, nullable: false
         field :include_deleted_objects, -> { Internal::Types::Boolean }, optional: true, nullable: false
         field :include_related_objects, -> { Internal::Types::Boolean }, optional: true, nullable: false
         field :begin_time, -> { String }, optional: true, nullable: false

data/lib/square/channels/client.rb

@@ -3,80 +3,127 @@
 module Square
   module Channels
     class Client
-      # @return [Square::Channels::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 [Square::Types::ReferenceType, nil] :reference_type
+      # @option params [String, nil] :reference_id
+      # @option params [Square::Types::ChannelStatus, nil] :status
+      # @option params [String, nil] :cursor
+      # @option params [Integer, nil] :limit
+      #
       # @return [Square::Types::ListChannelsResponse]
       def list(request_options: {}, **params)
-        _query_param_names = [
-          %w[reference_type reference_id status cursor limit],
-          %i[reference_type reference_id status 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[reference_type reference_id status cursor limit]
+        query_params = {}
+        query_params["reference_type"] = params[:reference_type] if params.key?(:reference_type)
+        query_params["reference_id"] = params[:reference_id] if params.key?(:reference_id)
+        query_params["status"] = params[:status] if params.key?(:status)
+        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/channels",
-          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::ListChannelsResponse.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: :channels,
+          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/channels",
+            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::ListChannelsResponse.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 [Square::Channels::Types::BulkRetrieveChannelsRequest]
+      # @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::BulkRetrieveChannelsResponse]
       def bulk_retrieve(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/channels/bulk-retrieve",
-          body: params
+          body: Square::Channels::Types::BulkRetrieveChannelsRequest.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::BulkRetrieveChannelsResponse.load(_response.body)
+          Square::Types::BulkRetrieveChannelsResponse.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
 
+      # @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] :channel_id
+      #
       # @return [Square::Types::RetrieveChannelResponse]
       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/channels/#{params[:channel_id]}"
+          path: "v2/channels/#{params[:channel_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::RetrieveChannelResponse.load(_response.body)
+          Square::Types::RetrieveChannelResponse.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/checkout/client.rb

@@ -3,104 +3,150 @@
 module Square
   module Checkout
     class Client
-      # @return [Square::Checkout::Client]
+      # @param client [Square::Internal::Http::RawClient]
+      #
+      # @return [void]
       def initialize(client:)
         @client = client
       end
 
       # Retrieves the location-level settings for a Square-hosted checkout page.
       #
+      # @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] :location_id
+      #
       # @return [Square::Types::RetrieveLocationSettingsResponse]
       def retrieve_location_settings(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/online-checkout/location-settings/#{params[:location_id]}"
+          path: "v2/online-checkout/location-settings/#{params[:location_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::RetrieveLocationSettingsResponse.load(_response.body)
+          Square::Types::RetrieveLocationSettingsResponse.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 the location-level settings for a Square-hosted checkout page.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Checkout::Types::UpdateLocationSettingsRequest]
+      # @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] :location_id
+      #
       # @return [Square::Types::UpdateLocationSettingsResponse]
       def update_location_settings(request_options: {}, **params)
-        _path_param_names = ["location_id"]
+        params = Square::Internal::Types::Utils.normalize_keys(params)
+        request_data = Square::Checkout::Types::UpdateLocationSettingsRequest.new(params).to_h
+        non_body_param_names = ["location_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/online-checkout/location-settings/#{params[:location_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::UpdateLocationSettingsResponse.load(_response.body)
+          Square::Types::UpdateLocationSettingsResponse.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 the merchant-level settings for a Square-hosted checkout page.
       #
+      # @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::RetrieveMerchantSettingsResponse]
-      def retrieve_merchant_settings(request_options: {}, **_params)
-        _request = Square::Internal::JSON::Request.new(
-          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+      def retrieve_merchant_settings(request_options: {}, **params)
+        Square::Internal::Types::Utils.normalize_keys(params)
+        request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
           method: "GET",
-          path: "v2/online-checkout/merchant-settings"
+          path: "v2/online-checkout/merchant-settings",
+          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::RetrieveMerchantSettingsResponse.load(_response.body)
+          Square::Types::RetrieveMerchantSettingsResponse.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 the merchant-level settings for a Square-hosted checkout page.
       #
+      # @param request_options [Hash]
+      # @param params [Square::Checkout::Types::UpdateMerchantSettingsRequest]
+      # @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::UpdateMerchantSettingsResponse]
       def update_merchant_settings(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/online-checkout/merchant-settings",
-          body: params
+          body: Square::Checkout::Types::UpdateMerchantSettingsRequest.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::UpdateMerchantSettingsResponse.load(_response.body)
+          Square::Types::UpdateMerchantSettingsResponse.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