dodopayments 2.2.0 → 2.3.0

data/rbi/dodopayments/models/get_dispute.rbi

@@ -39,11 +39,11 @@ module Dodopayments
       attr_accessor :dispute_id
 
       # The current stage of the dispute process.
-      sig { returns(Dodopayments::DisputeStage::TaggedSymbol) }
+      sig { returns(Dodopayments::DisputeStage::OrSymbol) }
       attr_accessor :dispute_stage
 
       # The current status of the dispute.
-      sig { returns(Dodopayments::DisputeStatus::TaggedSymbol) }
+      sig { returns(Dodopayments::DisputeStatus::OrSymbol) }
       attr_accessor :dispute_status
 
       # The unique identifier of the payment associated with the dispute.
@@ -109,8 +109,8 @@ module Dodopayments
             currency: String,
             customer: Dodopayments::CustomerLimitedDetails,
             dispute_id: String,
-            dispute_stage: Dodopayments::DisputeStage::TaggedSymbol,
-            dispute_status: Dodopayments::DisputeStatus::TaggedSymbol,
+            dispute_stage: Dodopayments::DisputeStage::OrSymbol,
+            dispute_status: Dodopayments::DisputeStatus::OrSymbol,
             payment_id: String,
             reason: T.nilable(String),
             remarks: T.nilable(String)

data/rbi/dodopayments/models/invoices/payment_retrieve_payout_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    module Invoices
+      class PaymentRetrievePayoutParams < Dodopayments::Internal::Type::BaseModel
+        extend Dodopayments::Internal::Type::RequestParameters::Converter
+        include Dodopayments::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Invoices::PaymentRetrievePayoutParams,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :payout_id
+
+        sig do
+          params(
+            payout_id: String,
+            request_options: Dodopayments::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(payout_id:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { payout_id: String, request_options: Dodopayments::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/license_key.rbi

@@ -41,7 +41,7 @@ module Dodopayments
       attr_accessor :product_id
 
       # The current status of the license key (e.g., active, inactive, expired).
-      sig { returns(Dodopayments::LicenseKeyStatus::TaggedSymbol) }
+      sig { returns(Dodopayments::LicenseKeyStatus::OrSymbol) }
       attr_accessor :status
 
       # The maximum number of activations allowed for this license key.
@@ -113,7 +113,7 @@ module Dodopayments
             key: String,
             payment_id: String,
             product_id: String,
-            status: Dodopayments::LicenseKeyStatus::TaggedSymbol,
+            status: Dodopayments::LicenseKeyStatus::OrSymbol,
             activations_limit: T.nilable(Integer),
             expires_at: T.nilable(Time),
             subscription_id: T.nilable(String)

data/rbi/dodopayments/models/meter_cart_response_item.rbi

@@ -11,7 +11,7 @@ module Dodopayments
           )
         end
 
-      sig { returns(Dodopayments::Currency::TaggedSymbol) }
+      sig { returns(Dodopayments::Currency::OrSymbol) }
       attr_accessor :currency
 
       sig { returns(Integer) }
@@ -58,7 +58,7 @@ module Dodopayments
       sig do
         override.returns(
           {
-            currency: Dodopayments::Currency::TaggedSymbol,
+            currency: Dodopayments::Currency::OrSymbol,
             free_threshold: Integer,
             measurement_unit: String,
             meter_id: String,

data/rbi/dodopayments/models/payment.rbi

@@ -28,7 +28,7 @@ module Dodopayments
       attr_accessor :created_at
 
       # Currency used for the payment
-      sig { returns(Dodopayments::Currency::TaggedSymbol) }
+      sig { returns(Dodopayments::Currency::OrSymbol) }
       attr_accessor :currency
 
       # Details about the customer who made the payment
@@ -69,7 +69,7 @@ module Dodopayments
       # The currency in which the settlement_amount will be credited to your Dodo
       # balance. This may differ from the customer's payment currency in adaptive
       # pricing scenarios.
-      sig { returns(Dodopayments::Currency::TaggedSymbol) }
+      sig { returns(Dodopayments::Currency::OrSymbol) }
       attr_accessor :settlement_currency
 
       # Total amount charged to the customer including tax, in smallest currency unit
@@ -82,7 +82,7 @@ module Dodopayments
       attr_accessor :card_holder_name
 
       # ISO2 country code of the card
-      sig { returns(T.nilable(Dodopayments::CountryCode::TaggedSymbol)) }
+      sig { returns(T.nilable(Dodopayments::CountryCode::OrSymbol)) }
       attr_accessor :card_issuing_country
 
       # The last four digits of the card
@@ -144,9 +144,7 @@ module Dodopayments
 
       # Summary of the refund status for this payment. None if no succeeded refunds
       # exist.
-      sig do
-        returns(T.nilable(Dodopayments::PaymentRefundStatus::TaggedSymbol))
-      end
+      sig { returns(T.nilable(Dodopayments::PaymentRefundStatus::OrSymbol)) }
       attr_accessor :refund_status
 
       # This represents the portion of settlement_amount that corresponds to taxes
@@ -156,7 +154,7 @@ module Dodopayments
       attr_accessor :settlement_tax
 
       # Current status of the payment intent
-      sig { returns(T.nilable(Dodopayments::IntentStatus::TaggedSymbol)) }
+      sig { returns(T.nilable(Dodopayments::IntentStatus::OrSymbol)) }
       attr_accessor :status
 
       # Identifier of the subscription if payment is part of a subscription
@@ -305,7 +303,7 @@ module Dodopayments
             brand_id: String,
             business_id: String,
             created_at: Time,
-            currency: Dodopayments::Currency::TaggedSymbol,
+            currency: Dodopayments::Currency::OrSymbol,
             customer: Dodopayments::CustomerLimitedDetails,
             digital_products_delivered: T::Boolean,
             disputes: T::Array[Dodopayments::Dispute],
@@ -313,11 +311,11 @@ module Dodopayments
             payment_id: String,
             refunds: T::Array[Dodopayments::RefundListItem],
             settlement_amount: Integer,
-            settlement_currency: Dodopayments::Currency::TaggedSymbol,
+            settlement_currency: Dodopayments::Currency::OrSymbol,
             total_amount: Integer,
             card_holder_name: T.nilable(String),
             card_issuing_country:
-              T.nilable(Dodopayments::CountryCode::TaggedSymbol),
+              T.nilable(Dodopayments::CountryCode::OrSymbol),
             card_last_four: T.nilable(String),
             card_network: T.nilable(String),
             card_type: T.nilable(String),
@@ -335,9 +333,9 @@ module Dodopayments
             product_cart:
               T.nilable(T::Array[Dodopayments::OneTimeProductCartItem]),
             refund_status:
-              T.nilable(Dodopayments::PaymentRefundStatus::TaggedSymbol),
+              T.nilable(Dodopayments::PaymentRefundStatus::OrSymbol),
             settlement_tax: T.nilable(Integer),
-            status: T.nilable(Dodopayments::IntentStatus::TaggedSymbol),
+            status: T.nilable(Dodopayments::IntentStatus::OrSymbol),
             subscription_id: T.nilable(String),
             tax: T.nilable(Integer),
             updated_at: T.nilable(Time)

data/rbi/dodopayments/models/payment_method_types.rbi

@@ -2,6 +2,9 @@
 
 module Dodopayments
   module Models
+    # All supported payment method types (from Hyperswitch).
+    #
+    # Used for disabled-payment-methods filtering and validation.
     module PaymentMethodTypes
       extend Dodopayments::Internal::Type::Enum
 

data/rbi/dodopayments/models/product_collection_create_params.rbi

@@ -0,0 +1,180 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ProductCollectionCreateParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::ProductCollectionCreateParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Groups of products in this collection
+      sig do
+        returns(T::Array[Dodopayments::ProductCollectionCreateParams::Group])
+      end
+      attr_accessor :groups
+
+      # Name of the product collection
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Brand id for the collection, if not provided will default to primary brand
+      sig { returns(T.nilable(String)) }
+      attr_accessor :brand_id
+
+      # Optional description of the product collection
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig do
+        params(
+          groups:
+            T::Array[
+              Dodopayments::ProductCollectionCreateParams::Group::OrHash
+            ],
+          name: String,
+          brand_id: T.nilable(String),
+          description: T.nilable(String),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Groups of products in this collection
+        groups:,
+        # Name of the product collection
+        name:,
+        # Brand id for the collection, if not provided will default to primary brand
+        brand_id: nil,
+        # Optional description of the product collection
+        description: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            groups:
+              T::Array[Dodopayments::ProductCollectionCreateParams::Group],
+            name: String,
+            brand_id: T.nilable(String),
+            description: T.nilable(String),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Group < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::ProductCollectionCreateParams::Group,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        # Products in this group
+        sig do
+          returns(
+            T::Array[
+              Dodopayments::ProductCollectionCreateParams::Group::Product
+            ]
+          )
+        end
+        attr_accessor :products
+
+        # Optional group name. Multiple groups can have null names, but named groups must
+        # be unique per collection
+        sig { returns(T.nilable(String)) }
+        attr_accessor :group_name
+
+        # Status of the group (defaults to true if not provided)
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :status
+
+        sig do
+          params(
+            products:
+              T::Array[
+                Dodopayments::ProductCollectionCreateParams::Group::Product::OrHash
+              ],
+            group_name: T.nilable(String),
+            status: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Products in this group
+          products:,
+          # Optional group name. Multiple groups can have null names, but named groups must
+          # be unique per collection
+          group_name: nil,
+          # Status of the group (defaults to true if not provided)
+          status: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              products:
+                T::Array[
+                  Dodopayments::ProductCollectionCreateParams::Group::Product
+                ],
+              group_name: T.nilable(String),
+              status: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Product < Dodopayments::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::ProductCollectionCreateParams::Group::Product,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          # Product ID to include in the group
+          sig { returns(String) }
+          attr_accessor :product_id
+
+          # Status of the product in this group (defaults to true if not provided)
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_accessor :status
+
+          sig do
+            params(product_id: String, status: T.nilable(T::Boolean)).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # Product ID to include in the group
+            product_id:,
+            # Status of the product in this group (defaults to true if not provided)
+            status: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              { product_id: String, status: T.nilable(T::Boolean) }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/product_collection_create_response.rbi

@@ -0,0 +1,303 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class ProductCollectionCreateResponse < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::Models::ProductCollectionCreateResponse,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Unique identifier for the product collection
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Brand ID for the collection
+      sig { returns(String) }
+      attr_accessor :brand_id
+
+      # Timestamp when the collection was created
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # Groups in this collection
+      sig do
+        returns(
+          T::Array[Dodopayments::Models::ProductCollectionCreateResponse::Group]
+        )
+      end
+      attr_accessor :groups
+
+      # Name of the collection
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Timestamp when the collection was last updated
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      # Description of the collection
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # URL of the collection image
+      sig { returns(T.nilable(String)) }
+      attr_accessor :image
+
+      sig do
+        params(
+          id: String,
+          brand_id: String,
+          created_at: Time,
+          groups:
+            T::Array[
+              Dodopayments::Models::ProductCollectionCreateResponse::Group::OrHash
+            ],
+          name: String,
+          updated_at: Time,
+          description: T.nilable(String),
+          image: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the product collection
+        id:,
+        # Brand ID for the collection
+        brand_id:,
+        # Timestamp when the collection was created
+        created_at:,
+        # Groups in this collection
+        groups:,
+        # Name of the collection
+        name:,
+        # Timestamp when the collection was last updated
+        updated_at:,
+        # Description of the collection
+        description: nil,
+        # URL of the collection image
+        image: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            brand_id: String,
+            created_at: Time,
+            groups:
+              T::Array[
+                Dodopayments::Models::ProductCollectionCreateResponse::Group
+              ],
+            name: String,
+            updated_at: Time,
+            description: T.nilable(String),
+            image: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Group < Dodopayments::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dodopayments::Models::ProductCollectionCreateResponse::Group,
+              Dodopayments::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :group_id
+
+        sig do
+          returns(
+            T::Array[
+              Dodopayments::Models::ProductCollectionCreateResponse::Group::Product
+            ]
+          )
+        end
+        attr_accessor :products
+
+        sig { returns(T::Boolean) }
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :group_name
+
+        sig do
+          params(
+            group_id: String,
+            products:
+              T::Array[
+                Dodopayments::Models::ProductCollectionCreateResponse::Group::Product::OrHash
+              ],
+            status: T::Boolean,
+            group_name: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(group_id:, products:, status:, group_name: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              group_id: String,
+              products:
+                T::Array[
+                  Dodopayments::Models::ProductCollectionCreateResponse::Group::Product
+                ],
+              status: T::Boolean,
+              group_name: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Product < Dodopayments::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Dodopayments::Models::ProductCollectionCreateResponse::Group::Product,
+                Dodopayments::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :id
+
+          sig { returns(Integer) }
+          attr_accessor :addons_count
+
+          sig { returns(Integer) }
+          attr_accessor :files_count
+
+          # Whether this product has any credit entitlements attached
+          sig { returns(T::Boolean) }
+          attr_accessor :has_credit_entitlements
+
+          sig { returns(T::Boolean) }
+          attr_accessor :is_recurring
+
+          sig { returns(T::Boolean) }
+          attr_accessor :license_key_enabled
+
+          sig { returns(Integer) }
+          attr_accessor :meters_count
+
+          sig { returns(String) }
+          attr_accessor :product_id
+
+          sig { returns(T::Boolean) }
+          attr_accessor :status
+
+          sig { returns(T.nilable(Dodopayments::Currency::TaggedSymbol)) }
+          attr_accessor :currency
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :description
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :name
+
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :price
+
+          # One-time price details.
+          sig { returns(T.nilable(Dodopayments::Price::Variants)) }
+          attr_accessor :price_detail
+
+          # Represents the different categories of taxation applicable to various products
+          # and services.
+          sig { returns(T.nilable(Dodopayments::TaxCategory::TaggedSymbol)) }
+          attr_accessor :tax_category
+
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_accessor :tax_inclusive
+
+          sig do
+            params(
+              id: String,
+              addons_count: Integer,
+              files_count: Integer,
+              has_credit_entitlements: T::Boolean,
+              is_recurring: T::Boolean,
+              license_key_enabled: T::Boolean,
+              meters_count: Integer,
+              product_id: String,
+              status: T::Boolean,
+              currency: T.nilable(Dodopayments::Currency::OrSymbol),
+              description: T.nilable(String),
+              name: T.nilable(String),
+              price: T.nilable(Integer),
+              price_detail:
+                T.nilable(
+                  T.any(
+                    Dodopayments::Price::OneTimePrice::OrHash,
+                    Dodopayments::Price::RecurringPrice::OrHash,
+                    Dodopayments::Price::UsageBasedPrice::OrHash
+                  )
+                ),
+              tax_category: T.nilable(Dodopayments::TaxCategory::OrSymbol),
+              tax_inclusive: T.nilable(T::Boolean)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            addons_count:,
+            files_count:,
+            # Whether this product has any credit entitlements attached
+            has_credit_entitlements:,
+            is_recurring:,
+            license_key_enabled:,
+            meters_count:,
+            product_id:,
+            status:,
+            currency: nil,
+            description: nil,
+            name: nil,
+            price: nil,
+            # One-time price details.
+            price_detail: nil,
+            # Represents the different categories of taxation applicable to various products
+            # and services.
+            tax_category: nil,
+            tax_inclusive: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                id: String,
+                addons_count: Integer,
+                files_count: Integer,
+                has_credit_entitlements: T::Boolean,
+                is_recurring: T::Boolean,
+                license_key_enabled: T::Boolean,
+                meters_count: Integer,
+                product_id: String,
+                status: T::Boolean,
+                currency: T.nilable(Dodopayments::Currency::TaggedSymbol),
+                description: T.nilable(String),
+                name: T.nilable(String),
+                price: T.nilable(Integer),
+                price_detail: T.nilable(Dodopayments::Price::Variants),
+                tax_category:
+                  T.nilable(Dodopayments::TaxCategory::TaggedSymbol),
+                tax_inclusive: T.nilable(T::Boolean)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end