modern_treasury 0.1.0.pre.alpha.18 → 0.1.0.pre.alpha.19

data/rbi/lib/modern_treasury/internal/transport/base_client.rbi

@@ -1,199 +0,0 @@
-# typed: strong
-
-module ModernTreasury
-  module Internal
-    module Transport
-      # @api private
-      class BaseClient
-        abstract!
-
-        RequestComponentsShape =
-          T.type_alias do
-            {
-              method: Symbol,
-              path: T.any(String, T::Array[String]),
-              query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-              headers: T.nilable(
-                T::Hash[String,
-                        T.nilable(
-                          T.any(
-                            String,
-                            Integer,
-                            T::Array[T.nilable(T.any(String, Integer))]
-                          )
-                        )]
-              ),
-              body: T.nilable(T.anything),
-              unwrap: T.nilable(Symbol),
-              page: T.nilable(T::Class[ModernTreasury::Internal::Type::BasePage[ModernTreasury::Internal::Type::BaseModel]]),
-              stream: T.nilable(T::Class[T.anything]),
-              model: T.nilable(ModernTreasury::Internal::Type::Converter::Input),
-              options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
-            }
-          end
-
-        RequestInputShape =
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              max_retries: Integer,
-              timeout: Float
-            }
-          end
-
-        # from whatwg fetch spec
-        MAX_REDIRECTS = 20
-
-        PLATFORM_HEADERS = T::Hash[String, String]
-
-        class << self
-          # @api private
-          sig { params(req: ModernTreasury::Internal::Transport::BaseClient::RequestComponentsShape).void }
-          def validate!(req); end
-
-          # @api private
-          sig do
-            params(
-              status: Integer,
-              headers: T.any(
-                T::Hash[String, String],
-                Net::HTTPHeader
-              )
-            ).returns(T::Boolean)
-          end
-          def should_retry?(status, headers:); end
-
-          # @api private
-          sig do
-            params(
-              request: ModernTreasury::Internal::Transport::BaseClient::RequestInputShape,
-              status: Integer,
-              response_headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-            )
-              .returns(ModernTreasury::Internal::Transport::BaseClient::RequestInputShape)
-          end
-          def follow_redirect(request, status:, response_headers:); end
-
-          # @api private
-          sig do
-            params(
-              status: T.any(Integer, ModernTreasury::Errors::APIConnectionError),
-              stream: T.nilable(T::Enumerable[String])
-            )
-              .void
-          end
-          def reap_connection!(status, stream:); end
-        end
-
-        # @api private
-        sig { returns(ModernTreasury::Internal::Transport::PooledNetRequester) }
-        attr_accessor :requester
-
-        # @api private
-        sig do
-          params(
-            base_url: String,
-            timeout: Float,
-            max_retries: Integer,
-            initial_retry_delay: Float,
-            max_retry_delay: Float,
-            headers: T::Hash[String,
-                             T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))],
-            idempotency_header: T.nilable(String)
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(
-          base_url:,
-          timeout: 0.0,
-          max_retries: 0,
-          initial_retry_delay: 0.0,
-          max_retry_delay: 0.0,
-          headers: {},
-          idempotency_header: nil
-        ); end
-        # @api private
-        sig { overridable.returns(T::Hash[String, String]) }
-        private def auth_headers; end
-
-        # @api private
-        sig { returns(String) }
-        private def generate_idempotency_key; end
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              req: ModernTreasury::Internal::Transport::BaseClient::RequestComponentsShape,
-              opts: ModernTreasury::Internal::AnyHash
-            )
-            .returns(ModernTreasury::Internal::Transport::BaseClient::RequestInputShape)
-        end
-        private def build_request(req, opts); end
-
-        # @api private
-        sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) }
-        private def retry_delay(headers, retry_count:); end
-
-        # @api private
-        sig do
-          params(
-            request: ModernTreasury::Internal::Transport::BaseClient::RequestInputShape,
-            redirect_count: Integer,
-            retry_count: Integer,
-            send_retry_header: T::Boolean
-          )
-            .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:); end
-
-        # Execute the request specified by `req`. This is the method that all resource
-        # methods call into.
-        #
-        # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: ModernTreasury::Internal::Type::Unknown, options: {})
-        sig do
-          params(
-            method: Symbol,
-            path: T.any(String, T::Array[String]),
-            query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-            headers: T.nilable(
-              T::Hash[String,
-                      T.nilable(
-                        T.any(
-                          String,
-                          Integer,
-                          T::Array[T.nilable(T.any(String, Integer))]
-                        )
-                      )]
-            ),
-            body: T.nilable(T.anything),
-            unwrap: T.nilable(Symbol),
-            page: T.nilable(T::Class[ModernTreasury::Internal::Type::BasePage[ModernTreasury::Internal::Type::BaseModel]]),
-            stream: T.nilable(T::Class[T.anything]),
-            model: T.nilable(ModernTreasury::Internal::Type::Converter::Input),
-            options: T.nilable(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash))
-          )
-            .returns(T.anything)
-        end
-        def request(
-          method,
-          path,
-          query: {},
-          headers: {},
-          body: nil,
-          unwrap: nil,
-          page: nil,
-          stream: nil,
-          model: ModernTreasury::Internal::Type::Unknown,
-          options: {}
-        ); end
-        # @api private
-        sig { returns(String) }
-        def inspect; end
-      end
-    end
-  end
-end

data/rbi/lib/modern_treasury/internal/type/base_model.rbi

@@ -1,203 +0,0 @@
-# typed: strong
-
-module ModernTreasury
-  module Internal
-    module Type
-      class BaseModel
-        extend ModernTreasury::Internal::Type::Converter
-
-        abstract!
-
-        KnownFieldShape = T.type_alias do
-          {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean}
-        end
-
-        class << self
-          # @api private
-          #
-          # Assumes superclass fields are totally defined before fields are accessed /
-          # defined on subclasses.
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  ModernTreasury::Internal::Type::BaseModel::KnownFieldShape,
-                  {type_fn: T.proc.returns(ModernTreasury::Internal::Type::Converter::Input)}
-                )
-              ]
-            )
-          end
-          def known_fields; end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  ModernTreasury::Internal::Type::BaseModel::KnownFieldShape,
-                  {type: ModernTreasury::Internal::Type::Converter::Input}
-                )
-              ]
-            )
-          end
-          def fields; end
-
-          # @api private
-          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::Internal::Type::Converter::Input)),
-                  union: T.nilable(T.proc.returns(ModernTreasury::Internal::Type::Converter::Input)),
-                  api_name: Symbol,
-                  nil?: T::Boolean
-                },
-                T.proc.returns(ModernTreasury::Internal::Type::Converter::Input),
-                ModernTreasury::Internal::Type::Converter::Input
-              ),
-              spec: ModernTreasury::Internal::AnyHash
-            )
-              .void
-          end
-          private def add_field(name_sym, required:, type_info:, spec:); end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              type_info: T.any(
-                ModernTreasury::Internal::AnyHash,
-                T.proc.returns(ModernTreasury::Internal::Type::Converter::Input),
-                ModernTreasury::Internal::Type::Converter::Input
-              ),
-              spec: ModernTreasury::Internal::AnyHash
-            )
-              .void
-          end
-          def required(name_sym, type_info, spec = {}); end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              type_info: T.any(
-                ModernTreasury::Internal::AnyHash,
-                T.proc.returns(ModernTreasury::Internal::Type::Converter::Input),
-                ModernTreasury::Internal::Type::Converter::Input
-              ),
-              spec: ModernTreasury::Internal::AnyHash
-            )
-              .void
-          end
-          def optional(name_sym, type_info, spec = {}); end
-
-          # @api private
-          #
-          # `request_only` attributes not excluded from `.#coerce` when receiving responses
-          # even if well behaved servers should not send them
-          sig { params(blk: T.proc.void).void }
-          private def request_only(&blk); end
-
-          # @api private
-          #
-          # `response_only` attributes are omitted from `.#dump` when making requests
-          sig { params(blk: T.proc.void).void }
-          private def response_only(&blk); end
-
-          sig { params(other: T.anything).returns(T::Boolean) }
-          def ==(other); end
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(
-                  ModernTreasury::Internal::Type::BaseModel,
-                  T::Hash[T.anything, T.anything],
-                  T.anything
-                ),
-                state: ModernTreasury::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(T.attached_class, T.anything))
-          end
-          def coerce(value, state:); end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(T.attached_class, T.anything),
-                state: ModernTreasury::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
-          end
-          def dump(value, state:); end
-        end
-
-        # Returns the raw value associated with the given key, if found. Otherwise, nil is
-        # returned.
-        #
-        # It is valid to lookup keys that are not in the API spec, for example to access
-        # undocumented features. This method does not parse response data into
-        # higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
-        sig { params(key: Symbol).returns(T.nilable(T.anything)) }
-        def [](key); end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(ModernTreasury::Internal::AnyHash) }
-        def to_h; end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(ModernTreasury::Internal::AnyHash) }
-        def to_hash; end
-
-        sig { params(keys: T.nilable(T::Array[Symbol])).returns(ModernTreasury::Internal::AnyHash) }
-        def deconstruct_keys(keys); end
-
-        sig { params(a: T.anything).returns(String) }
-        def to_json(*a); end
-
-        sig { params(a: T.anything).returns(String) }
-        def to_yaml(*a); end
-
-        # Create a new instance of a model.
-        sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(T.attached_class) }
-        def self.new(data = {}); end
-
-        class << self
-          # @api private
-          sig { params(depth: Integer).returns(String) }
-          def inspect(depth: 0); end
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect; end
-      end
-    end
-  end
-end

data/rbi/lib/modern_treasury/internal/type/request_parameters.rbi

@@ -1,21 +0,0 @@
-# typed: strong
-
-module ModernTreasury
-  module Internal
-    module Type
-      # @api private
-      module RequestParameters
-        # Options to specify HTTP behaviour for this request.
-        sig { returns(T.any(ModernTreasury::RequestOptions, ModernTreasury::Internal::AnyHash)) }
-        attr_accessor :request_options
-
-        # @api private
-        module Converter
-          # @api private
-          sig { params(params: T.anything).returns([T.anything, ModernTreasury::Internal::AnyHash]) }
-          def dump_request(params); end
-        end
-      end
-    end
-  end
-end

data/rbi/lib/modern_treasury/internal/type/union.rbi

@@ -1,77 +0,0 @@
-# typed: strong
-
-module ModernTreasury
-  module Internal
-    module Type
-      # @api private
-      module Union
-        include ModernTreasury::Internal::Type::Converter
-
-        # @api private
-        #
-        # All of the specified variant info for this union.
-        sig do
-          returns(
-            T::Array[[
-              T.nilable(Symbol),
-              T.proc.returns(ModernTreasury::Internal::Type::Converter::Input)
-            ]]
-          )
-        end
-        private def known_variants; end
-
-        # @api private
-        sig { returns(T::Array[[T.nilable(Symbol), T.anything]]) }
-        protected def derefed_variants; end
-
-        # All of the specified variants for this union.
-        sig { overridable.returns(T::Array[T.anything]) }
-        def variants; end
-
-        # @api private
-        sig { params(property: Symbol).void }
-        private def discriminator(property); end
-
-        # @api private
-        sig do
-          params(
-            key: T.any(Symbol, ModernTreasury::Internal::AnyHash, T.proc.returns(T.anything), T.anything),
-            spec: T.any(ModernTreasury::Internal::AnyHash, T.proc.returns(T.anything), T.anything)
-          )
-            .void
-        end
-        private def variant(key, spec = nil); end
-
-        # @api private
-        sig { params(value: T.anything).returns(T.nilable(T.anything)) }
-        private def resolve_variant(value); end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ===(other); end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        # @api private
-        sig do
-          override
-            .params(value: T.anything, state: ModernTreasury::Internal::Type::Converter::CoerceState)
-            .returns(T.anything)
-        end
-        def coerce(value, state:); end
-
-        # @api private
-        sig do
-          override
-            .params(value: T.anything, state: ModernTreasury::Internal::Type::Converter::DumpState)
-            .returns(T.anything)
-        end
-        def dump(value, state:); end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0); end
-      end
-    end
-  end
-end