square.rb 44.1.0.20250924 → 45.0.1.20260122

data/lib/square/terminal/refunds/client.rb

@@ -4,102 +4,149 @@ module Square
   module Terminal
     module Refunds
       class Client
-        # @return [Square::Terminal::Refunds::Client]
+        # @param client [Square::Internal::Http::RawClient]
+        #
+        # @return [void]
         def initialize(client:)
           @client = client
         end
 
-        # Creates a request to refund an Interac payment completed on a Square Terminal. Refunds for Interac payments on a Square Terminal are supported only for Interac debit cards in Canada. Other refunds for Terminal payments should use the Refunds API. For more information, see [Refunds API](api:Refunds).
+        # Creates a request to refund an Interac payment completed on a Square Terminal. Refunds for Interac payments on
+        # a Square Terminal are supported only for Interac debit cards in Canada. Other refunds for Terminal payments
+        # should use the Refunds API. For more information, see [Refunds API](api:Refunds).
+        #
+        # @param request_options [Hash]
+        # @param params [Square::Terminal::Refunds::Types::CreateTerminalRefundRequest]
+        # @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::CreateTerminalRefundResponse]
         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/terminals/refunds",
-            body: params
+            body: Square::Terminal::Refunds::Types::CreateTerminalRefundRequest.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::CreateTerminalRefundResponse.load(_response.body)
+            Square::Types::CreateTerminalRefundResponse.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 filtered list of Interac Terminal refund requests created by the seller making the request. Terminal refund requests are available for 30 days.
+        # Retrieves a filtered list of Interac Terminal refund requests created by the seller making the request.
+        # Terminal refund requests are available for 30 days.
+        #
+        # @param request_options [Hash]
+        # @param params [Square::Terminal::Refunds::Types::SearchTerminalRefundsRequest]
+        # @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::SearchTerminalRefundsResponse]
         def search(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/terminals/refunds/search",
-            body: params
+            body: Square::Terminal::Refunds::Types::SearchTerminalRefundsRequest.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::SearchTerminalRefundsResponse.load(_response.body)
+            Square::Types::SearchTerminalRefundsResponse.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 an Interac Terminal refund object by ID. Terminal refund objects are available for 30 days.
         #
+        # @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] :terminal_refund_id
+        #
         # @return [Square::Types::GetTerminalRefundResponse]
         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/terminals/refunds/#{params[:terminal_refund_id]}"
+            path: "v2/terminals/refunds/#{params[:terminal_refund_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::GetTerminalRefundResponse.load(_response.body)
+            Square::Types::GetTerminalRefundResponse.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
 
         # Cancels an Interac Terminal refund request by refund request ID if the status of the request permits 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] :terminal_refund_id
+        #
         # @return [Square::Types::CancelTerminalRefundResponse]
         def cancel(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/terminals/refunds/#{params[:terminal_refund_id]}/cancel"
+            path: "v2/terminals/refunds/#{params[:terminal_refund_id]}/cancel",
+            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::CancelTerminalRefundResponse.load(_response.body)
+            Square::Types::CancelTerminalRefundResponse.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/transfer_orders/client.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    class Client
+      # @return [Square::TransferOrders::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Creates a new transfer order in [DRAFT](entity:TransferOrderStatus) status. A transfer order represents the intent
+      # to move [CatalogItemVariation](entity:CatalogItemVariation)s from one [Location](entity:Location) to another.
+      # The source and destination locations must be different and must belong to your Square account.
+      #
+      # In [DRAFT](entity:TransferOrderStatus) status, you can:
+      # - Add or remove items
+      # - Modify quantities
+      # - Update shipping information
+      # - Delete the entire order via [DeleteTransferOrder](api-endpoint:TransferOrders-DeleteTransferOrder)
+      #
+      # The request requires source_location_id and destination_location_id.
+      # Inventory levels are not affected until the order is started via
+      # [StartTransferOrder](api-endpoint:TransferOrders-StartTransferOrder).
+      #
+      # Common integration points:
+      # - Sync with warehouse management systems
+      # - Automate regular stock transfers
+      # - Initialize transfers from inventory optimization systems
+      #
+      # Creates a [transfer_order.created](webhook:transfer_order.created) webhook event.
+      #
+      # @return [Square::Types::CreateTransferOrderResponse]
+      def create(request_options: {}, **params)
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "POST",
+          path: "v2/transfer-orders",
+          body: params
+        )
+        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::CreateTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Searches for transfer orders using filters. Returns a paginated list of matching
+      # [TransferOrder](entity:TransferOrder)s sorted by creation date.
+      #
+      # Common search scenarios:
+      # - Find orders for a source [Location](entity:Location)
+      # - Find orders for a destination [Location](entity:Location)
+      # - Find orders in a particular [TransferOrderStatus](entity:TransferOrderStatus)
+      #
+      # @return [Square::Types::SearchTransferOrdersResponse]
+      def search(request_options: {}, **params)
+        Square::Internal::CursorItemIterator.new(
+          cursor_field: :cursor,
+          item_field: :transfer_orders,
+          initial_cursor: params[:cursor]
+        ) do |next_cursor|
+          params[:cursor] = next_cursor
+          _request = Square::Internal::JSON::Request.new(
+            base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+            method: "POST",
+            path: "v2/transfer-orders/search",
+            body: params
+          )
+          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::SearchTransferOrdersResponse.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 [TransferOrder](entity:TransferOrder) by ID. Returns the complete
+      # order details including:
+      #
+      # - Basic information (status, dates, notes)
+      # - Line items with ordered and received quantities
+      # - Source and destination [Location](entity:Location)s
+      # - Tracking information (if available)
+      #
+      # @return [Square::Types::RetrieveTransferOrderResponse]
+      def get(request_options: {}, **params)
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "GET",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}"
+        )
+        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::RetrieveTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Updates an existing transfer order. This endpoint supports sparse updates,
+      # allowing you to modify specific fields without affecting others.
+      #
+      # Creates a [transfer_order.updated](webhook:transfer_order.updated) webhook event.
+      #
+      # @return [Square::Types::UpdateTransferOrderResponse]
+      def update(request_options: {}, **params)
+        _path_param_names = ["transfer_order_id"]
+
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "PUT",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}",
+          body: params.except(*_path_param_names)
+        )
+        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::UpdateTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Deletes a transfer order in [DRAFT](entity:TransferOrderStatus) status.
+      # Only draft orders can be deleted. Once an order is started via
+      # [StartTransferOrder](api-endpoint:TransferOrders-StartTransferOrder), it can no longer be deleted.
+      #
+      # Creates a [transfer_order.deleted](webhook:transfer_order.deleted) webhook event.
+      #
+      # @return [Square::Types::DeleteTransferOrderResponse]
+      def delete(request_options: {}, **params)
+        params = Square::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[version]
+        _query = params.slice(*_query_param_names)
+        params = params.except(*_query_param_names)
+
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "DELETE",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}",
+          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::DeleteTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Cancels a transfer order in [STARTED](entity:TransferOrderStatus) or
+      # [PARTIALLY_RECEIVED](entity:TransferOrderStatus) status. Any unreceived quantities will no
+      # longer be receivable and will be immediately returned to the source [Location](entity:Location)'s inventory.
+      #
+      # Common reasons for cancellation:
+      # - Items no longer needed at destination
+      # - Source location needs the inventory
+      # - Order created in error
+      #
+      # Creates a [transfer_order.updated](webhook:transfer_order.updated) webhook event.
+      #
+      # @return [Square::Types::CancelTransferOrderResponse]
+      def cancel(request_options: {}, **params)
+        _path_param_names = ["transfer_order_id"]
+
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "POST",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}/cancel",
+          body: params.except(*_path_param_names)
+        )
+        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::CancelTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Records receipt of [CatalogItemVariation](entity:CatalogItemVariation)s for a transfer order.
+      # This endpoint supports partial receiving - you can receive items in multiple batches.
+      #
+      # For each line item, you can specify:
+      # - Quantity received in good condition (added to destination inventory with [InventoryState](entity:InventoryState) of IN_STOCK)
+      # - Quantity damaged during transit/handling (added to destination inventory with [InventoryState](entity:InventoryState) of WASTE)
+      # - Quantity canceled (returned to source location's inventory)
+      #
+      # The order must be in [STARTED](entity:TransferOrderStatus) or [PARTIALLY_RECEIVED](entity:TransferOrderStatus) status.
+      # Received quantities are added to the destination [Location](entity:Location)'s inventory according to their condition.
+      # Canceled quantities are immediately returned to the source [Location](entity:Location)'s inventory.
+      #
+      # When all items are either received, damaged, or canceled, the order moves to
+      # [COMPLETED](entity:TransferOrderStatus) status.
+      #
+      # Creates a [transfer_order.updated](webhook:transfer_order.updated) webhook event.
+      #
+      # @return [Square::Types::ReceiveTransferOrderResponse]
+      def receive(request_options: {}, **params)
+        _path_param_names = ["transfer_order_id"]
+
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "POST",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}/receive",
+          body: params.except(*_path_param_names)
+        )
+        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::ReceiveTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Changes a [DRAFT](entity:TransferOrderStatus) transfer order to [STARTED](entity:TransferOrderStatus) status.
+      # This decrements inventory at the source [Location](entity:Location) and marks it as in-transit.
+      #
+      # The order must be in [DRAFT](entity:TransferOrderStatus) status and have all required fields populated.
+      # Once started, the order can no longer be deleted, but it can be canceled via
+      # [CancelTransferOrder](api-endpoint:TransferOrders-CancelTransferOrder).
+      #
+      # Creates a [transfer_order.updated](webhook:transfer_order.updated) webhook event.
+      #
+      # @return [Square::Types::StartTransferOrderResponse]
+      def start(request_options: {}, **params)
+        _path_param_names = ["transfer_order_id"]
+
+        _request = Square::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Square::Environment::PRODUCTION,
+          method: "POST",
+          path: "v2/transfer-orders/#{params[:transfer_order_id]}/start",
+          body: params.except(*_path_param_names)
+        )
+        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::StartTransferOrderResponse.load(_response.body)
+        else
+          error_class = Square::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/cancel_transfer_order_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class CancelTransferOrderRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+        field :idempotency_key, -> { String }, optional: false, nullable: false
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/create_transfer_order_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class CreateTransferOrderRequest < Internal::Types::Model
+        field :idempotency_key, -> { String }, optional: false, nullable: false
+        field :transfer_order, -> { Square::Types::CreateTransferOrderData }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/delete_transfer_orders_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class DeleteTransferOrdersRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/get_transfer_orders_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class GetTransferOrdersRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/receive_transfer_order_request.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class ReceiveTransferOrderRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+        field :idempotency_key, -> { String }, optional: false, nullable: false
+        field :receipt, -> { Square::Types::TransferOrderGoodsReceipt }, optional: false, nullable: false
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/search_transfer_orders_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class SearchTransferOrdersRequest < Internal::Types::Model
+        field :query, -> { Square::Types::TransferOrderQuery }, optional: true, nullable: false
+        field :cursor, -> { String }, optional: true, nullable: false
+        field :limit, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/start_transfer_order_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class StartTransferOrderRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+        field :idempotency_key, -> { String }, optional: false, nullable: false
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/transfer_orders/types/update_transfer_order_request.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Square
+  module TransferOrders
+    module Types
+      class UpdateTransferOrderRequest < Internal::Types::Model
+        field :transfer_order_id, -> { String }, optional: false, nullable: false
+        field :idempotency_key, -> { String }, optional: false, nullable: false
+        field :transfer_order, -> { Square::Types::UpdateTransferOrderData }, optional: false, nullable: false
+        field :version, -> { Integer }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/square/types/address.rb

@@ -3,7 +3,8 @@
 module Square
   module Types
     # Represents a postal address in a country.
-    # For more information, see [Working with Addresses](https://developer.squareup.com/docs/build-basics/working-with-addresses).
+    # For more information, see [Working with
+    # Addresses](https://developer.squareup.com/docs/build-basics/working-with-addresses).
     class Address < Internal::Types::Model
       field :address_line_1, -> { String }, optional: true, nullable: false
       field :address_line_2, -> { String }, optional: true, nullable: false

data/lib/square/types/application_details.rb

@@ -4,9 +4,7 @@ module Square
   module Types
     # Details about the application that took the payment.
     class ApplicationDetails < Internal::Types::Model
-      field :square_product, lambda {
-        Square::Types::ApplicationDetailsExternalSquareProduct
-      }, optional: true, nullable: false
+      field :square_product, -> { Square::Types::ApplicationDetailsExternalSquareProduct }, optional: true, nullable: false
       field :application_id, -> { String }, optional: true, nullable: false
     end
   end

data/lib/square/types/application_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Square
+  module Types
+    module ApplicationType
+      # ApplicationType is an alias for Object
+
+      # @option str [String]
+      #
+      # @return [untyped]
+      def self.load(str)
+        ::JSON.parse(str)
+      end
+
+      # @option value [untyped]
+      #
+      # @return [String]
+      def self.dump(value)
+        ::JSON.generate(value)
+      end
+    end
+  end
+end

data/lib/square/types/availability.rb

@@ -2,13 +2,12 @@
 
 module Square
   module Types
-    # Defines an appointment slot that encapsulates the appointment segments, location and starting time available for booking.
+    # Defines an appointment slot that encapsulates the appointment segments, location and starting time available for
+    # booking.
     class Availability < Internal::Types::Model
       field :start_at, -> { String }, optional: true, nullable: false
       field :location_id, -> { String }, optional: true, nullable: false
-      field :appointment_segments, lambda {
-        Internal::Types::Array[Square::Types::AppointmentSegment]
-      }, optional: true, nullable: false
+      field :appointment_segments, -> { Internal::Types::Array[Square::Types::AppointmentSegment] }, optional: true, nullable: false
     end
   end
 end

data/lib/square/types/bank_account.rb

@@ -23,6 +23,7 @@ module Square
       field :fingerprint, -> { String }, optional: true, nullable: false
       field :version, -> { Integer }, optional: true, nullable: false
       field :bank_name, -> { String }, optional: true, nullable: false
+      field :customer_id, -> { String }, optional: true, nullable: false
     end
   end
 end