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

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

@@ -4,103 +4,63 @@ module ModernTreasury
   module Models
     class ForeignExchangeQuote < 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
 
+      # 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::Util::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 +69,7 @@ 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::Util::AnyHash),
           internal_account_id: String,
           live_mode: T::Boolean,
           metadata: T::Hash[Symbol, String],
@@ -117,9 +77,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:,
@@ -158,83 +118,52 @@ module ModernTreasury
       end
 
       class ForeignExchangeRate < ModernTreasury::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
+        attr_accessor :base_amount
 
-        sig { returns(Symbol) }
-        def base_currency
-        end
-
-        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
+        attr_accessor :target_amount
 
-        sig { params(_: Integer).returns(Integer) }
-        def target_amount=(_)
-        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::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(
-          base_amount:,
-          base_currency:,
-          exponent:,
-          rate_string:,
-          target_amount:,
-          target_currency:,
-          value:
-        )
+        def self.new(base_amount:, base_currency:, exponent:, rate_string:, target_amount:, target_currency:, value:)
         end
 
         sig do
@@ -242,11 +171,11 @@ 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
               }
             )

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

@@ -6,67 +6,57 @@ module ModernTreasury
       extend ModernTreasury::RequestParameters::Converter
       include ModernTreasury::RequestParameters
 
+      # 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
 
-      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::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         internal_account_id:,
         target_currency:,
         base_amount: nil,
@@ -82,9 +72,9 @@ module ModernTreasury
           .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

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

@@ -7,76 +7,64 @@ 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
 
+      # 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::Util::AnyHash)
         )
-          .void
+          .returns(T.attached_class)
       end
-      def initialize(
+      def self.new(
         after_cursor: nil,
         base_currency: nil,
         effective_at_end: nil,

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