moderation_api 2.41.0 → 3.1.0

data/rbi/moderation_api/internal/type/array_of.rbi

@@ -1,104 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Internal
-    module Type
-      # @api private
-      #
-      # Array of items of a given type.
-      class ArrayOf
-        include ModerationAPI::Internal::Type::Converter
-        include ModerationAPI::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        Elem = type_member(:out)
-
-        sig do
-          params(
-            type_info:
-              T.any(
-                ModerationAPI::Internal::AnyHash,
-                T.proc.returns(ModerationAPI::Internal::Type::Converter::Input),
-                ModerationAPI::Internal::Type::Converter::Input
-              ),
-            spec: ModerationAPI::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::Array[T.anything], T.anything),
-              state: ModerationAPI::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(T::Array[T.anything], T.anything))
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(T::Array[T.anything], T.anything),
-              state: ModerationAPI::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(T::Array[T.anything], 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(
-                ModerationAPI::Internal::AnyHash,
-                T.proc.returns(ModerationAPI::Internal::Type::Converter::Input),
-                ModerationAPI::Internal::Type::Converter::Input
-              ),
-            spec: ModerationAPI::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/moderation_api/internal/type/base_model.rbi

@@ -1,314 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Internal
-    module Type
-      class BaseModel
-        extend ModerationAPI::Internal::Type::Converter
-        extend ModerationAPI::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(
-              ModerationAPI::Internal::Type::BaseModel,
-              ModerationAPI::Internal::AnyHash
-            )
-          end
-
-        class << self
-          # @api private
-          #
-          # Assumes superclass fields are totally defined before fields are accessed /
-          # defined on subclasses.
-          sig { params(child: ModerationAPI::Internal::Type::BaseModel).void }
-          def inherited(child)
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  ModerationAPI::Internal::Type::BaseModel::KnownField,
-                  {
-                    type_fn:
-                      T.proc.returns(
-                        ModerationAPI::Internal::Type::Converter::Input
-                      )
-                  }
-                )
-              ]
-            )
-          end
-          def known_fields
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  ModerationAPI::Internal::Type::BaseModel::KnownField,
-                  { type: ModerationAPI::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(
-                          ModerationAPI::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          ModerationAPI::Internal::Type::Converter::Input
-                        )
-                      ),
-                    api_name: Symbol,
-                    nil?: T::Boolean
-                  },
-                  T.proc.returns(
-                    ModerationAPI::Internal::Type::Converter::Input
-                  ),
-                  ModerationAPI::Internal::Type::Converter::Input
-                ),
-              spec: ModerationAPI::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(
-                  ModerationAPI::Internal::AnyHash,
-                  T.proc.returns(
-                    ModerationAPI::Internal::Type::Converter::Input
-                  ),
-                  ModerationAPI::Internal::Type::Converter::Input
-                ),
-              spec: ModerationAPI::Internal::AnyHash
-            ).void
-          end
-          def required(name_sym, type_info, spec = {})
-          end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              type_info:
-                T.any(
-                  ModerationAPI::Internal::AnyHash,
-                  T.proc.returns(
-                    ModerationAPI::Internal::Type::Converter::Input
-                  ),
-                  ModerationAPI::Internal::Type::Converter::Input
-                ),
-              spec: ModerationAPI::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(
-                    ModerationAPI::Internal::Type::BaseModel,
-                    T::Hash[T.anything, T.anything],
-                    T.anything
-                  ),
-                state: ModerationAPI::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: ModerationAPI::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: ModerationAPI::Internal::Type::BaseModel,
-              convert: T::Boolean
-            ).returns(ModerationAPI::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(ModerationAPI::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(ModerationAPI::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(ModerationAPI::Internal::AnyHash) }
-        def deep_to_h
-        end
-
-        sig do
-          params(keys: T.nilable(T::Array[Symbol])).returns(
-            ModerationAPI::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],
-                ModerationAPI::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/moderation_api/internal/type/base_page.rbi

@@ -1,43 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  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: ModerationAPI::Internal::Transport::BaseClient,
-            req:
-              ModerationAPI::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/moderation_api/internal/type/boolean.rbi

@@ -1,58 +0,0 @@
-# typed: strong
-
-module ModerationAPI
-  module Internal
-    module Type
-      # @api private
-      #
-      # Ruby has no Boolean class; this is something for models to refer to.
-      class Boolean
-        extend ModerationAPI::Internal::Type::Converter
-        extend ModerationAPI::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: ModerationAPI::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: ModerationAPI::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