checkout-intents 0.0.2

data/rbi/checkout_intents/models/offer.rbi

@@ -0,0 +1,225 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    class Offer < CheckoutIntents::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(CheckoutIntents::Offer, CheckoutIntents::Internal::AnyHash)
+        end
+
+      sig { returns(CheckoutIntents::Offer::Cost) }
+      attr_reader :cost
+
+      sig { params(cost: CheckoutIntents::Offer::Cost::OrHash).void }
+      attr_writer :cost
+
+      sig { returns(CheckoutIntents::Offer::Shipping) }
+      attr_reader :shipping
+
+      sig { params(shipping: CheckoutIntents::Offer::Shipping::OrHash).void }
+      attr_writer :shipping
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :applied_promo_codes
+
+      sig { params(applied_promo_codes: T::Array[String]).void }
+      attr_writer :applied_promo_codes
+
+      sig do
+        params(
+          cost: CheckoutIntents::Offer::Cost::OrHash,
+          shipping: CheckoutIntents::Offer::Shipping::OrHash,
+          applied_promo_codes: T::Array[String]
+        ).returns(T.attached_class)
+      end
+      def self.new(cost:, shipping:, applied_promo_codes: nil)
+      end
+
+      sig do
+        override.returns(
+          {
+            cost: CheckoutIntents::Offer::Cost,
+            shipping: CheckoutIntents::Offer::Shipping,
+            applied_promo_codes: T::Array[String]
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Cost < CheckoutIntents::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              CheckoutIntents::Offer::Cost,
+              CheckoutIntents::Internal::AnyHash
+            )
+          end
+
+        sig { returns(CheckoutIntents::Money) }
+        attr_reader :subtotal
+
+        sig { params(subtotal: CheckoutIntents::Money::OrHash).void }
+        attr_writer :subtotal
+
+        sig { returns(CheckoutIntents::Money) }
+        attr_reader :total
+
+        sig { params(total: CheckoutIntents::Money::OrHash).void }
+        attr_writer :total
+
+        sig { returns(T.nilable(CheckoutIntents::Money)) }
+        attr_reader :discount
+
+        sig { params(discount: CheckoutIntents::Money::OrHash).void }
+        attr_writer :discount
+
+        sig { returns(T.nilable(CheckoutIntents::Money)) }
+        attr_reader :shipping
+
+        sig { params(shipping: CheckoutIntents::Money::OrHash).void }
+        attr_writer :shipping
+
+        sig { returns(T.nilable(CheckoutIntents::Money)) }
+        attr_reader :surcharge
+
+        sig { params(surcharge: CheckoutIntents::Money::OrHash).void }
+        attr_writer :surcharge
+
+        sig { returns(T.nilable(CheckoutIntents::Money)) }
+        attr_reader :tax
+
+        sig { params(tax: CheckoutIntents::Money::OrHash).void }
+        attr_writer :tax
+
+        sig do
+          params(
+            subtotal: CheckoutIntents::Money::OrHash,
+            total: CheckoutIntents::Money::OrHash,
+            discount: CheckoutIntents::Money::OrHash,
+            shipping: CheckoutIntents::Money::OrHash,
+            surcharge: CheckoutIntents::Money::OrHash,
+            tax: CheckoutIntents::Money::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          subtotal:,
+          total:,
+          discount: nil,
+          shipping: nil,
+          surcharge: nil,
+          tax: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              subtotal: CheckoutIntents::Money,
+              total: CheckoutIntents::Money,
+              discount: CheckoutIntents::Money,
+              shipping: CheckoutIntents::Money,
+              surcharge: CheckoutIntents::Money,
+              tax: CheckoutIntents::Money
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Shipping < CheckoutIntents::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              CheckoutIntents::Offer::Shipping,
+              CheckoutIntents::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(T::Array[CheckoutIntents::Offer::Shipping::AvailableOption])
+        end
+        attr_accessor :available_options
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :selected_option_id
+
+        sig { params(selected_option_id: String).void }
+        attr_writer :selected_option_id
+
+        sig do
+          params(
+            available_options:
+              T::Array[
+                CheckoutIntents::Offer::Shipping::AvailableOption::OrHash
+              ],
+            selected_option_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(available_options:, selected_option_id: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              available_options:
+                T::Array[CheckoutIntents::Offer::Shipping::AvailableOption],
+              selected_option_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class AvailableOption < CheckoutIntents::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                CheckoutIntents::Offer::Shipping::AvailableOption,
+                CheckoutIntents::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(CheckoutIntents::Money) }
+          attr_reader :cost
+
+          sig { params(cost: CheckoutIntents::Money::OrHash).void }
+          attr_writer :cost
+
+          sig { returns(T.nilable(CheckoutIntents::Money)) }
+          attr_reader :discount
+
+          sig { params(discount: CheckoutIntents::Money::OrHash).void }
+          attr_writer :discount
+
+          sig do
+            params(
+              id: String,
+              cost: CheckoutIntents::Money::OrHash,
+              discount: CheckoutIntents::Money::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(id:, cost:, discount: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                cost: CheckoutIntents::Money,
+                discount: CheckoutIntents::Money
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models/payment_method.rbi

@@ -0,0 +1,292 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    module PaymentMethod
+      extend CheckoutIntents::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod,
+            CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod,
+            CheckoutIntents::PaymentMethod::NekudaPaymentMethod
+          )
+        end
+
+      class StripeTokenPaymentMethod < CheckoutIntents::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod,
+              CheckoutIntents::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :stripe_token
+
+        sig do
+          returns(
+            CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type::OrSymbol
+          )
+        end
+        attr_accessor :type
+
+        sig do
+          params(
+            stripe_token: String,
+            type:
+              CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(stripe_token:, type:)
+        end
+
+        sig do
+          override.returns(
+            {
+              stripe_token: String,
+              type:
+                CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          STRIPE_TOKEN =
+            T.let(
+              :stripe_token,
+              CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class BasisTheoryPaymentMethod < CheckoutIntents::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod,
+              CheckoutIntents::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :basis_theory_token
+
+        sig do
+          returns(
+            CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type::OrSymbol
+          )
+        end
+        attr_accessor :type
+
+        sig do
+          params(
+            basis_theory_token: String,
+            type:
+              CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(basis_theory_token:, type:)
+        end
+
+        sig do
+          override.returns(
+            {
+              basis_theory_token: String,
+              type:
+                CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          BASIS_THEORY_TOKEN =
+            T.let(
+              :basis_theory_token,
+              CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class NekudaPaymentMethod < CheckoutIntents::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              CheckoutIntents::PaymentMethod::NekudaPaymentMethod,
+              CheckoutIntents::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :nekuda_user_id
+
+        sig do
+          returns(
+            CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type::OrSymbol
+          )
+        end
+        attr_accessor :type
+
+        # Construct a type with a set of properties K of type T
+        sig do
+          returns(
+            T.nilable(
+              T::Hash[
+                Symbol,
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::NekudaMandateData::Variants
+              ]
+            )
+          )
+        end
+        attr_reader :nekuda_mandate_data
+
+        sig do
+          params(
+            nekuda_mandate_data:
+              T::Hash[
+                Symbol,
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::NekudaMandateData::Variants
+              ]
+          ).void
+        end
+        attr_writer :nekuda_mandate_data
+
+        sig do
+          params(
+            nekuda_user_id: String,
+            type:
+              CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type::OrSymbol,
+            nekuda_mandate_data:
+              T::Hash[
+                Symbol,
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::NekudaMandateData::Variants
+              ]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          nekuda_user_id:,
+          type:,
+          # Construct a type with a set of properties K of type T
+          nekuda_mandate_data: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              nekuda_user_id: String,
+              type:
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type::OrSymbol,
+              nekuda_mandate_data:
+                T::Hash[
+                  Symbol,
+                  CheckoutIntents::PaymentMethod::NekudaPaymentMethod::NekudaMandateData::Variants
+                ]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend CheckoutIntents::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          NEKUDA_TOKEN =
+            T.let(
+              :nekuda_token,
+              CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module NekudaMandateData
+          extend CheckoutIntents::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(String, Float) }
+
+          sig do
+            override.returns(
+              T::Array[
+                CheckoutIntents::PaymentMethod::NekudaPaymentMethod::NekudaMandateData::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+
+      sig do
+        override.returns(T::Array[CheckoutIntents::PaymentMethod::Variants])
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models/variant_selection.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module CheckoutIntents
+  module Models
+    class VariantSelection < CheckoutIntents::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            CheckoutIntents::VariantSelection,
+            CheckoutIntents::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :label
+
+      sig { returns(CheckoutIntents::VariantSelection::Value::Variants) }
+      attr_accessor :value
+
+      sig do
+        params(
+          label: String,
+          value: CheckoutIntents::VariantSelection::Value::Variants
+        ).returns(T.attached_class)
+      end
+      def self.new(label:, value:)
+      end
+
+      sig do
+        override.returns(
+          {
+            label: String,
+            value: CheckoutIntents::VariantSelection::Value::Variants
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Value
+        extend CheckoutIntents::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(String, Float) }
+
+        sig do
+          override.returns(
+            T::Array[CheckoutIntents::VariantSelection::Value::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/checkout_intents/models.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module CheckoutIntents
+  BaseCheckoutIntent = CheckoutIntents::Models::BaseCheckoutIntent
+
+  Betas = CheckoutIntents::Models::Betas
+
+  BrandRetrieveParams = CheckoutIntents::Models::BrandRetrieveParams
+
+  Buyer = CheckoutIntents::Models::Buyer
+
+  CheckoutIntent = CheckoutIntents::Models::CheckoutIntent
+
+  CheckoutIntentAddPaymentParams =
+    CheckoutIntents::Models::CheckoutIntentAddPaymentParams
+
+  CheckoutIntentConfirmParams =
+    CheckoutIntents::Models::CheckoutIntentConfirmParams
+
+  CheckoutIntentCreateParams =
+    CheckoutIntents::Models::CheckoutIntentCreateParams
+
+  CheckoutIntentListParams = CheckoutIntents::Models::CheckoutIntentListParams
+
+  CheckoutIntentPurchaseParams =
+    CheckoutIntents::Models::CheckoutIntentPurchaseParams
+
+  CheckoutIntentRetrieveParams =
+    CheckoutIntents::Models::CheckoutIntentRetrieveParams
+
+  CheckoutSession = CheckoutIntents::Models::CheckoutSession
+
+  Money = CheckoutIntents::Models::Money
+
+  Offer = CheckoutIntents::Models::Offer
+
+  PaymentMethod = CheckoutIntents::Models::PaymentMethod
+
+  VariantSelection = CheckoutIntents::Models::VariantSelection
+end

data/rbi/checkout_intents/request_options.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module CheckoutIntents
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < CheckoutIntents::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(
+          CheckoutIntents::RequestOptions,
+          CheckoutIntents::Internal::AnyHash
+        )
+      end
+
+    # @api private
+    sig { params(opts: CheckoutIntents::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: CheckoutIntents::Internal::AnyHash).returns(
+        T.attached_class
+      )
+    end
+    def self.new(values = {})
+    end
+  end
+end