dodopayments 0.0.1.pre.alpha.0

data/rbi/lib/dodopayments/resources/products.rbi

@@ -0,0 +1,164 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Products
+      sig { returns(Dodopayments::Resources::Products::Images) }
+      def images
+      end
+
+      sig do
+        params(
+          price: T.any(Dodopayments::Models::Price::OneTimePrice, Dodopayments::Models::Price::RecurringPrice),
+          tax_category: Symbol,
+          addons: T.nilable(T::Array[String]),
+          description: T.nilable(String),
+          license_key_activation_message: T.nilable(String),
+          license_key_activations_limit: T.nilable(Integer),
+          license_key_duration: T.nilable(Dodopayments::Models::LicenseKeyDuration),
+          license_key_enabled: T.nilable(T::Boolean),
+          name: T.nilable(String),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Product)
+      end
+      def create(
+        price:,
+        # Represents the different categories of taxation applicable to various products
+        #   and services.
+        tax_category:,
+        # Addons available for subscription product
+        addons: nil,
+        # Optional description of the product
+        description: nil,
+        # Optional message displayed during license key activation
+        license_key_activation_message: nil,
+        # The number of times the license key can be activated. Must be 0 or greater
+        license_key_activations_limit: nil,
+        license_key_duration: nil,
+        # When true, generates and sends a license key to your customer. Defaults to false
+        license_key_enabled: nil,
+        # Optional name of the product
+        name: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Product)
+      end
+      def retrieve(
+        # Product Id
+        id,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          addons: T.nilable(T::Array[String]),
+          description: T.nilable(String),
+          image_id: T.nilable(String),
+          license_key_activation_message: T.nilable(String),
+          license_key_activations_limit: T.nilable(Integer),
+          license_key_duration: T.nilable(Dodopayments::Models::LicenseKeyDuration),
+          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(Symbol),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .void
+      end
+      def update(
+        id,
+        # Available Addons for subscription products
+        addons: nil,
+        # Description of the product, optional and must be at most 1000 characters.
+        description: nil,
+        # Product image id after its uploaded to S3
+        image_id: nil,
+        # Message sent to the customer upon license key activation.
+        #
+        #   Only applicable if `license_key_enabled` is `true`. This message contains
+        #   instructions for activating the license key.
+        license_key_activation_message: nil,
+        # Limit for the number of activations for the license key.
+        #
+        #   Only applicable if `license_key_enabled` is `true`. Represents the maximum
+        #   number of times the license key can be activated.
+        license_key_activations_limit: nil,
+        license_key_duration: nil,
+        # Whether the product requires a license key.
+        #
+        #   If `true`, additional fields related to license key (duration, activations
+        #   limit, activation message) become applicable.
+        license_key_enabled: nil,
+        # Name of the product, optional and must be at most 100 characters.
+        name: nil,
+        price: nil,
+        # Represents the different categories of taxation applicable to various products
+        #   and services.
+        tax_category: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          archived: T::Boolean,
+          page_number: T.nilable(Integer),
+          page_size: T.nilable(Integer),
+          recurring: T.nilable(T::Boolean),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::DefaultPageNumberPagination[Dodopayments::Models::ProductListResponse])
+      end
+      def list(
+        # List archived products
+        archived: nil,
+        # Page number default is 0
+        page_number: nil,
+        # Page size default is 10 max is 100
+        page_size: nil,
+        # Filter products by pricing type:
+        #
+        #   - `true`: Show only recurring pricing products (e.g. subscriptions)
+        #   - `false`: Show only one-time price products
+        #   - `null` or absent: Show both types of products
+        recurring: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .void
+      end
+      def delete(id, request_options: {})
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .void
+      end
+      def unarchive(id, request_options: {})
+      end
+
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/resources/refunds.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Refunds
+      sig do
+        params(
+          payment_id: String,
+          amount: T.nilable(Integer),
+          reason: T.nilable(String),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Refund)
+      end
+      def create(
+        # The unique identifier of the payment to be refunded.
+        payment_id:,
+        # The amount to be refunded. Must be non-negative. Optional. Partial refunds are
+        #   currently disabled.
+        amount: nil,
+        # The reason for the refund, if any. Maximum length is 3000 characters. Optional.
+        reason: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          refund_id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Refund)
+      end
+      def retrieve(
+        # Refund Id
+        refund_id,
+        request_options: {}
+      )
+      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(Symbol),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::DefaultPageNumberPagination[Dodopayments::Models::Refund])
+      end
+      def list(
+        # Get events after this created time
+        created_at_gte: nil,
+        # Get events created before this time
+        created_at_lte: nil,
+        # Filter by customer_id
+        customer_id: nil,
+        # Page number default is 0
+        page_number: nil,
+        # Page size default is 10 max is 100
+        page_size: nil,
+        # Filter by status
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/resources/subscriptions.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class Subscriptions
+      sig do
+        params(
+          billing: Dodopayments::Models::BillingAddress,
+          customer: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer),
+          product_id: String,
+          quantity: Integer,
+          discount_code: T.nilable(String),
+          metadata: T::Hash[Symbol, String],
+          payment_link: T.nilable(T::Boolean),
+          return_url: T.nilable(String),
+          tax_id: T.nilable(String),
+          trial_period_days: T.nilable(Integer),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::SubscriptionCreateResponse)
+      end
+      def create(
+        billing:,
+        customer:,
+        # Unique identifier of the product to subscribe to
+        product_id:,
+        # Number of units to subscribe for. Must be at least 1.
+        quantity:,
+        # Discount Code to apply to the subscription
+        discount_code: nil,
+        metadata: nil,
+        # If true, generates a payment link. Defaults to false if not specified.
+        payment_link: nil,
+        # Optional URL to redirect after successful subscription creation
+        return_url: nil,
+        # Tax ID in case the payment is B2B. If tax id validation fails the payment
+        #   creation will fail
+        tax_id: nil,
+        # Optional trial period in days If specified, this value overrides the trial
+        #   period set in the product's price Must be between 0 and 10000 days
+        trial_period_days: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          subscription_id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Subscription)
+      end
+      def retrieve(
+        # Subscription Id
+        subscription_id,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          subscription_id: String,
+          metadata: T.nilable(T::Hash[Symbol, String]),
+          status: T.nilable(Symbol),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::Models::Subscription)
+      end
+      def update(
+        # Subscription Id
+        subscription_id,
+        metadata: nil,
+        status: nil,
+        request_options: {}
+      )
+      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(Symbol),
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::DefaultPageNumberPagination[Dodopayments::Models::Subscription])
+      end
+      def list(
+        # Get events after this created time
+        created_at_gte: nil,
+        # Get events created before this time
+        created_at_lte: nil,
+        # Filter by customer id
+        customer_id: nil,
+        # Page number default is 0
+        page_number: nil,
+        # Page size default is 10 max is 100
+        page_size: nil,
+        # Filter by status
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/resources/webhook_events.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Dodopayments
+  module Resources
+    class WebhookEvents
+      sig do
+        params(
+          webhook_event_id: String,
+          request_options: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .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: T.nilable(T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(Dodopayments::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
+
+      sig { params(client: Dodopayments::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/util.rbi

@@ -0,0 +1,270 @@
+# typed: strong
+
+module Dodopayments
+  # @api private
+  module Util
+    # @api private
+    sig { returns(Float) }
+    def self.monotonic_secs
+    end
+
+    class << self
+      # @api private
+      sig { returns(String) }
+      def arch
+      end
+
+      # @api private
+      sig { returns(String) }
+      def os
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def primitive?(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def coerce_boolean(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+      def coerce_boolean!(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+      def coerce_integer(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+      def coerce_float(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+      def coerce_hash(input)
+      end
+    end
+
+    OMIT = T.let(T.anything, T.anything)
+
+    class << self
+      # @api private
+      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+      private def deep_merge_lr(lhs, rhs, concat: false)
+      end
+
+      # @api private
+      #
+      # Recursively merge one hash with another. If the values at a given key are not
+      #   both hashes, just take the new value.
+      sig do
+        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+          .returns(T.anything)
+      end
+      def deep_merge(
+        *values,
+        # the value to return if no values are provided.
+        sentinel: nil,
+        # whether to merge sequences by concatenation.
+        concat: false
+      )
+      end
+
+      # @api private
+      sig do
+        params(
+          data: T.any(T::Hash[Symbol, T.anything], T::Array[T.anything], T.anything),
+          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
+          sentinel: T.nilable(T.anything),
+          blk: T.nilable(T.proc.returns(T.anything))
+        )
+          .returns(T.nilable(T.anything))
+      end
+      def dig(data, pick, sentinel = nil, &blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(uri: URI::Generic).returns(String) }
+      def uri_origin(uri)
+      end
+
+      # @api private
+      sig { params(path: T.any(String, T::Array[String])).returns(String) }
+      def interpolate_path(path)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+      def decode_query(query)
+      end
+
+      # @api private
+      sig do
+        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+          .returns(T.nilable(String))
+      end
+      def encode_query(query)
+      end
+    end
+
+    ParsedUriShape = T.type_alias do
+      {
+        scheme: T.nilable(String),
+        host: T.nilable(String),
+        port: T.nilable(Integer),
+        path: T.nilable(String),
+        query: T::Hash[String, T::Array[String]]
+      }
+    end
+
+    class << self
+      # @api private
+      sig { params(url: T.any(URI::Generic, String)).returns(Dodopayments::Util::ParsedUriShape) }
+      def parse_uri(url)
+      end
+
+      # @api private
+      sig { params(parsed: Dodopayments::Util::ParsedUriShape).returns(URI::Generic) }
+      def unparse_uri(parsed)
+      end
+
+      # @api private
+      sig do
+        params(lhs: Dodopayments::Util::ParsedUriShape, rhs: Dodopayments::Util::ParsedUriShape)
+          .returns(URI::Generic)
+      end
+      def join_parsed_uri(lhs, rhs)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(
+          headers: T::Hash[String,
+                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
+        )
+          .returns(T::Hash[String, String])
+      end
+      def normalized_headers(*headers)
+      end
+    end
+
+    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+    class ReadIOAdapter
+      # @api private
+      sig { params(max_len: T.nilable(Integer)).returns(String) }
+      private def read_enum(max_len)
+      end
+
+      # @api private
+      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
+      def read(max_len = nil, out_string = nil)
+      end
+
+      # @api private
+      sig do
+        params(
+          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(stream, &blk)
+      end
+    end
+
+    class << self
+      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
+      def string_io(&blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+      end
+      private def encode_multipart_formdata(y, boundary:, key:, val:)
+      end
+
+      # @api private
+      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
+      private def encode_multipart_streaming(body)
+      end
+
+      # @api private
+      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+      def encode_content(headers, body)
+      end
+
+      # @api private
+      sig do
+        params(
+          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+          stream: T::Enumerable[String],
+          suppress_error: T::Boolean
+        )
+          .returns(T.anything)
+      end
+      def decode_content(headers, stream:, suppress_error: false)
+      end
+    end
+
+    class << self
+      # @api private
+      #
+      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
+      sig do
+        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def fused_enum(enum, external: false, &close)
+      end
+
+      # @api private
+      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+      def close_fused!(enum)
+      end
+
+      # @api private
+      sig do
+        params(
+          enum: T.nilable(T::Enumerable[T.anything]),
+          blk: T.proc.params(arg0: Enumerator::Yielder).void
+        ).void
+      end
+      def chain_fused(enum, &blk)
+      end
+    end
+
+    ServerSentEvent = T.type_alias do
+      {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
+    end
+
+    class << self
+      # @api private
+      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+      def decode_lines(enum)
+      end
+
+      # @api private
+      #
+      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+      sig { params(lines: T::Enumerable[String]).returns(Dodopayments::Util::ServerSentEvent) }
+      def decode_sse(lines)
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Dodopayments
+  VERSION = "0.0.1-alpha.0"
+end