dodopayments 1.22.0 → 1.47.0

data/rbi/dodopayments/resources/subscriptions.rbi

@@ -5,35 +5,34 @@ module Dodopayments
     class Subscriptions
       sig do
         params(
-          billing: T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash),
-          customer: T.any(
-            Dodopayments::Models::AttachExistingCustomer,
-            Dodopayments::Internal::AnyHash,
-            Dodopayments::Models::CreateNewCustomer
-          ),
+          billing: Dodopayments::BillingAddress::OrHash,
+          customer:
+            T.any(
+              Dodopayments::AttachExistingCustomer::OrHash,
+              Dodopayments::NewCustomer::OrHash
+            ),
           product_id: String,
           quantity: Integer,
-          addons: T.nilable(
-            T::Array[T.any(Dodopayments::Models::SubscriptionCreateParams::Addon, Dodopayments::Internal::AnyHash)]
-          ),
-          allowed_payment_method_types: T.nilable(T::Array[Dodopayments::Models::SubscriptionCreateParams::AllowedPaymentMethodType::OrSymbol]),
-          billing_currency: T.nilable(Dodopayments::Models::Currency::OrSymbol),
+          addons: T.nilable(T::Array[Dodopayments::AttachAddon::OrHash]),
+          allowed_payment_method_types:
+            T.nilable(T::Array[Dodopayments::PaymentMethodTypes::OrSymbol]),
+          billing_currency: T.nilable(Dodopayments::Currency::OrSymbol),
           discount_code: T.nilable(String),
           metadata: T::Hash[Symbol, String],
-          on_demand: T.nilable(
-            T.any(Dodopayments::Models::SubscriptionCreateParams::OnDemand, Dodopayments::Internal::AnyHash)
-          ),
+          on_demand:
+            T.nilable(Dodopayments::SubscriptionCreateParams::OnDemand::OrHash),
           payment_link: T.nilable(T::Boolean),
           return_url: T.nilable(String),
           show_saved_payment_methods: T::Boolean,
           tax_id: T.nilable(String),
           trial_period_days: T.nilable(Integer),
-          request_options: Dodopayments::RequestOpts
-        )
-          .returns(Dodopayments::Models::SubscriptionCreateResponse)
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Models::SubscriptionCreateResponse)
       end
       def create(
+        # Billing address information for the subscription
         billing:,
+        # Customer details for the subscription
         customer:,
         # Unique identifier of the product to subscribe to
         product_id:,
@@ -48,9 +47,12 @@ module Dodopayments
         # Availability still depends on other factors (e.g., customer location, merchant
         # settings).
         allowed_payment_method_types: nil,
+        # Fix the currency in which the end customer is billed. If Dodo Payments cannot
+        # support that currency for this transaction, it will not proceed
         billing_currency: nil,
         # Discount Code to apply to the subscription
         discount_code: nil,
+        # Additional metadata for the subscription Defaults to empty if not specified
         metadata: nil,
         on_demand: nil,
         # If true, generates a payment link. Defaults to false if not specified.
@@ -66,55 +68,69 @@ module Dodopayments
         # period set in the product's price Must be between 0 and 10000 days
         trial_period_days: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        params(subscription_id: String, request_options: Dodopayments::RequestOpts)
-          .returns(Dodopayments::Models::Subscription)
+        params(
+          subscription_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Subscription)
       end
       def retrieve(
         # Subscription Id
         subscription_id,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
         params(
           subscription_id: String,
-          billing: T.nilable(T.any(Dodopayments::Models::BillingAddress, Dodopayments::Internal::AnyHash)),
-          disable_on_demand: T.nilable(
-            T.any(Dodopayments::Models::SubscriptionUpdateParams::DisableOnDemand, Dodopayments::Internal::AnyHash)
-          ),
+          billing: T.nilable(Dodopayments::BillingAddress::OrHash),
+          cancel_at_next_billing_date: T.nilable(T::Boolean),
+          disable_on_demand:
+            T.nilable(
+              Dodopayments::SubscriptionUpdateParams::DisableOnDemand::OrHash
+            ),
           metadata: T.nilable(T::Hash[Symbol, String]),
-          status: T.nilable(Dodopayments::Models::SubscriptionStatus::OrSymbol),
+          status: T.nilable(Dodopayments::SubscriptionStatus::OrSymbol),
           tax_id: T.nilable(String),
-          request_options: Dodopayments::RequestOpts
-        )
-          .returns(Dodopayments::Models::Subscription)
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Subscription)
       end
       def update(
         # Subscription Id
         subscription_id,
         billing: nil,
+        cancel_at_next_billing_date: nil,
         disable_on_demand: nil,
         metadata: nil,
         status: nil,
         tax_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       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::SubscriptionStatus::OrSymbol),
-          request_options: Dodopayments::RequestOpts
+          brand_id: String,
+          created_at_gte: Time,
+          created_at_lte: Time,
+          customer_id: String,
+          page_number: Integer,
+          page_size: Integer,
+          status: Dodopayments::SubscriptionListParams::Status::OrSymbol,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(
+          Dodopayments::Internal::DefaultPageNumberPagination[
+            Dodopayments::Models::SubscriptionListResponse
+          ]
         )
-          .returns(
-            Dodopayments::Internal::DefaultPageNumberPagination[Dodopayments::Models::SubscriptionListResponse]
-          )
       end
       def list(
+        # filter by Brand id
+        brand_id: nil,
         # Get events after this created time
         created_at_gte: nil,
         # Get events created before this time
@@ -128,25 +144,26 @@ module Dodopayments
         # Filter by status
         status: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
         params(
           subscription_id: String,
           product_id: String,
-          proration_billing_mode: Dodopayments::Models::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
+          proration_billing_mode:
+            Dodopayments::SubscriptionChangePlanParams::ProrationBillingMode::OrSymbol,
           quantity: Integer,
-          addons: T.nilable(
-            T::Array[T.any(Dodopayments::Models::SubscriptionChangePlanParams::Addon, Dodopayments::Internal::AnyHash)]
-          ),
-          request_options: Dodopayments::RequestOpts
-        )
-          .void
+          addons: T.nilable(T::Array[Dodopayments::AttachAddon::OrHash]),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).void
       end
       def change_plan(
         # Subscription Id
         subscription_id,
         # 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:,
@@ -154,10 +171,19 @@ module Dodopayments
         # addons
         addons: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        params(subscription_id: String, product_price: Integer, request_options: Dodopayments::RequestOpts)
-          .returns(Dodopayments::Models::SubscriptionChargeResponse)
+        params(
+          subscription_id: String,
+          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::OrHash
+        ).returns(Dodopayments::Models::SubscriptionChargeResponse)
       end
       def charge(
         # Subscription Id
@@ -165,11 +191,27 @@ module Dodopayments
         # 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
+      )
+      end
+
       # @api private
       sig { params(client: Dodopayments::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/dodopayments/resources/webhook_events.rbi

@@ -3,42 +3,10 @@
 module Dodopayments
   module Resources
     class WebhookEvents
-      sig do
-        params(webhook_event_id: String, request_options: Dodopayments::RequestOpts)
-          .returns(Dodopayments::Models::WebhookEvent)
-      end
-      def retrieve(webhook_event_id, request_options: {}); end
-
-      sig do
-        params(
-          created_at_gte: T.nilable(Time),
-          created_at_lte: T.nilable(Time),
-          limit: T.nilable(Integer),
-          object_id_: T.nilable(String),
-          page_number: T.nilable(Integer),
-          page_size: T.nilable(Integer),
-          request_options: Dodopayments::RequestOpts
-        )
-          .returns(Dodopayments::Internal::DefaultPageNumberPagination[Dodopayments::Models::WebhookEvent])
-      end
-      def list(
-        # Get events after this created time
-        created_at_gte: nil,
-        # Get events created before this time
-        created_at_lte: nil,
-        # Min : 1, Max : 100, default 10
-        limit: nil,
-        # Get events history of a specific object like payment/subscription/refund/dispute
-        object_id_: nil,
-        # Page number default is 0
-        page_number: nil,
-        # Page size default is 10 max is 100
-        page_size: nil,
-        request_options: {}
-      ); end
       # @api private
       sig { params(client: Dodopayments::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/dodopayments/resources/webhooks/headers.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Webhooks
+      class Headers
+        # Get a webhook by id
+        sig do
+          params(
+            webhook_id: String,
+            request_options: Dodopayments::RequestOptions::OrHash
+          ).returns(Dodopayments::Models::Webhooks::HeaderRetrieveResponse)
+        end
+        def retrieve(webhook_id, request_options: {})
+        end
+
+        # Patch a webhook by id
+        sig do
+          params(
+            webhook_id: String,
+            headers: T::Hash[Symbol, String],
+            request_options: Dodopayments::RequestOptions::OrHash
+          ).void
+        end
+        def update(
+          webhook_id,
+          # Object of header-value pair to update or add
+          headers:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/resources/webhooks.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Webhooks
+      sig { returns(Dodopayments::Resources::Webhooks::Headers) }
+      attr_reader :headers
+
+      # Create a new webhook
+      sig do
+        params(
+          url: String,
+          description: T.nilable(String),
+          disabled: T.nilable(T::Boolean),
+          filter_types: T::Array[Dodopayments::WebhookEventType::OrSymbol],
+          headers: T.nilable(T::Hash[Symbol, String]),
+          idempotency_key: T.nilable(String),
+          metadata: T.nilable(T::Hash[Symbol, String]),
+          rate_limit: T.nilable(Integer),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Models::WebhookCreateResponse)
+      end
+      def create(
+        # Url of the webhook
+        url:,
+        # Filter events to the webhook.
+        #
+        # Webhook event will only be sent for events in the list.
+        description: nil,
+        # Create the webhook in a disabled state.
+        #
+        # Default is false
+        disabled: nil,
+        filter_types: nil,
+        # Custom headers to be passed
+        headers: nil,
+        # The request's idempotency key
+        idempotency_key: nil,
+        # Metadata to be passed to the webhook Defaut is {}
+        metadata: nil,
+        rate_limit: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a webhook by id
+      sig do
+        params(
+          webhook_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Models::WebhookRetrieveResponse)
+      end
+      def retrieve(webhook_id, request_options: {})
+      end
+
+      # Patch a webhook by id
+      sig do
+        params(
+          webhook_id: String,
+          description: T.nilable(String),
+          disabled: T.nilable(T::Boolean),
+          filter_types:
+            T.nilable(T::Array[Dodopayments::WebhookEventType::OrSymbol]),
+          metadata: T.nilable(T::Hash[Symbol, String]),
+          rate_limit: T.nilable(Integer),
+          url: T.nilable(String),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(Dodopayments::Models::WebhookUpdateResponse)
+      end
+      def update(
+        webhook_id,
+        # Description of the webhook
+        description: nil,
+        # To Disable the endpoint, set it to true.
+        disabled: nil,
+        # Filter events to the endpoint.
+        #
+        # Webhook event will only be sent for events in the list.
+        filter_types: nil,
+        # Metadata
+        metadata: nil,
+        # Rate limit
+        rate_limit: nil,
+        # Url endpoint
+        url: nil,
+        request_options: {}
+      )
+      end
+
+      # List all webhooks
+      sig do
+        params(
+          iterator: T.nilable(String),
+          limit: T.nilable(Integer),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(
+          Dodopayments::Internal::CursorPagePagination[
+            Dodopayments::Models::WebhookListResponse
+          ]
+        )
+      end
+      def list(
+        # The iterator returned from a prior invocation
+        iterator: nil,
+        # Limit the number of returned items
+        limit: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a webhook by id
+      sig do
+        params(
+          webhook_id: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).void
+      end
+      def delete(webhook_id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/dodopayments/resources/your_webhook_url.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class YourWebhookURL
+      sig do
+        params(
+          business_id: String,
+          data:
+            T.any(
+              Dodopayments::WebhookPayload::Data::Payment::OrHash,
+              Dodopayments::WebhookPayload::Data::Subscription::OrHash,
+              Dodopayments::WebhookPayload::Data::Refund::OrHash,
+              Dodopayments::WebhookPayload::Data::Dispute::OrHash,
+              Dodopayments::WebhookPayload::Data::LicenseKey::OrHash
+            ),
+          timestamp: Time,
+          type: Dodopayments::WebhookEventType::OrSymbol,
+          webhook_id: String,
+          webhook_signature: String,
+          webhook_timestamp: String,
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).void
+      end
+      def create(
+        # Body param:
+        business_id:,
+        # Body param: The latest data at the time of delivery attempt
+        data:,
+        # Body param: The timestamp of when the event occurred (not necessarily the same
+        # of when it was delivered)
+        timestamp:,
+        # Body param: Event types for Dodo events
+        type:,
+        # Header param: Unique identifier for the webhook
+        webhook_id:,
+        # Header param: Signature of the Webhook
+        webhook_signature:,
+        # Header param: Unix timestamp when the webhook was sent
+        webhook_timestamp:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/sig/dodopayments/client.rbs

@@ -45,6 +45,12 @@ module Dodopayments
 
     attr_reader addons: Dodopayments::Resources::Addons
 
+    attr_reader brands: Dodopayments::Resources::Brands
+
+    attr_reader webhooks: Dodopayments::Resources::Webhooks
+
+    attr_reader your_webhook_url: Dodopayments::Resources::YourWebhookURL
+
     private def auth_headers: -> ::Hash[String, String]
 
     def initialize: (

data/sig/dodopayments/errors.rbs

@@ -5,6 +5,15 @@ module Dodopayments
     end
 
     class ConversionError < Dodopayments::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
     end
 
     class APIError < Dodopayments::Errors::Error

data/sig/dodopayments/internal/cursor_page_pagination.rbs

@@ -0,0 +1,15 @@
+module Dodopayments
+  module Internal
+    class CursorPagePagination[Elem]
+      include Dodopayments::Internal::Type::BasePage[Elem]
+
+      attr_accessor data: ::Array[Elem]?
+
+      attr_accessor iterator: String
+
+      attr_accessor done: bool
+
+      def inspect: -> String
+    end
+  end
+end

data/sig/dodopayments/internal/transport/base_client.rbs

@@ -2,6 +2,8 @@ module Dodopayments
   module Internal
     module Transport
       class BaseClient
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
+
         type request_components =
           {
             method: Symbol,
@@ -20,7 +22,6 @@ module Dodopayments
             model: Dodopayments::Internal::Type::Converter::input?,
             options: Dodopayments::request_opts?
           }
-
         type request_input =
           {
             method: Symbol,
@@ -55,6 +56,20 @@ module Dodopayments
           stream: Enumerable[String]?
         ) -> void
 
+        attr_reader base_url: URI::Generic
+
+        attr_reader timeout: Float
+
+        attr_reader max_retries: Integer
+
+        attr_reader initial_retry_delay: Float
+
+        attr_reader max_retry_delay: Float
+
+        attr_reader headers: ::Hash[String, String]
+
+        attr_reader idempotency_header: String?
+
         # @api private
         attr_reader requester: Dodopayments::Internal::Transport::PooledNetRequester
 
@@ -84,7 +99,7 @@ module Dodopayments
           retry_count: Integer
         ) -> Float
 
-        private def send_request: (
+        def send_request: (
           Dodopayments::Internal::Transport::BaseClient::request_input request,
           redirect_count: Integer,
           retry_count: Integer,

data/sig/dodopayments/internal/transport/pooled_net_requester.rbs

@@ -2,6 +2,8 @@ module Dodopayments
   module Internal
     module Transport
       class PooledNetRequester
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
+
         type request =
           {
             method: Symbol,
@@ -13,6 +15,8 @@ module Dodopayments
 
         KEEP_ALIVE_TIMEOUT: 30
 
+        DEFAULT_MAX_CONNECTIONS: Integer
+
         def self.connect: (URI::Generic url) -> top
 
         def self.calibrate_socket_timeout: (top conn, Float deadline) -> void

data/sig/dodopayments/internal/type/array_of.rbs

@@ -3,6 +3,7 @@ module Dodopayments
     module Type
       class ArrayOf[Elem]
         include Dodopayments::Internal::Type::Converter
+        include Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         def self.[]: (
           ::Hash[Symbol, top]
@@ -27,6 +28,8 @@ module Dodopayments
           state: Dodopayments::Internal::Type::Converter::dump_state
         ) -> (::Array[top] | top)
 
+        def to_sorbet_type: -> top
+
         def item_type: -> Elem
 
         def nilable?: -> bool

data/sig/dodopayments/internal/type/base_model.rbs

@@ -3,10 +3,13 @@ module Dodopayments
     module Type
       class BaseModel
         extend Dodopayments::Internal::Type::Converter
+        extend Dodopayments::Internal::Util::SorbetRuntimeSupport
 
         type known_field =
           { mode: (:coerce | :dump)?, required: bool, nilable: bool }
 
+        def self.inherited: (self child) -> void
+
         def self.known_fields: -> ::Hash[Symbol, (Dodopayments::Internal::Type::BaseModel::known_field
         & { type_fn: (^-> Dodopayments::Internal::Type::Converter::input) })]
 
@@ -67,23 +70,28 @@ module Dodopayments
           state: Dodopayments::Internal::Type::Converter::dump_state
         ) -> (::Hash[top, top] | top)
 
+        def self.to_sorbet_type: -> top
+
+        def self.recursively_to_h: (
+          Dodopayments::Internal::Type::BaseModel model,
+          convert: bool
+        ) -> ::Hash[Symbol, top]
+
         def []: (Symbol key) -> top?
 
         def to_h: -> ::Hash[Symbol, top]
 
         alias to_hash to_h
 
-        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
+        def deep_to_h: -> ::Hash[Symbol, top]
 
-        def self.walk: (
-          Dodopayments::Internal::Type::BaseModel model
-        ) -> ::Hash[Symbol, top]
+        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
 
         def to_json: (*top a) -> String
 
         def to_yaml: (*top a) -> String
 
-        def initialize: (?::Hash[Symbol, top] | self data) -> void
+        def initialize: (?::Hash[Symbol, top] | instance data) -> void
 
         def self.inspect: (?depth: Integer) -> String