checkout-intents 0.0.2

data/rbi/checkout_intents/resources/betas/checkout_sessions.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module CheckoutIntents
+  module Resources
+    class Betas
+      class CheckoutSessions
+        # Create a new checkout session.
+        #
+        # Checkout sessions are hosted checkout forms your shoppers can use to complete
+        # their purchases.
+        sig do
+          params(
+            product_url: String,
+            quantity: Float,
+            buyer:
+              ::CheckoutIntents::Betas::CheckoutSessionCreateParams::Buyer::OrHash,
+            constraints:
+              ::CheckoutIntents::Betas::CheckoutSessionCreateParams::Constraints::OrHash,
+            promo_codes: T::Array[String],
+            variant_selections:
+              T::Array[::CheckoutIntents::VariantSelection::OrHash],
+            request_options: ::CheckoutIntents::RequestOptions::OrHash
+          ).returns(::CheckoutIntents::CheckoutSession)
+        end
+        def create(
+          product_url:,
+          quantity:,
+          # Optional buyer information, used to pre-fill the checkout form with the buyer's
+          # information.
+          buyer: nil,
+          constraints: nil,
+          promo_codes: nil,
+          variant_selections: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig do
+          params(client: ::CheckoutIntents::Client).returns(T.attached_class)
+        end
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/checkout_intents/resources/betas.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module CheckoutIntents
+  module Resources
+    class Betas
+      sig { returns(::CheckoutIntents::Resources::Betas::CheckoutSessions) }
+      attr_reader :checkout_sessions
+
+      # @api private
+      sig { params(client: ::CheckoutIntents::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/checkout_intents/resources/brands.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+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.
+      sig do
+        params(
+          domain: String,
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::Models::BrandRetrieveResponse)
+      end
+      def retrieve(
+        # Represents a valid domain name string.
+        domain,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: ::CheckoutIntents::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/checkout_intents/resources/checkout_intents.rbi

@@ -0,0 +1,165 @@
+# typed: strong
+
+module CheckoutIntents
+  module Resources
+    class CheckoutIntents
+      # Create a checkout intent with the given request body.
+      sig do
+        params(
+          buyer: ::CheckoutIntents::Buyer::OrHash,
+          product_url: String,
+          quantity: Float,
+          constraints:
+            ::CheckoutIntents::CheckoutIntentCreateParams::Constraints::OrHash,
+          promo_codes: T::Array[String],
+          variant_selections:
+            T::Array[::CheckoutIntents::VariantSelection::OrHash],
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::CheckoutIntent::Variants)
+      end
+      def create(
+        buyer:,
+        product_url:,
+        quantity:,
+        constraints: nil,
+        promo_codes: nil,
+        variant_selections: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a checkout intent by id
+      #
+      # Returns checkout intent information if the lookup succeeds.
+      sig do
+        params(
+          id: String,
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::CheckoutIntent::Variants)
+      end
+      def retrieve(
+        # The id of the checkout intent to look up
+        id,
+        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.
+      sig do
+        params(
+          id: T::Array[String],
+          after: String,
+          before: String,
+          limit: Float,
+          state:
+            T::Array[
+              ::CheckoutIntents::CheckoutIntentListParams::State::OrSymbol
+            ],
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(
+          ::CheckoutIntents::Internal::CursorPagination[
+            ::CheckoutIntents::CheckoutIntent::Variants
+          ]
+        )
+      end
+      def list(
+        id: nil,
+        after: nil,
+        before: nil,
+        limit: nil,
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      # Add payment details to a checkout intent
+      sig do
+        params(
+          id: String,
+          payment_method:
+            T.any(
+              ::CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::NekudaPaymentMethod::OrHash
+            ),
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::CheckoutIntent::Variants)
+      end
+      def add_payment(
+        # The id of the checkout intent to add payment details to
+        id,
+        payment_method:,
+        request_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.
+      sig do
+        params(
+          id: String,
+          payment_method:
+            T.any(
+              ::CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::NekudaPaymentMethod::OrHash
+            ),
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::CheckoutIntent::Variants)
+      end
+      def confirm(
+        # The id of the checkout intent to confirm
+        id,
+        payment_method:,
+        request_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.
+      sig do
+        params(
+          buyer: ::CheckoutIntents::Buyer::OrHash,
+          payment_method:
+            T.any(
+              ::CheckoutIntents::PaymentMethod::StripeTokenPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::BasisTheoryPaymentMethod::OrHash,
+              ::CheckoutIntents::PaymentMethod::NekudaPaymentMethod::OrHash
+            ),
+          product_url: String,
+          quantity: Float,
+          constraints:
+            ::CheckoutIntents::CheckoutIntentPurchaseParams::Constraints::OrHash,
+          promo_codes: T::Array[String],
+          variant_selections:
+            T::Array[::CheckoutIntents::VariantSelection::OrHash],
+          request_options: ::CheckoutIntents::RequestOptions::OrHash
+        ).returns(::CheckoutIntents::CheckoutIntent::Variants)
+      end
+      def purchase(
+        buyer:,
+        payment_method:,
+        product_url:,
+        quantity:,
+        constraints: nil,
+        promo_codes: nil,
+        variant_selections: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: ::CheckoutIntents::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/checkout_intents/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module CheckoutIntents
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/checkout_intents/client.rbs

@@ -0,0 +1,36 @@
+module CheckoutIntents
+  class Client < CheckoutIntents::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    ENVIRONMENTS: {
+      staging: "https://staging.api.rye.com/",
+      production: "https://api.rye.com/"
+    }
+
+    attr_reader api_key: String
+
+    attr_reader checkout_intents: CheckoutIntents::Resources::CheckoutIntents
+
+    attr_reader betas: CheckoutIntents::Resources::Betas
+
+    attr_reader brands: CheckoutIntents::Resources::Brands
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?environment: :staging | :production | nil,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end

data/sig/checkout_intents/errors.rbs

@@ -0,0 +1,117 @@
+module CheckoutIntents
+  module Errors
+    class Error < StandardError
+      attr_accessor cause: StandardError?
+    end
+
+    class ConversionError < CheckoutIntents::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
+    end
+
+    class APIError < CheckoutIntents::Errors::Error
+      attr_accessor url: URI::Generic
+
+      attr_accessor status: Integer?
+
+      attr_accessor headers: ::Hash[String, String]?
+
+      attr_accessor body: top?
+
+      def initialize: (
+        url: URI::Generic,
+        ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
+        ?body: Object?,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIConnectionError < CheckoutIntents::Errors::APIError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APITimeoutError < CheckoutIntents::Errors::APIConnectionError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIStatusError < CheckoutIntents::Errors::APIError
+      def self.for: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> instance
+
+      def initialize: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> void
+    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: Range[Integer]
+    end
+  end
+end

data/sig/checkout_intents/file_part.rbs

@@ -0,0 +1,21 @@
+module CheckoutIntents
+  class FilePart
+    attr_reader content: Pathname | StringIO | IO | String
+
+    attr_reader content_type: String?
+
+    attr_reader filename: String?
+
+    private def read: -> String
+
+    def to_json: (*top a) -> String
+
+    def to_yaml: (*top a) -> String
+
+    def initialize: (
+      Pathname | StringIO | IO | String content,
+      ?filename: (Pathname | String)?,
+      ?content_type: String?
+    ) -> void
+  end
+end

data/sig/checkout_intents/internal/cursor_pagination.rbs

@@ -0,0 +1,48 @@
+module CheckoutIntents
+  module Internal
+    class CursorPagination[Elem]
+      include CheckoutIntents::Internal::Type::BasePage[Elem]
+
+      attr_accessor data: ::Array[Elem]?
+
+      attr_accessor page_info: PageInfo
+
+      def inspect: -> String
+
+      type page_info =
+        {
+          end_cursor: String?,
+          has_next_page: bool,
+          has_previous_page: bool,
+          start_cursor: String?
+        }
+      class PageInfo < CheckoutIntents::Internal::Type::BaseModel
+        attr_accessor end_cursor: String?
+
+        attr_reader has_next_page: bool?
+
+        def has_next_page=: (bool) -> bool
+
+        attr_reader has_previous_page: bool?
+
+        def has_previous_page=: (bool) -> bool
+
+        attr_accessor start_cursor: String?
+
+        def initialize: (
+          ?end_cursor: String?,
+          ?has_next_page: bool,
+          ?has_previous_page: bool,
+          ?start_cursor: String?
+        ) -> void
+
+        def to_hash: -> {
+          end_cursor: String?,
+          has_next_page: bool,
+          has_previous_page: bool,
+          start_cursor: String?
+        }
+      end
+    end
+  end
+end

data/sig/checkout_intents/internal/transport/base_client.rbs

@@ -0,0 +1,133 @@
+module CheckoutIntents
+  module Internal
+    module Transport
+      class BaseClient
+        extend CheckoutIntents::Internal::Util::SorbetRuntimeSupport
+
+        type request_components =
+          {
+            method: Symbol,
+            path: String | ::Array[String],
+            query: ::Hash[String, (::Array[String] | String)?]?,
+            headers: ::Hash[String, (String
+            | Integer
+            | ::Array[(String | Integer)?])?]?,
+            body: top?,
+            unwrap: (Symbol
+            | Integer
+            | ::Array[(Symbol | Integer)]
+            | (^(top arg0) -> top))?,
+            page: Class?,
+            stream: Class?,
+            model: CheckoutIntents::Internal::Type::Converter::input?,
+            options: CheckoutIntents::request_opts?
+          }
+        type request_input =
+          {
+            method: Symbol,
+            url: URI::Generic,
+            headers: ::Hash[String, String],
+            body: top,
+            max_retries: Integer,
+            timeout: Float
+          }
+
+        MAX_REDIRECTS: 20
+
+        PLATFORM_HEADERS: ::Hash[String, String]
+
+        def self.validate!: (
+          CheckoutIntents::Internal::Transport::BaseClient::request_components req
+        ) -> void
+
+        def self.should_retry?: (
+          Integer status,
+          headers: ::Hash[String, String]
+        ) -> bool
+
+        def self.follow_redirect: (
+          CheckoutIntents::Internal::Transport::BaseClient::request_input request,
+          status: Integer,
+          response_headers: ::Hash[String, String]
+        ) -> CheckoutIntents::Internal::Transport::BaseClient::request_input
+
+        def self.reap_connection!: (
+          Integer | CheckoutIntents::Errors::APIConnectionError status,
+          stream: Enumerable[String]?
+        ) -> void
+
+        attr_reader base_url: URI::Generic
+
+        attr_reader timeout: Float
+
+        attr_reader max_retries: Integer
+
+        attr_reader initial_retry_delay: Float
+
+        attr_reader max_retry_delay: Float
+
+        attr_reader headers: ::Hash[String, String]
+
+        attr_reader idempotency_header: String?
+
+        # @api private
+        attr_reader requester: CheckoutIntents::Internal::Transport::PooledNetRequester
+
+        def initialize: (
+          base_url: String,
+          ?timeout: Float,
+          ?max_retries: Integer,
+          ?initial_retry_delay: Float,
+          ?max_retry_delay: Float,
+          ?headers: ::Hash[String, (String
+          | Integer
+          | ::Array[(String | Integer)?])?],
+          ?idempotency_header: String?
+        ) -> void
+
+        private def auth_headers: -> ::Hash[String, String]
+
+        private def user_agent: -> String
+
+        private def generate_idempotency_key: -> String
+
+        private def build_request: (
+          CheckoutIntents::Internal::Transport::BaseClient::request_components req,
+          CheckoutIntents::request_options opts
+        ) -> CheckoutIntents::Internal::Transport::BaseClient::request_input
+
+        private def retry_delay: (
+          ::Hash[String, String] headers,
+          retry_count: Integer
+        ) -> Float
+
+        def send_request: (
+          CheckoutIntents::Internal::Transport::BaseClient::request_input request,
+          redirect_count: Integer,
+          retry_count: Integer,
+          send_retry_header: bool
+        ) -> [Integer, top, Enumerable[String]]
+
+        def request: (
+          Symbol method,
+          String | ::Array[String] path,
+          ?query: ::Hash[String, (::Array[String] | String)?]?,
+          ?headers: ::Hash[String, (String
+          | Integer
+          | ::Array[(String | Integer)?])?]?,
+          ?body: top?,
+          ?unwrap: (Symbol
+          | Integer
+          | ::Array[(Symbol | Integer)]
+          | (^(top arg0) -> top))?,
+          ?page: Class?,
+          ?stream: Class?,
+          ?model: CheckoutIntents::Internal::Type::Converter::input?,
+          ?options: CheckoutIntents::request_opts?
+        ) -> top
+
+        def inspect: -> String
+      end
+    end
+  end
+end

data/sig/checkout_intents/internal/transport/pooled_net_requester.rbs

@@ -0,0 +1,48 @@
+module CheckoutIntents
+  module Internal
+    module Transport
+      class PooledNetRequester
+        extend CheckoutIntents::Internal::Util::SorbetRuntimeSupport
+
+        type request =
+          {
+            method: Symbol,
+            url: URI::Generic,
+            headers: ::Hash[String, String],
+            body: top,
+            deadline: Float
+          }
+
+        KEEP_ALIVE_TIMEOUT: 30
+
+        DEFAULT_MAX_CONNECTIONS: Integer
+
+        def self.connect: (
+          cert_store: OpenSSL::X509::Store,
+          url: URI::Generic
+        ) -> top
+
+        def self.calibrate_socket_timeout: (top conn, Float deadline) -> void
+
+        def self.build_request: (
+          CheckoutIntents::Internal::Transport::PooledNetRequester::request request
+        ) {
+          (String arg0) -> void
+        } -> [top, (^-> void)]
+
+        private def with_pool: (
+          URI::Generic url,
+          deadline: Float
+        ) {
+          (top arg0) -> void
+        } -> void
+
+        def execute: (
+          CheckoutIntents::Internal::Transport::PooledNetRequester::request request
+        ) -> [Integer, top, Enumerable[String]]
+
+        def initialize: (?size: Integer) -> void
+      end
+    end
+  end
+end