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

data/rbi/lib/modern_treasury/page.rbi

@@ -7,32 +7,10 @@ module ModernTreasury
     Elem = type_member
 
     sig { returns(Integer) }
-    def per_page
-    end
-
-    sig { params(_: Integer).returns(Integer) }
-    def per_page=(_)
-    end
+    attr_accessor :per_page
 
     sig { returns(String) }
-    def after_cursor
-    end
-
-    sig { params(_: String).returns(String) }
-    def after_cursor=(_)
-    end
-
-    sig do
-      params(
-        client: ModernTreasury::BaseClient,
-        req: ModernTreasury::BaseClient::RequestComponentsShape,
-        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-        unwrapped: T::Hash[Symbol, T.anything]
-      )
-        .void
-    end
-    def initialize(client:, req:, headers:, unwrapped:)
-    end
+    attr_accessor :after_cursor
 
     sig { override.returns(T::Boolean) }
     def next_page?
@@ -45,5 +23,9 @@ module ModernTreasury
     sig { override.params(blk: T.proc.params(arg0: Elem).void).void }
     def auto_paging_each(&blk)
     end
+
+    sig { returns(String) }
+    def inspect
+    end
   end
 end

data/rbi/lib/modern_treasury/pooled_net_requester.rbi

@@ -1,59 +1,62 @@
 # typed: strong
 
 module ModernTreasury
+  # @api private
   class PooledNetRequester
-    RequestShape = T.type_alias do
-      {
-        method: Symbol,
-        url: URI::Generic,
-        headers: T::Hash[String, String],
-        body: T.anything,
-        streaming: T::Boolean,
-        max_retries: Integer,
-        deadline: Float
-      }
-    end
+    RequestShape =
+      T.type_alias do
+        {
+          method: Symbol,
+          url: URI::Generic,
+          headers: T::Hash[String, String],
+          body: T.anything,
+          deadline: Float
+        }
+      end
 
-    sig { params(url: URI::Generic).returns(Net::HTTP) }
-    def self.connect(url)
-    end
+    # from the golang stdlib
+    #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+    KEEP_ALIVE_TIMEOUT = 30
 
-    sig { params(conn: Net::HTTP, deadline: Float).void }
-    private_class_method def self.calibrate_socket_timeout(conn, deadline)
-    end
+    class << self
+      # @api private
+      sig { params(url: URI::Generic).returns(Net::HTTP) }
+      def connect(url)
+      end
 
-    sig do
-      params(
-        conn: Net::HTTP,
-        req: Net::HTTPGenericRequest,
-        deadline: Float,
-        blk: T.proc.params(arg0: T.any(Net::HTTPGenericRequest, String)).void
-      )
-        .void
-    end
-    def self.transport(conn, req, deadline, &blk)
-    end
+      # @api private
+      sig { params(conn: Net::HTTP, deadline: Float).void }
+      def calibrate_socket_timeout(conn, deadline)
+      end
 
-    sig do
-      params(
-        url: URI::Generic,
-        streaming: T::Boolean,
-        blk: T.proc.params(arg0: Net::HTTP, arg1: Enumerator::Yielder).void
-      )
-        .void
+      # @api private
+      sig do
+        params(
+          request: ModernTreasury::PooledNetRequester::RequestShape,
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(Net::HTTPGenericRequest)
+      end
+      def build_request(request, &blk)
+      end
     end
-    private def with_pool(url, streaming:, &blk)
+
+    # @api private
+    sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void }
+    private def with_pool(url, deadline:, &blk)
     end
 
+    # @api private
     sig do
       params(request: ModernTreasury::PooledNetRequester::RequestShape)
-        .returns([Net::HTTPResponse, T::Enumerable[String]])
+        .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
     end
     def execute(request)
     end
 
-    sig { void }
-    def initialize
+    # @api private
+    sig { params(size: Integer).returns(T.attached_class) }
+    def self.new(size: Etc.nprocessors)
     end
   end
 end

data/rbi/lib/modern_treasury/request_options.rbi

@@ -1,84 +1,63 @@
 # typed: strong
 
 module ModernTreasury
+  # @api private
   module RequestParameters
-    abstract!
-
-    sig { returns(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything])) }
-    def request_options
-    end
-
-    sig do
-      params(_: T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
-        .returns(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
-    end
-    def request_options=(_)
-    end
+    # Options to specify HTTP behaviour for this request.
+    sig { returns(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash)) }
+    attr_accessor :request_options
 
+    # @api private
     module Converter
-      sig { params(params: T.anything).returns([T.anything, T::Hash[Symbol, T.anything]]) }
+      # @api private
+      sig { params(params: T.anything).returns([T.anything, ModernTreasury::Util::AnyHash]) }
       def dump_request(params)
       end
     end
   end
 
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  #   or override those provided at the client level.
+  #
+  #   When making a request, you can pass an actual {RequestOptions} instance, or
+  #   simply pass a Hash with symbol keys matching the attributes on this class.
   class RequestOptions < ModernTreasury::BaseModel
+    # @api private
     sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
     def self.validate!(opts)
     end
 
+    # Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
     sig { returns(T.nilable(String)) }
-    def idempotency_key
-    end
-
-    sig { params(_: T.nilable(String)).returns(T.nilable(String)) }
-    def idempotency_key=(_)
-    end
+    attr_accessor :idempotency_key
 
+    # Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
-    def extra_query
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-        .returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
-    end
-    def extra_query=(_)
-    end
+    attr_accessor :extra_query
 
+    # Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
     sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
-    def extra_headers
-    end
-
-    sig do
-      params(_: T.nilable(T::Hash[String, T.nilable(String)]))
-        .returns(T.nilable(T::Hash[String, T.nilable(String)]))
-    end
-    def extra_headers=(_)
-    end
+    attr_accessor :extra_headers
 
-    sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body
-    end
-
-    sig { params(_: T.nilable(T::Hash[Symbol, T.anything])).returns(T.nilable(T::Hash[Symbol, T.anything])) }
-    def extra_body=(_)
-    end
+    # Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
 
+    # Maximum number of retries to attempt after a failed initial request.
     sig { returns(T.nilable(Integer)) }
-    def max_retries
-    end
-
-    sig { params(_: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def max_retries=(_)
-    end
+    attr_accessor :max_retries
 
+    # Request timeout in seconds.
     sig { returns(T.nilable(Float)) }
-    def timeout
-    end
+    attr_accessor :timeout
 
-    sig { params(_: T.nilable(Float)).returns(T.nilable(Float)) }
-    def timeout=(_)
+    # Returns a new instance of RequestOptions.
+    sig { params(values: ModernTreasury::Util::AnyHash).returns(T.attached_class) }
+    def self.new(values = {})
     end
   end
 end

data/rbi/lib/modern_treasury/resources/account_collection_flows.rbi

@@ -3,39 +3,60 @@
 module ModernTreasury
   module Resources
     class AccountCollectionFlows
+      # create account_collection_flow
       sig do
         params(
           counterparty_id: String,
           payment_types: T::Array[String],
-          receiving_countries: T::Array[Symbol],
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          receiving_countries: T::Array[ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry::OrSymbol],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountCollectionFlow)
       end
-      def create(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {})
+      def create(
+        # Required.
+        counterparty_id:,
+        payment_types:,
+        receiving_countries: nil,
+        request_options: {}
+      )
       end
 
+      # get account_collection_flow
       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::AccountCollectionFlow)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # update account_collection_flow
       sig do
         params(
           id: String,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          status: ModernTreasury::Models::AccountCollectionFlowUpdateParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountCollectionFlow)
       end
-      def update(id, status:, request_options: {})
+      def update(
+        # id
+        id,
+        # Required. The updated status of the account collection flow. Can only be used to
+        #   mark a flow as `cancelled`.
+        status:,
+        request_options: {}
+      )
       end
 
+      # list account_collection_flows
       sig do
         params(
           after_cursor: T.nilable(String),
@@ -44,7 +65,7 @@ module ModernTreasury
           external_account_id: String,
           per_page: Integer,
           status: 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::Page[ModernTreasury::Models::AccountCollectionFlow])
       end
@@ -59,8 +80,8 @@ module ModernTreasury
       )
       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/resources/account_details.rbi

@@ -3,58 +3,97 @@
 module ModernTreasury
   module Resources
     class AccountDetails
+      # Create an account detail for an external account.
       sig do
         params(
           account_id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailCreateParams::AccountsType::OrSymbol,
           account_number: String,
-          account_number_type: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          account_number_type: ModernTreasury::Models::AccountDetailCreateParams::AccountNumberType::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Models::AccountDetail)
       end
-      def create(account_id, accounts_type:, account_number:, account_number_type: nil, request_options: {})
+      def create(
+        # Path param: The ID of the account.
+        account_id,
+        # Path param:
+        accounts_type:,
+        # Body param: The account number for the bank account.
+        account_number:,
+        # Body param: One of `iban`, `clabe`, `wallet_address`, or `other`. Use `other` if
+        #   the bank account number is in a generic format.
+        account_number_type: nil,
+        request_options: {}
+      )
       end
 
+      # Get a single account detail for a single internal or external account.
       sig do
         params(
           id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           account_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::AccountDetail)
       end
-      def retrieve(id, accounts_type:, account_id:, request_options: {})
+      def retrieve(
+        # The ID of the account detail.
+        id,
+        accounts_type:,
+        # The ID of the account.
+        account_id:,
+        request_options: {}
+      )
       end
 
+      # Get a list of account details for a single internal or external account.
       sig do
         params(
           account_id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountsType::OrSymbol,
           after_cursor: T.nilable(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::AccountDetail])
       end
-      def list(account_id, accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
+      def list(
+        # Path param: The ID of the account.
+        account_id,
+        # Path param:
+        accounts_type:,
+        # Query param:
+        after_cursor: nil,
+        # Query param:
+        per_page: nil,
+        request_options: {}
+      )
       end
 
+      # Delete a single account detail for an external account.
       sig do
         params(
           id: String,
-          accounts_type: Symbol,
+          accounts_type: ModernTreasury::Models::AccountDetailDeleteParams::AccountsType::OrSymbol,
           account_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))
         )
           .void
       end
-      def delete(id, accounts_type:, account_id:, request_options: {})
+      def delete(
+        # The ID of the account detail.
+        id,
+        accounts_type:,
+        # The ID of the account.
+        account_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/resources/bulk_requests.rbi

@@ -3,13 +3,15 @@
 module ModernTreasury
   module Resources
     class BulkRequests
+      # create bulk_request
       sig do
         params(
-          action_type: Symbol,
-          resource_type: Symbol,
+          action_type: ModernTreasury::Models::BulkRequestCreateParams::ActionType::OrSymbol,
+          resource_type: ModernTreasury::Models::BulkRequestCreateParams::ResourceType::OrSymbol,
           resources: T::Array[
           T.any(
             ModernTreasury::Models::BulkRequestCreateParams::Resource::PaymentOrderAsyncCreateRequest,
+            ModernTreasury::Util::AnyHash,
             ModernTreasury::Models::BulkRequestCreateParams::Resource::ExpectedPaymentCreateRequest,
             ModernTreasury::Models::BulkRequestCreateParams::Resource::LedgerTransactionCreateRequest,
             ModernTreasury::Models::BulkRequestCreateParams::Resource::TransactionCreateRequest,
@@ -21,48 +23,72 @@ module ModernTreasury
           )
           ],
           metadata: T::Hash[Symbol, 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::BulkRequest)
       end
-      def create(action_type:, resource_type:, resources:, metadata: nil, request_options: {})
+      def create(
+        # One of create, or update.
+        action_type:,
+        # One of payment_order, expected_payment, or ledger_transaction.
+        resource_type:,
+        # An array of objects where each object contains the input params for a single
+        #   `action_type` request on a `resource_type` resource
+        resources:,
+        # Additional data represented as key-value pairs. Both the key and value must be
+        #   strings.
+        metadata: nil,
+        request_options: {}
+      )
       end
 
+      # get bulk_request
       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::BulkRequest)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # list bulk_requests
       sig do
         params(
-          action_type: Symbol,
+          action_type: ModernTreasury::Models::BulkRequestListParams::ActionType::OrSymbol,
           after_cursor: T.nilable(String),
           metadata: T::Hash[Symbol, String],
           per_page: Integer,
-          resource_type: Symbol,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          resource_type: ModernTreasury::Models::BulkRequestListParams::ResourceType::OrSymbol,
+          status: ModernTreasury::Models::BulkRequestListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::BulkRequest])
       end
       def list(
+        # One of create, or update.
         action_type: nil,
         after_cursor: 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,
+        # One of payment_order, expected_payment, or ledger_transaction.
         resource_type: nil,
+        # One of pending, processing, or completed.
         status: nil,
         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/resources/bulk_results.rbi

@@ -3,43 +3,57 @@
 module ModernTreasury
   module Resources
     class BulkResults
+      # get bulk_result
       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::BulkResult)
       end
-      def retrieve(id, request_options: {})
+      def retrieve(
+        # id
+        id,
+        request_options: {}
+      )
       end
 
+      # list bulk_results
       sig do
         params(
           after_cursor: T.nilable(String),
           entity_id: String,
-          entity_type: Symbol,
+          entity_type: ModernTreasury::Models::BulkResultListParams::EntityType::OrSymbol,
           per_page: Integer,
           request_id: String,
-          request_type: Symbol,
-          status: Symbol,
-          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          request_type: ModernTreasury::Models::BulkResultListParams::RequestType::OrSymbol,
+          status: ModernTreasury::Models::BulkResultListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Util::AnyHash))
         )
           .returns(ModernTreasury::Page[ModernTreasury::Models::BulkResult])
       end
       def list(
         after_cursor: nil,
+        # Unique identifier for the result entity object.
         entity_id: nil,
+        # The type of the request that created this result. bulk_request is the only
+        #   supported `request_type`
         entity_type: nil,
         per_page: nil,
+        # Unique identifier for the request that created this bulk result. This is the ID
+        #   of the bulk request when `request_type` is bulk_request
         request_id: nil,
+        # The type of the request that created this result. bulk_request is the only
+        #   supported `request_type`
         request_type: nil,
+        # One of successful or failed.
         status: nil,
         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