dodopayments 1.51.1 → 1.52.4

data/rbi/dodopayments/models/event.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class Event < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::Event, Dodopayments::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      sig { returns(String) }
+      attr_accessor :customer_id
+
+      sig { returns(String) }
+      attr_accessor :event_id
+
+      sig { returns(String) }
+      attr_accessor :event_name
+
+      sig { returns(Time) }
+      attr_accessor :timestamp
+
+      # Arbitrary key-value metadata. Values can be string, integer, number, or boolean.
+      sig do
+        returns(
+          T.nilable(T::Hash[Symbol, Dodopayments::Event::Metadata::Variants])
+        )
+      end
+      attr_accessor :metadata
+
+      sig do
+        params(
+          business_id: String,
+          customer_id: String,
+          event_id: String,
+          event_name: String,
+          timestamp: Time,
+          metadata:
+            T.nilable(T::Hash[Symbol, Dodopayments::Event::Metadata::Variants])
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        business_id:,
+        customer_id:,
+        event_id:,
+        event_name:,
+        timestamp:,
+        # Arbitrary key-value metadata. Values can be string, integer, number, or boolean.
+        metadata: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            business_id: String,
+            customer_id: String,
+            event_id: String,
+            event_name: String,
+            timestamp: Time,
+            metadata:
+              T.nilable(
+                T::Hash[Symbol, Dodopayments::Event::Metadata::Variants]
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Metadata value can be a string, integer, number, or boolean
+      module Metadata
+        extend Dodopayments::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(String, Float, T::Boolean) }
+
+        sig do
+          override.returns(T::Array[Dodopayments::Event::Metadata::Variants])
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/event_input.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class EventInput < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::EventInput, Dodopayments::Internal::AnyHash)
+        end
+
+      # customer_id of the customer whose usage needs to be tracked
+      sig { returns(String) }
+      attr_accessor :customer_id
+
+      # Event Id acts as an idempotency key. Any subsequent requests with the same
+      # event_id will be ignored
+      sig { returns(String) }
+      attr_accessor :event_id
+
+      # Name of the event
+      sig { returns(String) }
+      attr_accessor :event_name
+
+      # Custom metadata. Only key value pairs are accepted, objects or arrays submitted
+      # will be rejected.
+      sig do
+        returns(
+          T.nilable(
+            T::Hash[Symbol, Dodopayments::EventInput::Metadata::Variants]
+          )
+        )
+      end
+      attr_accessor :metadata
+
+      # Custom Timestamp. Defaults to current timestamp in UTC. Timestamps that are
+      # older that 1 hour or after 5 mins, from current timestamp, will be rejected.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :timestamp
+
+      sig do
+        params(
+          customer_id: String,
+          event_id: String,
+          event_name: String,
+          metadata:
+            T.nilable(
+              T::Hash[Symbol, Dodopayments::EventInput::Metadata::Variants]
+            ),
+          timestamp: T.nilable(Time)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # customer_id of the customer whose usage needs to be tracked
+        customer_id:,
+        # Event Id acts as an idempotency key. Any subsequent requests with the same
+        # event_id will be ignored
+        event_id:,
+        # Name of the event
+        event_name:,
+        # Custom metadata. Only key value pairs are accepted, objects or arrays submitted
+        # will be rejected.
+        metadata: nil,
+        # Custom Timestamp. Defaults to current timestamp in UTC. Timestamps that are
+        # older that 1 hour or after 5 mins, from current timestamp, will be rejected.
+        timestamp: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            customer_id: String,
+            event_id: String,
+            event_name: String,
+            metadata:
+              T.nilable(
+                T::Hash[Symbol, Dodopayments::EventInput::Metadata::Variants]
+              ),
+            timestamp: T.nilable(Time)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Metadata value can be a string, integer, number, or boolean
+      module Metadata
+        extend Dodopayments::Internal::Type::Union
+
+        Variants = T.type_alias { T.any(String, Float, T::Boolean) }
+
+        sig do
+          override.returns(
+            T::Array[Dodopayments::EventInput::Metadata::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/invoices/payment_retrieve_refund_params.rbi

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

data/rbi/dodopayments/models/meter.rbi

@@ -0,0 +1,107 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class Meter < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::Meter, Dodopayments::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(Dodopayments::MeterAggregation) }
+      attr_reader :aggregation
+
+      sig { params(aggregation: Dodopayments::MeterAggregation::OrHash).void }
+      attr_writer :aggregation
+
+      sig { returns(String) }
+      attr_accessor :business_id
+
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      sig { returns(String) }
+      attr_accessor :event_name
+
+      sig { returns(String) }
+      attr_accessor :measurement_unit
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Time) }
+      attr_accessor :updated_at
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # A filter structure that combines multiple conditions with logical conjunctions
+      # (AND/OR).
+      #
+      # Supports up to 3 levels of nesting to create complex filter expressions. Each
+      # filter has a conjunction (and/or) and clauses that can be either direct
+      # conditions or nested filters.
+      sig { returns(T.nilable(Dodopayments::MeterFilter)) }
+      attr_reader :filter
+
+      sig { params(filter: T.nilable(Dodopayments::MeterFilter::OrHash)).void }
+      attr_writer :filter
+
+      sig do
+        params(
+          id: String,
+          aggregation: Dodopayments::MeterAggregation::OrHash,
+          business_id: String,
+          created_at: Time,
+          event_name: String,
+          measurement_unit: String,
+          name: String,
+          updated_at: Time,
+          description: T.nilable(String),
+          filter: T.nilable(Dodopayments::MeterFilter::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        aggregation:,
+        business_id:,
+        created_at:,
+        event_name:,
+        measurement_unit:,
+        name:,
+        updated_at:,
+        description: nil,
+        # A filter structure that combines multiple conditions with logical conjunctions
+        # (AND/OR).
+        #
+        # Supports up to 3 levels of nesting to create complex filter expressions. Each
+        # filter has a conjunction (and/or) and clauses that can be either direct
+        # conditions or nested filters.
+        filter: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            aggregation: Dodopayments::MeterAggregation,
+            business_id: String,
+            created_at: Time,
+            event_name: String,
+            measurement_unit: String,
+            name: String,
+            updated_at: Time,
+            description: T.nilable(String),
+            filter: T.nilable(Dodopayments::MeterFilter)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/meter_aggregation.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class MeterAggregation < Dodopayments::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Dodopayments::MeterAggregation, Dodopayments::Internal::AnyHash)
+        end
+
+      # Aggregation type for the meter
+      sig { returns(Dodopayments::MeterAggregation::Type::OrSymbol) }
+      attr_accessor :type
+
+      # Required when type is not COUNT
+      sig { returns(T.nilable(String)) }
+      attr_accessor :key
+
+      sig do
+        params(
+          type: Dodopayments::MeterAggregation::Type::OrSymbol,
+          key: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Aggregation type for the meter
+        type:,
+        # Required when type is not COUNT
+        key: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            type: Dodopayments::MeterAggregation::Type::OrSymbol,
+            key: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Aggregation type for the meter
+      module Type
+        extend Dodopayments::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Dodopayments::MeterAggregation::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        COUNT =
+          T.let(:count, Dodopayments::MeterAggregation::Type::TaggedSymbol)
+        SUM = T.let(:sum, Dodopayments::MeterAggregation::Type::TaggedSymbol)
+        UNIQUE_COUNT =
+          T.let(
+            :unique_count,
+            Dodopayments::MeterAggregation::Type::TaggedSymbol
+          )
+        MAX = T.let(:max, Dodopayments::MeterAggregation::Type::TaggedSymbol)
+        LAST = T.let(:last, Dodopayments::MeterAggregation::Type::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Dodopayments::MeterAggregation::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/dodopayments/models/meter_archive_params.rbi

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

data/rbi/dodopayments/models/meter_create_params.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Dodopayments
+  module Models
+    class MeterCreateParams < Dodopayments::Internal::Type::BaseModel
+      extend Dodopayments::Internal::Type::RequestParameters::Converter
+      include Dodopayments::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Dodopayments::MeterCreateParams,
+            Dodopayments::Internal::AnyHash
+          )
+        end
+
+      # Aggregation configuration for the meter
+      sig { returns(Dodopayments::MeterAggregation) }
+      attr_reader :aggregation
+
+      sig { params(aggregation: Dodopayments::MeterAggregation::OrHash).void }
+      attr_writer :aggregation
+
+      # Event name to track
+      sig { returns(String) }
+      attr_accessor :event_name
+
+      # measurement unit
+      sig { returns(String) }
+      attr_accessor :measurement_unit
+
+      # Name of the meter
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Optional description of the meter
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # Optional filter to apply to the meter
+      sig { returns(T.nilable(Dodopayments::MeterFilter)) }
+      attr_reader :filter
+
+      sig { params(filter: T.nilable(Dodopayments::MeterFilter::OrHash)).void }
+      attr_writer :filter
+
+      sig do
+        params(
+          aggregation: Dodopayments::MeterAggregation::OrHash,
+          event_name: String,
+          measurement_unit: String,
+          name: String,
+          description: T.nilable(String),
+          filter: T.nilable(Dodopayments::MeterFilter::OrHash),
+          request_options: Dodopayments::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Aggregation configuration for the meter
+        aggregation:,
+        # Event name to track
+        event_name:,
+        # measurement unit
+        measurement_unit:,
+        # Name of the meter
+        name:,
+        # Optional description of the meter
+        description: nil,
+        # Optional filter to apply to the meter
+        filter: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            aggregation: Dodopayments::MeterAggregation,
+            event_name: String,
+            measurement_unit: String,
+            name: String,
+            description: T.nilable(String),
+            filter: T.nilable(Dodopayments::MeterFilter),
+            request_options: Dodopayments::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end