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

data/rbi/lib/modern_treasury/models/foreign_exchange_quote.rbi

@@ -2,105 +2,68 @@
 
 module ModernTreasury
   module Models
-    class ForeignExchangeQuote < ModernTreasury::BaseModel
+    class ForeignExchangeQuote < ModernTreasury::Internal::Type::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
 
+      # The timestamp until when the quoted rate is valid.
       sig { returns(Time) }
-      def effective_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def effective_at=(_)
-      end
+      attr_accessor :effective_at
 
+      # The timestamp until which the quote must be booked by.
       sig { returns(Time) }
-      def expires_at
-      end
-
-      sig { params(_: Time).returns(Time) }
-      def expires_at=(_)
-      end
+      attr_accessor :expires_at
 
+      # Either `fixed_to_variable` if the `base_amount` was specified, or
+      # `variable_to_fixed` if the `target_amount` was specified when requesting the
+      # quote.
       sig { returns(String) }
-      def foreign_exchange_indicator
-      end
-
-      sig { params(_: String).returns(String) }
-      def foreign_exchange_indicator=(_)
-      end
+      attr_accessor :foreign_exchange_indicator
 
+      # The serialized rate information represented by this quote.
       sig { returns(ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate) }
-      def foreign_exchange_rate
-      end
+      attr_reader :foreign_exchange_rate
 
       sig do
-        params(_: ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate)
-          .returns(ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate)
-      end
-      def foreign_exchange_rate=(_)
+        params(
+          foreign_exchange_rate: T.any(
+            ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate,
+            ModernTreasury::Internal::AnyHash
+          )
+        )
+          .void
       end
+      attr_writer :foreign_exchange_rate
 
+      # The ID for the `InternalAccount` this quote is associated with.
       sig { returns(String) }
-      def internal_account_id
-      end
-
-      sig { params(_: String).returns(String) }
-      def internal_account_id=(_)
-      end
+      attr_accessor :internal_account_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::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
 
+      # This vendor assigned ID for this quote.
       sig { returns(T.nilable(String)) }
-      def vendor_id
-      end
+      attr_reader :vendor_id
 
-      sig { params(_: String).returns(String) }
-      def vendor_id=(_)
-      end
+      sig { params(vendor_id: String).void }
+      attr_writer :vendor_id
 
       sig do
         params(
@@ -109,7 +72,10 @@ module ModernTreasury
           effective_at: Time,
           expires_at: Time,
           foreign_exchange_indicator: String,
-          foreign_exchange_rate: ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate,
+          foreign_exchange_rate: T.any(
+            ModernTreasury::Models::ForeignExchangeQuote::ForeignExchangeRate,
+            ModernTreasury::Internal::AnyHash
+          ),
           internal_account_id: String,
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
@@ -117,9 +83,9 @@ module ModernTreasury
           updated_at: Time,
           vendor_id: String
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         id:,
         created_at:,
         effective_at:,
@@ -132,9 +98,7 @@ module ModernTreasury
         object:,
         updated_at:,
         vendor_id: nil
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -154,79 +118,55 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
 
-      class ForeignExchangeRate < ModernTreasury::BaseModel
+      class ForeignExchangeRate < ModernTreasury::Internal::Type::BaseModel
+        # Amount in the lowest denomination of the `base_currency` to convert, often
+        # called the "sell" amount.
         sig { returns(Integer) }
-        def base_amount
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def base_amount=(_)
-        end
-
-        sig { returns(Symbol) }
-        def base_currency
-        end
+        attr_accessor :base_amount
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def base_currency=(_)
-        end
+        # Currency to convert, often called the "sell" currency.
+        sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+        attr_accessor :base_currency
 
+        # The exponent component of the rate. The decimal is calculated as `value` / (10 ^
+        # `exponent`).
         sig { returns(Integer) }
-        def exponent
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def exponent=(_)
-        end
+        attr_accessor :exponent
 
+        # A string representation of the rate.
         sig { returns(String) }
-        def rate_string
-        end
-
-        sig { params(_: String).returns(String) }
-        def rate_string=(_)
-        end
+        attr_accessor :rate_string
 
+        # Amount in the lowest denomination of the `target_currency`, often called the
+        # "buy" amount.
         sig { returns(Integer) }
-        def target_amount
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def target_amount=(_)
-        end
-
-        sig { returns(Symbol) }
-        def target_currency
-        end
+        attr_accessor :target_amount
 
-        sig { params(_: Symbol).returns(Symbol) }
-        def target_currency=(_)
-        end
+        # Currency to convert the `base_currency` to, often called the "buy" currency.
+        sig { returns(ModernTreasury::Models::Currency::TaggedSymbol) }
+        attr_accessor :target_currency
 
+        # The whole number component of the rate. The decimal is calculated as `value` /
+        # (10 ^ `exponent`).
         sig { returns(Integer) }
-        def value
-        end
-
-        sig { params(_: Integer).returns(Integer) }
-        def value=(_)
-        end
+        attr_accessor :value
 
+        # The serialized rate information represented by this quote.
         sig do
           params(
             base_amount: Integer,
-            base_currency: Symbol,
+            base_currency: ModernTreasury::Models::Currency::OrSymbol,
             exponent: Integer,
             rate_string: String,
             target_amount: Integer,
-            target_currency: Symbol,
+            target_currency: ModernTreasury::Models::Currency::OrSymbol,
             value: Integer
           )
-            .void
+            .returns(T.attached_class)
         end
-        def initialize(
+        def self.new(
           base_amount:,
           base_currency:,
           exponent:,
@@ -242,17 +182,16 @@ module ModernTreasury
             .returns(
               {
                 base_amount: Integer,
-                base_currency: Symbol,
+                base_currency: ModernTreasury::Models::Currency::TaggedSymbol,
                 exponent: Integer,
                 rate_string: String,
                 target_amount: Integer,
-                target_currency: Symbol,
+                target_currency: ModernTreasury::Models::Currency::TaggedSymbol,
                 value: Integer
               }
             )
         end
-        def to_hash
-        end
+        def to_hash; end
       end
     end
   end

data/rbi/lib/modern_treasury/models/foreign_exchange_quote_create_params.rbi

@@ -2,71 +2,61 @@
 
 module ModernTreasury
   module Models
-    class ForeignExchangeQuoteCreateParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class ForeignExchangeQuoteCreateParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::RequestParameters
 
+      # The ID for the `InternalAccount` this quote is associated with.
       sig { returns(String) }
-      def internal_account_id
-      end
+      attr_accessor :internal_account_id
 
-      sig { params(_: String).returns(String) }
-      def internal_account_id=(_)
-      end
-
-      sig { returns(Symbol) }
-      def target_currency
-      end
-
-      sig { params(_: Symbol).returns(Symbol) }
-      def target_currency=(_)
-      end
+      # Currency to convert the `base_currency` to, often called the "buy" currency.
+      sig { returns(ModernTreasury::Models::Currency::OrSymbol) }
+      attr_accessor :target_currency
 
+      # Amount in the lowest denomination of the `base_currency` to convert, often
+      # called the "sell" amount.
       sig { returns(T.nilable(Integer)) }
-      def base_amount
-      end
+      attr_reader :base_amount
 
-      sig { params(_: Integer).returns(Integer) }
-      def base_amount=(_)
-      end
+      sig { params(base_amount: Integer).void }
+      attr_writer :base_amount
 
-      sig { returns(T.nilable(Symbol)) }
-      def base_currency
-      end
+      # Currency to convert, often called the "sell" currency.
+      sig { returns(T.nilable(ModernTreasury::Models::Currency::OrSymbol)) }
+      attr_reader :base_currency
 
-      sig { params(_: Symbol).returns(Symbol) }
-      def base_currency=(_)
-      end
+      sig { params(base_currency: ModernTreasury::Models::Currency::OrSymbol).void }
+      attr_writer :base_currency
 
+      # The timestamp until when the quoted rate is valid.
       sig { returns(T.nilable(Time)) }
-      def effective_at
-      end
+      attr_reader :effective_at
 
-      sig { params(_: Time).returns(Time) }
-      def effective_at=(_)
-      end
+      sig { params(effective_at: Time).void }
+      attr_writer :effective_at
 
+      # Amount in the lowest denomination of the `target_currency`, often called the
+      # "buy" amount.
       sig { returns(T.nilable(Integer)) }
-      def target_amount
-      end
+      attr_reader :target_amount
 
-      sig { params(_: Integer).returns(Integer) }
-      def target_amount=(_)
-      end
+      sig { params(target_amount: Integer).void }
+      attr_writer :target_amount
 
       sig do
         params(
           internal_account_id: String,
-          target_currency: Symbol,
+          target_currency: ModernTreasury::Models::Currency::OrSymbol,
           base_amount: Integer,
-          base_currency: Symbol,
+          base_currency: ModernTreasury::Models::Currency::OrSymbol,
           effective_at: Time,
           target_amount: Integer,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         internal_account_id:,
         target_currency:,
         base_amount: nil,
@@ -74,25 +64,22 @@ module ModernTreasury
         effective_at: nil,
         target_amount: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
             {
               internal_account_id: String,
-              target_currency: Symbol,
+              target_currency: ModernTreasury::Models::Currency::OrSymbol,
               base_amount: Integer,
-              base_currency: Symbol,
+              base_currency: ModernTreasury::Models::Currency::OrSymbol,
               effective_at: Time,
               target_amount: Integer,
               request_options: ModernTreasury::RequestOptions
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/foreign_exchange_quote_list_params.rbi

@@ -2,81 +2,69 @@
 
 module ModernTreasury
   module Models
-    class ForeignExchangeQuoteListParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class ForeignExchangeQuoteListParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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
 
+      # Currency to convert, often called the "sell" currency.
       sig { returns(T.nilable(String)) }
-      def base_currency
-      end
+      attr_reader :base_currency
 
-      sig { params(_: String).returns(String) }
-      def base_currency=(_)
-      end
+      sig { params(base_currency: String).void }
+      attr_writer :base_currency
 
+      # An inclusive upper bound for searching effective_at
       sig { returns(T.nilable(Date)) }
-      def effective_at_end
-      end
+      attr_reader :effective_at_end
 
-      sig { params(_: Date).returns(Date) }
-      def effective_at_end=(_)
-      end
+      sig { params(effective_at_end: Date).void }
+      attr_writer :effective_at_end
 
+      # An inclusive lower bound for searching effective_at
       sig { returns(T.nilable(Date)) }
-      def effective_at_start
-      end
+      attr_reader :effective_at_start
 
-      sig { params(_: Date).returns(Date) }
-      def effective_at_start=(_)
-      end
+      sig { params(effective_at_start: Date).void }
+      attr_writer :effective_at_start
 
+      # The timestamp until which the quote must be booked by.
       sig { returns(T.nilable(Time)) }
-      def expires_at
-      end
+      attr_reader :expires_at
 
-      sig { params(_: Time).returns(Time) }
-      def expires_at=(_)
-      end
+      sig { params(expires_at: Time).void }
+      attr_writer :expires_at
 
+      # The ID for the `InternalAccount` this quote is associated with.
       sig { returns(T.nilable(String)) }
-      def internal_account_id
-      end
+      attr_reader :internal_account_id
 
-      sig { params(_: String).returns(String) }
-      def internal_account_id=(_)
-      end
+      sig { params(internal_account_id: String).void }
+      attr_writer :internal_account_id
 
+      # 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
 
+      # Currency to convert the `base_currency` to, often called the "buy" currency.
       sig { returns(T.nilable(String)) }
-      def target_currency
-      end
+      attr_reader :target_currency
 
-      sig { params(_: String).returns(String) }
-      def target_currency=(_)
-      end
+      sig { params(target_currency: String).void }
+      attr_writer :target_currency
 
       sig do
         params(
@@ -89,11 +77,11 @@ module ModernTreasury
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
           target_currency: String,
-          request_options: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])
+          request_options: T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         base_currency: nil,
         effective_at_end: nil,
@@ -104,9 +92,7 @@ module ModernTreasury
         per_page: nil,
         target_currency: nil,
         request_options: {}
-      )
-      end
-
+      ); end
       sig do
         override
           .returns(
@@ -124,8 +110,7 @@ module ModernTreasury
             }
           )
       end
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end

data/rbi/lib/modern_treasury/models/foreign_exchange_quote_retrieve_params.rbi

@@ -2,17 +2,18 @@
 
 module ModernTreasury
   module Models
-    class ForeignExchangeQuoteRetrieveParams < ModernTreasury::BaseModel
-      extend ModernTreasury::RequestParameters::Converter
-      include ModernTreasury::RequestParameters
+    class ForeignExchangeQuoteRetrieveParams < ModernTreasury::Internal::Type::BaseModel
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      include ModernTreasury::Internal::Type::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::Internal::AnyHash))
+          .returns(T.attached_class)
       end
+      def self.new(request_options: {}); end
 
       sig { override.returns({request_options: ModernTreasury::RequestOptions}) }
-      def to_hash
-      end
+      def to_hash; end
     end
   end
 end