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

data/rbi/lib/modern_treasury/resources/virtual_accounts.rbi

@@ -3,47 +3,71 @@
 module ModernTreasury
   module Resources
     class VirtualAccounts
+      # create virtual_account
       sig do
         params(
           internal_account_id: String,
           name: String,
-          account_details: T::Array[ModernTreasury::Models::VirtualAccountCreateParams::AccountDetail],
+          account_details: T::Array[T.any(ModernTreasury::Models::VirtualAccountCreateParams::AccountDetail, ModernTreasury::Util::AnyHash)],
           counterparty_id: String,
           credit_ledger_account_id: String,
           debit_ledger_account_id: String,
           description: String,
-          ledger_account: ModernTreasury::Models::VirtualAccountCreateParams::LedgerAccount,
+          ledger_account: T.any(ModernTreasury::Models::VirtualAccountCreateParams::LedgerAccount, ModernTreasury::Util::AnyHash),
           metadata: T::Hash[Symbol, String],
-          routing_details: T::Array[ModernTreasury::Models::VirtualAccountCreateParams::RoutingDetail],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          routing_details: T::Array[T.any(ModernTreasury::Models::VirtualAccountCreateParams::RoutingDetail, ModernTreasury::Util::AnyHash)],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::VirtualAccount)
       end
       def create(
+        # The ID of the internal account that this virtual account is associated with.
         internal_account_id:,
+        # The name of the virtual account.
         name:,
+        # An array of account detail objects.
         account_details: nil,
+        # The ID of the counterparty that the virtual account belongs to.
         counterparty_id: nil,
+        # The ID of a credit normal ledger account. When money leaves the virtual account,
+        #   this ledger account will be credited. Must be accompanied by a
+        #   debit_ledger_account_id if present.
         credit_ledger_account_id: nil,
+        # The ID of a debit normal ledger account. When money enters the virtual account,
+        #   this ledger account will be debited. Must be accompanied by a
+        #   credit_ledger_account_id if present.
         debit_ledger_account_id: nil,
+        # An optional description for internal use.
         description: nil,
+        # Specifies a ledger account object that will be created with the virtual account.
+        #   The resulting ledger account is linked to the virtual account for auto-ledgering
+        #   IPDs.
         ledger_account: nil,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
         metadata: nil,
+        # An array of routing detail objects.
         routing_details: nil,
         request_options: {}
       )
       end
 
+      # get virtual_account
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::VirtualAccount)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # Virtual Acccount ID
+        id,
+        request_options: {}
+      )
       end
 
+      # update virtual_account
       sig do
         params(
           id: String,
@@ -51,13 +75,15 @@ module ModernTreasury
           ledger_account_id: String,
           metadata: T::Hash[Symbol, String],
           name: T.nilable(String),
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::VirtualAccount)
       end
       def update(
+        # Virtual Acccount ID
         id,
         counterparty_id: nil,
+        # The ledger account that you'd like to link to the virtual account.
         ledger_account_id: nil,
         metadata: nil,
         name: nil,
@@ -65,6 +91,7 @@ module ModernTreasury
       )
       end
 
+      # Get a list of virtual accounts.
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -72,7 +99,7 @@ module ModernTreasury
           internal_account_id: String,
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::VirtualAccount])
       end
@@ -80,24 +107,32 @@ module ModernTreasury
         after_cursor: nil,
         counterparty_id: nil,
         internal_account_id: nil,
+        # 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.
         metadata: nil,
         per_page: nil,
         request_options: {}
       )
       end
 
+      # delete virtual_account
       sig do
         params(
           id: String,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::VirtualAccount)
       end
-      def delete(id, request_options: {})
+      def delete(
+        # Virtual Acccount ID
+        id,
+        request_options: {}
+      )
       end
 
-      sig { params(client: ModernTreasury::Client).void }
-      def initialize(client:)
+      sig { params(client: ModernTreasury::Client).returns(T.attached_class) }
+      def self.new(client:)
       end
     end
   end

data/rbi/lib/modern_treasury/util.rbi

@@ -1,135 +1,281 @@
 # typed: strong
 
 module ModernTreasury
+  # @api private
   module Util
-    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
-    def self.primitive?(input)
-    end
+    # Due to the current WIP status of Shapes support in Sorbet, types referencing
+    #   this alias might be refined in the future.
+    AnyHash = T.type_alias { T::Hash[Symbol, T.anything] }
 
-    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
-    def self.coerce_boolean(input)
+    # @api private
+    sig { returns(Float) }
+    def self.monotonic_secs
     end
 
-    sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
-    def self.coerce_boolean!(input)
-    end
+    class << self
+      # @api private
+      sig { returns(String) }
+      def arch
+      end
 
-    sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
-    def self.coerce_integer(input)
+      # @api private
+      sig { returns(String) }
+      def os
+      end
     end
 
-    sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
-    def self.coerce_float(input)
-    end
+    class << self
+      # @api private
+      sig { params(input: T.anything).returns(T::Boolean) }
+      def primitive?(input)
+      end
 
-    sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
-    def self.coerce_hash(input)
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def coerce_boolean(input)
+      end
 
-    sig { returns(Float) }
-    def self.monotonic_secs
-    end
+      # @api private
+      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+      def coerce_boolean!(input)
+      end
 
-    sig do
-      params(
-        exceptions: T::Array[Exception],
-        sentinel: T.nilable(T.anything),
-        blk: T.nilable(T.proc.returns(T.anything))
-      )
-        .returns(T.nilable(T.anything))
-    end
-    def self.suppress(*exceptions, sentinel: nil, &blk)
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+      def coerce_integer(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+      def coerce_float(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+      def coerce_hash(input)
+      end
     end
 
+    # Use this to indicate that a value should be explicitly removed from a data
+    #   structure when using `ModernTreasury::Util.deep_merge`.
+    #
+    #   e.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging
+    #   `{a: 1}` and `{}` would produce `{a: 1}`.
     OMIT = T.let(T.anything, T.anything)
 
-    sig do
-      params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
-        .returns(T.anything)
-    end
-    def self.deep_merge(*values, sentinel: nil, concat: false)
-    end
+    class << self
+      # @api private
+      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+      private def deep_merge_lr(lhs, rhs, concat: false)
+      end
 
-    sig do
-      params(
-        data: T.any(T::Hash[Symbol, T.anything], T::Array[T.anything], T.anything),
-        pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
-        sentinel: T.nilable(T.anything),
-        blk: T.nilable(T.proc.returns(T.anything))
+      # @api private
+      #
+      # Recursively merge one hash with another. If the values at a given key are not
+      #   both hashes, just take the new value.
+      sig do
+        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+          .returns(T.anything)
+      end
+      def deep_merge(
+        *values,
+        # the value to return if no values are provided.
+        sentinel: nil,
+        # whether to merge sequences by concatenation.
+        concat: false
       )
-        .returns(T.nilable(T.anything))
-    end
-    def self.dig(data, pick, sentinel = nil, &blk)
-    end
+      end
 
-    sig { params(uri: URI::Generic).returns(String) }
-    def self.uri_origin(uri)
+      # @api private
+      sig do
+        params(
+          data: T.any(ModernTreasury::Util::AnyHash, T::Array[T.anything], T.anything),
+          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
+          sentinel: T.nilable(T.anything),
+          blk: T.nilable(T.proc.returns(T.anything))
+        )
+          .returns(T.nilable(T.anything))
+      end
+      def dig(data, pick, sentinel = nil, &blk)
+      end
     end
 
-    sig { params(path: T.any(String, T::Array[String])).returns(String) }
-    def self.interpolate_path(path)
-    end
+    class << self
+      # @api private
+      sig { params(uri: URI::Generic).returns(String) }
+      def uri_origin(uri)
+      end
 
-    ParsedUriShape = T.type_alias do
-      {
-        scheme: T.nilable(String),
-        host: T.nilable(String),
-        port: T.nilable(Integer),
-        path: T.nilable(String),
-        query: T::Hash[String, T::Array[String]]
-      }
+      # @api private
+      sig { params(path: T.any(String, T::Array[String])).returns(String) }
+      def interpolate_path(path)
+      end
     end
 
-    sig { params(url: T.any(URI::Generic, String)).returns(ModernTreasury::Util::ParsedUriShape) }
-    def self.parse_uri(url)
-    end
+    class << self
+      # @api private
+      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+      def decode_query(query)
+      end
 
-    sig { params(parsed: ModernTreasury::Util::ParsedUriShape).returns(URI::Generic) }
-    def self.unparse_uri(parsed)
+      # @api private
+      sig do
+        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+          .returns(T.nilable(String))
+      end
+      def encode_query(query)
+      end
     end
 
-    sig do
-      params(lhs: ModernTreasury::Util::ParsedUriShape, rhs: ModernTreasury::Util::ParsedUriShape)
-        .returns(URI::Generic)
-    end
-    def self.join_parsed_uri(lhs, rhs)
-    end
+    ParsedUriShape =
+      T.type_alias do
+        {
+          scheme: T.nilable(String),
+          host: T.nilable(String),
+          port: T.nilable(Integer),
+          path: T.nilable(String),
+          query: T::Hash[String, T::Array[String]]
+        }
+      end
 
-    sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
-    def self.decode_query(query)
-    end
+    class << self
+      # @api private
+      sig { params(url: T.any(URI::Generic, String)).returns(ModernTreasury::Util::ParsedUriShape) }
+      def parse_uri(url)
+      end
 
-    sig do
-      params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(String))
-    end
-    def self.encode_query(query)
+      # @api private
+      sig { params(parsed: ModernTreasury::Util::ParsedUriShape).returns(URI::Generic) }
+      def unparse_uri(parsed)
+      end
+
+      # @api private
+      sig do
+        params(lhs: ModernTreasury::Util::ParsedUriShape, rhs: ModernTreasury::Util::ParsedUriShape)
+          .returns(URI::Generic)
+      end
+      def join_parsed_uri(lhs, rhs)
+      end
     end
 
-    sig do
-      params(headers: T::Array[T::Hash[String, T.nilable(T.any(String, Integer))]])
-        .returns(T::Hash[String, String])
+    class << self
+      # @api private
+      sig do
+        params(
+          headers: T::Hash[String,
+                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
+        )
+          .returns(T::Hash[String, String])
+      end
+      def normalized_headers(*headers)
+      end
     end
-    def self.normalized_headers(*headers)
+
+    # @api private
+    #
+    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+    class ReadIOAdapter
+      # @api private
+      sig { params(max_len: T.nilable(Integer)).returns(String) }
+      private def read_enum(max_len)
+      end
+
+      # @api private
+      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
+      def read(max_len = nil, out_string = nil)
+      end
+
+      # @api private
+      sig do
+        params(
+          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(stream, &blk)
+      end
     end
 
-    sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
-    def self.encode_content(headers, body)
+    class << self
+      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
+      def string_io(&blk)
+      end
     end
 
-    sig do
-      params(
-        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        stream: T::Enumerable[String],
-        suppress_error: T::Boolean
-      )
-        .returns(T.anything)
+    class << self
+      # @api private
+      sig do
+        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+      end
+      private def encode_multipart_formdata(y, boundary:, key:, val:)
+      end
+
+      # @api private
+      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
+      private def encode_multipart_streaming(body)
+      end
+
+      # @api private
+      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+      def encode_content(headers, body)
+      end
+
+      # @api private
+      sig do
+        params(
+          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+          stream: T::Enumerable[String],
+          suppress_error: T::Boolean
+        )
+          .returns(T.anything)
+      end
+      def decode_content(headers, stream:, suppress_error: false)
+      end
     end
-    def self.decode_content(headers, stream:, suppress_error: false)
+
+    class << self
+      # @api private
+      #
+      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
+      sig do
+        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def fused_enum(enum, external: false, &close)
+      end
+
+      # @api private
+      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+      def close_fused!(enum)
+      end
+
+      # @api private
+      sig do
+        params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def chain_fused(enum, &blk)
+      end
     end
 
-    sig { params(io: StringIO, boundary: String, key: T.any(Symbol, String), val: T.anything).void }
-    private_class_method def self.encode_multipart_formdata(io, boundary:, key:, val:)
+    ServerSentEvent =
+      T.type_alias do
+        {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
+      end
+
+    class << self
+      # @api private
+      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+      def decode_lines(enum)
+      end
+
+      # @api private
+      #
+      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+      sig { params(lines: T::Enumerable[String]).returns(ModernTreasury::Util::ServerSentEvent) }
+      def decode_sse(lines)
+      end
     end
   end
 end

data/rbi/lib/modern_treasury/version.rbi

@@ -1,5 +1,5 @@
 # typed: strong
 
 module ModernTreasury
-  VERSION = "0.1.0-alpha.15"
+  VERSION = "0.1.0-alpha.16"
 end

data/sig/modern_treasury/base_client.rbs

@@ -5,10 +5,13 @@ module ModernTreasury
         method: Symbol,
         path: String | ::Array[String],
         query: ::Hash[String, (::Array[String] | String)?]?,
-        headers: ::Hash[String, String?]?,
+        headers: ::Hash[String, (String
+        | Integer
+        | ::Array[(String | Integer)?])?]?,
         body: top?,
         unwrap: Symbol?,
         page: Class?,
+        stream: Class?,
         model: ModernTreasury::Converter::input?,
         options: ModernTreasury::request_opts?
       }
@@ -19,13 +22,14 @@ module ModernTreasury
         url: URI::Generic,
         headers: ::Hash[String, String],
         body: top,
-        streaming: bool,
         max_retries: Integer,
         timeout: Float
       }
 
     MAX_REDIRECTS: 20
 
+    PLATFORM_HEADERS: ::Hash[String, String]
+
     def self.validate!: (
       ModernTreasury::BaseClient::request_components req
     ) -> void
@@ -41,17 +45,24 @@ module ModernTreasury
       response_headers: ::Hash[String, String]
     ) -> ModernTreasury::BaseClient::request_input
 
-    # @private
+    def self.reap_connection!: (
+      Integer | ModernTreasury::APIConnectionError status,
+      stream: Enumerable[String]?
+    ) -> void
+
+    # @api private
     attr_accessor requester: top
 
     def initialize: (
       base_url: String,
-      timeout: Float,
-      max_retries: Integer,
-      initial_retry_delay: Float,
-      max_retry_delay: Float,
-      headers: ::Hash[String, String?],
-      idempotency_header: String?
+      ?timeout: Float,
+      ?max_retries: Integer,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float,
+      ?headers: ::Hash[String, (String
+      | Integer
+      | ::Array[(String | Integer)?])?],
+      ?idempotency_header: String?
     ) -> void
 
     private def auth_headers: -> ::Hash[String, String]
@@ -73,25 +84,22 @@ module ModernTreasury
       redirect_count: Integer,
       retry_count: Integer,
       send_retry_header: bool
-    ) -> [top, Enumerable[String]]
-
-    private def parse_response: (
-      ModernTreasury::BaseClient::request_components req,
-      headers: ::Hash[String, String],
-      stream: Enumerable[String]
-    ) -> top
+    ) -> [Integer, top, Enumerable[String]]
 
     def request:
       (
         Symbol method,
         String | ::Array[String] path,
-        query: ::Hash[String, (::Array[String] | String)?]?,
-        headers: ::Hash[String, String?]?,
-        body: top?,
-        unwrap: Symbol?,
-        page: Class?,
-        model: ModernTreasury::Converter::input?,
-        options: ModernTreasury::request_opts?
+        ?query: ::Hash[String, (::Array[String] | String)?]?,
+        ?headers: ::Hash[String, (String
+        | Integer
+        | ::Array[(String | Integer)?])?]?,
+        ?body: top?,
+        ?unwrap: Symbol?,
+        ?page: Class?,
+        ?stream: Class?,
+        ?model: ModernTreasury::Converter::input?,
+        ?options: ModernTreasury::request_opts?
       ) -> top
       | (ModernTreasury::BaseClient::request_components req) -> top