modern_treasury 0.1.0.pre.alpha.15 → 0.1.0.pre.alpha.17

data/rbi/lib/modern_treasury/util.rbi

@@ -1,135 +0,0 @@
-# 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/sig/modern_treasury/base_client.rbs

@@ -1,100 +0,0 @@
-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

data/sig/modern_treasury/base_model.rbs

@@ -1,246 +0,0 @@
-module ModernTreasury
-  module Converter
-    type input = ModernTreasury::Converter | Class
-
-    def coerce: (top value) -> top
-
-    def dump: (top value) -> top
-
-    def try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-
-    def self.type_info: (
-      {
-        const: (nil | bool | Integer | Float | Symbol)?,
-        enum: ^-> ModernTreasury::Converter::input?,
-        union: ^-> ModernTreasury::Converter::input?
-      }
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input spec
-    ) -> (^-> top)
-
-    def self.coerce: (ModernTreasury::Converter::input target, top value) -> top
-
-    def self.dump: (ModernTreasury::Converter::input target, top value) -> top
-
-    def self.try_strict_coerce: (
-      ModernTreasury::Converter::input target,
-      top value
-    ) -> top
-  end
-
-  class Unknown
-    extend ModernTreasury::Converter
-
-    def self.===: (top other) -> bool
-
-    def self.==: (top other) -> bool
-
-    def self.coerce: (top value) -> top
-
-    def self.dump: (top value) -> top
-
-    def self.try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-  end
-
-  class BooleanModel
-    extend ModernTreasury::Converter
-
-    def self.===: (top other) -> bool
-
-    def self.==: (top other) -> bool
-
-    def self.coerce: (bool | top value) -> (bool | top)
-
-    def self.dump: (bool | top value) -> (bool | top)
-
-    def self.try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-  end
-
-  class Enum
-    extend ModernTreasury::Converter
-
-    def self.values: -> ::Array[(nil | bool | Integer | Float | Symbol)]
-
-    private def self.finalize!: -> void
-
-    def self.===: (top other) -> bool
-
-    def self.==: (top other) -> bool
-
-    def self.coerce: (String | Symbol | top value) -> (Symbol | top)
-
-    def self.dump: (Symbol | top value) -> (Symbol | top)
-
-    def self.try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-  end
-
-  class Union
-    extend ModernTreasury::Extern
-    extend ModernTreasury::Converter
-
-    private def self.known_variants: -> ::Array[[Symbol?, Proc]]
-
-    def self.variants: -> ::Array[[Symbol?, top]]
-
-    private def self.discriminator: (Symbol property) -> void
-
-    private def self.variant: (
-      Symbol
-      | ::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input key,
-      ?::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input spec
-    ) -> void
-
-    private def self.resolve_variant: (
-      top value
-    ) -> ModernTreasury::Converter::input?
-
-    def self.===: (top other) -> bool
-
-    def self.==: (top other) -> bool
-
-    def self.coerce: (top value) -> top
-
-    def self.dump: (top value) -> top
-
-    def self.try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-  end
-
-  class ArrayOf
-    include ModernTreasury::Converter
-
-    def ===: (top other) -> bool
-
-    def ==: (top other) -> bool
-
-    def coerce: (Enumerable[top] | top value) -> (::Array[top] | top)
-
-    def dump: (Enumerable[top] | top value) -> (::Array[top] | top)
-
-    def try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-
-    def item_type: -> ModernTreasury::Converter::input
-
-    def initialize: (
-      ::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input type_info,
-      ?::Hash[Symbol, top] spec
-    ) -> void
-  end
-
-  class HashOf
-    include ModernTreasury::Converter
-
-    def ===: (top other) -> bool
-
-    def ==: (top other) -> bool
-
-    def coerce: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
-
-    def dump: (::Hash[top, top] | top value) -> (::Hash[Symbol, top] | top)
-
-    def try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-
-    def item_type: -> ModernTreasury::Converter::input
-
-    def initialize: (
-      ::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input type_info,
-      ?::Hash[Symbol, top] spec
-    ) -> void
-  end
-
-  class BaseModel
-    extend ModernTreasury::Extern
-    extend ModernTreasury::Converter
-
-    type known_field = { mode: (:coerce | :dump)?, required: bool }
-
-    def self.known_fields: -> ::Hash[Symbol, (ModernTreasury::BaseModel::known_field
-    & { type_fn: (^-> ModernTreasury::Converter::input) })]
-
-    def self.fields: -> ::Hash[Symbol, (ModernTreasury::BaseModel::known_field
-    & { type: ModernTreasury::Converter::input })]
-
-    def self.defaults: -> ::Hash[Symbol, (^-> Class)]
-
-    private def self.add_field: (
-      Symbol name_sym,
-      required: bool,
-      type_info: {
-        const: (nil | bool | Integer | Float | Symbol)?,
-        enum: ^-> ModernTreasury::Converter::input?,
-        union: ^-> ModernTreasury::Converter::input?,
-        api_name: Symbol
-      }
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input,
-      spec: ::Hash[Symbol, top]
-    ) -> void
-
-    def self.required: (
-      Symbol name_sym,
-      ::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input type_info,
-      ?::Hash[Symbol, top] spec
-    ) -> void
-
-    def self.optional: (
-      Symbol name_sym,
-      ::Hash[Symbol, top]
-      | ^-> ModernTreasury::Converter::input
-      | ModernTreasury::Converter::input type_info,
-      ?::Hash[Symbol, top] spec
-    ) -> void
-
-    private def self.request_only: { -> void } -> void
-
-    private def self.response_only: { -> void } -> void
-
-    def ==: (top other) -> bool
-
-    def self.coerce: (
-      ModernTreasury::BaseModel | ::Hash[top, top] | top value
-    ) -> (instance | top)
-
-    def self.dump: (instance | top value) -> (::Hash[top, top] | top)
-
-    def self.try_strict_coerce: (
-      top value
-    ) -> ([true, top, nil] | [false, bool, Integer])
-
-    def []: (Symbol key) -> top?
-
-    def to_h: -> ::Hash[Symbol, top]
-
-    alias to_hash to_h
-
-    def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
-
-    def initialize: (?::Hash[Symbol, top] | self data) -> void
-
-    def to_s: -> String
-
-    def inspect: -> String
-  end
-end

data/sig/modern_treasury/base_page.rbs

@@ -1,20 +0,0 @@
-module ModernTreasury
-  module BasePage[Elem]
-    def next_page?: -> bool
-
-    def next_page: -> self
-
-    def auto_paging_each: { (Elem arg0) -> void } -> void
-
-    def to_enum: -> Enumerable[Elem]
-
-    alias enum_for to_enum
-
-    def initialize: (
-      client: ModernTreasury::BaseClient,
-      req: ModernTreasury::BaseClient::request_components,
-      headers: ::Hash[String, String],
-      unwrapped: top
-    ) -> void
-  end
-end

data/sig/modern_treasury/page.rbs

@@ -1,22 +0,0 @@
-module ModernTreasury
-  class Page[Elem] < ::Array[Elem]
-    include ModernTreasury::BasePage[Elem]
-
-    attr_accessor per_page: Integer
-
-    attr_accessor after_cursor: String
-
-    def initialize: (
-      client: ModernTreasury::BaseClient,
-      req: ModernTreasury::BaseClient::request_components,
-      headers: ::Hash[String, String],
-      unwrapped: ::Hash[Symbol, top]
-    ) -> void
-
-    def next_page?: -> bool
-
-    def next_page: -> self
-
-    def auto_paging_each: { (Elem arg0) -> void } -> void
-  end
-end

data/sig/modern_treasury/pooled_net_requester.rbs

@@ -1,42 +0,0 @@
-module ModernTreasury
-  class PooledNetRequester
-    type request =
-      {
-        method: Symbol,
-        url: URI::Generic,
-        headers: ::Hash[String, String],
-        body: top,
-        streaming: bool,
-        max_retries: Integer,
-        deadline: Float
-      }
-
-    def self.connect: (URI::Generic url) -> top
-
-    private def self.calibrate_socket_timeout: (
-      top conn,
-      Float deadline
-    ) -> void
-
-    def self.transport: (
-      top conn,
-      top req,
-      Float deadline
-    ) {
-      (top | String arg0) -> void
-    } -> void
-
-    private def with_pool: (
-      URI::Generic url,
-      streaming: bool
-    ) {
-      (top arg0, Enumerator::Yielder arg1) -> void
-    } -> void
-
-    def execute: (
-      ModernTreasury::PooledNetRequester::request request
-    ) -> [top, Enumerable[String]]
-
-    def initialize: -> void
-  end
-end

data/sig/modern_treasury/util.rbs

@@ -1,91 +0,0 @@
-module ModernTreasury
-  module Util
-    def self?.primitive?: (top input) -> (bool | top)
-
-    def self?.coerce_boolean: (top input) -> (bool | top)
-
-    def self?.coerce_boolean!: (top input) -> bool?
-
-    def self?.coerce_integer: (top input) -> (Integer | top)
-
-    def self?.coerce_float: (top input) -> (Float | top)
-
-    def self?.coerce_hash: (top input) -> (::Hash[top, top] | top)
-
-    def self?.monotonic_secs: -> Float
-
-    def self?.suppress: (
-      *::Array[Exception] exceptions,
-      sentinel: top?
-    ) {
-      -> top?
-    } -> top?
-
-    OMIT: top
-
-    def self?.deep_merge: (
-      *::Array[top] values,
-      sentinel: top?,
-      concat: bool
-    ) -> top
-
-    def self?.dig: (
-      ::Hash[Symbol, top] | ::Array[top] | top data,
-      (Symbol | Integer | ::Array[(Symbol | Integer)])? pick,
-      ?top? sentinel
-    ) {
-      -> top?
-    } -> top?
-
-    def self?.uri_origin: (URI::Generic uri) -> String
-
-    def self?.interpolate_path: (String | ::Array[String] path) -> String
-
-    type parsed_uri =
-      {
-        scheme: String?,
-        host: String?,
-        port: Integer?,
-        path: String?,
-        query: ::Hash[String, ::Array[String]]
-      }
-
-    def self?.parse_uri: (
-      URI::Generic | String url
-    ) -> ModernTreasury::Util::parsed_uri
-
-    def self?.unparse_uri: (
-      ModernTreasury::Util::parsed_uri parsed
-    ) -> URI::Generic
-
-    def self?.join_parsed_uri: (
-      ModernTreasury::Util::parsed_uri lhs,
-      ModernTreasury::Util::parsed_uri rhs
-    ) -> URI::Generic
-
-    def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]]
-
-    def self?.encode_query: (
-      ::Hash[String, (::Array[String] | String)?]? query
-    ) -> String?
-
-    def self?.normalized_headers: (
-      *::Array[::Hash[String, (String | Integer)?]] headers
-    ) -> ::Hash[String, String]
-
-    def self?.encode_content: (::Hash[String, String] headers, top body) -> top
-
-    def self?.decode_content: (
-      ::Hash[String, String] headers,
-      stream: Enumerable[String],
-      suppress_error: bool
-    ) -> top
-
-    def self?.encode_multipart_formdata: (
-      StringIO io,
-      boundary: String,
-      key: Symbol | String,
-      val: top
-    ) -> void
-  end
-end