modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.16

data/rbi/lib/modern_treasury/models/bulk_request_list_params.rbi

@@ -6,67 +6,58 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(T.nilable(Symbol)) }
-      def action_type
-      end
+      # One of create, or update.
+      sig { returns(T.nilable(ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol)) }
+      attr_reader :action_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def action_type=(_)
-      end
+      sig { params(action_type: ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol).void }
+      attr_writer :action_type
 
       sig { returns(T.nilable(String)) }
-      def after_cursor
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def after_cursor=(_)
-      end
+      attr_accessor :after_cursor
 
+      # For example, if you want to query for records with metadata key `Type` and value
+      #   `Loan`, the query would be `metadata%5BType%5D=Loan`. This encodes the query
+      #   parameters.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
+      attr_reader :metadata
 
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      sig { params(metadata: T::Hash[Symbol, String]).void }
+      attr_writer :metadata
 
       sig { returns(T.nilable(Integer)) }
-      def per_page
-      end
+      attr_reader :per_page
 
-      sig { params(_: Integer).returns(Integer) }
-      def per_page=(_)
-      end
+      sig { params(per_page: Integer).void }
+      attr_writer :per_page
 
-      sig { returns(T.nilable(Symbol)) }
-      def resource_type
-      end
+      # One of payment_order, expected_payment, or ledger_transaction.
+      sig { returns(T.nilable(ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol)) }
+      attr_reader :resource_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def resource_type=(_)
-      end
+      sig { params(resource_type: ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol).void }
+      attr_writer :resource_type
 
-      sig { returns(T.nilable(Symbol)) }
-      def status
-      end
+      # One of pending, processing, or completed.
+      sig { returns(T.nilable(ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol)) }
+      attr_reader :status
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      sig { params(status: ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol).void }
+      attr_writer :status
 
       sig do
         params(
-          action_type: Symbol,
+          action_type: ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol,
           after_cursor: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          resource_type: Symbol,
-          status: Symbol,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          resource_type: ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol,
+          status: ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol,
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         action_type: nil,
         after_cursor: nil,
         metadata: nil,
@@ -81,12 +72,12 @@ module ModernTreasury
         override
           .returns(
             {
-              action_type: Symbol,
+              action_type: ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol,
               after_cursor: T.nilable(String),
               metadata: T::Hash[Symbol, String],
               per_page: Integer,
-              resource_type: Symbol,
-              status: Symbol,
+              resource_type: ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol,
+              status: ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol,
               request_options: ModernTreasury::RequestOptions
             }
           )
@@ -94,39 +85,59 @@ module ModernTreasury
       def to_hash
       end
 
-      class ActionType < ModernTreasury::Enum
-        abstract!
+      # One of create, or update.
+      module ActionType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkRequestListParams::ActionType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkRequestListParams::ActionType::TaggedSymbol) }
 
-        CREATE = :create
-        UPDATE = :update
-        DELETE = :delete
+        CREATE = T.let(:create, ModernTreasury::Models::BulkRequestListParams::ActionType::TaggedSymbol)
+        UPDATE = T.let(:update, ModernTreasury::Models::BulkRequestListParams::ActionType::TaggedSymbol)
+        DELETE = T.let(:delete, ModernTreasury::Models::BulkRequestListParams::ActionType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkRequestListParams::ActionType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class ResourceType < ModernTreasury::Enum
-        abstract!
+      # One of payment_order, expected_payment, or ledger_transaction.
+      module ResourceType
+        extend ModernTreasury::Enum
 
-        PAYMENT_ORDER = :payment_order
-        LEDGER_TRANSACTION = :ledger_transaction
-        TRANSACTION = :transaction
-        EXPECTED_PAYMENT = :expected_payment
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkRequestListParams::ResourceType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        PAYMENT_ORDER =
+          T.let(:payment_order, ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol)
+        LEDGER_TRANSACTION =
+          T.let(:ledger_transaction, ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol)
+        TRANSACTION =
+          T.let(:transaction, ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol)
+        EXPECTED_PAYMENT =
+          T.let(:expected_payment, ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkRequestListParams::ResourceType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # One of pending, processing, or completed.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkRequestListParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkRequestListParams::Status::TaggedSymbol) }
 
-        PENDING = :pending
-        PROCESSING = :processing
-        COMPLETED = :completed
+        PENDING = T.let(:pending, ModernTreasury::Models::BulkRequestListParams::Status::TaggedSymbol)
+        PROCESSING = T.let(:processing, ModernTreasury::Models::BulkRequestListParams::Status::TaggedSymbol)
+        COMPLETED = T.let(:completed, ModernTreasury::Models::BulkRequestListParams::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkRequestListParams::Status::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/bulk_request_retrieve_params.rbi

@@ -6,8 +6,11 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { params(request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])).void }
-      def initialize(request_options: {})
+      sig do
+        params(request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(request_options: {})
       end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }

data/rbi/lib/modern_treasury/models/bulk_result.rbi

@@ -4,21 +4,14 @@ module ModernTreasury
   module Models
     class BulkResult < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # An object with type as indicated by `entity_type`. This is the result object
+      #   that is generated by performing the requested action on the provided input
+      #   `request_params`.
       sig do
         returns(
           T.any(
@@ -30,103 +23,48 @@ module ModernTreasury
           )
         )
       end
-      def entity
-      end
-
-      sig do
-        params(
-          _: T.any(
-            ModernTreasury::Models::PaymentOrder,
-            ModernTreasury::Models::ExpectedPayment,
-            ModernTreasury::Models::LedgerTransaction,
-            ModernTreasury::Models::Transaction,
-            ModernTreasury::Models::BulkResult::Entity::BulkError
-          )
-        )
-          .returns(
-            T.any(
-              ModernTreasury::Models::PaymentOrder,
-              ModernTreasury::Models::ExpectedPayment,
-              ModernTreasury::Models::LedgerTransaction,
-              ModernTreasury::Models::Transaction,
-              ModernTreasury::Models::BulkResult::Entity::BulkError
-            )
-          )
-      end
-      def entity=(_)
-      end
+      attr_accessor :entity
 
+      # Unique identifier for the result entity object.
       sig { returns(String) }
-      def entity_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def entity_id=(_)
-      end
+      attr_accessor :entity_id
 
-      sig { returns(Symbol) }
-      def entity_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def entity_type=(_)
-      end
+      # The type of the result entity object. For a successful bulk result, this is the
+      #   same as the `resource_type` of the bulk request. For a failed bulk result, this
+      #   is always bulk_error
+      sig { returns(ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol) }
+      attr_accessor :entity_type
 
+      # This field will be true if this object exists in the live environment or false
+      #   if it exists in the test environment.
       sig { returns(T::Boolean) }
-      def live_mode
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def live_mode=(_)
-      end
+      attr_accessor :live_mode
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # Unique identifier for the request that created this bulk result. This is the ID
+      #   of the bulk request when `request_type` is bulk_request
       sig { returns(String) }
-      def request_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def request_id=(_)
-      end
+      attr_accessor :request_id
 
+      # An optional object that contains the provided input params for the request that
+      #   created this result. This is an item in the `resources` array for the
+      #   bulk_request
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def request_params
-      end
-
-      sig { params(_: T.nilable(T::Hash[Symbol, String])).returns(T.nilable(T::Hash[Symbol, String])) }
-      def request_params=(_)
-      end
-
-      sig { returns(Symbol) }
-      def request_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def request_type=(_)
-      end
+      attr_accessor :request_params
 
-      sig { returns(Symbol) }
-      def status
-      end
+      # The type of the request that created this result. bulk_request is the only
+      #   supported `request_type`
+      sig { returns(ModernTreasury::Models::BulkResult::RequestType::TaggedSymbol) }
+      attr_accessor :request_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      # One of successful or failed.
+      sig { returns(ModernTreasury::Models::BulkResult::Status::TaggedSymbol) }
+      attr_accessor :status
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
@@ -134,24 +72,25 @@ module ModernTreasury
           created_at: Time,
           entity: T.any(
             ModernTreasury::Models::PaymentOrder,
+            ModernTreasury::Util::AnyHash,
             ModernTreasury::Models::ExpectedPayment,
             ModernTreasury::Models::LedgerTransaction,
             ModernTreasury::Models::Transaction,
             ModernTreasury::Models::BulkResult::Entity::BulkError
           ),
           entity_id: String,
-          entity_type: Symbol,
+          entity_type: ModernTreasury::Models::BulkResult::EntityType::OrSymbol,
           live_mode: T::Boolean,
           object: String,
           request_id: String,
           request_params: T.nilable(T::Hash[Symbol, String]),
-          request_type: Symbol,
-          status: Symbol,
+          request_type: ModernTreasury::Models::BulkResult::RequestType::OrSymbol,
+          status: ModernTreasury::Models::BulkResult::Status::OrSymbol,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         created_at:,
         entity:,
@@ -181,13 +120,13 @@ module ModernTreasury
                 ModernTreasury::Models::BulkResult::Entity::BulkError
               ),
               entity_id: String,
-              entity_type: Symbol,
+              entity_type: ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol,
               live_mode: T::Boolean,
               object: String,
               request_id: String,
               request_params: T.nilable(T::Hash[Symbol, String]),
-              request_type: Symbol,
-              status: Symbol,
+              request_type: ModernTreasury::Models::BulkResult::RequestType::TaggedSymbol,
+              status: ModernTreasury::Models::BulkResult::Status::TaggedSymbol,
               updated_at: Time
             }
           )
@@ -195,60 +134,32 @@ module ModernTreasury
       def to_hash
       end
 
-      class Entity < ModernTreasury::Union
-        abstract!
+      # An object with type as indicated by `entity_type`. This is the result object
+      #   that is generated by performing the requested action on the provided input
+      #   `request_params`.
+      module Entity
+        extend ModernTreasury::Union
 
         class BulkError < ModernTreasury::BaseModel
           sig { returns(String) }
-          def id
-          end
-
-          sig { params(_: String).returns(String) }
-          def id=(_)
-          end
+          attr_accessor :id
 
           sig { returns(Time) }
-          def created_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def created_at=(_)
-          end
+          attr_accessor :created_at
 
+          # This field will be true if this object exists in the live environment or false
+          #   if it exists in the test environment.
           sig { returns(T::Boolean) }
-          def live_mode
-          end
-
-          sig { params(_: T::Boolean).returns(T::Boolean) }
-          def live_mode=(_)
-          end
+          attr_accessor :live_mode
 
           sig { returns(String) }
-          def object
-          end
-
-          sig { params(_: String).returns(String) }
-          def object=(_)
-          end
+          attr_accessor :object
 
           sig { returns(T::Array[ModernTreasury::Models::BulkResult::Entity::BulkError::RequestError]) }
-          def request_errors
-          end
-
-          sig do
-            params(_: T::Array[ModernTreasury::Models::BulkResult::Entity::BulkError::RequestError])
-              .returns(T::Array[ModernTreasury::Models::BulkResult::Entity::BulkError::RequestError])
-          end
-          def request_errors=(_)
-          end
+          attr_accessor :request_errors
 
           sig { returns(Time) }
-          def updated_at
-          end
-
-          sig { params(_: Time).returns(Time) }
-          def updated_at=(_)
-          end
+          attr_accessor :updated_at
 
           sig do
             params(
@@ -256,12 +167,12 @@ module ModernTreasury
               created_at: Time,
               live_mode: T::Boolean,
               object: String,
-              request_errors: T::Array[ModernTreasury::Models::BulkResult::Entity::BulkError::RequestError],
+              request_errors: T::Array[T.any(ModernTreasury::Models::BulkResult::Entity::BulkError::RequestError, ModernTreasury::Util::AnyHash)],
               updated_at: Time
             )
-              .void
+              .returns(T.attached_class)
           end
-          def initialize(id:, created_at:, live_mode:, object:, request_errors:, updated_at:)
+          def self.new(id:, created_at:, live_mode:, object:, request_errors:, updated_at:)
           end
 
           sig do
@@ -282,31 +193,25 @@ module ModernTreasury
 
           class RequestError < ModernTreasury::BaseModel
             sig { returns(T.nilable(String)) }
-            def code
-            end
+            attr_reader :code
 
-            sig { params(_: String).returns(String) }
-            def code=(_)
-            end
+            sig { params(code: String).void }
+            attr_writer :code
 
             sig { returns(T.nilable(String)) }
-            def message
-            end
+            attr_reader :message
 
-            sig { params(_: String).returns(String) }
-            def message=(_)
-            end
+            sig { params(message: String).void }
+            attr_writer :message
 
             sig { returns(T.nilable(String)) }
-            def parameter
-            end
+            attr_reader :parameter
 
-            sig { params(_: String).returns(String) }
-            def parameter=(_)
-            end
+            sig { params(parameter: String).void }
+            attr_writer :parameter
 
-            sig { params(code: String, message: String, parameter: String).void }
-            def initialize(code: nil, message: nil, parameter: nil)
+            sig { params(code: String, message: String, parameter: String).returns(T.attached_class) }
+            def self.new(code: nil, message: nil, parameter: nil)
             end
 
             sig { override.returns({code: String, message: String, parameter: String}) }
@@ -318,45 +223,61 @@ module ModernTreasury
         sig do
           override
             .returns(
-              [[NilClass, ModernTreasury::Models::PaymentOrder], [NilClass, ModernTreasury::Models::ExpectedPayment], [NilClass, ModernTreasury::Models::LedgerTransaction], [NilClass, ModernTreasury::Models::Transaction], [NilClass, ModernTreasury::Models::BulkResult::Entity::BulkError]]
+              [ModernTreasury::Models::PaymentOrder, ModernTreasury::Models::ExpectedPayment, ModernTreasury::Models::LedgerTransaction, ModernTreasury::Models::Transaction, ModernTreasury::Models::BulkResult::Entity::BulkError]
             )
         end
-        private_class_method def self.variants
+        def self.variants
         end
       end
 
-      class EntityType < ModernTreasury::Enum
-        abstract!
+      # The type of the result entity object. For a successful bulk result, this is the
+      #   same as the `resource_type` of the bulk request. For a failed bulk result, this
+      #   is always bulk_error
+      module EntityType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkResult::EntityType) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol) }
 
-        PAYMENT_ORDER = :payment_order
-        LEDGER_TRANSACTION = :ledger_transaction
-        TRANSACTION = :transaction
-        EXPECTED_PAYMENT = :expected_payment
-        BULK_ERROR = :bulk_error
+        PAYMENT_ORDER = T.let(:payment_order, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol)
+        LEDGER_TRANSACTION =
+          T.let(:ledger_transaction, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol)
+        TRANSACTION = T.let(:transaction, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol)
+        EXPECTED_PAYMENT = T.let(:expected_payment, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol)
+        BULK_ERROR = T.let(:bulk_error, ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkResult::EntityType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class RequestType < ModernTreasury::Enum
-        abstract!
+      # The type of the request that created this result. bulk_request is the only
+      #   supported `request_type`
+      module RequestType
+        extend ModernTreasury::Enum
 
-        BULK_REQUEST = :bulk_request
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkResult::RequestType) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkResult::RequestType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
+        BULK_REQUEST = T.let(:bulk_request, ModernTreasury::Models::BulkResult::RequestType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkResult::RequestType::TaggedSymbol]) }
         def self.values
         end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # One of successful or failed.
+      module Status
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::BulkResult::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::BulkResult::Status::TaggedSymbol) }
 
-        PENDING = :pending
-        SUCCESSFUL = :successful
-        FAILED = :failed
+        PENDING = T.let(:pending, ModernTreasury::Models::BulkResult::Status::TaggedSymbol)
+        SUCCESSFUL = T.let(:successful, ModernTreasury::Models::BulkResult::Status::TaggedSymbol)
+        FAILED = T.let(:failed, ModernTreasury::Models::BulkResult::Status::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::BulkResult::Status::TaggedSymbol]) }
         def self.values
         end
       end