dodopayments 1.20.0 → 1.47.0

data/rbi/dodopayments/models/price.rbi

@@ -2,11 +2,29 @@
 
 module Dodopayments
   module Models
+    # One-time price details.
     module Price
       extend Dodopayments::Internal::Type::Union
 
+      Variants =
+        T.type_alias do
+          T.any(
+            Dodopayments::Price::OneTimePrice,
+            Dodopayments::Price::RecurringPrice
+          )
+        end
+
       class OneTimePrice < Dodopayments::Internal::Type::BaseModel
-        sig { returns(Dodopayments::Models::Currency::OrSymbol) }
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Price::OneTimePrice,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # The currency in which the payment is made.
+        sig { returns(Dodopayments::Currency::OrSymbol) }
         attr_accessor :currency
 
         # Discount applied to the price, represented as a percentage (0 to 100).
@@ -26,7 +44,7 @@ module Dodopayments
         sig { returns(T::Boolean) }
         attr_accessor :purchasing_power_parity
 
-        sig { returns(Symbol) }
+        sig { returns(Dodopayments::Price::OneTimePrice::Type::OrSymbol) }
         attr_accessor :type
 
         # Indicates whether the customer can pay any amount they choose. If set to `true`,
@@ -47,20 +65,21 @@ module Dodopayments
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :tax_inclusive
 
+        # One-time price details.
         sig do
           params(
-            currency: Dodopayments::Models::Currency::OrSymbol,
+            currency: Dodopayments::Currency::OrSymbol,
             discount: Float,
             price: Integer,
             purchasing_power_parity: T::Boolean,
+            type: Dodopayments::Price::OneTimePrice::Type::OrSymbol,
             pay_what_you_want: T::Boolean,
             suggested_price: T.nilable(Integer),
-            tax_inclusive: T.nilable(T::Boolean),
-            type: Symbol
-          )
-            .returns(T.attached_class)
+            tax_inclusive: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
         end
         def self.new(
+          # The currency in which the payment is made.
           currency:,
           # Discount applied to the price, represented as a percentage (0 to 100).
           discount:,
@@ -73,6 +92,7 @@ module Dodopayments
           # Indicates if purchasing power parity adjustments are applied to the price.
           # Purchasing power parity feature is not available as of now.
           purchasing_power_parity:,
+          type:,
           # Indicates whether the customer can pay any amount they choose. If set to `true`,
           # the [`price`](Self::price) field is the minimum amount.
           pay_what_you_want: nil,
@@ -81,29 +101,63 @@ module Dodopayments
           # ignored.
           suggested_price: nil,
           # Indicates if the price is tax inclusive.
-          tax_inclusive: nil,
-          type: :one_time_price
-        ); end
+          tax_inclusive: nil
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                currency: Dodopayments::Models::Currency::OrSymbol,
-                discount: Float,
-                price: Integer,
-                purchasing_power_parity: T::Boolean,
-                type: Symbol,
-                pay_what_you_want: T::Boolean,
-                suggested_price: T.nilable(Integer),
-                tax_inclusive: T.nilable(T::Boolean)
-              }
+          override.returns(
+            {
+              currency: Dodopayments::Currency::OrSymbol,
+              discount: Float,
+              price: Integer,
+              purchasing_power_parity: T::Boolean,
+              type: Dodopayments::Price::OneTimePrice::Type::OrSymbol,
+              pay_what_you_want: T::Boolean,
+              suggested_price: T.nilable(Integer),
+              tax_inclusive: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Dodopayments::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Dodopayments::Price::OneTimePrice::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ONE_TIME_PRICE =
+            T.let(
+              :one_time_price,
+              Dodopayments::Price::OneTimePrice::Type::TaggedSymbol
             )
+
+          sig do
+            override.returns(
+              T::Array[Dodopayments::Price::OneTimePrice::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
-        def to_hash; end
       end
 
       class RecurringPrice < Dodopayments::Internal::Type::BaseModel
-        sig { returns(Dodopayments::Models::Currency::OrSymbol) }
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Price::RecurringPrice,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # The currency in which the payment is made.
+        sig { returns(Dodopayments::Currency::OrSymbol) }
         attr_accessor :currency
 
         # Discount applied to the price, represented as a percentage (0 to 100).
@@ -115,7 +169,8 @@ module Dodopayments
         sig { returns(Integer) }
         attr_accessor :payment_frequency_count
 
-        sig { returns(Dodopayments::Models::TimeInterval::OrSymbol) }
+        # The time interval for the payment frequency (e.g., day, month, year).
+        sig { returns(Dodopayments::TimeInterval::OrSymbol) }
         attr_accessor :payment_frequency_interval
 
         # The payment amount. Represented in the lowest denomination of the currency
@@ -133,10 +188,11 @@ module Dodopayments
         sig { returns(Integer) }
         attr_accessor :subscription_period_count
 
-        sig { returns(Dodopayments::Models::TimeInterval::OrSymbol) }
+        # The time interval for the subscription period (e.g., day, month, year).
+        sig { returns(Dodopayments::TimeInterval::OrSymbol) }
         attr_accessor :subscription_period_interval
 
-        sig { returns(Symbol) }
+        sig { returns(Dodopayments::Price::RecurringPrice::Type::OrSymbol) }
         attr_accessor :type
 
         # Indicates if the price is tax inclusive
@@ -150,29 +206,31 @@ module Dodopayments
         sig { params(trial_period_days: Integer).void }
         attr_writer :trial_period_days
 
+        # Recurring price details.
         sig do
           params(
-            currency: Dodopayments::Models::Currency::OrSymbol,
+            currency: Dodopayments::Currency::OrSymbol,
             discount: Float,
             payment_frequency_count: Integer,
-            payment_frequency_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+            payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
             price: Integer,
             purchasing_power_parity: T::Boolean,
             subscription_period_count: Integer,
-            subscription_period_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+            subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
+            type: Dodopayments::Price::RecurringPrice::Type::OrSymbol,
             tax_inclusive: T.nilable(T::Boolean),
-            trial_period_days: Integer,
-            type: Symbol
-          )
-            .returns(T.attached_class)
+            trial_period_days: Integer
+          ).returns(T.attached_class)
         end
         def self.new(
+          # The currency in which the payment is made.
           currency:,
           # Discount applied to the price, represented as a percentage (0 to 100).
           discount:,
           # Number of units for the payment frequency. For example, a value of `1` with a
           # `payment_frequency_interval` of `month` represents monthly payments.
           payment_frequency_count:,
+          # The time interval for the payment frequency (e.g., day, month, year).
           payment_frequency_interval:,
           # The payment amount. Represented in the lowest denomination of the currency
           # (e.g., cents for USD). For example, to charge $1.00, pass `100`.
@@ -183,36 +241,65 @@ module Dodopayments
           # Number of units for the subscription period. For example, a value of `12` with a
           # `subscription_period_interval` of `month` represents a one-year subscription.
           subscription_period_count:,
+          # The time interval for the subscription period (e.g., day, month, year).
           subscription_period_interval:,
+          type:,
           # Indicates if the price is tax inclusive
           tax_inclusive: nil,
           # Number of days for the trial period. A value of `0` indicates no trial period.
-          trial_period_days: nil,
-          type: :recurring_price
-        ); end
+          trial_period_days: nil
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                currency: Dodopayments::Models::Currency::OrSymbol,
-                discount: Float,
-                payment_frequency_count: Integer,
-                payment_frequency_interval: Dodopayments::Models::TimeInterval::OrSymbol,
-                price: Integer,
-                purchasing_power_parity: T::Boolean,
-                subscription_period_count: Integer,
-                subscription_period_interval: Dodopayments::Models::TimeInterval::OrSymbol,
-                type: Symbol,
-                tax_inclusive: T.nilable(T::Boolean),
-                trial_period_days: Integer
-              }
+          override.returns(
+            {
+              currency: Dodopayments::Currency::OrSymbol,
+              discount: Float,
+              payment_frequency_count: Integer,
+              payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
+              price: Integer,
+              purchasing_power_parity: T::Boolean,
+              subscription_period_count: Integer,
+              subscription_period_interval:
+                Dodopayments::TimeInterval::OrSymbol,
+              type: Dodopayments::Price::RecurringPrice::Type::OrSymbol,
+              tax_inclusive: T.nilable(T::Boolean),
+              trial_period_days: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Type
+          extend Dodopayments::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Dodopayments::Price::RecurringPrice::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          RECURRING_PRICE =
+            T.let(
+              :recurring_price,
+              Dodopayments::Price::RecurringPrice::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Dodopayments::Price::RecurringPrice::Type::TaggedSymbol]
             )
+          end
+          def self.values
+          end
         end
-        def to_hash; end
       end
 
-      sig { override.returns([Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice]) }
-      def self.variants; end
+      sig { override.returns(T::Array[Dodopayments::Price::Variants]) }
+      def self.variants
+      end
     end
   end
 end

data/rbi/dodopayments/models/product.rbi

@@ -3,6 +3,14 @@
 module Dodopayments
   module Models
     class Product < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::Product, Dodopayments::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :brand_id
+
       # Unique identifier for the business to which the product belongs.
       sig { returns(String) }
       attr_accessor :business_id
@@ -19,16 +27,20 @@ module Dodopayments
       sig { returns(T::Boolean) }
       attr_accessor :license_key_enabled
 
-      sig { returns(T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice)) }
+      # Additional custom data associated with the product
+      sig { returns(T::Hash[Symbol, String]) }
+      attr_accessor :metadata
+
+      # Pricing information for the product.
+      sig { returns(Dodopayments::Price::Variants) }
       attr_accessor :price
 
       # Unique identifier for the product.
       sig { returns(String) }
       attr_accessor :product_id
 
-      # Represents the different categories of taxation applicable to various products
-      # and services.
-      sig { returns(Dodopayments::Models::TaxCategory::TaggedSymbol) }
+      # Tax category associated with the product.
+      sig { returns(Dodopayments::TaxCategory::TaggedSymbol) }
       attr_accessor :tax_category
 
       # Timestamp when the product was last updated.
@@ -43,6 +55,17 @@ module Dodopayments
       sig { returns(T.nilable(String)) }
       attr_accessor :description
 
+      sig { returns(T.nilable(Dodopayments::Product::DigitalProductDelivery)) }
+      attr_reader :digital_product_delivery
+
+      sig do
+        params(
+          digital_product_delivery:
+            T.nilable(Dodopayments::Product::DigitalProductDelivery::OrHash)
+        ).void
+      end
+      attr_writer :digital_product_delivery
+
       # URL of the product image, optional.
       sig { returns(T.nilable(String)) }
       attr_accessor :image
@@ -55,14 +78,15 @@ module Dodopayments
       sig { returns(T.nilable(Integer)) }
       attr_accessor :license_key_activations_limit
 
-      sig { returns(T.nilable(Dodopayments::Models::LicenseKeyDuration)) }
+      # Duration of the license key validity, if enabled.
+      sig { returns(T.nilable(Dodopayments::LicenseKeyDuration)) }
       attr_reader :license_key_duration
 
       sig do
         params(
-          license_key_duration: T.nilable(T.any(Dodopayments::Models::LicenseKeyDuration, Dodopayments::Internal::AnyHash))
-        )
-          .void
+          license_key_duration:
+            T.nilable(Dodopayments::LicenseKeyDuration::OrHash)
+        ).void
       end
       attr_writer :license_key_duration
 
@@ -72,29 +96,34 @@ module Dodopayments
 
       sig do
         params(
+          brand_id: String,
           business_id: String,
           created_at: Time,
           is_recurring: T::Boolean,
           license_key_enabled: T::Boolean,
-          price: T.any(
-            Dodopayments::Models::Price::OneTimePrice,
-            Dodopayments::Internal::AnyHash,
-            Dodopayments::Models::Price::RecurringPrice
-          ),
+          metadata: T::Hash[Symbol, String],
+          price:
+            T.any(
+              Dodopayments::Price::OneTimePrice::OrHash,
+              Dodopayments::Price::RecurringPrice::OrHash
+            ),
           product_id: String,
-          tax_category: Dodopayments::Models::TaxCategory::OrSymbol,
+          tax_category: Dodopayments::TaxCategory::OrSymbol,
           updated_at: Time,
           addons: T.nilable(T::Array[String]),
           description: T.nilable(String),
+          digital_product_delivery:
+            T.nilable(Dodopayments::Product::DigitalProductDelivery::OrHash),
           image: T.nilable(String),
           license_key_activation_message: T.nilable(String),
           license_key_activations_limit: T.nilable(Integer),
-          license_key_duration: T.nilable(T.any(Dodopayments::Models::LicenseKeyDuration, Dodopayments::Internal::AnyHash)),
+          license_key_duration:
+            T.nilable(Dodopayments::LicenseKeyDuration::OrHash),
           name: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
+        brand_id:,
         # Unique identifier for the business to which the product belongs.
         business_id:,
         # Timestamp when the product was created.
@@ -103,11 +132,13 @@ module Dodopayments
         is_recurring:,
         # Indicates whether the product requires a license key.
         license_key_enabled:,
+        # Additional custom data associated with the product
+        metadata:,
+        # Pricing information for the product.
         price:,
         # Unique identifier for the product.
         product_id:,
-        # Represents the different categories of taxation applicable to various products
-        # and services.
+        # Tax category associated with the product.
         tax_category:,
         # Timestamp when the product was last updated.
         updated_at:,
@@ -115,39 +146,147 @@ module Dodopayments
         addons: nil,
         # Description of the product, optional.
         description: nil,
+        digital_product_delivery: nil,
         # URL of the product image, optional.
         image: nil,
         # Message sent upon license key activation, if applicable.
         license_key_activation_message: nil,
         # Limit on the number of activations for the license key, if enabled.
         license_key_activations_limit: nil,
+        # Duration of the license key validity, if enabled.
         license_key_duration: nil,
         # Name of the product, optional.
         name: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
+        override.returns(
+          {
+            brand_id: String,
+            business_id: String,
+            created_at: Time,
+            is_recurring: T::Boolean,
+            license_key_enabled: T::Boolean,
+            metadata: T::Hash[Symbol, String],
+            price: Dodopayments::Price::Variants,
+            product_id: String,
+            tax_category: Dodopayments::TaxCategory::TaggedSymbol,
+            updated_at: Time,
+            addons: T.nilable(T::Array[String]),
+            description: T.nilable(String),
+            digital_product_delivery:
+              T.nilable(Dodopayments::Product::DigitalProductDelivery),
+            image: T.nilable(String),
+            license_key_activation_message: T.nilable(String),
+            license_key_activations_limit: T.nilable(Integer),
+            license_key_duration: T.nilable(Dodopayments::LicenseKeyDuration),
+            name: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class DigitalProductDelivery < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Product::DigitalProductDelivery,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # External URL to digital product
+        sig { returns(T.nilable(String)) }
+        attr_accessor :external_url
+
+        # Uploaded files ids of digital product
+        sig do
+          returns(
+            T.nilable(
+              T::Array[Dodopayments::Product::DigitalProductDelivery::File]
+            )
+          )
+        end
+        attr_accessor :files
+
+        # Instructions to download and use the digital product
+        sig { returns(T.nilable(String)) }
+        attr_accessor :instructions
+
+        sig do
+          params(
+            external_url: T.nilable(String),
+            files:
+              T.nilable(
+                T::Array[
+                  Dodopayments::Product::DigitalProductDelivery::File::OrHash
+                ]
+              ),
+            instructions: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # External URL to digital product
+          external_url: nil,
+          # Uploaded files ids of digital product
+          files: nil,
+          # Instructions to download and use the digital product
+          instructions: nil
+        )
+        end
+
+        sig do
+          override.returns(
             {
-              business_id: String,
-              created_at: Time,
-              is_recurring: T::Boolean,
-              license_key_enabled: T::Boolean,
-              price: T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice),
-              product_id: String,
-              tax_category: Dodopayments::Models::TaxCategory::TaggedSymbol,
-              updated_at: Time,
-              addons: T.nilable(T::Array[String]),
-              description: T.nilable(String),
-              image: T.nilable(String),
-              license_key_activation_message: T.nilable(String),
-              license_key_activations_limit: T.nilable(Integer),
-              license_key_duration: T.nilable(Dodopayments::Models::LicenseKeyDuration),
-              name: T.nilable(String)
+              external_url: T.nilable(String),
+              files:
+                T.nilable(
+                  T::Array[Dodopayments::Product::DigitalProductDelivery::File]
+                ),
+              instructions: T.nilable(String)
             }
           )
+        end
+        def to_hash
+        end
+
+        class File < Dodopayments::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Product::DigitalProductDelivery::File,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :file_id
+
+          sig { returns(String) }
+          attr_accessor :file_name
+
+          sig { returns(String) }
+          attr_accessor :url
+
+          sig do
+            params(file_id: String, file_name: String, url: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(file_id:, file_name:, url:)
+          end
+
+          sig do
+            override.returns(
+              { file_id: String, file_name: String, url: String }
+            )
+          end
+          def to_hash
+          end
+        end
       end
-      def to_hash; end
     end
   end
 end