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

data/rbi/lib/modern_treasury/models/document.rbi

@@ -4,122 +4,70 @@ module ModernTreasury
   module Models
     class Document < 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
 
       sig { returns(T.nilable(Time)) }
-      def discarded_at
-      end
-
-      sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-      def discarded_at=(_)
-      end
+      attr_accessor :discarded_at
 
       sig { returns(T::Array[ModernTreasury::Models::Document::DocumentDetail]) }
-      def document_details
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::Document::DocumentDetail])
-          .returns(T::Array[ModernTreasury::Models::Document::DocumentDetail])
-      end
-      def document_details=(_)
-      end
+      attr_accessor :document_details
 
+      # A category given to the document, can be `null`.
       sig { returns(T.nilable(String)) }
-      def document_type
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def document_type=(_)
-      end
+      attr_accessor :document_type
 
+      # The unique identifier for the associated object.
       sig { returns(String) }
-      def documentable_id
-      end
+      attr_accessor :documentable_id
 
-      sig { params(_: String).returns(String) }
-      def documentable_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def documentable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def documentable_type=(_)
-      end
+      # The type of the associated object. Currently can be one of `payment_order`,
+      #   `transaction`, `paper_item`, `expected_payment`, `counterparty`, `organization`,
+      #   `case`, `internal_account`, `decision`, or `external_account`.
+      sig { returns(ModernTreasury::Models::Document::DocumentableType::TaggedSymbol) }
+      attr_accessor :documentable_type
 
       sig { returns(ModernTreasury::Models::Document::File) }
-      def file
-      end
+      attr_reader :file
 
-      sig { params(_: ModernTreasury::Models::Document::File).returns(ModernTreasury::Models::Document::File) }
-      def file=(_)
-      end
+      sig { params(file: T.any(ModernTreasury::Models::Document::File, ModernTreasury::Util::AnyHash)).void }
+      attr_writer :file
 
+      # 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
 
+      # The source of the document. Can be `vendor`, `customer`, or `modern_treasury`.
       sig { returns(String) }
-      def source
-      end
-
-      sig { params(_: String).returns(String) }
-      def source=(_)
-      end
+      attr_accessor :source
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
       sig do
         params(
           id: String,
           created_at: Time,
           discarded_at: T.nilable(Time),
-          document_details: T::Array[ModernTreasury::Models::Document::DocumentDetail],
+          document_details: T::Array[T.any(ModernTreasury::Models::Document::DocumentDetail, ModernTreasury::Util::AnyHash)],
           document_type: T.nilable(String),
           documentable_id: String,
-          documentable_type: Symbol,
-          file: ModernTreasury::Models::Document::File,
+          documentable_type: ModernTreasury::Models::Document::DocumentableType::OrSymbol,
+          file: T.any(ModernTreasury::Models::Document::File, ModernTreasury::Util::AnyHash),
           live_mode: T::Boolean,
           object: String,
           source: String,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         created_at:,
         discarded_at:,
@@ -145,7 +93,7 @@ module ModernTreasury
               document_details: T::Array[ModernTreasury::Models::Document::DocumentDetail],
               document_type: T.nilable(String),
               documentable_id: String,
-              documentable_type: Symbol,
+              documentable_type: ModernTreasury::Models::Document::DocumentableType::TaggedSymbol,
               file: ModernTreasury::Models::Document::File,
               live_mode: T::Boolean,
               object: String,
@@ -159,68 +107,30 @@ module ModernTreasury
 
       class DocumentDetail < 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
 
         sig { returns(T.nilable(Time)) }
-        def discarded_at
-        end
-
-        sig { params(_: T.nilable(Time)).returns(T.nilable(Time)) }
-        def discarded_at=(_)
-        end
+        attr_accessor :discarded_at
 
         sig { returns(String) }
-        def document_identifier
-        end
-
-        sig { params(_: String).returns(String) }
-        def document_identifier=(_)
-        end
+        attr_accessor :document_identifier
 
         sig { returns(String) }
-        def document_identifier_type
-        end
-
-        sig { params(_: String).returns(String) }
-        def document_identifier_type=(_)
-        end
+        attr_accessor :document_identifier_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
 
         sig { returns(Time) }
-        def updated_at
-        end
-
-        sig { params(_: Time).returns(Time) }
-        def updated_at=(_)
-        end
+        attr_accessor :updated_at
 
         sig do
           params(
@@ -233,9 +143,9 @@ module ModernTreasury
             object: String,
             updated_at: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           created_at:,
           discarded_at:,
@@ -266,54 +176,62 @@ module ModernTreasury
         end
       end
 
-      class DocumentableType < ModernTreasury::Enum
-        abstract!
-
-        CASE = :case
-        COUNTERPARTY = :counterparty
-        EXPECTED_PAYMENT = :expected_payment
-        EXTERNAL_ACCOUNT = :external_account
-        INCOMING_PAYMENT_DETAIL = :incoming_payment_detail
-        INTERNAL_ACCOUNT = :internal_account
-        ORGANIZATION = :organization
-        PAPER_ITEM = :paper_item
-        PAYMENT_ORDER = :payment_order
-        TRANSACTION = :transaction
-        DECISION = :decision
-        CONNECTION = :connection
-
-        sig { override.returns(T::Array[Symbol]) }
+      # The type of the associated object. Currently can be one of `payment_order`,
+      #   `transaction`, `paper_item`, `expected_payment`, `counterparty`, `organization`,
+      #   `case`, `internal_account`, `decision`, or `external_account`.
+      module DocumentableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Document::DocumentableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol) }
+
+        CASE = T.let(:case, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        COUNTERPARTY = T.let(:counterparty, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        EXPECTED_PAYMENT =
+          T.let(:expected_payment, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        EXTERNAL_ACCOUNT =
+          T.let(:external_account, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        INCOMING_PAYMENT_DETAIL =
+          T.let(:incoming_payment_detail, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        INTERNAL_ACCOUNT =
+          T.let(:internal_account, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        ORGANIZATION = T.let(:organization, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        PAPER_ITEM = T.let(:paper_item, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        PAYMENT_ORDER = T.let(:payment_order, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        TRANSACTION = T.let(:transaction, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        DECISION = T.let(:decision, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+        CONNECTION = T.let(:connection, ModernTreasury::Models::Document::DocumentableType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Document::DocumentableType::TaggedSymbol]) }
         def self.values
         end
       end
 
       class File < ModernTreasury::BaseModel
+        # The MIME content type of the document.
         sig { returns(T.nilable(String)) }
-        def content_type
-        end
+        attr_reader :content_type
 
-        sig { params(_: String).returns(String) }
-        def content_type=(_)
-        end
+        sig { params(content_type: String).void }
+        attr_writer :content_type
 
+        # The original filename of the document.
         sig { returns(T.nilable(String)) }
-        def filename
-        end
+        attr_reader :filename
 
-        sig { params(_: String).returns(String) }
-        def filename=(_)
-        end
+        sig { params(filename: String).void }
+        attr_writer :filename
 
+        # The size of the document in bytes.
         sig { returns(T.nilable(Integer)) }
-        def size
-        end
+        attr_reader :size
 
-        sig { params(_: Integer).returns(Integer) }
-        def size=(_)
-        end
+        sig { params(size: Integer).void }
+        attr_writer :size
 
-        sig { params(content_type: String, filename: String, size: Integer).void }
-        def initialize(content_type: nil, filename: nil, size: nil)
+        sig { params(content_type: String, filename: String, size: Integer).returns(T.attached_class) }
+        def self.new(content_type: nil, filename: nil, size: nil)
         end
 
         sig { override.returns({content_type: String, filename: String, size: Integer}) }

data/rbi/lib/modern_treasury/models/document_create_params.rbi

@@ -6,49 +6,34 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # The unique identifier for the associated object.
       sig { returns(String) }
-      def documentable_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def documentable_id=(_)
-      end
+      attr_accessor :documentable_id
 
-      sig { returns(Symbol) }
-      def documentable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def documentable_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::DocumentCreateParams::DocumentableType::OrSymbol) }
+      attr_accessor :documentable_type
 
       sig { returns(T.any(IO, StringIO)) }
-      def file
-      end
-
-      sig { params(_: T.any(IO, StringIO)).returns(T.any(IO, StringIO)) }
-      def file=(_)
-      end
+      attr_accessor :file
 
+      # A category given to the document, can be `null`.
       sig { returns(T.nilable(String)) }
-      def document_type
-      end
+      attr_reader :document_type
 
-      sig { params(_: String).returns(String) }
-      def document_type=(_)
-      end
+      sig { params(document_type: String).void }
+      attr_writer :document_type
 
       sig do
         params(
           documentable_id: String,
-          documentable_type: Symbol,
+          documentable_type: ModernTreasury::Models::DocumentCreateParams::DocumentableType::OrSymbol,
           file: T.any(IO, StringIO),
           document_type: String,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(documentable_id:, documentable_type:, file:, document_type: nil, request_options: {})
+      def self.new(documentable_id:, documentable_type:, file:, document_type: nil, request_options: {})
       end
 
       sig do
@@ -56,7 +41,7 @@ module ModernTreasury
           .returns(
             {
               documentable_id: String,
-              documentable_type: Symbol,
+              documentable_type: ModernTreasury::Models::DocumentCreateParams::DocumentableType::OrSymbol,
               file: T.any(IO, StringIO),
               document_type: String,
               request_options: ModernTreasury::RequestOptions
@@ -66,23 +51,42 @@ module ModernTreasury
       def to_hash
       end
 
-      class DocumentableType < ModernTreasury::Enum
-        abstract!
+      module DocumentableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::DocumentCreateParams::DocumentableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol) }
 
-        CASES = :cases
-        COUNTERPARTIES = :counterparties
-        EXPECTED_PAYMENTS = :expected_payments
-        EXTERNAL_ACCOUNTS = :external_accounts
-        INCOMING_PAYMENT_DETAILS = :incoming_payment_details
-        INTERNAL_ACCOUNTS = :internal_accounts
-        ORGANIZATIONS = :organizations
-        PAPER_ITEMS = :paper_items
-        PAYMENT_ORDERS = :payment_orders
-        TRANSACTIONS = :transactions
-        DECISIONS = :decisions
-        CONNECTIONS = :connections
+        CASES = T.let(:cases, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        COUNTERPARTIES =
+          T.let(:counterparties, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        EXPECTED_PAYMENTS =
+          T.let(:expected_payments, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        EXTERNAL_ACCOUNTS =
+          T.let(:external_accounts, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        INCOMING_PAYMENT_DETAILS =
+          T.let(
+            :incoming_payment_details,
+            ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol
+          )
+        INTERNAL_ACCOUNTS =
+          T.let(:internal_accounts, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        ORGANIZATIONS =
+          T.let(:organizations, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        PAPER_ITEMS =
+          T.let(:paper_items, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        PAYMENT_ORDERS =
+          T.let(:payment_orders, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        TRANSACTIONS =
+          T.let(:transactions, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        DECISIONS =
+          T.let(:decisions, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
+        CONNECTIONS =
+          T.let(:connections, ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::DocumentCreateParams::DocumentableType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/document_list_params.rbi

@@ -7,54 +7,41 @@ module ModernTreasury
       include ModernTreasury::RequestParameters
 
       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
 
+      # The unique identifier for the associated object.
       sig { returns(T.nilable(String)) }
-      def documentable_id
-      end
+      attr_reader :documentable_id
 
-      sig { params(_: String).returns(String) }
-      def documentable_id=(_)
-      end
+      sig { params(documentable_id: String).void }
+      attr_writer :documentable_id
 
-      sig { returns(T.nilable(Symbol)) }
-      def documentable_type
-      end
+      # The type of the associated object. Currently can be one of `payment_order`,
+      #   `transaction`, `paper_item`, `expected_payment`, `counterparty`, `organization`,
+      #   `case`, `internal_account`, `decision`, or `external_account`.
+      sig { returns(T.nilable(ModernTreasury::Models::DocumentListParams::DocumentableType::OrSymbol)) }
+      attr_reader :documentable_type
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def documentable_type=(_)
-      end
+      sig { params(documentable_type: ModernTreasury::Models::DocumentListParams::DocumentableType::OrSymbol).void }
+      attr_writer :documentable_type
 
       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 do
         params(
           after_cursor: T.nilable(String),
           documentable_id: String,
-          documentable_type: Symbol,
+          documentable_type: ModernTreasury::Models::DocumentListParams::DocumentableType::OrSymbol,
           per_page: Integer,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
-        after_cursor: nil,
-        documentable_id: nil,
-        documentable_type: nil,
-        per_page: nil,
-        request_options: {}
-      )
+      def self.new(after_cursor: nil, documentable_id: nil, documentable_type: nil, per_page: nil, request_options: {})
       end
 
       sig do
@@ -63,7 +50,7 @@ module ModernTreasury
             {
               after_cursor: T.nilable(String),
               documentable_id: String,
-              documentable_type: Symbol,
+              documentable_type: ModernTreasury::Models::DocumentListParams::DocumentableType::OrSymbol,
               per_page: Integer,
               request_options: ModernTreasury::RequestOptions
             }
@@ -72,23 +59,44 @@ module ModernTreasury
       def to_hash
       end
 
-      class DocumentableType < ModernTreasury::Enum
-        abstract!
+      # The type of the associated object. Currently can be one of `payment_order`,
+      #   `transaction`, `paper_item`, `expected_payment`, `counterparty`, `organization`,
+      #   `case`, `internal_account`, `decision`, or `external_account`.
+      module DocumentableType
+        extend ModernTreasury::Enum
 
-        CASES = :cases
-        COUNTERPARTIES = :counterparties
-        EXPECTED_PAYMENTS = :expected_payments
-        EXTERNAL_ACCOUNTS = :external_accounts
-        INCOMING_PAYMENT_DETAILS = :incoming_payment_details
-        INTERNAL_ACCOUNTS = :internal_accounts
-        ORGANIZATIONS = :organizations
-        PAPER_ITEMS = :paper_items
-        PAYMENT_ORDERS = :payment_orders
-        TRANSACTIONS = :transactions
-        DECISIONS = :decisions
-        CONNECTIONS = :connections
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::DocumentListParams::DocumentableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol) }
+
+        CASES = T.let(:cases, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        COUNTERPARTIES =
+          T.let(:counterparties, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        EXPECTED_PAYMENTS =
+          T.let(:expected_payments, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        EXTERNAL_ACCOUNTS =
+          T.let(:external_accounts, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        INCOMING_PAYMENT_DETAILS =
+          T.let(
+            :incoming_payment_details,
+            ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol
+          )
+        INTERNAL_ACCOUNTS =
+          T.let(:internal_accounts, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        ORGANIZATIONS =
+          T.let(:organizations, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        PAPER_ITEMS =
+          T.let(:paper_items, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        PAYMENT_ORDERS =
+          T.let(:payment_orders, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        TRANSACTIONS =
+          T.let(:transactions, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        DECISIONS = T.let(:decisions, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
+        CONNECTIONS =
+          T.let(:connections, ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::DocumentListParams::DocumentableType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/document_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}) }