modern_treasury 0.0.0 → 0.1.0.pre.alpha.15

data/rbi/lib/modern_treasury/base_model.rbi

@@ -0,0 +1,480 @@
+# typed: strong
+
+module ModernTreasury
+  module Converter
+    abstract!
+
+    Input = T.type_alias { T.any(ModernTreasury::Converter, T::Class[T.anything]) }
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def coerce(value)
+    end
+
+    sig { overridable.params(value: T.anything).returns(T.anything) }
+    def dump(value)
+    end
+
+    sig do
+      overridable
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig do
+      params(
+        spec: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(ModernTreasury::Converter::Input)),
+            union: T.nilable(T.proc.returns(ModernTreasury::Converter::Input))
+          },
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        )
+      )
+        .returns(T.proc.returns(T.anything).void)
+    end
+    def self.type_info(spec)
+    end
+
+    sig { params(target: ModernTreasury::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.coerce(target, value)
+    end
+
+    sig { params(target: ModernTreasury::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.dump(target, value)
+    end
+
+    sig { params(target: ModernTreasury::Converter::Input, value: T.anything).returns(T.anything) }
+    def self.try_strict_coerce(target, value)
+    end
+  end
+
+  class Unknown
+    abstract!
+
+    extend ModernTreasury::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class BooleanModel
+    abstract!
+
+    extend ModernTreasury::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(T::Boolean, T.anything)).returns(T.any(T::Boolean, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Enum
+    abstract!
+
+    extend ModernTreasury::Converter
+
+    sig { overridable.returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]) }
+    def self.values
+    end
+
+    sig { void }
+    private_class_method def self.finalize!
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.any(String, Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.any(Symbol, T.anything)).returns(T.any(Symbol, T.anything)) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class Union
+    abstract!
+
+    extend ModernTreasury::Extern
+    extend ModernTreasury::Converter
+
+    sig { returns(T::Array[[T.nilable(Symbol), Proc]]) }
+    private_class_method def self.known_variants
+    end
+
+    sig { overridable.returns(T::Array[[T.nilable(Symbol), T.anything]]) }
+    private_class_method def self.variants
+    end
+
+    sig { params(property: Symbol).void }
+    private_class_method def self.discriminator(property)
+    end
+
+    sig do
+      params(
+        key: T.any(
+          Symbol,
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        )
+      )
+        .void
+    end
+    private_class_method def self.variant(key, spec = nil)
+    end
+
+    sig { params(value: T.anything).returns(T.nilable(ModernTreasury::Converter::Input)) }
+    private_class_method def self.resolve_variant(value)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def self.==(other)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.coerce(value)
+    end
+
+    sig { override.params(value: T.anything).returns(T.anything) }
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+  end
+
+  class ArrayOf
+    abstract!
+
+    include ModernTreasury::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Enumerable[T.anything], T.anything))
+        .returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Enumerable[T.anything], T.anything))
+        .returns(T.any(T::Array[T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(ModernTreasury::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class HashOf
+    abstract!
+
+    include ModernTreasury::Converter
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ===(other)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T::Hash[Symbol, T.anything], T.anything))
+    end
+    def dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def try_strict_coerce(value)
+    end
+
+    sig { returns(ModernTreasury::Converter::Input) }
+    protected def item_type
+    end
+
+    sig do
+      params(
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def initialize(type_info, spec = {})
+    end
+  end
+
+  class BaseModel
+    abstract!
+
+    extend ModernTreasury::Extern
+    extend ModernTreasury::Converter
+
+    KnownFieldShape = T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean} }
+
+    sig do
+      returns(
+        T::Hash[
+        Symbol,
+        T.all(
+          ModernTreasury::BaseModel::KnownFieldShape,
+          {type_fn: T.proc.returns(ModernTreasury::Converter::Input)}
+        )
+        ]
+      )
+    end
+    def self.known_fields
+    end
+
+    sig do
+      returns(
+        T::Hash[Symbol,
+                T.all(ModernTreasury::BaseModel::KnownFieldShape, {type: ModernTreasury::Converter::Input})]
+      )
+    end
+    def self.fields
+    end
+
+    sig { returns(T::Hash[Symbol, T.proc.returns(T::Class[T.anything])]) }
+    def self.defaults
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        required: T::Boolean,
+        type_info: T.any(
+          {
+            const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
+            enum: T.nilable(T.proc.returns(ModernTreasury::Converter::Input)),
+            union: T.nilable(T.proc.returns(ModernTreasury::Converter::Input)),
+            api_name: Symbol,
+            nil?: T::Boolean
+          },
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    private_class_method def self.add_field(name_sym, required:, type_info:, spec:)
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def self.required(name_sym, type_info, spec = {})
+    end
+
+    sig do
+      params(
+        name_sym: Symbol,
+        type_info: T.any(
+          T::Hash[Symbol, T.anything],
+          T.proc.returns(ModernTreasury::Converter::Input),
+          ModernTreasury::Converter::Input
+        ),
+        spec: T::Hash[Symbol, T.anything]
+      )
+        .void
+    end
+    def self.optional(name_sym, type_info, spec = {})
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.request_only(&blk)
+    end
+
+    sig { params(blk: T.proc.void).void }
+    private_class_method def self.response_only(&blk)
+    end
+
+    sig { params(other: T.anything).returns(T::Boolean) }
+    def ==(other)
+    end
+
+    sig do
+      override
+        .params(value: T.any(ModernTreasury::BaseModel, T::Hash[T.anything, T.anything], T.anything))
+        .returns(T.any(T.attached_class, T.anything))
+    end
+    def self.coerce(value)
+    end
+
+    sig do
+      override
+        .params(value: T.any(T.attached_class, T.anything))
+        .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
+    end
+    def self.dump(value)
+    end
+
+    sig do
+      override
+        .params(value: T.anything)
+        .returns(T.any([T::Boolean, T.anything, NilClass], [T::Boolean, T::Boolean, Integer]))
+    end
+    def self.try_strict_coerce(value)
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T.anything)) }
+    def [](key)
+    end
+
+    sig { overridable.returns(T::Hash[Symbol, T.anything]) }
+    def to_h
+    end
+
+    alias_method :to_hash, :to_h
+
+    sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.anything]) }
+    def deconstruct_keys(keys)
+    end
+
+    sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).void }
+    def initialize(data = {})
+    end
+
+    sig { returns(String) }
+    def to_s
+    end
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

data/rbi/lib/modern_treasury/base_page.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module ModernTreasury
+  module BasePage
+    abstract!
+
+    Elem = type_member(:out)
+
+    sig { overridable.returns(T::Boolean) }
+    def next_page?
+    end
+
+    sig { overridable.returns(T.self_type) }
+    def next_page
+    end
+
+    sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void }
+    def auto_paging_each(&blk)
+    end
+
+    sig { returns(T::Enumerable[Elem]) }
+    def to_enum
+    end
+
+    alias_method :enum_for, :to_enum
+
+    sig do
+      params(
+        client: ModernTreasury::BaseClient,
+        req: ModernTreasury::BaseClient::RequestComponentsShape,
+        headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+        unwrapped: T.anything
+      )
+        .void
+    end
+    def initialize(client:, req:, headers:, unwrapped:)
+    end
+  end
+end

data/rbi/lib/modern_treasury/client.rbi

@@ -0,0 +1,198 @@
+# typed: strong
+
+module ModernTreasury
+  class Client < ModernTreasury::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    sig { returns(String) }
+    def api_key
+    end
+
+    sig { returns(String) }
+    def organization_id
+    end
+
+    sig { returns(ModernTreasury::Resources::Connections) }
+    def connections
+    end
+
+    sig { returns(ModernTreasury::Resources::Counterparties) }
+    def counterparties
+    end
+
+    sig { returns(ModernTreasury::Resources::Events) }
+    def events
+    end
+
+    sig { returns(ModernTreasury::Resources::ExpectedPayments) }
+    def expected_payments
+    end
+
+    sig { returns(ModernTreasury::Resources::ExternalAccounts) }
+    def external_accounts
+    end
+
+    sig { returns(ModernTreasury::Resources::IncomingPaymentDetails) }
+    def incoming_payment_details
+    end
+
+    sig { returns(ModernTreasury::Resources::Invoices) }
+    def invoices
+    end
+
+    sig { returns(ModernTreasury::Resources::Documents) }
+    def documents
+    end
+
+    sig { returns(ModernTreasury::Resources::AccountCollectionFlows) }
+    def account_collection_flows
+    end
+
+    sig { returns(ModernTreasury::Resources::AccountDetails) }
+    def account_details
+    end
+
+    sig { returns(ModernTreasury::Resources::RoutingDetails) }
+    def routing_details
+    end
+
+    sig { returns(ModernTreasury::Resources::InternalAccounts) }
+    def internal_accounts
+    end
+
+    sig { returns(ModernTreasury::Resources::Ledgers) }
+    def ledgers
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerableEvents) }
+    def ledgerable_events
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerAccountCategories) }
+    def ledger_account_categories
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerAccounts) }
+    def ledger_accounts
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerAccountBalanceMonitors) }
+    def ledger_account_balance_monitors
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerAccountStatements) }
+    def ledger_account_statements
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerEntries) }
+    def ledger_entries
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerEventHandlers) }
+    def ledger_event_handlers
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerTransactions) }
+    def ledger_transactions
+    end
+
+    sig { returns(ModernTreasury::Resources::LineItems) }
+    def line_items
+    end
+
+    sig { returns(ModernTreasury::Resources::PaymentFlows) }
+    def payment_flows
+    end
+
+    sig { returns(ModernTreasury::Resources::PaymentOrders) }
+    def payment_orders
+    end
+
+    sig { returns(ModernTreasury::Resources::PaymentReferences) }
+    def payment_references
+    end
+
+    sig { returns(ModernTreasury::Resources::Returns) }
+    def returns
+    end
+
+    sig { returns(ModernTreasury::Resources::Transactions) }
+    def transactions
+    end
+
+    sig { returns(ModernTreasury::Resources::Validations) }
+    def validations
+    end
+
+    sig { returns(ModernTreasury::Resources::PaperItems) }
+    def paper_items
+    end
+
+    sig { returns(ModernTreasury::Resources::VirtualAccounts) }
+    def virtual_accounts
+    end
+
+    sig { returns(ModernTreasury::Resources::BulkRequests) }
+    def bulk_requests
+    end
+
+    sig { returns(ModernTreasury::Resources::BulkResults) }
+    def bulk_results
+    end
+
+    sig { returns(ModernTreasury::Resources::LedgerAccountSettlements) }
+    def ledger_account_settlements
+    end
+
+    sig { returns(ModernTreasury::Resources::ForeignExchangeQuotes) }
+    def foreign_exchange_quotes
+    end
+
+    sig { returns(ModernTreasury::Resources::ConnectionLegalEntities) }
+    def connection_legal_entities
+    end
+
+    sig { returns(ModernTreasury::Resources::LegalEntities) }
+    def legal_entities
+    end
+
+    sig { returns(ModernTreasury::Resources::LegalEntityAssociations) }
+    def legal_entity_associations
+    end
+
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    sig do
+      params(
+        base_url: T.nilable(String),
+        api_key: T.nilable(String),
+        organization_id: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float,
+        idempotency_header: String
+      )
+        .void
+    end
+    def initialize(
+      base_url: nil,
+      api_key: ENV["MODERN_TREASURY_API_KEY"],
+      organization_id: ENV["MODERN_TREASURY_ORGANIZATION_ID"],
+      max_retries: DEFAULT_MAX_RETRIES,
+      timeout: DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: DEFAULT_MAX_RETRY_DELAY,
+      idempotency_header: "Idempotency-Key"
+    )
+    end
+  end
+end