checkout-intents 0.2.2 → 0.3.0

data/rbi/checkout_intents/models/base_checkout_intent.rbi

@@ -121,21 +121,105 @@ module CheckoutIntents
         sig { params(max_total_price: Integer).void }
         attr_writer :max_total_price
 
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
         sig do
-          params(max_shipping_price: Integer, max_total_price: Integer).returns(
-            T.attached_class
+          returns(
+            T.nilable(
+              CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
           )
         end
-        def self.new(max_shipping_price: nil, max_total_price: nil)
+        attr_reader :offer_retrieval_effort
+
+        sig do
+          params(
+            offer_retrieval_effort:
+              CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::OrSymbol
+          ).void
+        end
+        attr_writer :offer_retrieval_effort
+
+        sig do
+          params(
+            max_shipping_price: Integer,
+            max_total_price: Integer,
+            offer_retrieval_effort:
+              CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          max_shipping_price: nil,
+          max_total_price: nil,
+          # Controls how much effort the system should spend retrieving an offer.
+          #
+          # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+          # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+          #   success rate)
+          #
+          # Default: 'max'
+          offer_retrieval_effort: nil
+        )
         end
 
         sig do
           override.returns(
-            { max_shipping_price: Integer, max_total_price: Integer }
+            {
+              max_shipping_price: Integer,
+              max_total_price: Integer,
+              offer_retrieval_effort:
+                CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::TaggedSymbol
+            }
           )
         end
         def to_hash
         end
+
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
+        module OfferRetrievalEffort
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          MAX =
+            T.let(
+              :max,
+              CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+          LOW =
+            T.let(
+              :low,
+              CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::BaseCheckoutIntent::Constraints::OfferRetrievalEffort::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/checkout_intents/models/betas/checkout_session_create_params.rbi

@@ -258,22 +258,105 @@ module CheckoutIntents
           sig { params(max_total_price: Integer).void }
           attr_writer :max_total_price
 
+          # Controls how much effort the system should spend retrieving an offer.
+          #
+          # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+          # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+          #   success rate)
+          #
+          # Default: 'max'
+          sig do
+            returns(
+              T.nilable(
+                CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+              )
+            )
+          end
+          attr_reader :offer_retrieval_effort
+
+          sig do
+            params(
+              offer_retrieval_effort:
+                CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+            ).void
+          end
+          attr_writer :offer_retrieval_effort
+
           sig do
             params(
               max_shipping_price: Integer,
-              max_total_price: Integer
+              max_total_price: Integer,
+              offer_retrieval_effort:
+                CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
             ).returns(T.attached_class)
           end
-          def self.new(max_shipping_price: nil, max_total_price: nil)
+          def self.new(
+            max_shipping_price: nil,
+            max_total_price: nil,
+            # Controls how much effort the system should spend retrieving an offer.
+            #
+            # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+            # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+            #   success rate)
+            #
+            # Default: 'max'
+            offer_retrieval_effort: nil
+          )
           end
 
           sig do
             override.returns(
-              { max_shipping_price: Integer, max_total_price: Integer }
+              {
+                max_shipping_price: Integer,
+                max_total_price: Integer,
+                offer_retrieval_effort:
+                  CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+              }
             )
           end
           def to_hash
           end
+
+          # Controls how much effort the system should spend retrieving an offer.
+          #
+          # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+          # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+          #   success rate)
+          #
+          # Default: 'max'
+          module OfferRetrievalEffort
+            extend CheckoutIntents::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            MAX =
+              T.let(
+                :max,
+                CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+              )
+            LOW =
+              T.let(
+                :low,
+                CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
         end
       end
     end

data/rbi/checkout_intents/models/checkout_intent_create_params.rbi

@@ -120,21 +120,105 @@ module CheckoutIntents
         sig { params(max_total_price: Integer).void }
         attr_writer :max_total_price
 
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
         sig do
-          params(max_shipping_price: Integer, max_total_price: Integer).returns(
-            T.attached_class
+          returns(
+            T.nilable(
+              CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+            )
           )
         end
-        def self.new(max_shipping_price: nil, max_total_price: nil)
+        attr_reader :offer_retrieval_effort
+
+        sig do
+          params(
+            offer_retrieval_effort:
+              CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+          ).void
+        end
+        attr_writer :offer_retrieval_effort
+
+        sig do
+          params(
+            max_shipping_price: Integer,
+            max_total_price: Integer,
+            offer_retrieval_effort:
+              CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          max_shipping_price: nil,
+          max_total_price: nil,
+          # Controls how much effort the system should spend retrieving an offer.
+          #
+          # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+          # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+          #   success rate)
+          #
+          # Default: 'max'
+          offer_retrieval_effort: nil
+        )
         end
 
         sig do
           override.returns(
-            { max_shipping_price: Integer, max_total_price: Integer }
+            {
+              max_shipping_price: Integer,
+              max_total_price: Integer,
+              offer_retrieval_effort:
+                CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::OrSymbol
+            }
           )
         end
         def to_hash
         end
+
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
+        module OfferRetrievalEffort
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          MAX =
+            T.let(
+              :max,
+              CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+          LOW =
+            T.let(
+              :low,
+              CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::CheckoutIntentCreateParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/checkout_intents/models/checkout_intent_purchase_params.rbi

@@ -144,21 +144,105 @@ module CheckoutIntents
         sig { params(max_total_price: Integer).void }
         attr_writer :max_total_price
 
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
         sig do
-          params(max_shipping_price: Integer, max_total_price: Integer).returns(
-            T.attached_class
+          returns(
+            T.nilable(
+              CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::OrSymbol
+            )
           )
         end
-        def self.new(max_shipping_price: nil, max_total_price: nil)
+        attr_reader :offer_retrieval_effort
+
+        sig do
+          params(
+            offer_retrieval_effort:
+              CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::OrSymbol
+          ).void
+        end
+        attr_writer :offer_retrieval_effort
+
+        sig do
+          params(
+            max_shipping_price: Integer,
+            max_total_price: Integer,
+            offer_retrieval_effort:
+              CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          max_shipping_price: nil,
+          max_total_price: nil,
+          # Controls how much effort the system should spend retrieving an offer.
+          #
+          # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+          # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+          #   success rate)
+          #
+          # Default: 'max'
+          offer_retrieval_effort: nil
+        )
         end
 
         sig do
           override.returns(
-            { max_shipping_price: Integer, max_total_price: Integer }
+            {
+              max_shipping_price: Integer,
+              max_total_price: Integer,
+              offer_retrieval_effort:
+                CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::OrSymbol
+            }
           )
         end
         def to_hash
         end
+
+        # Controls how much effort the system should spend retrieving an offer.
+        #
+        # - 'max': Full effort including AI agent fallback (slower, higher success rate)
+        # - 'low': Fast API-only retrieval, fails if API unavailable (faster, lower
+        #   success rate)
+        #
+        # Default: 'max'
+        module OfferRetrievalEffort
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          MAX =
+            T.let(
+              :max,
+              CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+          LOW =
+            T.let(
+              :low,
+              CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OfferRetrievalEffort::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/checkout_intents/models/money.rbi

@@ -8,14 +8,14 @@ module CheckoutIntents
           T.any(CheckoutIntents::Money, CheckoutIntents::Internal::AnyHash)
         end
 
-      sig { returns(Float) }
+      sig { returns(Integer) }
       attr_accessor :amount_subunits
 
       sig { returns(String) }
       attr_accessor :currency_code
 
       sig do
-        params(amount_subunits: Float, currency_code: String).returns(
+        params(amount_subunits: Integer, currency_code: String).returns(
           T.attached_class
         )
       end
@@ -23,7 +23,7 @@ module CheckoutIntents
       end
 
       sig do
-        override.returns({ amount_subunits: Float, currency_code: String })
+        override.returns({ amount_subunits: Integer, currency_code: String })
       end
       def to_hash
       end

data/rbi/checkout_intents/models/product.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    class Product < CheckoutIntents::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(CheckoutIntents::Product, CheckoutIntents::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # The availability status of a product.
+      #
+      # - `in_stock`: Product is available for immediate purchase
+      # - `out_of_stock`: Product is currently unavailable
+      # - `preorder`: Product is available for pre-order before release
+      # - `backorder`: Product is temporarily out of stock but can be ordered
+      # - `unknown`: Availability could not be determined
+      sig { returns(CheckoutIntents::ProductAvailability::TaggedSymbol) }
+      attr_accessor :availability
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :brand
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig { returns(T::Array[CheckoutIntents::ProductImage]) }
+      attr_accessor :images
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(CheckoutIntents::Money) }
+      attr_reader :price
+
+      sig { params(price: CheckoutIntents::Money::OrHash).void }
+      attr_writer :price
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :sku
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig do
+        params(
+          id: String,
+          availability: CheckoutIntents::ProductAvailability::OrSymbol,
+          brand: T.nilable(String),
+          description: T.nilable(String),
+          images: T::Array[CheckoutIntents::ProductImage::OrHash],
+          name: String,
+          price: CheckoutIntents::Money::OrHash,
+          sku: T.nilable(String),
+          url: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # The availability status of a product.
+        #
+        # - `in_stock`: Product is available for immediate purchase
+        # - `out_of_stock`: Product is currently unavailable
+        # - `preorder`: Product is available for pre-order before release
+        # - `backorder`: Product is temporarily out of stock but can be ordered
+        # - `unknown`: Availability could not be determined
+        availability:,
+        brand:,
+        description:,
+        images:,
+        name:,
+        price:,
+        sku:,
+        url:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            availability: CheckoutIntents::ProductAvailability::TaggedSymbol,
+            brand: T.nilable(String),
+            description: T.nilable(String),
+            images: T::Array[CheckoutIntents::ProductImage],
+            name: String,
+            price: CheckoutIntents::Money,
+            sku: T.nilable(String),
+            url: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models/product_availability.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    # The availability status of a product.
+    #
+    # - `in_stock`: Product is available for immediate purchase
+    # - `out_of_stock`: Product is currently unavailable
+    # - `preorder`: Product is available for pre-order before release
+    # - `backorder`: Product is temporarily out of stock but can be ordered
+    # - `unknown`: Availability could not be determined
+    module ProductAvailability
+      extend CheckoutIntents::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, CheckoutIntents::ProductAvailability) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      IN_STOCK =
+        T.let(:in_stock, CheckoutIntents::ProductAvailability::TaggedSymbol)
+      OUT_OF_STOCK =
+        T.let(:out_of_stock, CheckoutIntents::ProductAvailability::TaggedSymbol)
+      PREORDER =
+        T.let(:preorder, CheckoutIntents::ProductAvailability::TaggedSymbol)
+      BACKORDER =
+        T.let(:backorder, CheckoutIntents::ProductAvailability::TaggedSymbol)
+      UNKNOWN =
+        T.let(:unknown, CheckoutIntents::ProductAvailability::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[CheckoutIntents::ProductAvailability::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models/product_image.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    class ProductImage < CheckoutIntents::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            CheckoutIntents::ProductImage,
+            CheckoutIntents::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Boolean) }
+      attr_accessor :is_featured
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig do
+        params(is_featured: T::Boolean, url: String).returns(T.attached_class)
+      end
+      def self.new(is_featured:, url:)
+      end
+
+      sig { override.returns({ is_featured: T::Boolean, url: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models/product_lookup_params.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    class ProductLookupParams < CheckoutIntents::Internal::Type::BaseModel
+      extend CheckoutIntents::Internal::Type::RequestParameters::Converter
+      include CheckoutIntents::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            CheckoutIntents::ProductLookupParams,
+            CheckoutIntents::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig do
+        params(
+          url: String,
+          request_options: CheckoutIntents::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(url:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { url: String, request_options: CheckoutIntents::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models.rbi

@@ -36,5 +36,13 @@ module CheckoutIntents
 
   PaymentMethod = CheckoutIntents::Models::PaymentMethod
 
+  Product = CheckoutIntents::Models::Product
+
+  ProductAvailability = CheckoutIntents::Models::ProductAvailability
+
+  ProductImage = CheckoutIntents::Models::ProductImage
+
+  ProductLookupParams = CheckoutIntents::Models::ProductLookupParams
+
   VariantSelection = CheckoutIntents::Models::VariantSelection
 end