dodopayments 1.18.3 → 1.20.0

data/rbi/dodopayments/models/price.rbi

@@ -0,0 +1,218 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Price
+      extend Dodopayments::Internal::Type::Union
+
+      class OneTimePrice < Dodopayments::Internal::Type::BaseModel
+        sig { returns(Dodopayments::Models::Currency::OrSymbol) }
+        attr_accessor :currency
+
+        # Discount applied to the price, represented as a percentage (0 to 100).
+        sig { returns(Float) }
+        attr_accessor :discount
+
+        # The payment amount, in the smallest denomination of the currency (e.g., cents
+        # for USD). For example, to charge $1.00, pass `100`.
+        #
+        # If [`pay_what_you_want`](Self::pay_what_you_want) is set to `true`, this field
+        # represents the **minimum** amount the customer must pay.
+        sig { returns(Integer) }
+        attr_accessor :price
+
+        # Indicates if purchasing power parity adjustments are applied to the price.
+        # Purchasing power parity feature is not available as of now.
+        sig { returns(T::Boolean) }
+        attr_accessor :purchasing_power_parity
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Indicates whether the customer can pay any amount they choose. If set to `true`,
+        # the [`price`](Self::price) field is the minimum amount.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :pay_what_you_want
+
+        sig { params(pay_what_you_want: T::Boolean).void }
+        attr_writer :pay_what_you_want
+
+        # A suggested price for the user to pay. This value is only considered if
+        # [`pay_what_you_want`](Self::pay_what_you_want) is `true`. Otherwise, it is
+        # ignored.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :suggested_price
+
+        # Indicates if the price is tax inclusive.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :tax_inclusive
+
+        sig do
+          params(
+            currency: Dodopayments::Models::Currency::OrSymbol,
+            discount: Float,
+            price: Integer,
+            purchasing_power_parity: T::Boolean,
+            pay_what_you_want: T::Boolean,
+            suggested_price: T.nilable(Integer),
+            tax_inclusive: T.nilable(T::Boolean),
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          currency:,
+          # Discount applied to the price, represented as a percentage (0 to 100).
+          discount:,
+          # The payment amount, in the smallest denomination of the currency (e.g., cents
+          # for USD). For example, to charge $1.00, pass `100`.
+          #
+          # If [`pay_what_you_want`](Self::pay_what_you_want) is set to `true`, this field
+          # represents the **minimum** amount the customer must pay.
+          price:,
+          # Indicates if purchasing power parity adjustments are applied to the price.
+          # Purchasing power parity feature is not available as of now.
+          purchasing_power_parity:,
+          # 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,
+          # A suggested price for the user to pay. This value is only considered if
+          # [`pay_what_you_want`](Self::pay_what_you_want) is `true`. Otherwise, it is
+          # ignored.
+          suggested_price: nil,
+          # Indicates if the price is tax inclusive.
+          tax_inclusive: nil,
+          type: :one_time_price
+        ); 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)
+              }
+            )
+        end
+        def to_hash; end
+      end
+
+      class RecurringPrice < Dodopayments::Internal::Type::BaseModel
+        sig { returns(Dodopayments::Models::Currency::OrSymbol) }
+        attr_accessor :currency
+
+        # Discount applied to the price, represented as a percentage (0 to 100).
+        sig { returns(Float) }
+        attr_accessor :discount
+
+        # Number of units for the payment frequency. For example, a value of `1` with a
+        # `payment_frequency_interval` of `month` represents monthly payments.
+        sig { returns(Integer) }
+        attr_accessor :payment_frequency_count
+
+        sig { returns(Dodopayments::Models::TimeInterval::OrSymbol) }
+        attr_accessor :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`.
+        sig { returns(Integer) }
+        attr_accessor :price
+
+        # Indicates if purchasing power parity adjustments are applied to the price.
+        # Purchasing power parity feature is not available as of now
+        sig { returns(T::Boolean) }
+        attr_accessor :purchasing_power_parity
+
+        # 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.
+        sig { returns(Integer) }
+        attr_accessor :subscription_period_count
+
+        sig { returns(Dodopayments::Models::TimeInterval::OrSymbol) }
+        attr_accessor :subscription_period_interval
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Indicates if the price is tax inclusive
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :tax_inclusive
+
+        # Number of days for the trial period. A value of `0` indicates no trial period.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :trial_period_days
+
+        sig { params(trial_period_days: Integer).void }
+        attr_writer :trial_period_days
+
+        sig do
+          params(
+            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,
+            tax_inclusive: T.nilable(T::Boolean),
+            trial_period_days: Integer,
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          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:,
+          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`.
+          price:,
+          # Indicates if purchasing power parity adjustments are applied to the price.
+          # Purchasing power parity feature is not available as of now
+          purchasing_power_parity:,
+          # 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:,
+          subscription_period_interval:,
+          # 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
+        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
+              }
+            )
+        end
+        def to_hash; end
+      end
+
+      sig { override.returns([Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice]) }
+      def self.variants; end
+    end
+  end
+end

data/rbi/{lib/dodopayments → dodopayments}/models/product.rbi

@@ -28,7 +28,7 @@ module Dodopayments
 
       # Represents the different categories of taxation applicable to various products
       # and services.
-      sig { returns(Dodopayments::Models::Product::TaxCategory::TaggedSymbol) }
+      sig { returns(Dodopayments::Models::TaxCategory::TaggedSymbol) }
       attr_accessor :tax_category
 
       # Timestamp when the product was last updated.
@@ -82,7 +82,7 @@ module Dodopayments
             Dodopayments::Models::Price::RecurringPrice
           ),
           product_id: String,
-          tax_category: Dodopayments::Models::Product::TaxCategory::OrSymbol,
+          tax_category: Dodopayments::Models::TaxCategory::OrSymbol,
           updated_at: Time,
           addons: T.nilable(T::Array[String]),
           description: T.nilable(String),
@@ -135,7 +135,7 @@ module Dodopayments
               license_key_enabled: T::Boolean,
               price: T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice),
               product_id: String,
-              tax_category: Dodopayments::Models::Product::TaxCategory::TaggedSymbol,
+              tax_category: Dodopayments::Models::TaxCategory::TaggedSymbol,
               updated_at: Time,
               addons: T.nilable(T::Array[String]),
               description: T.nilable(String),
@@ -148,23 +148,6 @@ module Dodopayments
           )
       end
       def to_hash; end
-
-      # Represents the different categories of taxation applicable to various products
-      # and services.
-      module TaxCategory
-        extend Dodopayments::Internal::Type::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::Product::TaxCategory) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        DIGITAL_PRODUCTS = T.let(:digital_products, Dodopayments::Models::Product::TaxCategory::TaggedSymbol)
-        SAAS = T.let(:saas, Dodopayments::Models::Product::TaxCategory::TaggedSymbol)
-        E_BOOK = T.let(:e_book, Dodopayments::Models::Product::TaxCategory::TaggedSymbol)
-        EDTECH = T.let(:edtech, Dodopayments::Models::Product::TaxCategory::TaggedSymbol)
-
-        sig { override.returns(T::Array[Dodopayments::Models::Product::TaxCategory::TaggedSymbol]) }
-        def self.values; end
-      end
     end
   end
 end

data/rbi/{lib/dodopayments → dodopayments}/models/product_create_params.rbi

@@ -11,7 +11,7 @@ module Dodopayments
 
       # Represents the different categories of taxation applicable to various products
       # and services.
-      sig { returns(Dodopayments::Models::ProductCreateParams::TaxCategory::OrSymbol) }
+      sig { returns(Dodopayments::Models::TaxCategory::OrSymbol) }
       attr_accessor :tax_category
 
       # Addons available for subscription product
@@ -56,7 +56,7 @@ module Dodopayments
             Dodopayments::Internal::AnyHash,
             Dodopayments::Models::Price::RecurringPrice
           ),
-          tax_category: Dodopayments::Models::ProductCreateParams::TaxCategory::OrSymbol,
+          tax_category: Dodopayments::Models::TaxCategory::OrSymbol,
           addons: T.nilable(T::Array[String]),
           description: T.nilable(String),
           license_key_activation_message: T.nilable(String),
@@ -93,7 +93,7 @@ module Dodopayments
           .returns(
             {
               price: T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice),
-              tax_category: Dodopayments::Models::ProductCreateParams::TaxCategory::OrSymbol,
+              tax_category: Dodopayments::Models::TaxCategory::OrSymbol,
               addons: T.nilable(T::Array[String]),
               description: T.nilable(String),
               license_key_activation_message: T.nilable(String),
@@ -106,24 +106,6 @@ module Dodopayments
           )
       end
       def to_hash; end
-
-      # Represents the different categories of taxation applicable to various products
-      # and services.
-      module TaxCategory
-        extend Dodopayments::Internal::Type::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::ProductCreateParams::TaxCategory) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        DIGITAL_PRODUCTS =
-          T.let(:digital_products, Dodopayments::Models::ProductCreateParams::TaxCategory::TaggedSymbol)
-        SAAS = T.let(:saas, Dodopayments::Models::ProductCreateParams::TaxCategory::TaggedSymbol)
-        E_BOOK = T.let(:e_book, Dodopayments::Models::ProductCreateParams::TaxCategory::TaggedSymbol)
-        EDTECH = T.let(:edtech, Dodopayments::Models::ProductCreateParams::TaxCategory::TaggedSymbol)
-
-        sig { override.returns(T::Array[Dodopayments::Models::ProductCreateParams::TaxCategory::TaggedSymbol]) }
-        def self.values; end
-      end
     end
   end
 end

data/rbi/dodopayments/models/product_list_response.rbi

@@ -0,0 +1,153 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ProductListResponse < Dodopayments::Internal::Type::BaseModel
+      # Unique identifier for the business to which the product belongs.
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # Timestamp when the product was created.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Indicates if the product is recurring (e.g., subscriptions).
+      sig { returns(T::Boolean) }
+      attr_accessor :is_recurring
+
+      # 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) }
+      attr_accessor :tax_category
+
+      # Timestamp when the product was last updated.
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      sig { returns(T.nilable(Dodopayments::Models::Currency::TaggedSymbol)) }
+      attr_accessor :currency
+
+      # Description of the product, optional.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # URL of the product image, optional.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :image
+
+      # Name of the product, optional.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :name
+
+      # Price of the product, optional.
+      #
+      # The price is represented in the lowest denomination of the currency. For
+      # example:
+      #
+      # - In USD, a price of `$12.34` would be represented as `1234` (cents).
+      # - In JPY, a price of `¥1500` would be represented as `1500` (yen).
+      # - In INR, a price of `₹1234.56` would be represented as `123456` (paise).
+      #
+      # This ensures precision and avoids floating-point rounding errors.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :price
+
+      sig do
+        returns(
+          T.nilable(T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice))
+        )
+      end
+      attr_accessor :price_detail
+
+      # Indicates if the price is tax inclusive
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :tax_inclusive
+
+      sig do
+        params(
+          business_id: String,
+          created_at: Time,
+          is_recurring: T::Boolean,
+          product_id: String,
+          tax_category: Dodopayments::Models::TaxCategory::OrSymbol,
+          updated_at: Time,
+          currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+          description: T.nilable(String),
+          image: T.nilable(String),
+          name: T.nilable(String),
+          price: T.nilable(Integer),
+          price_detail: T.nilable(
+            T.any(
+              Dodopayments::Models::Price::OneTimePrice,
+              Dodopayments::Internal::AnyHash,
+              Dodopayments::Models::Price::RecurringPrice
+            )
+          ),
+          tax_inclusive: T.nilable(T::Boolean)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the business to which the product belongs.
+        business_id:,
+        # Timestamp when the product was created.
+        created_at:,
+        # Indicates if the product is recurring (e.g., subscriptions).
+        is_recurring:,
+        # Unique identifier for the product.
+        product_id:,
+        # Represents the different categories of taxation applicable to various products
+        # and services.
+        tax_category:,
+        # Timestamp when the product was last updated.
+        updated_at:,
+        currency: nil,
+        # Description of the product, optional.
+        description: nil,
+        # URL of the product image, optional.
+        image: nil,
+        # Name of the product, optional.
+        name: nil,
+        # Price of the product, optional.
+        #
+        # The price is represented in the lowest denomination of the currency. For
+        # example:
+        #
+        # - In USD, a price of `$12.34` would be represented as `1234` (cents).
+        # - In JPY, a price of `¥1500` would be represented as `1500` (yen).
+        # - In INR, a price of `₹1234.56` would be represented as `123456` (paise).
+        #
+        # This ensures precision and avoids floating-point rounding errors.
+        price: nil,
+        price_detail: nil,
+        # Indicates if the price is tax inclusive
+        tax_inclusive: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              business_id: String,
+              created_at: Time,
+              is_recurring: T::Boolean,
+              product_id: String,
+              tax_category: Dodopayments::Models::TaxCategory::TaggedSymbol,
+              updated_at: Time,
+              currency: T.nilable(Dodopayments::Models::Currency::TaggedSymbol),
+              description: T.nilable(String),
+              image: T.nilable(String),
+              name: T.nilable(String),
+              price: T.nilable(Integer),
+              price_detail: T.nilable(T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice)),
+              tax_inclusive: T.nilable(T::Boolean)
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/{lib/dodopayments → dodopayments}/models/product_update_params.rbi

@@ -63,7 +63,7 @@ module Dodopayments
 
       # Represents the different categories of taxation applicable to various products
       # and services.
-      sig { returns(T.nilable(Dodopayments::Models::ProductUpdateParams::TaxCategory::OrSymbol)) }
+      sig { returns(T.nilable(Dodopayments::Models::TaxCategory::OrSymbol)) }
       attr_accessor :tax_category
 
       sig do
@@ -83,7 +83,7 @@ module Dodopayments
               Dodopayments::Models::Price::RecurringPrice
             )
           ),
-          tax_category: T.nilable(Dodopayments::Models::ProductUpdateParams::TaxCategory::OrSymbol),
+          tax_category: T.nilable(Dodopayments::Models::TaxCategory::OrSymbol),
           request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
         )
           .returns(T.attached_class)
@@ -132,30 +132,12 @@ module Dodopayments
               license_key_enabled: T.nilable(T::Boolean),
               name: T.nilable(String),
               price: T.nilable(T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice)),
-              tax_category: T.nilable(Dodopayments::Models::ProductUpdateParams::TaxCategory::OrSymbol),
+              tax_category: T.nilable(Dodopayments::Models::TaxCategory::OrSymbol),
               request_options: Dodopayments::RequestOptions
             }
           )
       end
       def to_hash; end
-
-      # Represents the different categories of taxation applicable to various products
-      # and services.
-      module TaxCategory
-        extend Dodopayments::Internal::Type::Enum
-
-        TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::ProductUpdateParams::TaxCategory) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        DIGITAL_PRODUCTS =
-          T.let(:digital_products, Dodopayments::Models::ProductUpdateParams::TaxCategory::TaggedSymbol)
-        SAAS = T.let(:saas, Dodopayments::Models::ProductUpdateParams::TaxCategory::TaggedSymbol)
-        E_BOOK = T.let(:e_book, Dodopayments::Models::ProductUpdateParams::TaxCategory::TaggedSymbol)
-        EDTECH = T.let(:edtech, Dodopayments::Models::ProductUpdateParams::TaxCategory::TaggedSymbol)
-
-        sig { override.returns(T::Array[Dodopayments::Models::ProductUpdateParams::TaxCategory::TaggedSymbol]) }
-        def self.values; end
-      end
     end
   end
 end

data/rbi/dodopayments/models/refund.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class Refund < Dodopayments::Internal::Type::BaseModel
+      # The unique identifier of the business issuing the refund.
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      # The timestamp of when the refund was created in UTC.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # The unique identifier of the payment associated with the refund.
+      sig { returns(String) }
+      attr_accessor :payment_id
+
+      # The unique identifier of the refund.
+      sig { returns(String) }
+      attr_accessor :refund_id
+
+      sig { returns(Dodopayments::Models::RefundStatus::TaggedSymbol) }
+      attr_accessor :status
+
+      # The refunded amount.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :amount
+
+      sig { returns(T.nilable(Dodopayments::Models::Currency::TaggedSymbol)) }
+      attr_accessor :currency
+
+      # The reason provided for the refund, if any. Optional.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      sig do
+        params(
+          business_id: String,
+          created_at: Time,
+          payment_id: String,
+          refund_id: String,
+          status: Dodopayments::Models::RefundStatus::OrSymbol,
+          amount: T.nilable(Integer),
+          currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+          reason: T.nilable(String)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        # The unique identifier of the business issuing the refund.
+        business_id:,
+        # The timestamp of when the refund was created in UTC.
+        created_at:,
+        # The unique identifier of the payment associated with the refund.
+        payment_id:,
+        # The unique identifier of the refund.
+        refund_id:,
+        status:,
+        # The refunded amount.
+        amount: nil,
+        currency: nil,
+        # The reason provided for the refund, if any. Optional.
+        reason: nil
+      ); end
+      sig do
+        override
+          .returns(
+            {
+              business_id: String,
+              created_at: Time,
+              payment_id: String,
+              refund_id: String,
+              status: Dodopayments::Models::RefundStatus::TaggedSymbol,
+              amount: T.nilable(Integer),
+              currency: T.nilable(Dodopayments::Models::Currency::TaggedSymbol),
+              reason: T.nilable(String)
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end