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

data/rbi/lib/modern_treasury/models/line_item.rbi

@@ -4,131 +4,80 @@ module ModernTreasury
   module Models
     class LineItem < ModernTreasury::BaseModel
       sig { returns(String) }
-      def id
-      end
-
-      sig { params(_: String).returns(String) }
-      def id=(_)
-      end
+      attr_accessor :id
 
       sig { returns(ModernTreasury::Models::LineItem::Accounting) }
-      def accounting
-      end
+      attr_reader :accounting
 
-      sig do
-        params(_: ModernTreasury::Models::LineItem::Accounting)
-          .returns(ModernTreasury::Models::LineItem::Accounting)
-      end
-      def accounting=(_)
-      end
+      sig { params(accounting: T.any(ModernTreasury::Models::LineItem::Accounting, ModernTreasury::Util::AnyHash)).void }
+      attr_writer :accounting
 
+      # The ID of one of your accounting categories. Note that these will only be
+      #   accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
-      def accounting_category_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def accounting_category_id=(_)
-      end
+      attr_accessor :accounting_category_id
 
+      # The ID of one of the class objects in your accounting system. Class objects
+      #   track segments of your business independent of client or project. Note that
+      #   these will only be accessible if your accounting system has been connected.
       sig { returns(T.nilable(String)) }
-      def accounting_ledger_class_id
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def accounting_ledger_class_id=(_)
-      end
+      attr_accessor :accounting_ledger_class_id
 
+      # Value in specified currency's smallest unit. e.g. $10 would be represented
+      #   as 1000.
       sig { returns(Integer) }
-      def amount
-      end
-
-      sig { params(_: Integer).returns(Integer) }
-      def amount=(_)
-      end
+      attr_accessor :amount
 
       sig { returns(Time) }
-      def created_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def created_at=(_)
-      end
+      attr_accessor :created_at
 
+      # A free-form description of the line item.
       sig { returns(T.nilable(String)) }
-      def description
-      end
-
-      sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-      def description=(_)
-      end
+      attr_accessor :description
 
+      # The ID of the payment order or expected payment.
       sig { returns(String) }
-      def itemizable_id
-      end
+      attr_accessor :itemizable_id
 
-      sig { params(_: String).returns(String) }
-      def itemizable_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def itemizable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def itemizable_type=(_)
-      end
+      # One of `payment_orders` or `expected_payments`.
+      sig { returns(ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol) }
+      attr_accessor :itemizable_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
 
+      # Additional data represented as key-value pairs. Both the key and value must be
+      #   strings.
       sig { returns(T::Hash[Symbol, String]) }
-      def metadata
-      end
-
-      sig { params(_: T::Hash[Symbol, String]).returns(T::Hash[Symbol, String]) }
-      def metadata=(_)
-      end
+      attr_accessor :metadata
 
       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,
-          accounting: ModernTreasury::Models::LineItem::Accounting,
+          accounting: T.any(ModernTreasury::Models::LineItem::Accounting, ModernTreasury::Util::AnyHash),
           accounting_category_id: T.nilable(String),
           accounting_ledger_class_id: T.nilable(String),
           amount: Integer,
           created_at: Time,
           description: T.nilable(String),
           itemizable_id: String,
-          itemizable_type: Symbol,
+          itemizable_type: ModernTreasury::Models::LineItem::ItemizableType::OrSymbol,
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
           object: String,
           updated_at: Time
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         accounting:,
         accounting_category_id:,
@@ -157,7 +106,7 @@ module ModernTreasury
               created_at: Time,
               description: T.nilable(String),
               itemizable_id: String,
-              itemizable_type: Symbol,
+              itemizable_type: ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol,
               live_mode: T::Boolean,
               metadata: T::Hash[Symbol, String],
               object: String,
@@ -169,24 +118,19 @@ module ModernTreasury
       end
 
       class Accounting < ModernTreasury::BaseModel
+        # The ID of one of your accounting categories. Note that these will only be
+        #   accessible if your accounting system has been connected.
         sig { returns(T.nilable(String)) }
-        def account_id
-        end
-
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def account_id=(_)
-        end
+        attr_accessor :account_id
 
+        # The ID of one of the class objects in your accounting system. Class objects
+        #   track segments of your business independent of client or project. Note that
+        #   these will only be accessible if your accounting system has been connected.
         sig { returns(T.nilable(String)) }
-        def class_id
-        end
+        attr_accessor :class_id
 
-        sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-        def class_id=(_)
-        end
-
-        sig { params(account_id: T.nilable(String), class_id: T.nilable(String)).void }
-        def initialize(account_id: nil, class_id: nil)
+        sig { params(account_id: T.nilable(String), class_id: T.nilable(String)).returns(T.attached_class) }
+        def self.new(account_id: nil, class_id: nil)
         end
 
         sig { override.returns({account_id: T.nilable(String), class_id: T.nilable(String)}) }
@@ -194,13 +138,18 @@ module ModernTreasury
         end
       end
 
-      class ItemizableType < ModernTreasury::Enum
-        abstract!
+      # One of `payment_orders` or `expected_payments`.
+      module ItemizableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::LineItem::ItemizableType) }
+        OrSymbol = T.type_alias { T.any(Symbol, ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol) }
 
-        EXPECTED_PAYMENT = :ExpectedPayment
-        PAYMENT_ORDER = :PaymentOrder
+        EXPECTED_PAYMENT =
+          T.let(:ExpectedPayment, ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol)
+        PAYMENT_ORDER = T.let(:PaymentOrder, ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LineItem::ItemizableType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/line_item_list_params.rbi

@@ -6,47 +6,35 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def itemizable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def itemizable_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::LineItemListParams::ItemizableType::OrSymbol) }
+      attr_accessor :itemizable_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
 
       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(
-          itemizable_type: Symbol,
+          itemizable_type: ModernTreasury::Models::LineItemListParams::ItemizableType::OrSymbol,
           after_cursor: T.nilable(String),
           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(itemizable_type:, after_cursor: nil, per_page: nil, request_options: {})
+      def self.new(itemizable_type:, after_cursor: nil, per_page: nil, request_options: {})
       end
 
       sig do
         override
           .returns(
             {
-              itemizable_type: Symbol,
+              itemizable_type: ModernTreasury::Models::LineItemListParams::ItemizableType::OrSymbol,
               after_cursor: T.nilable(String),
               per_page: Integer,
               request_options: ModernTreasury::RequestOptions
@@ -56,13 +44,19 @@ module ModernTreasury
       def to_hash
       end
 
-      class ItemizableType < ModernTreasury::Enum
-        abstract!
+      module ItemizableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, ModernTreasury::Models::LineItemListParams::ItemizableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LineItemListParams::ItemizableType::TaggedSymbol) }
 
-        EXPECTED_PAYMENTS = :expected_payments
-        PAYMENT_ORDERS = :payment_orders
+        EXPECTED_PAYMENTS =
+          T.let(:expected_payments, ModernTreasury::Models::LineItemListParams::ItemizableType::TaggedSymbol)
+        PAYMENT_ORDERS =
+          T.let(:payment_orders, ModernTreasury::Models::LineItemListParams::ItemizableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LineItemListParams::ItemizableType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/line_item_retrieve_params.rbi

@@ -6,51 +6,50 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def itemizable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def itemizable_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::OrSymbol) }
+      attr_accessor :itemizable_type
 
       sig { returns(String) }
-      def itemizable_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def itemizable_id=(_)
-      end
+      attr_accessor :itemizable_id
 
       sig do
         params(
-          itemizable_type: Symbol,
+          itemizable_type: ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::OrSymbol,
           itemizable_id: 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(itemizable_type:, itemizable_id:, request_options: {})
+      def self.new(itemizable_type:, itemizable_id:, request_options: {})
       end
 
       sig do
         override
-          .returns({
-                     itemizable_type: Symbol,
-                     itemizable_id: String,
-                     request_options: ModernTreasury::RequestOptions
-                   })
+          .returns(
+            {
+              itemizable_type: ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::OrSymbol,
+              itemizable_id: String,
+              request_options: ModernTreasury::RequestOptions
+            }
+          )
       end
       def to_hash
       end
 
-      class ItemizableType < ModernTreasury::Enum
-        abstract!
+      module ItemizableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LineItemRetrieveParams::ItemizableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::TaggedSymbol) }
 
-        EXPECTED_PAYMENTS = :expected_payments
-        PAYMENT_ORDERS = :payment_orders
+        EXPECTED_PAYMENTS =
+          T.let(:expected_payments, ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::TaggedSymbol)
+        PAYMENT_ORDERS =
+          T.let(:payment_orders, ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LineItemRetrieveParams::ItemizableType::TaggedSymbol]) }
         def self.values
         end
       end

data/rbi/lib/modern_treasury/models/line_item_update_params.rbi

@@ -6,47 +6,37 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
-      sig { returns(Symbol) }
-      def itemizable_type
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def itemizable_type=(_)
-      end
+      sig { returns(ModernTreasury::Models::LineItemUpdateParams::ItemizableType::OrSymbol) }
+      attr_accessor :itemizable_type
 
       sig { returns(String) }
-      def itemizable_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def itemizable_id=(_)
-      end
+      attr_accessor :itemizable_id
 
+      # 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
+      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 do
         params(
-          itemizable_type: Symbol,
+          itemizable_type: ModernTreasury::Models::LineItemUpdateParams::ItemizableType::OrSymbol,
           itemizable_id: String,
           metadata: T::Hash[Symbol, 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(itemizable_type:, itemizable_id:, metadata: nil, request_options: {})
+      def self.new(itemizable_type:, itemizable_id:, metadata: nil, request_options: {})
       end
 
       sig do
         override
           .returns(
             {
-              itemizable_type: Symbol,
+              itemizable_type: ModernTreasury::Models::LineItemUpdateParams::ItemizableType::OrSymbol,
               itemizable_id: String,
               metadata: T::Hash[Symbol, String],
               request_options: ModernTreasury::RequestOptions
@@ -56,13 +46,20 @@ module ModernTreasury
       def to_hash
       end
 
-      class ItemizableType < ModernTreasury::Enum
-        abstract!
+      module ItemizableType
+        extend ModernTreasury::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, ModernTreasury::Models::LineItemUpdateParams::ItemizableType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, ModernTreasury::Models::LineItemUpdateParams::ItemizableType::TaggedSymbol) }
 
-        EXPECTED_PAYMENTS = :expected_payments
-        PAYMENT_ORDERS = :payment_orders
+        EXPECTED_PAYMENTS =
+          T.let(:expected_payments, ModernTreasury::Models::LineItemUpdateParams::ItemizableType::TaggedSymbol)
+        PAYMENT_ORDERS =
+          T.let(:payment_orders, ModernTreasury::Models::LineItemUpdateParams::ItemizableType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Symbol]) }
+        sig { override.returns(T::Array[ModernTreasury::Models::LineItemUpdateParams::ItemizableType::TaggedSymbol]) }
         def self.values
         end
       end