dodopayments 1.22.0 → 1.49.0

data/rbi/dodopayments/models/payment_create_params.rbi

@@ -6,17 +6,31 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
-      sig { returns(Dodopayments::Models::BillingAddress) }
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::PaymentCreateParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Billing address details for the payment
+      sig { returns(Dodopayments::BillingAddress) }
       attr_reader :billing
 
-      sig { params(billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)).void }
+      sig { params(billing: Dodopayments::BillingAddress::OrHash).void }
       attr_writer :billing
 
-      sig { returns(T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer)) }
+      # Customer information for the payment
+      sig do
+        returns(
+          T.any(Dodopayments::AttachExistingCustomer, Dodopayments::NewCustomer)
+        )
+      end
       attr_accessor :customer
 
       # List of products in the cart. Must contain at least 1 and at most 100 items.
-      sig { returns(T::Array[Dodopayments::Models::OneTimeProductCartItem]) }
+      sig { returns(T::Array[Dodopayments::OneTimeProductCartItem]) }
       attr_accessor :product_cart
 
       # List of payment methods allowed during checkout.
@@ -26,19 +40,21 @@ module Dodopayments
       # Availability still depends on other factors (e.g., customer location, merchant
       # settings).
       sig do
-        returns(
-          T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol])
-        )
+        returns(T.nilable(T::Array[Dodopayments::PaymentMethodTypes::OrSymbol]))
       end
       attr_accessor :allowed_payment_method_types
 
-      sig { returns(T.nilable(Dodopayments::Models::Currency::OrSymbol)) }
+      # Fix the currency in which the end customer is billed. If Dodo Payments cannot
+      # support that currency for this transaction, it will not proceed
+      sig { returns(T.nilable(Dodopayments::Currency::OrSymbol)) }
       attr_accessor :billing_currency
 
       # Discount Code to apply to the transaction
       sig { returns(T.nilable(String)) }
       attr_accessor :discount_code
 
+      # Additional metadata associated with the payment. Defaults to empty if not
+      # provided.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
       attr_reader :metadata
 
@@ -68,27 +84,29 @@ module Dodopayments
 
       sig do
         params(
-          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
-          customer: T.any(
-            Dodopayments::Models::AttachExistingCustomer,
-            Dodopayments::Internal::AnyHash,
-            Dodopayments::Models::CreateNewCustomer
-          ),
-          product_cart: T::Array[T.any(Dodopayments::Models::OneTimeProductCartItem, Dodopayments::Internal::AnyHash)],
-          allowed_payment_method_types: T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol]),
-          billing_currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+          billing: Dodopayments::BillingAddress::OrHash,
+          customer:
+            T.any(
+              Dodopayments::AttachExistingCustomer::OrHash,
+              Dodopayments::NewCustomer::OrHash
+            ),
+          product_cart: T::Array[Dodopayments::OneTimeProductCartItem::OrHash],
+          allowed_payment_method_types:
+            T.nilable(T::Array[Dodopayments::PaymentMethodTypes::OrSymbol]),
+          billing_currency: T.nilable(Dodopayments::Currency::OrSymbol),
           discount_code: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           payment_link: T.nilable(T::Boolean),
           return_url: T.nilable(String),
           show_saved_payment_methods: T::Boolean,
           tax_id: T.nilable(String),
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
+        # Billing address details for the payment
         billing:,
+        # Customer information for the payment
         customer:,
         # List of products in the cart. Must contain at least 1 and at most 100 items.
         product_cart:,
@@ -99,9 +117,13 @@ module Dodopayments
         # Availability still depends on other factors (e.g., customer location, merchant
         # settings).
         allowed_payment_method_types: nil,
+        # Fix the currency in which the end customer is billed. If Dodo Payments cannot
+        # support that currency for this transaction, it will not proceed
         billing_currency: nil,
         # Discount Code to apply to the transaction
         discount_code: nil,
+        # Additional metadata associated with the payment. Defaults to empty if not
+        # provided.
         metadata: nil,
         # Whether to generate a payment link. Defaults to false if not specified.
         payment_link: nil,
@@ -114,75 +136,33 @@ module Dodopayments
         # creation will fail
         tax_id: nil,
         request_options: {}
-      ); end
-      sig do
-        override
-          .returns(
-            {
-              billing: Dodopayments::Models::BillingAddress,
-              customer: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer),
-              product_cart: T::Array[Dodopayments::Models::OneTimeProductCartItem],
-              allowed_payment_method_types: T.nilable(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::OrSymbol]),
-              billing_currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
-              discount_code: T.nilable(String),
-              metadata: T::Hash[Symbol, String],
-              payment_link: T.nilable(T::Boolean),
-              return_url: T.nilable(String),
-              show_saved_payment_methods: T::Boolean,
-              tax_id: T.nilable(String),
-              request_options: Dodopayments::RequestOptions
-            }
-          )
+      )
       end
-      def to_hash; end
-
-      module AllowedPaymentMethodType
-        extend Dodopayments::Internal::Type::Enum
-
-        TaggedSymbol =
-          T.type_alias { T.all(Symbol, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        CREDIT =
-          T.let(:credit, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        DEBIT = T.let(:debit, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        UPI_COLLECT =
-          T.let(:upi_collect, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        UPI_INTENT =
-          T.let(:upi_intent, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        APPLE_PAY =
-          T.let(:apple_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        CASHAPP =
-          T.let(:cashapp, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        GOOGLE_PAY =
-          T.let(:google_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        MULTIBANCO =
-          T.let(:multibanco, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        BANCONTACT_CARD =
-          T.let(:bancontact_card, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        EPS = T.let(:eps, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        IDEAL = T.let(:ideal, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        PRZELEWY24 =
-          T.let(:przelewy24, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        AFFIRM =
-          T.let(:affirm, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        KLARNA =
-          T.let(:klarna, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        SEPA = T.let(:sepa, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        ACH = T.let(:ach, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        AMAZON_PAY =
-          T.let(:amazon_pay, Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol)
-        AFTERPAY_CLEARPAY =
-          T.let(
-            :afterpay_clearpay,
-            Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol
-          )
 
-        sig do
-          override
-            .returns(T::Array[Dodopayments::Models::PaymentCreateParams::AllowedPaymentMethodType::TaggedSymbol])
-        end
-        def self.values; end
+      sig do
+        override.returns(
+          {
+            billing: Dodopayments::BillingAddress,
+            customer:
+              T.any(
+                Dodopayments::AttachExistingCustomer,
+                Dodopayments::NewCustomer
+              ),
+            product_cart: T::Array[Dodopayments::OneTimeProductCartItem],
+            allowed_payment_method_types:
+              T.nilable(T::Array[Dodopayments::PaymentMethodTypes::OrSymbol]),
+            billing_currency: T.nilable(Dodopayments::Currency::OrSymbol),
+            discount_code: T.nilable(String),
+            metadata: T::Hash[Symbol, String],
+            payment_link: T.nilable(T::Boolean),
+            return_url: T.nilable(String),
+            show_saved_payment_methods: T::Boolean,
+            tax_id: T.nilable(String),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
     end
   end

data/rbi/dodopayments/models/payment_create_response.rbi

@@ -3,19 +3,29 @@
 module Dodopayments
   module Models
     class PaymentCreateResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::PaymentCreateResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
       # Client secret used to load Dodo checkout SDK NOTE : Dodo checkout SDK will be
       # coming soon
       sig { returns(String) }
       attr_accessor :client_secret
 
-      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      # Limited details about the customer making the payment
+      sig { returns(Dodopayments::CustomerLimitedDetails) }
       attr_reader :customer
 
       sig do
-        params(customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash)).void
+        params(customer: Dodopayments::CustomerLimitedDetails::OrHash).void
       end
       attr_writer :customer
 
+      # Additional metadata associated with the payment
       sig { returns(T::Hash[Symbol, String]) }
       attr_accessor :metadata
 
@@ -31,32 +41,39 @@ module Dodopayments
       sig { returns(T.nilable(String)) }
       attr_accessor :discount_id
 
+      # Expiry timestamp of the payment link
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :expires_on
+
       # Optional URL to a hosted payment page
       sig { returns(T.nilable(String)) }
       attr_accessor :payment_link
 
       # Optional list of products included in the payment
-      sig { returns(T.nilable(T::Array[Dodopayments::Models::OneTimeProductCartItem])) }
+      sig { returns(T.nilable(T::Array[Dodopayments::OneTimeProductCartItem])) }
       attr_accessor :product_cart
 
       sig do
         params(
           client_secret: String,
-          customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash),
+          customer: Dodopayments::CustomerLimitedDetails::OrHash,
           metadata: T::Hash[Symbol, String],
           payment_id: String,
           total_amount: Integer,
           discount_id: T.nilable(String),
+          expires_on: T.nilable(Time),
           payment_link: T.nilable(String),
-          product_cart: T.nilable(T::Array[T.any(Dodopayments::Models::OneTimeProductCartItem, Dodopayments::Internal::AnyHash)])
-        )
-          .returns(T.attached_class)
+          product_cart:
+            T.nilable(T::Array[Dodopayments::OneTimeProductCartItem::OrHash])
+        ).returns(T.attached_class)
       end
       def self.new(
         # Client secret used to load Dodo checkout SDK NOTE : Dodo checkout SDK will be
         # coming soon
         client_secret:,
+        # Limited details about the customer making the payment
         customer:,
+        # Additional metadata associated with the payment
         metadata:,
         # Unique identifier for the payment
         payment_id:,
@@ -64,27 +81,33 @@ module Dodopayments
         total_amount:,
         # The discount id if discount is applied
         discount_id: nil,
+        # Expiry timestamp of the payment link
+        expires_on: nil,
         # Optional URL to a hosted payment page
         payment_link: nil,
         # Optional list of products included in the payment
         product_cart: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              client_secret: String,
-              customer: Dodopayments::Models::CustomerLimitedDetails,
-              metadata: T::Hash[Symbol, String],
-              payment_id: String,
-              total_amount: Integer,
-              discount_id: T.nilable(String),
-              payment_link: T.nilable(String),
-              product_cart: T.nilable(T::Array[Dodopayments::Models::OneTimeProductCartItem])
-            }
-          )
+        override.returns(
+          {
+            client_secret: String,
+            customer: Dodopayments::CustomerLimitedDetails,
+            metadata: T::Hash[Symbol, String],
+            payment_id: String,
+            total_amount: Integer,
+            discount_id: T.nilable(String),
+            expires_on: T.nilable(Time),
+            payment_link: T.nilable(String),
+            product_cart:
+              T.nilable(T::Array[Dodopayments::OneTimeProductCartItem])
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/dodopayments/models/payment_list_params.rbi

@@ -6,48 +6,90 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::PaymentListParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # filter by Brand id
+      sig { returns(T.nilable(String)) }
+      attr_reader :brand_id
+
+      sig { params(brand_id: String).void }
+      attr_writer :brand_id
+
       # Get events after this created time
       sig { returns(T.nilable(Time)) }
-      attr_accessor :created_at_gte
+      attr_reader :created_at_gte
+
+      sig { params(created_at_gte: Time).void }
+      attr_writer :created_at_gte
 
       # Get events created before this time
       sig { returns(T.nilable(Time)) }
-      attr_accessor :created_at_lte
+      attr_reader :created_at_lte
+
+      sig { params(created_at_lte: Time).void }
+      attr_writer :created_at_lte
 
       # Filter by customer id
       sig { returns(T.nilable(String)) }
-      attr_accessor :customer_id
+      attr_reader :customer_id
+
+      sig { params(customer_id: String).void }
+      attr_writer :customer_id
 
       # Page number default is 0
       sig { returns(T.nilable(Integer)) }
-      attr_accessor :page_number
+      attr_reader :page_number
+
+      sig { params(page_number: Integer).void }
+      attr_writer :page_number
 
       # Page size default is 10 max is 100
       sig { returns(T.nilable(Integer)) }
-      attr_accessor :page_size
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
 
       # Filter by status
-      sig { returns(T.nilable(Dodopayments::Models::IntentStatus::OrSymbol)) }
-      attr_accessor :status
+      sig do
+        returns(T.nilable(Dodopayments::PaymentListParams::Status::OrSymbol))
+      end
+      attr_reader :status
+
+      sig do
+        params(status: Dodopayments::PaymentListParams::Status::OrSymbol).void
+      end
+      attr_writer :status
 
       # Filter by subscription id
       sig { returns(T.nilable(String)) }
-      attr_accessor :subscription_id
+      attr_reader :subscription_id
+
+      sig { params(subscription_id: String).void }
+      attr_writer :subscription_id
 
       sig do
         params(
-          created_at_gte: T.nilable(Time),
-          created_at_lte: T.nilable(Time),
-          customer_id: T.nilable(String),
-          page_number: T.nilable(Integer),
-          page_size: T.nilable(Integer),
-          status: T.nilable(Dodopayments::Models::IntentStatus::OrSymbol),
-          subscription_id: T.nilable(String),
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          brand_id: String,
+          created_at_gte: Time,
+          created_at_lte: Time,
+          customer_id: String,
+          page_number: Integer,
+          page_size: Integer,
+          status: Dodopayments::PaymentListParams::Status::OrSymbol,
+          subscription_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
+        # filter by Brand id
+        brand_id: nil,
         # Get events after this created time
         created_at_gte: nil,
         # Get events created before this time
@@ -63,23 +105,98 @@ module Dodopayments
         # Filter by subscription id
         subscription_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              created_at_gte: T.nilable(Time),
-              created_at_lte: T.nilable(Time),
-              customer_id: T.nilable(String),
-              page_number: T.nilable(Integer),
-              page_size: T.nilable(Integer),
-              status: T.nilable(Dodopayments::Models::IntentStatus::OrSymbol),
-              subscription_id: T.nilable(String),
-              request_options: Dodopayments::RequestOptions
-            }
+        override.returns(
+          {
+            brand_id: String,
+            created_at_gte: Time,
+            created_at_lte: Time,
+            customer_id: String,
+            page_number: Integer,
+            page_size: Integer,
+            status: Dodopayments::PaymentListParams::Status::OrSymbol,
+            subscription_id: String,
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by status
+      module Status
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Dodopayments::PaymentListParams::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SUCCEEDED =
+          T.let(
+            :succeeded,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(:failed, Dodopayments::PaymentListParams::Status::TaggedSymbol)
+        CANCELLED =
+          T.let(
+            :cancelled,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        PROCESSING =
+          T.let(
+            :processing,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        REQUIRES_CUSTOMER_ACTION =
+          T.let(
+            :requires_customer_action,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        REQUIRES_MERCHANT_ACTION =
+          T.let(
+            :requires_merchant_action,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        REQUIRES_PAYMENT_METHOD =
+          T.let(
+            :requires_payment_method,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        REQUIRES_CONFIRMATION =
+          T.let(
+            :requires_confirmation,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        REQUIRES_CAPTURE =
+          T.let(
+            :requires_capture,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        PARTIALLY_CAPTURED =
+          T.let(
+            :partially_captured,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+        PARTIALLY_CAPTURED_AND_CAPTURABLE =
+          T.let(
+            :partially_captured_and_capturable,
+            Dodopayments::PaymentListParams::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Dodopayments::PaymentListParams::Status::TaggedSymbol]
           )
+        end
+        def self.values
+        end
       end
-      def to_hash; end
     end
   end
 end