dodopayments 0.0.1.pre.alpha.0

data/rbi/lib/dodopayments/models/license_validate_params.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class LicenseValidateParams < Dodopayments::BaseModel
+      extend Dodopayments::RequestParameters::Converter
+      include Dodopayments::RequestParameters
+
+      sig { returns(String) }
+      def license_key
+      end
+
+      sig { params(_: String).returns(String) }
+      def license_key=(_)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def license_key_instance_id
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def license_key_instance_id=(_)
+      end
+
+      sig do
+        params(
+          license_key: String,
+          license_key_instance_id: T.nilable(String),
+          request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything])
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(license_key:, license_key_instance_id: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              license_key: String,
+              license_key_instance_id: T.nilable(String),
+              request_options: Dodopayments::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/models/license_validate_response.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class LicenseValidateResponse < Dodopayments::BaseModel
+      sig { returns(T::Boolean) }
+      def valid
+      end
+
+      sig { params(_: T::Boolean).returns(T::Boolean) }
+      def valid=(_)
+      end
+
+      sig { params(valid: T::Boolean).returns(T.attached_class) }
+      def self.new(valid:)
+      end
+
+      sig { override.returns({valid: T::Boolean}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/models/misc_list_supported_countries_params.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class MiscListSupportedCountriesParams < Dodopayments::BaseModel
+      extend Dodopayments::RequestParameters::Converter
+      include Dodopayments::RequestParameters
+
+      sig do
+        params(request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything]))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Dodopayments::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/models/misc_list_supported_countries_response.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    MiscListSupportedCountriesResponse = T.type_alias { T::Array[Symbol] }
+  end
+end

data/rbi/lib/dodopayments/models/one_time_product_cart_item.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class OneTimeProductCartItem < Dodopayments::BaseModel
+      sig { returns(String) }
+      def product_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def product_id=(_)
+      end
+
+      sig { returns(Integer) }
+      def quantity
+      end
+
+      sig { params(_: Integer).returns(Integer) }
+      def quantity=(_)
+      end
+
+      # Amount the customer pays if pay_what_you_want is enabled. If disabled then
+      #   amount will be ignored
+      sig { returns(T.nilable(Integer)) }
+      def amount
+      end
+
+      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+      def amount=(_)
+      end
+
+      sig do
+        params(product_id: String, quantity: Integer, amount: T.nilable(Integer)).returns(T.attached_class)
+      end
+      def self.new(product_id:, quantity:, amount: nil)
+      end
+
+      sig { override.returns({product_id: String, quantity: Integer, amount: T.nilable(Integer)}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/models/payment.rbi

@@ -0,0 +1,439 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class Payment < Dodopayments::BaseModel
+      # Identifier of the business associated with the payment
+      sig { returns(String) }
+      def business_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def business_id=(_)
+      end
+
+      # Timestamp when the payment was created
+      sig { returns(Time) }
+      def created_at
+      end
+
+      sig { params(_: Time).returns(Time) }
+      def created_at=(_)
+      end
+
+      sig { returns(Symbol) }
+      def currency
+      end
+
+      sig { params(_: Symbol).returns(Symbol) }
+      def currency=(_)
+      end
+
+      sig { returns(Dodopayments::Models::CustomerLimitedDetails) }
+      def customer
+      end
+
+      sig do
+        params(_: Dodopayments::Models::CustomerLimitedDetails)
+          .returns(Dodopayments::Models::CustomerLimitedDetails)
+      end
+      def customer=(_)
+      end
+
+      # List of disputes associated with this payment
+      sig { returns(T::Array[Dodopayments::Models::Dispute]) }
+      def disputes
+      end
+
+      sig { params(_: T::Array[Dodopayments::Models::Dispute]).returns(T::Array[Dodopayments::Models::Dispute]) }
+      def disputes=(_)
+      end
+
+      sig { returns(T::Hash[Symbol, String]) }
+      def metadata
+      end
+
+      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
+      def metadata=(_)
+      end
+
+      # Unique identifier for the payment
+      sig { returns(String) }
+      def payment_id
+      end
+
+      sig { params(_: String).returns(String) }
+      def payment_id=(_)
+      end
+
+      # List of refunds issued for this payment
+      sig { returns(T::Array[Dodopayments::Models::Refund]) }
+      def refunds
+      end
+
+      sig { params(_: T::Array[Dodopayments::Models::Refund]).returns(T::Array[Dodopayments::Models::Refund]) }
+      def refunds=(_)
+      end
+
+      # Total amount charged to the customer including tax, in smallest currency unit
+      #   (e.g. cents)
+      sig { returns(Integer) }
+      def total_amount
+      end
+
+      sig { params(_: Integer).returns(Integer) }
+      def total_amount=(_)
+      end
+
+      # The discount id if discount is applied
+      sig { returns(T.nilable(String)) }
+      def discount_id
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def discount_id=(_)
+      end
+
+      # An error message if the payment failed
+      sig { returns(T.nilable(String)) }
+      def error_message
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def error_message=(_)
+      end
+
+      # Checkout URL
+      sig { returns(T.nilable(String)) }
+      def payment_link
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def payment_link=(_)
+      end
+
+      # Payment method used by customer (e.g. "card", "bank_transfer")
+      sig { returns(T.nilable(String)) }
+      def payment_method
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def payment_method=(_)
+      end
+
+      # Specific type of payment method (e.g. "visa", "mastercard")
+      sig { returns(T.nilable(String)) }
+      def payment_method_type
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def payment_method_type=(_)
+      end
+
+      # List of products purchased in a one-time payment
+      sig { returns(T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart])) }
+      def product_cart
+      end
+
+      sig do
+        params(_: T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart]))
+          .returns(T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart]))
+      end
+      def product_cart=(_)
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def status
+      end
+
+      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
+      def status=(_)
+      end
+
+      # Identifier of the subscription if payment is part of a subscription
+      sig { returns(T.nilable(String)) }
+      def subscription_id
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def subscription_id=(_)
+      end
+
+      # Amount of tax collected in smallest currency unit (e.g. cents)
+      sig { returns(T.nilable(Integer)) }
+      def tax
+      end
+
+      sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
+      def tax=(_)
+      end
+
+      # Timestamp when the payment was last updated
+      sig { returns(T.nilable(Time)) }
+      def updated_at
+      end
+
+      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
+      def updated_at=(_)
+      end
+
+      sig do
+        params(
+          business_id: String,
+          created_at: Time,
+          currency: Symbol,
+          customer: Dodopayments::Models::CustomerLimitedDetails,
+          disputes: T::Array[Dodopayments::Models::Dispute],
+          metadata: T::Hash[Symbol, String],
+          payment_id: String,
+          refunds: T::Array[Dodopayments::Models::Refund],
+          total_amount: Integer,
+          discount_id: T.nilable(String),
+          error_message: T.nilable(String),
+          payment_link: T.nilable(String),
+          payment_method: T.nilable(String),
+          payment_method_type: T.nilable(String),
+          product_cart: T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart]),
+          status: T.nilable(Symbol),
+          subscription_id: T.nilable(String),
+          tax: T.nilable(Integer),
+          updated_at: T.nilable(Time)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        business_id:,
+        created_at:,
+        currency:,
+        customer:,
+        disputes:,
+        metadata:,
+        payment_id:,
+        refunds:,
+        total_amount:,
+        discount_id: nil,
+        error_message: nil,
+        payment_link: nil,
+        payment_method: nil,
+        payment_method_type: nil,
+        product_cart: nil,
+        status: nil,
+        subscription_id: nil,
+        tax: nil,
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              business_id: String,
+              created_at: Time,
+              currency: Symbol,
+              customer: Dodopayments::Models::CustomerLimitedDetails,
+              disputes: T::Array[Dodopayments::Models::Dispute],
+              metadata: T::Hash[Symbol, String],
+              payment_id: String,
+              refunds: T::Array[Dodopayments::Models::Refund],
+              total_amount: Integer,
+              discount_id: T.nilable(String),
+              error_message: T.nilable(String),
+              payment_link: T.nilable(String),
+              payment_method: T.nilable(String),
+              payment_method_type: T.nilable(String),
+              product_cart: T.nilable(T::Array[Dodopayments::Models::Payment::ProductCart]),
+              status: T.nilable(Symbol),
+              subscription_id: T.nilable(String),
+              tax: T.nilable(Integer),
+              updated_at: T.nilable(Time)
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Currency < Dodopayments::Enum
+        abstract!
+
+        AED = :AED
+        ALL = :ALL
+        AMD = :AMD
+        ANG = :ANG
+        AOA = :AOA
+        ARS = :ARS
+        AUD = :AUD
+        AWG = :AWG
+        AZN = :AZN
+        BAM = :BAM
+        BBD = :BBD
+        BDT = :BDT
+        BGN = :BGN
+        BHD = :BHD
+        BIF = :BIF
+        BMD = :BMD
+        BND = :BND
+        BOB = :BOB
+        BRL = :BRL
+        BSD = :BSD
+        BWP = :BWP
+        BYN = :BYN
+        BZD = :BZD
+        CAD = :CAD
+        CHF = :CHF
+        CLP = :CLP
+        CNY = :CNY
+        COP = :COP
+        CRC = :CRC
+        CUP = :CUP
+        CVE = :CVE
+        CZK = :CZK
+        DJF = :DJF
+        DKK = :DKK
+        DOP = :DOP
+        DZD = :DZD
+        EGP = :EGP
+        ETB = :ETB
+        EUR = :EUR
+        FJD = :FJD
+        FKP = :FKP
+        GBP = :GBP
+        GEL = :GEL
+        GHS = :GHS
+        GIP = :GIP
+        GMD = :GMD
+        GNF = :GNF
+        GTQ = :GTQ
+        GYD = :GYD
+        HKD = :HKD
+        HNL = :HNL
+        HRK = :HRK
+        HTG = :HTG
+        HUF = :HUF
+        IDR = :IDR
+        ILS = :ILS
+        INR = :INR
+        IQD = :IQD
+        JMD = :JMD
+        JOD = :JOD
+        JPY = :JPY
+        KES = :KES
+        KGS = :KGS
+        KHR = :KHR
+        KMF = :KMF
+        KRW = :KRW
+        KWD = :KWD
+        KYD = :KYD
+        KZT = :KZT
+        LAK = :LAK
+        LBP = :LBP
+        LKR = :LKR
+        LRD = :LRD
+        LSL = :LSL
+        LYD = :LYD
+        MAD = :MAD
+        MDL = :MDL
+        MGA = :MGA
+        MKD = :MKD
+        MMK = :MMK
+        MNT = :MNT
+        MOP = :MOP
+        MRU = :MRU
+        MUR = :MUR
+        MVR = :MVR
+        MWK = :MWK
+        MXN = :MXN
+        MYR = :MYR
+        MZN = :MZN
+        NAD = :NAD
+        NGN = :NGN
+        NIO = :NIO
+        NOK = :NOK
+        NPR = :NPR
+        NZD = :NZD
+        OMR = :OMR
+        PAB = :PAB
+        PEN = :PEN
+        PGK = :PGK
+        PHP = :PHP
+        PKR = :PKR
+        PLN = :PLN
+        PYG = :PYG
+        QAR = :QAR
+        RON = :RON
+        RSD = :RSD
+        RUB = :RUB
+        RWF = :RWF
+        SAR = :SAR
+        SBD = :SBD
+        SCR = :SCR
+        SEK = :SEK
+        SGD = :SGD
+        SHP = :SHP
+        SLE = :SLE
+        SLL = :SLL
+        SOS = :SOS
+        SRD = :SRD
+        SSP = :SSP
+        STN = :STN
+        SVC = :SVC
+        SZL = :SZL
+        THB = :THB
+        TND = :TND
+        TOP = :TOP
+        TRY = :TRY
+        TTD = :TTD
+        TWD = :TWD
+        TZS = :TZS
+        UAH = :UAH
+        UGX = :UGX
+        USD = :USD
+        UYU = :UYU
+        UZS = :UZS
+        VES = :VES
+        VND = :VND
+        VUV = :VUV
+        WST = :WST
+        XAF = :XAF
+        XCD = :XCD
+        XOF = :XOF
+        XPF = :XPF
+        YER = :YER
+        ZAR = :ZAR
+        ZMW = :ZMW
+
+        class << self
+          sig { override.returns(T::Array[Symbol]) }
+          def values
+          end
+        end
+      end
+
+      class ProductCart < Dodopayments::BaseModel
+        sig { returns(String) }
+        def product_id
+        end
+
+        sig { params(_: String).returns(String) }
+        def product_id=(_)
+        end
+
+        sig { returns(Integer) }
+        def quantity
+        end
+
+        sig { params(_: Integer).returns(Integer) }
+        def quantity=(_)
+        end
+
+        sig { params(product_id: String, quantity: Integer).returns(T.attached_class) }
+        def self.new(product_id:, quantity:)
+        end
+
+        sig { override.returns({product_id: String, quantity: Integer}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/dodopayments/models/payment_create_params.rbi

@@ -0,0 +1,133 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class PaymentCreateParams < Dodopayments::BaseModel
+      extend Dodopayments::RequestParameters::Converter
+      include Dodopayments::RequestParameters
+
+      sig { returns(Dodopayments::Models::BillingAddress) }
+      def billing
+      end
+
+      sig { params(_: Dodopayments::Models::BillingAddress).returns(Dodopayments::Models::BillingAddress) }
+      def billing=(_)
+      end
+
+      sig { returns(T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer)) }
+      def customer
+      end
+
+      sig do
+        params(_: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer))
+          .returns(T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer))
+      end
+      def customer=(_)
+      end
+
+      # List of products in the cart. Must contain at least 1 and at most 100 items.
+      sig { returns(T::Array[Dodopayments::Models::OneTimeProductCartItem]) }
+      def product_cart
+      end
+
+      sig do
+        params(_: T::Array[Dodopayments::Models::OneTimeProductCartItem])
+          .returns(T::Array[Dodopayments::Models::OneTimeProductCartItem])
+      end
+      def product_cart=(_)
+      end
+
+      # Discount Code to apply to the transaction
+      sig { returns(T.nilable(String)) }
+      def discount_code
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def discount_code=(_)
+      end
+
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      def metadata
+      end
+
+      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
+      def metadata=(_)
+      end
+
+      # Whether to generate a payment link. Defaults to false if not specified.
+      sig { returns(T.nilable(T::Boolean)) }
+      def payment_link
+      end
+
+      sig { params(_: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      def payment_link=(_)
+      end
+
+      # Optional URL to redirect the customer after payment. Must be a valid URL if
+      #   provided.
+      sig { returns(T.nilable(String)) }
+      def return_url
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def return_url=(_)
+      end
+
+      # Tax ID in case the payment is B2B. If tax id validation fails the payment
+      #   creation will fail
+      sig { returns(T.nilable(String)) }
+      def tax_id
+      end
+
+      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
+      def tax_id=(_)
+      end
+
+      sig do
+        params(
+          billing: Dodopayments::Models::BillingAddress,
+          customer: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer),
+          product_cart: T::Array[Dodopayments::Models::OneTimeProductCartItem],
+          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),
+          request_options: T.any(Dodopayments::RequestOptions, T::Hash[Symbol, T.anything])
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        billing:,
+        customer:,
+        product_cart:,
+        discount_code: nil,
+        metadata: nil,
+        payment_link: nil,
+        return_url: nil,
+        tax_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              billing: Dodopayments::Models::BillingAddress,
+              customer: T.any(Dodopayments::Models::AttachExistingCustomer, Dodopayments::Models::CreateNewCustomer),
+              product_cart: T::Array[Dodopayments::Models::OneTimeProductCartItem],
+              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),
+              request_options: Dodopayments::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end