vitable-connect 0.5.0 → 1.0.0

data/rbi/vitable_connect/internal/type/enum.rbi

@@ -1,82 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # A value from among a specified list of options. OpenAPI enum values map to Ruby
-      # values in the SDK as follows:
-      #
-      # 1. boolean => true | false
-      # 2. integer => Integer
-      # 3. float => Float
-      # 4. string => Symbol
-      #
-      # We can therefore convert string values to Symbols, but can't convert other
-      # values safely.
-      module Enum
-        include VitableConnect::Internal::Type::Converter
-        include VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        # All of the valid Symbol values for this enum.
-        sig do
-          overridable.returns(
-            T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]
-          )
-        end
-        def values
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        # @api private
-        #
-        # Unlike with primitives, `Enum` additionally validates that the value is a member
-        # of the enum.
-        sig do
-          override
-            .params(
-              value: T.any(String, Symbol, T.anything),
-              state: VitableConnect::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(Symbol, T.anything))
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(Symbol, T.anything),
-              state: VitableConnect::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(Symbol, T.anything))
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { returns(T.anything) }
-        def to_sorbet_type
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/file_input.rbi

@@ -1,59 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # Either `Pathname` or `StringIO`, or `IO`, or
-      # `VitableConnect::Internal::Type::FileInput`.
-      #
-      # Note: when `IO` is used, all retries are disabled, since many IO` streams are
-      # not rewindable.
-      class FileInput
-        extend VitableConnect::Internal::Type::Converter
-
-        abstract!
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.==(other)
-        end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(StringIO, String, T.anything),
-                state: VitableConnect::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(StringIO, T.anything))
-          end
-          def coerce(value, state:)
-          end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(Pathname, StringIO, IO, String, T.anything),
-                state: VitableConnect::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(Pathname, StringIO, IO, String, T.anything))
-          end
-          def dump(value, state:)
-          end
-
-          # @api private
-          sig { returns(T.anything) }
-          def to_sorbet_type
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/hash_of.rbi

@@ -1,108 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # Hash of items of a given type.
-      class HashOf
-        include VitableConnect::Internal::Type::Converter
-        include VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        Elem = type_member(:out)
-
-        sig do
-          params(
-            type_info:
-              T.any(
-                VitableConnect::Internal::AnyHash,
-                T.proc.returns(
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-                VitableConnect::Internal::Type::Converter::Input
-              ),
-            spec: VitableConnect::Internal::AnyHash
-          ).returns(T.attached_class)
-        end
-        def self.[](type_info, spec = {})
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(T::Hash[T.anything, T.anything], T.anything),
-              state: VitableConnect::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(VitableConnect::Internal::AnyHash, T.anything))
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(T::Hash[T.anything, T.anything], T.anything),
-              state: VitableConnect::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(VitableConnect::Internal::AnyHash, T.anything))
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { returns(T.anything) }
-        def to_sorbet_type
-        end
-
-        # @api private
-        sig { returns(Elem) }
-        protected def item_type
-        end
-
-        # @api private
-        sig { returns(T::Boolean) }
-        protected def nilable?
-        end
-
-        # @api private
-        sig do
-          params(
-            type_info:
-              T.any(
-                VitableConnect::Internal::AnyHash,
-                T.proc.returns(
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-                VitableConnect::Internal::Type::Converter::Input
-              ),
-            spec: VitableConnect::Internal::AnyHash
-          ).void
-        end
-        def initialize(type_info, spec = {})
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/request_parameters.rbi

@@ -1,31 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      module RequestParameters
-        # Options to specify HTTP behaviour for this request.
-        sig { returns(VitableConnect::RequestOptions) }
-        attr_reader :request_options
-
-        sig do
-          params(request_options: VitableConnect::RequestOptions::OrHash).void
-        end
-        attr_writer :request_options
-
-        # @api private
-        module Converter
-          # @api private
-          sig do
-            params(params: T.anything).returns(
-              [T.anything, VitableConnect::Internal::AnyHash]
-            )
-          end
-          def dump_request(params)
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/union.rbi

@@ -1,130 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      module Union
-        include VitableConnect::Internal::Type::Converter
-        include VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        # @api private
-        #
-        # All of the specified variant info for this union.
-        sig do
-          returns(
-            T::Array[
-              [
-                T.nilable(Symbol),
-                T.proc.returns(
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-                VitableConnect::Internal::AnyHash
-              ]
-            ]
-          )
-        end
-        private def known_variants
-        end
-
-        # @api private
-        sig do
-          returns(
-            T::Array[
-              [T.nilable(Symbol), T.anything, VitableConnect::Internal::AnyHash]
-            ]
-          )
-        end
-        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,
-                VitableConnect::Internal::AnyHash,
-                T.proc.returns(T.anything),
-                T.anything
-              ),
-            spec:
-              T.any(
-                VitableConnect::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
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        # @api private
-        #
-        # Tries to efficiently coerce the given value to one of the known variants.
-        #
-        # If the value cannot match any of the known variants, the coercion is considered
-        # non-viable and returns the original value.
-        sig do
-          override
-            .params(
-              value: T.anything,
-              state: VitableConnect::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.anything)
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.anything,
-              state: VitableConnect::Internal::Type::Converter::DumpState
-            )
-            .returns(T.anything)
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { returns(T.anything) }
-        def to_sorbet_type
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/unknown.rbi

@@ -1,58 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # When we don't know what to expect for the value.
-      class Unknown
-        extend VitableConnect::Internal::Type::Converter
-        extend VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.==(other)
-        end
-
-        class << self
-          # @api private
-          #
-          # No coercion needed for Unknown type.
-          sig do
-            override
-              .params(
-                value: T.anything,
-                state: VitableConnect::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.anything)
-          end
-          def coerce(value, state:)
-          end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.anything,
-                state: VitableConnect::Internal::Type::Converter::DumpState
-              )
-              .returns(T.anything)
-          end
-          def dump(value, state:)
-          end
-
-          # @api private
-          sig { returns(T.anything) }
-          def to_sorbet_type
-          end
-        end
-      end
-    end
-  end
-end