dodopayments 1.20.0 → 1.47.0

data/rbi/dodopayments/models/refund_list_params.rbi

@@ -6,41 +6,67 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::RefundListParams, Dodopayments::Internal::AnyHash)
+        end
+
       # 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::RefundStatus::OrSymbol)) }
-      attr_accessor :status
+      sig do
+        returns(T.nilable(Dodopayments::RefundListParams::Status::OrSymbol))
+      end
+      attr_reader :status
+
+      sig do
+        params(status: Dodopayments::RefundListParams::Status::OrSymbol).void
+      end
+      attr_writer :status
 
       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::RefundStatus::OrSymbol),
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          created_at_gte: Time,
+          created_at_lte: Time,
+          customer_id: String,
+          page_number: Integer,
+          page_size: Integer,
+          status: Dodopayments::RefundListParams::Status::OrSymbol,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Get events after this created time
@@ -56,22 +82,53 @@ module Dodopayments
         # Filter by status
         status: 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::RefundStatus::OrSymbol),
-              request_options: Dodopayments::RequestOptions
-            }
+        override.returns(
+          {
+            created_at_gte: Time,
+            created_at_lte: Time,
+            customer_id: String,
+            page_number: Integer,
+            page_size: Integer,
+            status: Dodopayments::RefundListParams::Status::OrSymbol,
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by status
+      module Status
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Dodopayments::RefundListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        SUCCEEDED =
+          T.let(
+            :succeeded,
+            Dodopayments::RefundListParams::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(:failed, Dodopayments::RefundListParams::Status::TaggedSymbol)
+        PENDING =
+          T.let(:pending, Dodopayments::RefundListParams::Status::TaggedSymbol)
+        REVIEW =
+          T.let(:review, Dodopayments::RefundListParams::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Dodopayments::RefundListParams::Status::TaggedSymbol]
           )
+        end
+        def self.values
+        end
       end
-      def to_hash; end
     end
   end
 end

data/rbi/dodopayments/models/refund_retrieve_params.rbi

@@ -6,14 +6,27 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::RefundRetrieveParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
       sig do
-        params(request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash))
-          .returns(T.attached_class)
+        params(request_options: Dodopayments::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
       end
-      def self.new(request_options: {}); end
 
-      sig { override.returns({request_options: Dodopayments::RequestOptions}) }
-      def to_hash; end
+      sig do
+        override.returns({ request_options: Dodopayments::RequestOptions })
+      end
+      def to_hash
+      end
     end
   end
 end

data/rbi/dodopayments/models/refund_status.rbi

@@ -5,16 +5,19 @@ module Dodopayments
     module RefundStatus
       extend Dodopayments::Internal::Type::Enum
 
-      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::Models::RefundStatus) }
+      TaggedSymbol = T.type_alias { T.all(Symbol, Dodopayments::RefundStatus) }
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-      SUCCEEDED = T.let(:succeeded, Dodopayments::Models::RefundStatus::TaggedSymbol)
-      FAILED = T.let(:failed, Dodopayments::Models::RefundStatus::TaggedSymbol)
-      PENDING = T.let(:pending, Dodopayments::Models::RefundStatus::TaggedSymbol)
-      REVIEW = T.let(:review, Dodopayments::Models::RefundStatus::TaggedSymbol)
+      SUCCEEDED = T.let(:succeeded, Dodopayments::RefundStatus::TaggedSymbol)
+      FAILED = T.let(:failed, Dodopayments::RefundStatus::TaggedSymbol)
+      PENDING = T.let(:pending, Dodopayments::RefundStatus::TaggedSymbol)
+      REVIEW = T.let(:review, Dodopayments::RefundStatus::TaggedSymbol)
 
-      sig { override.returns(T::Array[Dodopayments::Models::RefundStatus::TaggedSymbol]) }
-      def self.values; end
+      sig do
+        override.returns(T::Array[Dodopayments::RefundStatus::TaggedSymbol])
+      end
+      def self.values
+      end
     end
   end
 end

data/rbi/dodopayments/models/subscription.rbi

@@ -3,31 +3,44 @@
 module Dodopayments
   module Models
     class Subscription < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::Subscription, Dodopayments::Internal::AnyHash)
+        end
+
       # Addons associated with this subscription
-      sig { returns(T::Array[Dodopayments::Models::AddonCartResponseItem]) }
+      sig { returns(T::Array[Dodopayments::AddonCartResponseItem]) }
       attr_accessor :addons
 
-      sig { returns(Dodopayments::Models::BillingAddress) }
+      # Billing address details for payments
+      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
 
+      # Indicates if the subscription will cancel at the next billing date
+      sig { returns(T::Boolean) }
+      attr_accessor :cancel_at_next_billing_date
+
       # Timestamp when the subscription was created
       sig { returns(Time) }
       attr_accessor :created_at
 
-      sig { returns(Dodopayments::Models::Currency::TaggedSymbol) }
+      # Currency used for the subscription payments
+      sig { returns(Dodopayments::Currency::OrSymbol) }
       attr_accessor :currency
 
-      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      # Customer details associated with the subscription
+      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 custom data associated with the subscription
       sig { returns(T::Hash[Symbol, String]) }
       attr_accessor :metadata
 
@@ -44,7 +57,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :payment_frequency_count
 
-      sig { returns(Dodopayments::Models::TimeInterval::TaggedSymbol) }
+      # Time interval for payment frequency (e.g. month, year)
+      sig { returns(Dodopayments::TimeInterval::OrSymbol) }
       attr_accessor :payment_frequency_interval
 
       # Timestamp of the last payment. Indicates the start of current billing period
@@ -64,7 +78,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :recurring_pre_tax_amount
 
-      sig { returns(Dodopayments::Models::SubscriptionStatus::TaggedSymbol) }
+      # Current status of the subscription
+      sig { returns(Dodopayments::SubscriptionStatus::OrSymbol) }
       attr_accessor :status
 
       # Unique identifier for the subscription
@@ -75,7 +90,8 @@ module Dodopayments
       sig { returns(Integer) }
       attr_accessor :subscription_period_count
 
-      sig { returns(Dodopayments::Models::TimeInterval::TaggedSymbol) }
+      # Time interval for the subscription period (e.g. month, year)
+      sig { returns(Dodopayments::TimeInterval::OrSymbol) }
       attr_accessor :subscription_period_interval
 
       # Indicates if the recurring_pre_tax_amount is tax inclusive
@@ -90,6 +106,10 @@ module Dodopayments
       sig { returns(T.nilable(Time)) }
       attr_accessor :cancelled_at
 
+      # Number of remaining discount cycles if discount is applied
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :discount_cycles_remaining
+
       # The discount id if discount is applied
       sig { returns(T.nilable(String)) }
       attr_accessor :discount_id
@@ -97,39 +117,46 @@ module Dodopayments
       # Response struct representing subscription details
       sig do
         params(
-          addons: T::Array[T.any(Dodopayments::Models::AddonCartResponseItem, Dodopayments::Internal::AnyHash)],
-          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
+          addons: T::Array[Dodopayments::AddonCartResponseItem::OrHash],
+          billing: Dodopayments::BillingAddress::OrHash,
+          cancel_at_next_billing_date: T::Boolean,
           created_at: Time,
-          currency: Dodopayments::Models::Currency::OrSymbol,
-          customer: T.any(Dodopayments::Models::CustomerLimitedDetails, Dodopayments::Internal::AnyHash),
+          currency: Dodopayments::Currency::OrSymbol,
+          customer: Dodopayments::CustomerLimitedDetails::OrHash,
           metadata: T::Hash[Symbol, String],
           next_billing_date: Time,
           on_demand: T::Boolean,
           payment_frequency_count: Integer,
-          payment_frequency_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+          payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
           previous_billing_date: Time,
           product_id: String,
           quantity: Integer,
           recurring_pre_tax_amount: Integer,
-          status: Dodopayments::Models::SubscriptionStatus::OrSymbol,
+          status: Dodopayments::SubscriptionStatus::OrSymbol,
           subscription_id: String,
           subscription_period_count: Integer,
-          subscription_period_interval: Dodopayments::Models::TimeInterval::OrSymbol,
+          subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
           tax_inclusive: T::Boolean,
           trial_period_days: Integer,
           cancelled_at: T.nilable(Time),
+          discount_cycles_remaining: T.nilable(Integer),
           discount_id: T.nilable(String)
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Addons associated with this subscription
         addons:,
+        # Billing address details for payments
         billing:,
+        # Indicates if the subscription will cancel at the next billing date
+        cancel_at_next_billing_date:,
         # Timestamp when the subscription was created
         created_at:,
+        # Currency used for the subscription payments
         currency:,
+        # Customer details associated with the subscription
         customer:,
+        # Additional custom data associated with the subscription
         metadata:,
         # Timestamp of the next scheduled billing. Indicates the end of current billing
         # period
@@ -138,6 +165,7 @@ module Dodopayments
         on_demand:,
         # Number of payment frequency intervals
         payment_frequency_count:,
+        # Time interval for payment frequency (e.g. month, year)
         payment_frequency_interval:,
         # Timestamp of the last payment. Indicates the start of current billing period
         previous_billing_date:,
@@ -148,11 +176,13 @@ module Dodopayments
         # Amount charged before tax for each recurring payment in smallest currency unit
         # (e.g. cents)
         recurring_pre_tax_amount:,
+        # Current status of the subscription
         status:,
         # Unique identifier for the subscription
         subscription_id:,
         # Number of subscription period intervals
         subscription_period_count:,
+        # Time interval for the subscription period (e.g. month, year)
         subscription_period_interval:,
         # Indicates if the recurring_pre_tax_amount is tax inclusive
         tax_inclusive:,
@@ -160,39 +190,45 @@ module Dodopayments
         trial_period_days:,
         # Cancelled timestamp if the subscription is cancelled
         cancelled_at: nil,
+        # Number of remaining discount cycles if discount is applied
+        discount_cycles_remaining: nil,
         # The discount id if discount is applied
         discount_id: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              addons: T::Array[Dodopayments::Models::AddonCartResponseItem],
-              billing: Dodopayments::Models::BillingAddress,
-              created_at: Time,
-              currency: Dodopayments::Models::Currency::TaggedSymbol,
-              customer: Dodopayments::Models::CustomerLimitedDetails,
-              metadata: T::Hash[Symbol, String],
-              next_billing_date: Time,
-              on_demand: T::Boolean,
-              payment_frequency_count: Integer,
-              payment_frequency_interval: Dodopayments::Models::TimeInterval::TaggedSymbol,
-              previous_billing_date: Time,
-              product_id: String,
-              quantity: Integer,
-              recurring_pre_tax_amount: Integer,
-              status: Dodopayments::Models::SubscriptionStatus::TaggedSymbol,
-              subscription_id: String,
-              subscription_period_count: Integer,
-              subscription_period_interval: Dodopayments::Models::TimeInterval::TaggedSymbol,
-              tax_inclusive: T::Boolean,
-              trial_period_days: Integer,
-              cancelled_at: T.nilable(Time),
-              discount_id: T.nilable(String)
-            }
-          )
+        override.returns(
+          {
+            addons: T::Array[Dodopayments::AddonCartResponseItem],
+            billing: Dodopayments::BillingAddress,
+            cancel_at_next_billing_date: T::Boolean,
+            created_at: Time,
+            currency: Dodopayments::Currency::OrSymbol,
+            customer: Dodopayments::CustomerLimitedDetails,
+            metadata: T::Hash[Symbol, String],
+            next_billing_date: Time,
+            on_demand: T::Boolean,
+            payment_frequency_count: Integer,
+            payment_frequency_interval: Dodopayments::TimeInterval::OrSymbol,
+            previous_billing_date: Time,
+            product_id: String,
+            quantity: Integer,
+            recurring_pre_tax_amount: Integer,
+            status: Dodopayments::SubscriptionStatus::OrSymbol,
+            subscription_id: String,
+            subscription_period_count: Integer,
+            subscription_period_interval: Dodopayments::TimeInterval::OrSymbol,
+            tax_inclusive: T::Boolean,
+            trial_period_days: Integer,
+            cancelled_at: T.nilable(Time),
+            discount_cycles_remaining: T.nilable(Integer),
+            discount_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/dodopayments/models/subscription_change_plan_params.rbi

@@ -6,65 +6,112 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionChangePlanParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
       # Unique identifier of the product to subscribe to
       sig { returns(String) }
       attr_accessor :product_id
 
-      sig { returns(Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol) }
+      # Proration Billing Mode
+      sig do
+        returns(
+          Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol
+        )
+      end
       attr_accessor :proration_billing_mode
 
       # Number of units to subscribe for. Must be at least 1.
       sig { returns(Integer) }
       attr_accessor :quantity
 
+      # Addons for the new plan. Note : Leaving this empty would remove any existing
+      # addons
+      sig { returns(T.nilable(T::Array[Dodopayments::AttachAddon])) }
+      attr_accessor :addons
+
       sig do
         params(
           product_id: String,
-          proration_billing_mode: Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
+          proration_billing_mode:
+            Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
           quantity: Integer,
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          addons: T.nilable(T::Array[Dodopayments::AttachAddon::OrHash]),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Unique identifier of the product to subscribe to
         product_id:,
+        # Proration Billing Mode
         proration_billing_mode:,
         # Number of units to subscribe for. Must be at least 1.
         quantity:,
+        # Addons for the new plan. Note : Leaving this empty would remove any existing
+        # addons
+        addons: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              product_id: String,
-              proration_billing_mode: Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
-              quantity: Integer,
-              request_options: Dodopayments::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            product_id: String,
+            proration_billing_mode:
+              Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
+            quantity: Integer,
+            addons: T.nilable(T::Array[Dodopayments::AttachAddon]),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
+      # Proration Billing Mode
       module ProrationBillingMode
         extend Dodopayments::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode) }
+          T.type_alias do
+            T.all(
+              Symbol,
+              Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         PRORATED_IMMEDIATELY =
           T.let(
             :prorated_immediately,
-            Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol
+            Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol
+          )
+        FULL_IMMEDIATELY =
+          T.let(
+            :full_immediately,
+            Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol
+          )
+        DIFFERENCE_IMMEDIATELY =
+          T.let(
+            :difference_immediately,
+            Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol
           )
 
         sig do
-          override
-            .returns(T::Array[Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol])
+          override.returns(
+            T::Array[
+              Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
         end
-        def self.values; end
       end
     end
   end

data/rbi/dodopayments/models/subscription_charge_params.rbi

@@ -6,26 +6,85 @@ module Dodopayments
       extend Dodopayments::Internal::Type::RequestParameters::Converter
       include Dodopayments::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::SubscriptionChargeParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
       # The product price. 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 :product_price
 
+      # Whether adaptive currency fees should be included in the product_price (true) or
+      # added on top (false). This field is ignored if adaptive pricing is not enabled
+      # for the business.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :adaptive_currency_fees_inclusive
+
+      # Metadata for the payment. If not passed, the metadata of the subscription will
+      # be taken
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_accessor :metadata
+
+      # Optional currency of the product price. If not specified, defaults to the
+      # currency of the product.
+      sig { returns(T.nilable(Dodopayments::Currency::OrSymbol)) }
+      attr_accessor :product_currency
+
+      # Optional product description override for billing and line items. If not
+      # specified, the stored description of the product will be used.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :product_description
+
       sig do
         params(
           product_price: Integer,
-          request_options: T.any(Dodopayments::RequestOptions, Dodopayments::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          adaptive_currency_fees_inclusive: T.nilable(T::Boolean),
+          metadata: T.nilable(T::Hash[Symbol, String]),
+          product_currency: T.nilable(Dodopayments::Currency::OrSymbol),
+          product_description: T.nilable(String),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # The product price. Represented in the lowest denomination of the currency (e.g.,
         # cents for USD). For example, to charge $1.00, pass `100`.
         product_price:,
+        # Whether adaptive currency fees should be included in the product_price (true) or
+        # added on top (false). This field is ignored if adaptive pricing is not enabled
+        # for the business.
+        adaptive_currency_fees_inclusive: nil,
+        # Metadata for the payment. If not passed, the metadata of the subscription will
+        # be taken
+        metadata: nil,
+        # Optional currency of the product price. If not specified, defaults to the
+        # currency of the product.
+        product_currency: nil,
+        # Optional product description override for billing and line items. If not
+        # specified, the stored description of the product will be used.
+        product_description: nil,
         request_options: {}
-      ); end
-      sig { override.returns({product_price: Integer, request_options: Dodopayments::RequestOptions}) }
-      def to_hash; end
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            product_price: Integer,
+            adaptive_currency_fees_inclusive: T.nilable(T::Boolean),
+            metadata: T.nilable(T::Hash[Symbol, String]),
+            product_currency: T.nilable(Dodopayments::Currency::OrSymbol),
+            product_description: T.nilable(String),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
     end
   end
 end