checkout-intents 0.0.2

data/lib/checkout_intents/resources/betas/checkout_sessions.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module CheckoutIntents
+  module Resources
+    class Betas
+      class CheckoutSessions
+        # Some parameter documentations has been truncated, see
+        # {::CheckoutIntents::Models::Betas::CheckoutSessionCreateParams} for more details.
+        #
+        # Create a new checkout session.
+        #
+        # Checkout sessions are hosted checkout forms your shoppers can use to complete
+        # their purchases.
+        #
+        # @overload create(product_url:, quantity:, buyer: nil, constraints: nil, promo_codes: nil, variant_selections: nil, request_options: {})
+        #
+        # @param product_url [String]
+        #
+        # @param quantity [Float]
+        #
+        # @param buyer [::CheckoutIntents::Models::Betas::CheckoutSessionCreateParams::Buyer] Optional buyer information, used to pre-fill the checkout form with the buyer's
+        #
+        # @param constraints [::CheckoutIntents::Models::Betas::CheckoutSessionCreateParams::Constraints]
+        #
+        # @param promo_codes [Array<String>]
+        #
+        # @param variant_selections [Array<::CheckoutIntents::Models::VariantSelection>]
+        #
+        # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [::CheckoutIntents::Models::CheckoutSession]
+        #
+        # @see ::CheckoutIntents::Models::Betas::CheckoutSessionCreateParams
+        def create(params)
+          parsed, options = ::CheckoutIntents::Betas::CheckoutSessionCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "api/v1/betas/checkout-sessions",
+            body: parsed,
+            model: ::CheckoutIntents::CheckoutSession,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [::CheckoutIntents::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/checkout_intents/resources/betas.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CheckoutIntents
+  module Resources
+    class Betas
+      # @return [::CheckoutIntents::Resources::Betas::CheckoutSessions]
+      attr_reader :checkout_sessions
+
+      # @api private
+      #
+      # @param client [::CheckoutIntents::Client]
+      def initialize(client:)
+        @client = client
+        @checkout_sessions = ::CheckoutIntents::Resources::Betas::CheckoutSessions.new(client: client)
+      end
+    end
+  end
+end

data/lib/checkout_intents/resources/brands.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CheckoutIntents
+  module Resources
+    class Brands
+      # Retrieve brand information by domain name
+      #
+      # Look up a brand by its domain name (e.g. "aloyoga.com" or "www.amazon.com").
+      # Returns brand information including the marketplace type if the lookup succeeds.
+      #
+      # @overload retrieve(domain, request_options: {})
+      #
+      # @param domain [String] Represents a valid domain name string.
+      #
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::BrandRetrieveResponse]
+      #
+      # @see ::CheckoutIntents::Models::BrandRetrieveParams
+      def retrieve(domain, params = {})
+        @client.request(
+          method: :get,
+          path: ["api/v1/brands/domain/%1$s", domain],
+          model: ::CheckoutIntents::Models::BrandRetrieveResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [::CheckoutIntents::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/checkout_intents/resources/checkout_intents.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module CheckoutIntents
+  module Resources
+    class CheckoutIntents
+      # Create a checkout intent with the given request body.
+      #
+      # @overload create(buyer:, product_url:, quantity:, constraints: nil, promo_codes: nil, variant_selections: nil, request_options: {})
+      #
+      # @param buyer [::CheckoutIntents::Models::Buyer]
+      # @param product_url [String]
+      # @param quantity [Float]
+      # @param constraints [::CheckoutIntents::Models::CheckoutIntentCreateParams::Constraints]
+      # @param promo_codes [Array<String>]
+      # @param variant_selections [Array<::CheckoutIntents::Models::VariantSelection>]
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentCreateParams
+      def create(params)
+        parsed, options = ::CheckoutIntents::CheckoutIntentCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/checkout-intents",
+          body: parsed,
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: options
+        )
+      end
+
+      # Retrieve a checkout intent by id
+      #
+      # Returns checkout intent information if the lookup succeeds.
+      #
+      # @overload retrieve(id, request_options: {})
+      #
+      # @param id [String] The id of the checkout intent to look up
+      #
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentRetrieveParams
+      def retrieve(id, params = {})
+        @client.request(
+          method: :get,
+          path: ["api/v1/checkout-intents/%1$s", id],
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: params[:request_options]
+        )
+      end
+
+      # Retrieve a paginated list of checkout intents
+      #
+      # Enables developers to query checkout intents associated with their account, with
+      # filters and cursor-based pagination.
+      #
+      # @overload list(id: nil, after: nil, before: nil, limit: nil, state: nil, request_options: {})
+      #
+      # @param id [Array<String>]
+      # @param after [String]
+      # @param before [String]
+      # @param limit [Float]
+      # @param state [Array<Symbol, ::CheckoutIntents::Models::CheckoutIntentListParams::State>]
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Internal::CursorPagination<::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent>]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentListParams
+      def list(params = {})
+        parsed, options = ::CheckoutIntents::CheckoutIntentListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "api/v1/checkout-intents",
+          query: parsed,
+          page: ::CheckoutIntents::Internal::CursorPagination,
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: options
+        )
+      end
+
+      # Add payment details to a checkout intent
+      #
+      # @overload add_payment(id, payment_method:, request_options: {})
+      #
+      # @param id [String] The id of the checkout intent to add payment details to
+      #
+      # @param payment_method [::CheckoutIntents::Models::PaymentMethod::StripeTokenPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::BasisTheoryPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::NekudaPaymentMethod]
+      #
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentAddPaymentParams
+      def add_payment(id, params)
+        parsed, options = ::CheckoutIntents::CheckoutIntentAddPaymentParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["api/v1/checkout-intents/%1$s/payment", id],
+          body: parsed,
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: options
+        )
+      end
+
+      # Confirm a checkout intent with provided payment information
+      #
+      # Confirm means we have buyer's name, address and payment info, so we can move
+      # forward to place the order.
+      #
+      # @overload confirm(id, payment_method:, request_options: {})
+      #
+      # @param id [String] The id of the checkout intent to confirm
+      #
+      # @param payment_method [::CheckoutIntents::Models::PaymentMethod::StripeTokenPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::BasisTheoryPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::NekudaPaymentMethod]
+      #
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentConfirmParams
+      def confirm(id, params)
+        parsed, options = ::CheckoutIntents::CheckoutIntentConfirmParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["api/v1/checkout-intents/%1$s/confirm", id],
+          body: parsed,
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: options
+        )
+      end
+
+      # Create a checkout intent and immediately trigger the purchase workflow.
+      #
+      # This is a "fire-and-forget" endpoint that combines create + confirm in one step.
+      # The workflow handles offer retrieval, payment authorization, and order placement
+      # asynchronously. Poll the GET endpoint to check status.
+      #
+      # @overload purchase(buyer:, payment_method:, product_url:, quantity:, constraints: nil, promo_codes: nil, variant_selections: nil, request_options: {})
+      #
+      # @param buyer [::CheckoutIntents::Models::Buyer]
+      # @param payment_method [::CheckoutIntents::Models::PaymentMethod::StripeTokenPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::BasisTheoryPaymentMethod, ::CheckoutIntents::Models::PaymentMethod::NekudaPaymentMethod]
+      # @param product_url [String]
+      # @param quantity [Float]
+      # @param constraints [::CheckoutIntents::Models::CheckoutIntentPurchaseParams::Constraints]
+      # @param promo_codes [Array<String>]
+      # @param variant_selections [Array<::CheckoutIntents::Models::VariantSelection>]
+      # @param request_options [::CheckoutIntents::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [::CheckoutIntents::Models::CheckoutIntent::RetrievingOfferCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::AwaitingConfirmationCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::PlacingOrderCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::CompletedCheckoutIntent, ::CheckoutIntents::Models::CheckoutIntent::FailedCheckoutIntent]
+      #
+      # @see ::CheckoutIntents::Models::CheckoutIntentPurchaseParams
+      def purchase(params)
+        parsed, options = ::CheckoutIntents::CheckoutIntentPurchaseParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "api/v1/checkout-intents/purchase",
+          body: parsed,
+          model: ::CheckoutIntents::CheckoutIntent,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [::CheckoutIntents::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/checkout_intents/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CheckoutIntents
+  VERSION = "0.0.2"
+end

data/lib/checkout_intents.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "base64"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "openssl"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) &&
+   caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+
+# Package files.
+require_relative "checkout_intents/version"
+require_relative "checkout_intents/internal/util"
+require_relative "checkout_intents/internal/type/converter"
+require_relative "checkout_intents/internal/type/unknown"
+require_relative "checkout_intents/internal/type/boolean"
+require_relative "checkout_intents/internal/type/file_input"
+require_relative "checkout_intents/internal/type/enum"
+require_relative "checkout_intents/internal/type/union"
+require_relative "checkout_intents/internal/type/array_of"
+require_relative "checkout_intents/internal/type/hash_of"
+require_relative "checkout_intents/internal/type/base_model"
+require_relative "checkout_intents/internal/type/base_page"
+require_relative "checkout_intents/internal/type/request_parameters"
+require_relative "checkout_intents/internal"
+require_relative "checkout_intents/request_options"
+require_relative "checkout_intents/file_part"
+require_relative "checkout_intents/errors"
+require_relative "checkout_intents/internal/transport/base_client"
+require_relative "checkout_intents/internal/transport/pooled_net_requester"
+require_relative "checkout_intents/client"
+require_relative "checkout_intents/internal/cursor_pagination"
+require_relative "checkout_intents/models/base_checkout_intent"
+require_relative "checkout_intents/models/betas/checkout_session_create_params"
+require_relative "checkout_intents/models/brand_retrieve_params"
+require_relative "checkout_intents/models/brand_retrieve_response"
+require_relative "checkout_intents/models/buyer"
+require_relative "checkout_intents/models/checkout_intent"
+require_relative "checkout_intents/models/checkout_intent_add_payment_params"
+require_relative "checkout_intents/models/checkout_intent_confirm_params"
+require_relative "checkout_intents/models/checkout_intent_create_params"
+require_relative "checkout_intents/models/checkout_intent_list_params"
+require_relative "checkout_intents/models/checkout_intent_purchase_params"
+require_relative "checkout_intents/models/checkout_intent_retrieve_params"
+require_relative "checkout_intents/models/checkout_session"
+require_relative "checkout_intents/models/money"
+require_relative "checkout_intents/models/offer"
+require_relative "checkout_intents/models/payment_method"
+require_relative "checkout_intents/models/variant_selection"
+require_relative "checkout_intents/models"
+require_relative "checkout_intents/resources/betas"
+require_relative "checkout_intents/resources/betas/checkout_sessions"
+require_relative "checkout_intents/resources/brands"
+require_relative "checkout_intents/resources/checkout_intents"

data/manifest.yaml

@@ -0,0 +1,17 @@
+dependencies:
+  - English
+  - base64
+  - cgi
+  - date
+  - erb
+  - etc
+  - json
+  - net/http
+  - openssl
+  - pathname
+  - rbconfig
+  - securerandom
+  - set
+  - stringio
+  - time
+  - uri

data/rbi/checkout_intents/client.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module CheckoutIntents
+  class Client < CheckoutIntents::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    ENVIRONMENTS =
+      T.let(
+        {
+          staging: "https://staging.api.rye.com/",
+          production: "https://api.rye.com/"
+        },
+        T::Hash[Symbol, String]
+      )
+
+    # Rye API key. Format: `RYE/{environment}-abcdef`
+    sig { returns(String) }
+    attr_reader :api_key
+
+    sig { returns(CheckoutIntents::Resources::CheckoutIntents) }
+    attr_reader :checkout_intents
+
+    sig { returns(CheckoutIntents::Resources::Betas) }
+    attr_reader :betas
+
+    sig { returns(CheckoutIntents::Resources::Brands) }
+    attr_reader :brands
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        api_key: T.nilable(String),
+        environment: T.nilable(T.any(Symbol, String)),
+        base_url: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      # Rye API key. Format: `RYE/{environment}-abcdef` Defaults to
+      # `ENV["CHECKOUT_INTENTS_API_KEY"]`
+      api_key: ENV["CHECKOUT_INTENTS_API_KEY"],
+      # Specifies the environment to use for the API.
+      #
+      # Each environment maps to a different base URL:
+      #
+      # - `staging` corresponds to `https://staging.api.rye.com/`
+      # - `production` corresponds to `https://api.rye.com/`
+      environment: nil,
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["CHECKOUT_INTENTS_BASE_URL"]`
+      base_url: ENV["CHECKOUT_INTENTS_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: CheckoutIntents::Client::DEFAULT_MAX_RETRIES,
+      timeout: CheckoutIntents::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: CheckoutIntents::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: CheckoutIntents::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/checkout_intents/errors.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module CheckoutIntents
+  module Errors
+    class Error < StandardError
+      sig { returns(T.nilable(StandardError)) }
+      attr_accessor :cause
+    end
+
+    class ConversionError < CheckoutIntents::Errors::Error
+      sig { returns(T.nilable(StandardError)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          on: T::Class[StandardError],
+          method: Symbol,
+          target: T.anything,
+          value: T.anything,
+          cause: T.nilable(StandardError)
+        ).returns(T.attached_class)
+      end
+      def self.new(on:, method:, target:, value:, cause: nil)
+      end
+    end
+
+    class APIError < CheckoutIntents::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :headers
+
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: T.nilable(Integer),
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: nil
+      )
+      end
+    end
+
+    class APIConnectionError < CheckoutIntents::Errors::APIError
+      sig { returns(NilClass) }
+      attr_accessor :status
+
+      sig { returns(NilClass) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+      end
+    end
+
+    class APITimeoutError < CheckoutIntents::Errors::APIConnectionError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+      end
+    end
+
+    class APIStatusError < CheckoutIntents::Errors::APIError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.for(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+
+      sig { returns(Integer) }
+      attr_accessor :status
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+    end
+
+    class BadRequestError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < CheckoutIntents::Errors::APIStatusError
+      HTTP_STATUS = T.let((500..), T::Range[Integer])
+    end
+  end
+end