modern_treasury 0.0.0 → 0.1.0.pre.alpha.15

data/rbi/lib/modern_treasury/resources/routing_details.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module ModernTreasury
+  module Resources
+    class RoutingDetails
+      sig do
+        params(
+          account_id: String,
+          accounts_type: Symbol,
+          routing_number: String,
+          routing_number_type: Symbol,
+          payment_type: T.nilable(Symbol),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::RoutingDetail)
+      end
+      def create(
+        account_id,
+        accounts_type:,
+        routing_number:,
+        routing_number_type:,
+        payment_type: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          accounts_type: Symbol,
+          account_id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::RoutingDetail)
+      end
+      def retrieve(id, accounts_type:, account_id:, request_options: {})
+      end
+
+      sig do
+        params(
+          account_id: String,
+          accounts_type: Symbol,
+          after_cursor: T.nilable(String),
+          per_page: Integer,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Page[ModernTreasury::Models::RoutingDetail])
+      end
+      def list(account_id, accounts_type:, after_cursor: nil, per_page: nil, request_options: {})
+      end
+
+      sig do
+        params(
+          id: String,
+          accounts_type: Symbol,
+          account_id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .void
+      end
+      def delete(id, accounts_type:, account_id:, request_options: {})
+      end
+
+      sig { params(client: ModernTreasury::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

data/rbi/lib/modern_treasury/resources/transactions/line_items.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module ModernTreasury
+  module Resources
+    class Transactions
+      class LineItems
+        sig do
+          params(
+            amount: Integer,
+            expected_payment_id: String,
+            transaction_id: String,
+            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(ModernTreasury::Models::Transactions::TransactionLineItem)
+        end
+        def create(amount:, expected_payment_id:, transaction_id:, request_options: {})
+        end
+
+        sig do
+          params(
+            id: String,
+            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(ModernTreasury::Models::Transactions::TransactionLineItem)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        sig do
+          params(
+            id: T::Hash[Symbol, String],
+            after_cursor: T.nilable(String),
+            per_page: Integer,
+            transaction_id: String,
+            type: T.nilable(Symbol),
+            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .returns(ModernTreasury::Page[ModernTreasury::Models::Transactions::TransactionLineItem])
+        end
+        def list(
+          id: nil,
+          after_cursor: nil,
+          per_page: nil,
+          transaction_id: nil,
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          params(
+            id: String,
+            request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+          )
+            .void
+        end
+        def delete(id, request_options: {})
+        end
+
+        sig { params(client: ModernTreasury::Client).void }
+        def initialize(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/modern_treasury/resources/transactions.rbi

@@ -0,0 +1,116 @@
+# typed: strong
+
+module ModernTreasury
+  module Resources
+    class Transactions
+      sig { returns(ModernTreasury::Resources::Transactions::LineItems) }
+      def line_items
+      end
+
+      sig do
+        params(
+          amount: Integer,
+          as_of_date: T.nilable(Date),
+          direction: String,
+          internal_account_id: String,
+          vendor_code: T.nilable(String),
+          vendor_code_type: T.nilable(String),
+          metadata: T::Hash[Symbol, String],
+          posted: T::Boolean,
+          type: T.nilable(Symbol),
+          vendor_description: T.nilable(String),
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::Transaction)
+      end
+      def create(
+        amount:,
+        as_of_date:,
+        direction:,
+        internal_account_id:,
+        vendor_code:,
+        vendor_code_type:,
+        metadata: nil,
+        posted: nil,
+        type: nil,
+        vendor_description: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::Transaction)
+      end
+      def retrieve(id, request_options: {})
+      end
+
+      sig do
+        params(
+          id: String,
+          metadata: T::Hash[Symbol, String],
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::Transaction)
+      end
+      def update(id, metadata: nil, request_options: {})
+      end
+
+      sig do
+        params(
+          after_cursor: T.nilable(String),
+          as_of_date_end: Date,
+          as_of_date_start: Date,
+          counterparty_id: String,
+          description: String,
+          direction: String,
+          internal_account_id: String,
+          metadata: T::Hash[Symbol, String],
+          payment_type: String,
+          per_page: Integer,
+          posted: T::Boolean,
+          transactable_type: String,
+          vendor_id: String,
+          virtual_account_id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Page[ModernTreasury::Models::Transaction])
+      end
+      def list(
+        after_cursor: nil,
+        as_of_date_end: nil,
+        as_of_date_start: nil,
+        counterparty_id: nil,
+        description: nil,
+        direction: nil,
+        internal_account_id: nil,
+        metadata: nil,
+        payment_type: nil,
+        per_page: nil,
+        posted: nil,
+        transactable_type: nil,
+        vendor_id: nil,
+        virtual_account_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .void
+      end
+      def delete(id, request_options: {})
+      end
+
+      sig { params(client: ModernTreasury::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

data/rbi/lib/modern_treasury/resources/validations.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module ModernTreasury
+  module Resources
+    class Validations
+      sig do
+        params(
+          routing_number: String,
+          routing_number_type: Symbol,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::RoutingNumberLookupRequest)
+      end
+      def validate_routing_number(routing_number:, routing_number_type:, request_options: {})
+      end
+
+      sig { params(client: ModernTreasury::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# typed: strong
+
+module ModernTreasury
+  module Resources
+    class VirtualAccounts
+      sig do
+        params(
+          internal_account_id: String,
+          name: String,
+          account_details: T::Array[ModernTreasury::Models::VirtualAccountCreateParams::AccountDetail],
+          counterparty_id: String,
+          credit_ledger_account_id: String,
+          debit_ledger_account_id: String,
+          description: String,
+          ledger_account: ModernTreasury::Models::VirtualAccountCreateParams::LedgerAccount,
+          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]))
+        )
+          .returns(ModernTreasury::Models::VirtualAccount)
+      end
+      def create(
+        internal_account_id:,
+        name:,
+        account_details: nil,
+        counterparty_id: nil,
+        credit_ledger_account_id: nil,
+        debit_ledger_account_id: nil,
+        description: nil,
+        ledger_account: nil,
+        metadata: nil,
+        routing_details: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::VirtualAccount)
+      end
+      def retrieve(id, request_options: {})
+      end
+
+      sig do
+        params(
+          id: String,
+          counterparty_id: String,
+          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]))
+        )
+          .returns(ModernTreasury::Models::VirtualAccount)
+      end
+      def update(
+        id,
+        counterparty_id: nil,
+        ledger_account_id: nil,
+        metadata: nil,
+        name: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          after_cursor: T.nilable(String),
+          counterparty_id: String,
+          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]))
+        )
+          .returns(ModernTreasury::Page[ModernTreasury::Models::VirtualAccount])
+      end
+      def list(
+        after_cursor: nil,
+        counterparty_id: nil,
+        internal_account_id: nil,
+        metadata: nil,
+        per_page: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        params(
+          id: String,
+          request_options: T.nilable(T.any(ModernTreasury::RequestOptions, T::Hash[Symbol, T.anything]))
+        )
+          .returns(ModernTreasury::Models::VirtualAccount)
+      end
+      def delete(id, request_options: {})
+      end
+
+      sig { params(client: ModernTreasury::Client).void }
+      def initialize(client:)
+      end
+    end
+  end
+end

data/rbi/lib/modern_treasury/util.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module ModernTreasury
+  module Util
+    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+    def self.primitive?(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+    def self.coerce_boolean(input)
+    end
+
+    sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+    def self.coerce_boolean!(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+    def self.coerce_integer(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+    def self.coerce_float(input)
+    end
+
+    sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+    def self.coerce_hash(input)
+    end
+
+    sig { returns(Float) }
+    def self.monotonic_secs
+    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)
+    end
+
+    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
+
+    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))
+      )
+        .returns(T.nilable(T.anything))
+    end
+    def self.dig(data, pick, sentinel = nil, &blk)
+    end
+
+    sig { params(uri: URI::Generic).returns(String) }
+    def self.uri_origin(uri)
+    end
+
+    sig { params(path: T.any(String, T::Array[String])).returns(String) }
+    def self.interpolate_path(path)
+    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(url: T.any(URI::Generic, String)).returns(ModernTreasury::Util::ParsedUriShape) }
+    def self.parse_uri(url)
+    end
+
+    sig { params(parsed: ModernTreasury::Util::ParsedUriShape).returns(URI::Generic) }
+    def self.unparse_uri(parsed)
+    end
+
+    sig do
+      params(lhs: ModernTreasury::Util::ParsedUriShape, rhs: ModernTreasury::Util::ParsedUriShape)
+        .returns(URI::Generic)
+    end
+    def self.join_parsed_uri(lhs, rhs)
+    end
+
+    sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+    def self.decode_query(query)
+    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)
+    end
+
+    sig do
+      params(headers: T::Array[T::Hash[String, T.nilable(T.any(String, Integer))]])
+        .returns(T::Hash[String, String])
+    end
+    def self.normalized_headers(*headers)
+    end
+
+    sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+    def self.encode_content(headers, body)
+    end
+
+    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 self.decode_content(headers, stream:, suppress_error: false)
+    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:)
+    end
+  end
+end

data/rbi/lib/modern_treasury/version.rbi

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

data/sig/modern_treasury/base_client.rbs

@@ -0,0 +1,100 @@
+module ModernTreasury
+  class BaseClient
+    type request_components =
+      {
+        method: Symbol,
+        path: String | ::Array[String],
+        query: ::Hash[String, (::Array[String] | String)?]?,
+        headers: ::Hash[String, String?]?,
+        body: top?,
+        unwrap: Symbol?,
+        page: Class?,
+        model: ModernTreasury::Converter::input?,
+        options: ModernTreasury::request_opts?
+      }
+
+    type request_input =
+      {
+        method: Symbol,
+        url: URI::Generic,
+        headers: ::Hash[String, String],
+        body: top,
+        streaming: bool,
+        max_retries: Integer,
+        timeout: Float
+      }
+
+    MAX_REDIRECTS: 20
+
+    def self.validate!: (
+      ModernTreasury::BaseClient::request_components req
+    ) -> void
+
+    def self.should_retry?: (
+      Integer status,
+      headers: ::Hash[String, String]
+    ) -> bool
+
+    def self.follow_redirect: (
+      ModernTreasury::BaseClient::request_input request,
+      status: Integer,
+      response_headers: ::Hash[String, String]
+    ) -> ModernTreasury::BaseClient::request_input
+
+    # @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?
+    ) -> void
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    private def generate_idempotency_key: -> String
+
+    private def build_request: (
+      ModernTreasury::BaseClient::request_components req,
+      ModernTreasury::request_options opts
+    ) -> ModernTreasury::BaseClient::request_input
+
+    private def retry_delay: (
+      ::Hash[String, String] headers,
+      retry_count: Integer
+    ) -> Float
+
+    private def send_request: (
+      ModernTreasury::BaseClient::request_input request,
+      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
+
+    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?
+      ) -> top
+      | (ModernTreasury::BaseClient::request_components req) -> top
+
+    def inspect: -> String
+  end
+end