vitable-connect 0.6.0 → 2.0.0

data/rbi/vitable_connect/internal/type/base_model.rbi

@@ -1,314 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      class BaseModel
-        extend VitableConnect::Internal::Type::Converter
-        extend VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        KnownField =
-          T.type_alias do
-            {
-              mode: T.nilable(Symbol),
-              required: T::Boolean,
-              nilable: T::Boolean
-            }
-          end
-
-        OrHash =
-          T.type_alias do
-            T.any(
-              VitableConnect::Internal::Type::BaseModel,
-              VitableConnect::Internal::AnyHash
-            )
-          end
-
-        class << self
-          # @api private
-          #
-          # Assumes superclass fields are totally defined before fields are accessed /
-          # defined on subclasses.
-          sig { params(child: VitableConnect::Internal::Type::BaseModel).void }
-          def inherited(child)
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  VitableConnect::Internal::Type::BaseModel::KnownField,
-                  {
-                    type_fn:
-                      T.proc.returns(
-                        VitableConnect::Internal::Type::Converter::Input
-                      )
-                  }
-                )
-              ]
-            )
-          end
-          def known_fields
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  VitableConnect::Internal::Type::BaseModel::KnownField,
-                  { type: VitableConnect::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(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      ),
-                    api_name: Symbol,
-                    nil?: T::Boolean
-                  },
-                  T.proc.returns(
-                    VitableConnect::Internal::Type::Converter::Input
-                  ),
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-              spec: VitableConnect::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(
-                  VitableConnect::Internal::AnyHash,
-                  T.proc.returns(
-                    VitableConnect::Internal::Type::Converter::Input
-                  ),
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-              spec: VitableConnect::Internal::AnyHash
-            ).void
-          end
-          def required(name_sym, type_info, spec = {})
-          end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              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 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
-
-          sig { returns(Integer) }
-          def hash
-          end
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value:
-                  T.any(
-                    VitableConnect::Internal::Type::BaseModel,
-                    T::Hash[T.anything, T.anything],
-                    T.anything
-                  ),
-                state: VitableConnect::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: VitableConnect::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
-          end
-          def dump(value, state:)
-          end
-
-          # @api private
-          sig { returns(T.anything) }
-          def to_sorbet_type
-          end
-        end
-
-        class << self
-          # @api private
-          sig do
-            params(
-              model: VitableConnect::Internal::Type::BaseModel,
-              convert: T::Boolean
-            ).returns(VitableConnect::Internal::AnyHash)
-          end
-          def recursively_to_h(model, convert:)
-          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(VitableConnect::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(VitableConnect::Internal::AnyHash) }
-        def to_hash
-        end
-
-        # In addition to the behaviour of `#to_h`, this method will recursively call
-        # `#to_h` on nested models.
-        sig { overridable.returns(VitableConnect::Internal::AnyHash) }
-        def deep_to_h
-        end
-
-        sig do
-          params(keys: T.nilable(T::Array[Symbol])).returns(
-            VitableConnect::Internal::AnyHash
-          )
-        end
-        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 do
-          params(
-            data:
-              T.any(
-                T::Hash[Symbol, T.anything],
-                VitableConnect::Internal::Type::BaseModel
-              )
-          ).returns(T.attached_class)
-        end
-        def self.new(data = {})
-        end
-
-        class << self
-          # @api private
-          sig { params(depth: Integer).returns(String) }
-          def inspect(depth: 0)
-          end
-        end
-
-        sig { returns(String) }
-        def to_s
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/base_page.rbi

@@ -1,43 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # This module provides a base implementation for paginated responses in the SDK.
-      module BasePage
-        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
-
-        # @api private
-        sig do
-          params(
-            client: VitableConnect::Internal::Transport::BaseClient,
-            req:
-              VitableConnect::Internal::Transport::BaseClient::RequestComponents,
-            headers: T::Hash[String, String],
-            page_data: T.anything
-          ).void
-        end
-        def initialize(client:, req:, headers:, page_data:)
-        end
-      end
-    end
-  end
-end

data/rbi/vitable_connect/internal/type/boolean.rbi

@@ -1,58 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      #
-      # Ruby has no Boolean class; this is something for models to refer to.
-      class Boolean
-        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
-          #
-          # Coerce value to Boolean if possible, otherwise return the original value.
-          sig do
-            override
-              .params(
-                value: T.any(T::Boolean, T.anything),
-                state: VitableConnect::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(T::Boolean, T.anything))
-          end
-          def coerce(value, state:)
-          end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(T::Boolean, T.anything),
-                state: VitableConnect::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(T::Boolean, 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/converter.rbi

@@ -1,225 +0,0 @@
-# typed: strong
-
-module VitableConnect
-  module Internal
-    module Type
-      # @api private
-      module Converter
-        extend VitableConnect::Internal::Util::SorbetRuntimeSupport
-
-        Input =
-          T.type_alias do
-            T.any(
-              VitableConnect::Internal::Type::Converter,
-              T::Class[T.anything]
-            )
-          end
-
-        CoerceState =
-          T.type_alias do
-            {
-              translate_names: T::Boolean,
-              strictness: T::Boolean,
-              exactness: {
-                yes: Integer,
-                no: Integer,
-                maybe: Integer
-              },
-              error: T::Class[StandardError],
-              branched: Integer
-            }
-          end
-
-        DumpState = T.type_alias { { can_retry: T::Boolean } }
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              value: T.anything,
-              state: VitableConnect::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.anything)
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              value: T.anything,
-              state: VitableConnect::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
-
-        class << self
-          # @api private
-          sig do
-            params(
-              spec:
-                T.any(
-                  {
-                    const:
-                      T.nilable(
-                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
-                      ),
-                    enum:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      )
-                  },
-                  T.proc.returns(
-                    VitableConnect::Internal::Type::Converter::Input
-                  ),
-                  VitableConnect::Internal::Type::Converter::Input
-                )
-            ).returns(T.proc.returns(T.anything))
-          end
-          def self.type_info(spec)
-          end
-
-          # @api private
-          sig do
-            params(
-              type_info:
-                T.any(
-                  {
-                    const:
-                      T.nilable(
-                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
-                      ),
-                    enum:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      )
-                  },
-                  T.proc.returns(
-                    VitableConnect::Internal::Type::Converter::Input
-                  ),
-                  VitableConnect::Internal::Type::Converter::Input
-                ),
-              spec:
-                T.any(
-                  {
-                    const:
-                      T.nilable(
-                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
-                      ),
-                    enum:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          VitableConnect::Internal::Type::Converter::Input
-                        )
-                      )
-                  },
-                  T.proc.returns(
-                    VitableConnect::Internal::Type::Converter::Input
-                  ),
-                  VitableConnect::Internal::Type::Converter::Input
-                )
-            ).returns(VitableConnect::Internal::AnyHash)
-          end
-          def self.meta_info(type_info, spec)
-          end
-
-          # @api private
-          sig do
-            params(translate_names: T::Boolean).returns(
-              VitableConnect::Internal::Type::Converter::CoerceState
-            )
-          end
-          def self.new_coerce_state(translate_names: true)
-          end
-
-          # @api private
-          #
-          # Based on `target`, transform `value` into `target`, to the extent possible:
-          #
-          # 1. if the given `value` conforms to `target` already, return the given `value`
-          # 2. if it's possible and safe to convert the given `value` to `target`, then the
-          #    converted value
-          # 3. otherwise, the given `value` unaltered
-          #
-          # The coercion process is subject to improvement between minor release versions.
-          # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
-          sig do
-            params(
-              target: VitableConnect::Internal::Type::Converter::Input,
-              value: T.anything,
-              state: VitableConnect::Internal::Type::Converter::CoerceState
-            ).returns(T.anything)
-          end
-          def self.coerce(
-            target,
-            value,
-            # The `strictness` is one of `true`, `false`. This informs the coercion strategy
-            # when we have to decide between multiple possible conversion targets:
-            #
-            # - `true`: the conversion must be exact, with minimum coercion.
-            # - `false`: the conversion can be approximate, with some coercion.
-            #
-            # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
-            # any given conversion attempt, the exactness will be updated based on how closely
-            # the value recursively matches the target type:
-            #
-            # - `yes`: the value can be converted to the target type with minimum coercion.
-            # - `maybe`: the value can be converted to the target type with some reasonable
-            #   coercion.
-            # - `no`: the value cannot be converted to the target type.
-            #
-            # See implementation below for more details.
-            state: VitableConnect::Internal::Type::Converter.new_coerce_state
-          )
-          end
-
-          # @api private
-          sig do
-            params(
-              target: VitableConnect::Internal::Type::Converter::Input,
-              value: T.anything,
-              state: VitableConnect::Internal::Type::Converter::DumpState
-            ).returns(T.anything)
-          end
-          def self.dump(target, value, state: { can_retry: true })
-          end
-
-          # @api private
-          sig { params(target: T.anything, depth: Integer).returns(String) }
-          def self.inspect(target, depth:)
-          end
-        end
-      end
-    end
-  end
-end