modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/models/invoice.rbi

@@ -2,338 +2,216 @@
 
 module ModernTreasury
   module Models
-    class Invoice < ModernTreasury::BaseModel
+    class Invoice < ModernTreasury::Internal::Type::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
+      # Amount paid on the invoice in specified currency's smallest unit, e.g., $10 USD
+      # would be represented as 1000.
       sig { returns(Integer) }
-      def amount_paid
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount_paid=(_)
-      end
+      attr_accessor :amount_paid
 
+      # Amount remaining due on the invoice in specified currency's smallest unit, e.g.,
+      # $10 USD would be represented as 1000.
       sig { returns(Integer) }
-      def amount_remaining
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount_remaining=(_)
-      end
+      attr_accessor :amount_remaining
 
+      # The invoicer's contact details displayed at the top of the invoice.
       sig { returns(T::Array[ModernTreasury::Models::Invoice::ContactDetail]) }
-      def contact_details
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::Invoice::ContactDetail])
-          .returns(T::Array[ModernTreasury::Models::Invoice::ContactDetail])
-      end
-      def contact_details=(_)
-      end
+      attr_accessor :contact_details
 
+      # The counterparty's billing address.
       sig { returns(T.nilable(ModernTreasury::Models::Invoice::CounterpartyBillingAddress)) }
-      def counterparty_billing_address
-      end
+      attr_reader :counterparty_billing_address
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::Invoice::CounterpartyBillingAddress))
-          .returns(T.nilable(ModernTreasury::Models::Invoice::CounterpartyBillingAddress))
-      end
-      def counterparty_billing_address=(_)
+        params(
+          counterparty_billing_address: T.nilable(
+            T.any(ModernTreasury::Models::Invoice::CounterpartyBillingAddress, ModernTreasury::Internal::AnyHash)
+          )
+        )
+          .void
       end
+      attr_writer :counterparty_billing_address
 
+      # The ID of the counterparty receiving the invoice.
       sig { returns(String) }
-      def counterparty_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def counterparty_id=(_)
-      end
+      attr_accessor :counterparty_id
 
+      # The counterparty's shipping address where physical goods should be delivered.
       sig { returns(T.nilable(ModernTreasury::Models::Invoice::CounterpartyShippingAddress)) }
-      def counterparty_shipping_address
-      end
+      attr_reader :counterparty_shipping_address
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::Invoice::CounterpartyShippingAddress))
-          .returns(T.nilable(ModernTreasury::Models::Invoice::CounterpartyShippingAddress))
-      end
-      def counterparty_shipping_address=(_)
+        params(
+          counterparty_shipping_address: T.nilable(
+            T.any(ModernTreasury::Models::Invoice::CounterpartyShippingAddress, ModernTreasury::Internal::AnyHash)
+          )
+        )
+          .void
       end
+      attr_writer :counterparty_shipping_address
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
-      sig { returns(Symbol) }
-      def currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def currency=(_)
-      end
+      # Currency that the invoice is denominated in. Defaults to `USD` if not provided.
+      sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+      attr_accessor :currency
 
+      # A free-form description of the invoice.
       sig { returns(String) }
-      def description
-      end
-
-      sig { params(_: String).returns(String) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # A future date by when the invoice needs to be paid.
       sig { returns(Time) }
-      def due_date
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def due_date=(_)
-      end
+      attr_accessor :due_date
 
+      # The expected payments created for an unpaid invoice.
       sig { returns(T::Array[ModernTreasury::Models::ExpectedPayment]) }
-      def expected_payments
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::ExpectedPayment])
-          .returns(T::Array[ModernTreasury::Models::ExpectedPayment])
-      end
-      def expected_payments=(_)
-      end
+      attr_accessor :expected_payments
 
+      # When payment_method is automatic, the fallback payment method to use when an
+      # automatic payment fails. One of `manual` or `ui`.
       sig { returns(T.nilable(String)) }
-      def fallback_payment_method
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def fallback_payment_method=(_)
-      end
+      attr_accessor :fallback_payment_method
 
+      # The URL of the hosted web UI where the invoice can be viewed.
       sig { returns(String) }
-      def hosted_url
-      end
-
-      sig { params(_: String).returns(String) }
-      def hosted_url=(_)
-      end
+      attr_accessor :hosted_url
 
+      # The invoice issuer's business address.
       sig { returns(T.nilable(ModernTreasury::Models::Invoice::InvoicerAddress)) }
-      def invoicer_address
-      end
+      attr_reader :invoicer_address
 
       sig do
-        params(_: T.nilable(ModernTreasury::Models::Invoice::InvoicerAddress))
-          .returns(T.nilable(ModernTreasury::Models::Invoice::InvoicerAddress))
-      end
-      def invoicer_address=(_)
+        params(
+          invoicer_address: T.nilable(T.any(ModernTreasury::Models::Invoice::InvoicerAddress, ModernTreasury::Internal::AnyHash))
+        )
+          .void
       end
+      attr_writer :invoicer_address
 
+      # The ledger account settlement object linked to the invoice.
       sig { returns(T.nilable(String)) }
-      def ledger_account_settlement_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def ledger_account_settlement_id=(_)
-      end
+      attr_accessor :ledger_account_settlement_id
 
+      # 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
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      # strings.
       sig { returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata
-      end
-
-      sig { params(_: T.nilable(T::Hash[Symbol, String])).returns(T.nilable(T::Hash[Symbol, String])) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
+      # Emails in addition to the counterparty email to send invoice status
+      # notifications to. At least one email is required if notifications are enabled
+      # and the counterparty doesn't have an email.
       sig { returns(T.nilable(T::Array[String])) }
-      def notification_email_addresses
-      end
-
-      sig { params(_: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-      def notification_email_addresses=(_)
-      end
+      attr_accessor :notification_email_addresses
 
+      # If true, the invoice will send email notifications to the invoice recipients
+      # about invoice status changes.
       sig { returns(T::Boolean) }
-      def notifications_enabled
-      end
-
-      sig { params(_: T::Boolean).returns(T::Boolean) }
-      def notifications_enabled=(_)
-      end
+      attr_accessor :notifications_enabled
 
+      # A unique record number assigned to each invoice that is issued.
       sig { returns(String) }
-      def number
-      end
-
-      sig { params(_: String).returns(String) }
-      def number=(_)
-      end
+      attr_accessor :number
 
       sig { returns(String) }
-      def object
-      end
-
-      sig { params(_: String).returns(String) }
-      def object=(_)
-      end
+      attr_accessor :object
 
+      # The ID of the internal account the invoice should be paid to.
       sig { returns(String) }
-      def originating_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def originating_account_id=(_)
-      end
+      attr_accessor :originating_account_id
 
+      # Date transactions are to be posted to the participants' account. Defaults to the
+      # current business day or the next business day if the current day is a bank
+      # holiday or weekend. Format: yyyy-mm-dd.
       sig { returns(T.nilable(Date)) }
-      def payment_effective_date
-      end
+      attr_accessor :payment_effective_date
 
-      sig { params(_: T.nilable(Date)).returns(T.nilable(Date)) }
-      def payment_effective_date=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def payment_method
-      end
-
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def payment_method=(_)
-      end
+      # When opening an invoice, whether to show the embedded payment UI , automatically
+      # debit the recipient, or rely on manual payment from the recipient.
+      sig { returns(T.nilable(ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol)) }
+      attr_accessor :payment_method
 
+      # The payment orders created for paying the invoice through the invoice payment
+      # UI.
       sig { returns(T::Array[ModernTreasury::Models::PaymentOrder]) }
-      def payment_orders
-      end
-
-      sig do
-        params(_: T::Array[ModernTreasury::Models::PaymentOrder])
-          .returns(T::Array[ModernTreasury::Models::PaymentOrder])
-      end
-      def payment_orders=(_)
-      end
-
-      sig { returns(T.nilable(Symbol)) }
-      def payment_type
-      end
+      attr_accessor :payment_orders
 
-      sig { params(_: T.nilable(Symbol)).returns(T.nilable(Symbol)) }
-      def payment_type=(_)
-      end
+      # One of `ach` or `eft`.
+      sig { returns(T.nilable(ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol)) }
+      attr_accessor :payment_type
 
+      # The URL where the invoice PDF can be downloaded.
       sig { returns(T.nilable(String)) }
-      def pdf_url
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def pdf_url=(_)
-      end
+      attr_accessor :pdf_url
 
+      # The receiving account ID. Can be an `internal_account`.
       sig { returns(T.nilable(String)) }
-      def receiving_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def receiving_account_id=(_)
-      end
+      attr_accessor :receiving_account_id
 
+      # The email of the recipient of the invoice. Leaving this value as null will
+      # fallback to using the counterparty's name.
       sig { returns(T.nilable(String)) }
-      def recipient_email
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def recipient_email=(_)
-      end
+      attr_accessor :recipient_email
 
+      # The name of the recipient of the invoice. Leaving this value as null will
+      # fallback to using the counterparty's name.
       sig { returns(T.nilable(String)) }
-      def recipient_name
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def recipient_name=(_)
-      end
+      attr_accessor :recipient_name
 
+      # Number of days after due date when overdue reminder emails will be sent out to
+      # invoice recipients.
       sig { returns(T.nilable(T::Array[Integer])) }
-      def remind_after_overdue_days
-      end
+      attr_accessor :remind_after_overdue_days
 
-      sig { params(_: T.nilable(T::Array[Integer])).returns(T.nilable(T::Array[Integer])) }
-      def remind_after_overdue_days=(_)
-      end
-
-      sig { returns(Symbol) }
-      def status
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def status=(_)
-      end
+      # The status of the invoice.
+      sig { returns(ModernTreasury::Models::Invoice::Status::TaggedSymbol) }
+      attr_accessor :status
 
+      # Total amount due in specified currency's smallest unit, e.g., $10 USD would be
+      # represented as 1000.
       sig { returns(Integer) }
-      def total_amount
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def total_amount=(_)
-      end
+      attr_accessor :total_amount
 
+      # IDs of transaction line items associated with an invoice.
       sig { returns(T::Array[String]) }
-      def transaction_line_item_ids
-      end
-
-      sig { params(_: T::Array[String]).returns(T::Array[String]) }
-      def transaction_line_item_ids=(_)
-      end
+      attr_accessor :transaction_line_item_ids
 
       sig { returns(Time) }
-      def updated_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def updated_at=(_)
-      end
+      attr_accessor :updated_at
 
+      # The ID of the virtual account the invoice should be paid to.
       sig { returns(T.nilable(String)) }
-      def virtual_account_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def virtual_account_id=(_)
-      end
+      attr_accessor :virtual_account_id
 
       sig do
         params(
           id: String,
           amount_paid: Integer,
           amount_remaining: Integer,
-          contact_details: T::Array[ModernTreasury::Models::Invoice::ContactDetail],
-          counterparty_billing_address: T.nilable(ModernTreasury::Models::Invoice::CounterpartyBillingAddress),
+          contact_details: T::Array[T.any(ModernTreasury::Models::Invoice::ContactDetail, ModernTreasury::Internal::AnyHash)],
+          counterparty_billing_address: T.nilable(
+            T.any(ModernTreasury::Models::Invoice::CounterpartyBillingAddress, ModernTreasury::Internal::AnyHash)
+          ),
           counterparty_id: String,
-          counterparty_shipping_address: T.nilable(ModernTreasury::Models::Invoice::CounterpartyShippingAddress),
+          counterparty_shipping_address: T.nilable(
+            T.any(ModernTreasury::Models::Invoice::CounterpartyShippingAddress, ModernTreasury::Internal::AnyHash)
+          ),
           created_at: Time,
-          currency: Symbol,
+          currency: ModernTreasury::Models::Currency::OrSymbol,
           description: String,
           due_date: Time,
-          expected_payments: T::Array[ModernTreasury::Models::ExpectedPayment],
+          expected_payments: T::Array[T.any(ModernTreasury::Models::ExpectedPayment, ModernTreasury::Internal::AnyHash)],
           fallback_payment_method: T.nilable(String),
           hosted_url: String,
-          invoicer_address: T.nilable(ModernTreasury::Models::Invoice::InvoicerAddress),
+          invoicer_address: T.nilable(T.any(ModernTreasury::Models::Invoice::InvoicerAddress, ModernTreasury::Internal::AnyHash)),
           ledger_account_settlement_id: T.nilable(String),
           live_mode: T::Boolean,
           metadata: T.nilable(T::Hash[Symbol, String]),
@@ -343,23 +221,23 @@ module ModernTreasury
           object: String,
           originating_account_id: String,
           payment_effective_date: T.nilable(Date),
-          payment_method: T.nilable(Symbol),
-          payment_orders: T::Array[ModernTreasury::Models::PaymentOrder],
-          payment_type: T.nilable(Symbol),
+          payment_method: T.nilable(ModernTreasury::Models::Invoice::PaymentMethod::OrSymbol),
+          payment_orders: T::Array[T.any(ModernTreasury::Models::PaymentOrder, ModernTreasury::Internal::AnyHash)],
+          payment_type: T.nilable(ModernTreasury::Models::Invoice::PaymentType::OrSymbol),
           pdf_url: T.nilable(String),
           receiving_account_id: T.nilable(String),
           recipient_email: T.nilable(String),
           recipient_name: T.nilable(String),
           remind_after_overdue_days: T.nilable(T::Array[Integer]),
-          status: Symbol,
+          status: ModernTreasury::Models::Invoice::Status::OrSymbol,
           total_amount: Integer,
           transaction_line_item_ids: T::Array[String],
           updated_at: Time,
           virtual_account_id: T.nilable(String)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         amount_paid:,
         amount_remaining:,
@@ -397,9 +275,7 @@ module ModernTreasury
         transaction_line_item_ids:,
         updated_at:,
         virtual_account_id:
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -412,7 +288,7 @@ module ModernTreasury
               counterparty_id: String,
               counterparty_shipping_address: T.nilable(ModernTreasury::Models::Invoice::CounterpartyShippingAddress),
               created_at: Time,
-              currency: Symbol,
+              currency: ModernTreasury::Models::Currency::TaggedSymbol,
               description: String,
               due_date: Time,
               expected_payments: T::Array[ModernTreasury::Models::ExpectedPayment],
@@ -428,15 +304,15 @@ module ModernTreasury
               object: String,
               originating_account_id: String,
               payment_effective_date: T.nilable(Date),
-              payment_method: T.nilable(Symbol),
+              payment_method: T.nilable(ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol),
               payment_orders: T::Array[ModernTreasury::Models::PaymentOrder],
-              payment_type: T.nilable(Symbol),
+              payment_type: T.nilable(ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol),
               pdf_url: T.nilable(String),
               receiving_account_id: T.nilable(String),
               recipient_email: T.nilable(String),
               recipient_name: T.nilable(String),
               remind_after_overdue_days: T.nilable(T::Array[Integer]),
-              status: Symbol,
+              status: ModernTreasury::Models::Invoice::Status::TaggedSymbol,
               total_amount: Integer,
               transaction_line_item_ids: T::Array[String],
               updated_at: Time,
@@ -444,88 +320,49 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class ContactDetail < ModernTreasury::BaseModel
+      class ContactDetail < ModernTreasury::Internal::Type::BaseModel
         sig { returns(String) }
-        def id
-        end
-
-        sig { params(_: String).returns(String) }
-        def id=(_)
-        end
+        attr_accessor :id
 
         sig { returns(String) }
-        def contact_identifier
-        end
-
-        sig { params(_: String).returns(String) }
-        def contact_identifier=(_)
-        end
+        attr_accessor :contact_identifier
 
-        sig { returns(Symbol) }
-        def contact_identifier_type
-        end
-
-        sig { params(_: Symbol).returns(Symbol) }
-        def contact_identifier_type=(_)
-        end
+        sig { returns(ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol) }
+        attr_accessor :contact_identifier_type
 
         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
 
+        # 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(
             id: String,
             contact_identifier: String,
-            contact_identifier_type: Symbol,
+            contact_identifier_type: ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::OrSymbol,
             created_at: Time,
             discarded_at: T.nilable(Time),
             live_mode: T::Boolean,
             object: String,
             updated_at: Time
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           id:,
           contact_identifier:,
           contact_identifier_type:,
@@ -534,16 +371,14 @@ module ModernTreasury
           live_mode:,
           object:,
           updated_at:
-        )
-        end
-
+        ); end
         sig do
           override
             .returns(
               {
                 id: String,
                 contact_identifier: String,
-                contact_identifier_type: Symbol,
+                contact_identifier_type: ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol,
                 created_at: Time,
                 discarded_at: T.nilable(Time),
                 live_mode: T::Boolean,
@@ -552,71 +387,58 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
 
-        class ContactIdentifierType < ModernTreasury::Enum
-          abstract!
+        module ContactIdentifierType
+          extend ModernTreasury::Internal::Type::Enum
 
-          EMAIL = :email
-          PHONE_NUMBER = :phone_number
-          WEBSITE = :website
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol) }
 
-          sig { override.returns(T::Array[Symbol]) }
-          def self.values
+          EMAIL =
+            T.let(:email, ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol)
+          PHONE_NUMBER =
+            T.let(:phone_number, ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol)
+          WEBSITE =
+            T.let(:website, ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol)
+
+          sig do
+            override
+              .returns(T::Array[ModernTreasury::Models::Invoice::ContactDetail::ContactIdentifierType::TaggedSymbol])
           end
+          def self.values; end
         end
       end
 
-      class CounterpartyBillingAddress < ModernTreasury::BaseModel
+      class CounterpartyBillingAddress < ModernTreasury::Internal::Type::BaseModel
+        # Country code conforms to [ISO 3166-1 alpha-2]
         sig { returns(String) }
-        def country
-        end
-
-        sig { params(_: String).returns(String) }
-        def country=(_)
-        end
+        attr_accessor :country
 
         sig { returns(String) }
-        def line1
-        end
-
-        sig { params(_: String).returns(String) }
-        def line1=(_)
-        end
+        attr_accessor :line1
 
+        # Locality or City.
         sig { returns(String) }
-        def locality
-        end
-
-        sig { params(_: String).returns(String) }
-        def locality=(_)
-        end
+        attr_accessor :locality
 
+        # The postal code of the address.
         sig { returns(String) }
-        def postal_code
-        end
-
-        sig { params(_: String).returns(String) }
-        def postal_code=(_)
-        end
+        attr_accessor :postal_code
 
+        # Region or State.
         sig { returns(String) }
-        def region
-        end
-
-        sig { params(_: String).returns(String) }
-        def region=(_)
-        end
+        attr_accessor :region
 
         sig { returns(T.nilable(String)) }
-        def line2
-        end
+        attr_reader :line2
 
-        sig { params(_: String).returns(String) }
-        def line2=(_)
-        end
+        sig { params(line2: String).void }
+        attr_writer :line2
 
+        # The counterparty's billing address.
         sig do
           params(
             country: String,
@@ -626,10 +448,9 @@ module ModernTreasury
             region: String,
             line2: String
           )
-            .void
-        end
-        def initialize(country:, line1:, locality:, postal_code:, region:, line2: nil)
+            .returns(T.attached_class)
         end
+        def self.new(country:, line1:, locality:, postal_code:, region:, line2: nil); end
 
         sig do
           override
@@ -644,59 +465,36 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class CounterpartyShippingAddress < ModernTreasury::BaseModel
+      class CounterpartyShippingAddress < ModernTreasury::Internal::Type::BaseModel
+        # Country code conforms to [ISO 3166-1 alpha-2]
         sig { returns(String) }
-        def country
-        end
-
-        sig { params(_: String).returns(String) }
-        def country=(_)
-        end
+        attr_accessor :country
 
         sig { returns(String) }
-        def line1
-        end
-
-        sig { params(_: String).returns(String) }
-        def line1=(_)
-        end
+        attr_accessor :line1
 
+        # Locality or City.
         sig { returns(String) }
-        def locality
-        end
-
-        sig { params(_: String).returns(String) }
-        def locality=(_)
-        end
+        attr_accessor :locality
 
+        # The postal code of the address.
         sig { returns(String) }
-        def postal_code
-        end
-
-        sig { params(_: String).returns(String) }
-        def postal_code=(_)
-        end
+        attr_accessor :postal_code
 
+        # Region or State.
         sig { returns(String) }
-        def region
-        end
-
-        sig { params(_: String).returns(String) }
-        def region=(_)
-        end
+        attr_accessor :region
 
         sig { returns(T.nilable(String)) }
-        def line2
-        end
+        attr_reader :line2
 
-        sig { params(_: String).returns(String) }
-        def line2=(_)
-        end
+        sig { params(line2: String).void }
+        attr_writer :line2
 
+        # The counterparty's shipping address where physical goods should be delivered.
         sig do
           params(
             country: String,
@@ -706,10 +504,9 @@ module ModernTreasury
             region: String,
             line2: String
           )
-            .void
-        end
-        def initialize(country:, line1:, locality:, postal_code:, region:, line2: nil)
+            .returns(T.attached_class)
         end
+        def self.new(country:, line1:, locality:, postal_code:, region:, line2: nil); end
 
         sig do
           override
@@ -724,59 +521,36 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class InvoicerAddress < ModernTreasury::BaseModel
+      class InvoicerAddress < ModernTreasury::Internal::Type::BaseModel
+        # Country code conforms to [ISO 3166-1 alpha-2]
         sig { returns(String) }
-        def country
-        end
-
-        sig { params(_: String).returns(String) }
-        def country=(_)
-        end
+        attr_accessor :country
 
         sig { returns(String) }
-        def line1
-        end
-
-        sig { params(_: String).returns(String) }
-        def line1=(_)
-        end
+        attr_accessor :line1
 
+        # Locality or City.
         sig { returns(String) }
-        def locality
-        end
-
-        sig { params(_: String).returns(String) }
-        def locality=(_)
-        end
+        attr_accessor :locality
 
+        # The postal code of the address.
         sig { returns(String) }
-        def postal_code
-        end
-
-        sig { params(_: String).returns(String) }
-        def postal_code=(_)
-        end
+        attr_accessor :postal_code
 
+        # Region or State.
         sig { returns(String) }
-        def region
-        end
-
-        sig { params(_: String).returns(String) }
-        def region=(_)
-        end
+        attr_accessor :region
 
         sig { returns(T.nilable(String)) }
-        def line2
-        end
+        attr_reader :line2
 
-        sig { params(_: String).returns(String) }
-        def line2=(_)
-        end
+        sig { params(line2: String).void }
+        attr_writer :line2
 
+        # The invoice issuer's business address.
         sig do
           params(
             country: String,
@@ -786,10 +560,9 @@ module ModernTreasury
             region: String,
             line2: String
           )
-            .void
-        end
-        def initialize(country:, line1:, locality:, postal_code:, region:, line2: nil)
+            .returns(T.attached_class)
         end
+        def self.new(country:, line1:, locality:, postal_code:, region:, line2: nil); end
 
         sig do
           override
@@ -804,46 +577,57 @@ module ModernTreasury
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
 
-      class PaymentMethod < ModernTreasury::Enum
-        abstract!
+      # When opening an invoice, whether to show the embedded payment UI , automatically
+      # debit the recipient, or rely on manual payment from the recipient.
+      module PaymentMethod
+        extend ModernTreasury::Internal::Type::Enum
 
-        UI = T.let(:ui, T.nilable(Symbol))
-        MANUAL = T.let(:manual, T.nilable(Symbol))
-        AUTOMATIC = T.let(:automatic, T.nilable(Symbol))
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Invoice::PaymentMethod) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        UI = T.let(:ui, ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol)
+        MANUAL = T.let(:manual, ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol)
+        AUTOMATIC = T.let(:automatic, ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Invoice::PaymentMethod::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class PaymentType < ModernTreasury::Enum
-        abstract!
+      # One of `ach` or `eft`.
+      module PaymentType
+        extend ModernTreasury::Internal::Type::Enum
 
-        EFT = T.let(:eft, T.nilable(Symbol))
-        ACH = T.let(:ach, T.nilable(Symbol))
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Invoice::PaymentType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        EFT = T.let(:eft, ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol)
+        ACH = T.let(:ach, ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Invoice::PaymentType::TaggedSymbol]) }
+        def self.values; end
       end
 
-      class Status < ModernTreasury::Enum
-        abstract!
+      # The status of the invoice.
+      module Status
+        extend ModernTreasury::Internal::Type::Enum
 
-        DRAFT = :draft
-        PAID = :paid
-        PARTIALLY_PAID = :partially_paid
-        PAYMENT_PENDING = :payment_pending
-        UNPAID = :unpaid
-        VOIDED = :voided
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::Invoice::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String, ModernTreasury::Models::Invoice::Status::TaggedSymbol) }
 
-        sig { override.returns(T::Array[Symbol]) }
-        def self.values
-        end
+        DRAFT = T.let(:draft, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+        PAID = T.let(:paid, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+        PARTIALLY_PAID = T.let(:partially_paid, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+        PAYMENT_PENDING = T.let(:payment_pending, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+        UNPAID = T.let(:unpaid, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+        VOIDED = T.let(:voided, ModernTreasury::Models::Invoice::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[ModernTreasury::Models::Invoice::Status::TaggedSymbol]) }
+        def self.values; end
       end
     end
   end