# This file is autogenerated. Do not edit it by hand. Regenerate it with:
#   srb rbi gems

# typed: true
#
# If you would like to make changes to this file, great! Please create the gem's shim here:
#
#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/dry-types/all/dry-types.rbi
#
# dry-types-1.3.1

module Dry
  def self.Types(*namespaces, default: nil, **aliases); end
end
module Dry::Types
  def self.Rule(options); end
  def self.[](name); end
  def self.const_missing(const); end
  def self.container; end
  def self.identifier(klass); end
  def self.included(*arg0); end
  def self.module(*args, &block); end
  def self.register(name, type = nil, &block); end
  def self.registered?(class_or_identifier); end
  def self.rule_compiler; end
  def self.type_map; end
  extend Anonymous_Dry_Core_Deprecations_Tagged_17
  extend Anonymous_Dry_Core_Deprecations_Tagged_19
  extend Anonymous_Dry_Core_Deprecations_Tagged_22
  extend Anonymous_Module_18
  extend Anonymous_Module_20
  extend Anonymous_Module_21
  extend Dry::Core::ClassAttributes
  extend Dry::Core::ClassAttributes
  extend Dry::Core::Deprecations::Interface
  extend Dry::Core::Deprecations::Interface
  extend Dry::Core::Deprecations::Interface
  extend Dry::Core::Extensions
  include Dry::Core::Constants
end
class Dry::Types::Container
  def config; end
  extend Dry::Configurable
  extend Dry::Configurable::ClassMethods
  include Dry::Container::Mixin
end
module Dry::Types::Type
  def ===(input = nil); end
  def [](input = nil, &block); end
  def call(input = nil, &block); end
  def safe(*args, &block); end
  def valid?(input = nil); end
  extend Anonymous_Dry_Core_Deprecations_Tagged_23
  extend Dry::Core::Deprecations::Interface
end
module Anonymous_Dry_Core_Deprecations_Tagged_23
end
module Dry::Types::Printable
  def inspect; end
  def to_s; end
end
module Dry::Types::Options
  def initialize(*args, **options); end
  def options; end
  def with(**new_options); end
end
module Dry::Types::Decorator
  def __new__(type); end
  def constrained?; end
  def decorate?(response); end
  def default?; end
  def initialize(type, *arg1, **arg2); end
  def method_missing(meth, *args, &block); end
  def respond_to_missing?(meth, include_private = nil); end
  def to_proc; end
  def try(input, &block); end
  def type; end
  include Dry::Types::Options
end
class Dry::Types::Default
  def call_safe(input = nil, &block); end
  def call_unsafe(input = nil); end
  def constrained(*args); end
  def default?; end
  def evaluate; end
  def initialize(type, value, **options); end
  def self.[](value); end
  def try(input); end
  def valid?(value = nil); end
  def value; end
  include Anonymous_Dry_Equalizer_24
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Decorator
  include Dry::Types::Printable
  include Dry::Types::Type
end
class Dry::Types::Default::Callable < Dry::Types::Default
  def evaluate; end
  include Anonymous_Dry_Equalizer_25
  include Dry::Equalizer::Methods
end
module Anonymous_Dry_Equalizer_25
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
module Anonymous_Dry_Equalizer_24
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Constrained
  def ===(value); end
  def call_safe(input, &block); end
  def call_unsafe(input); end
  def constrained(options); end
  def constrained?; end
  def constructor_type; end
  def decorate?(response); end
  def initialize(type, **options); end
  def lax; end
  def rule; end
  def to_ast(meta: nil); end
  def try(input, &block); end
  include Anonymous_Dry_Equalizer_26
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Decorator
  include Dry::Types::Printable
  include Dry::Types::Type
end
class Dry::Types::Constrained::Coercible < Dry::Types::Constrained
  def call_safe(input); end
  def call_unsafe(input); end
  def try(input, &block); end
end
module Anonymous_Dry_Equalizer_26
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Enum
  def call_safe(input, &block); end
  def call_unsafe(input); end
  def default(*arg0); end
  def include?(input = nil); end
  def initialize(type, **options); end
  def inspect; end
  def inverted_mapping; end
  def map_value(input); end
  def mapping; end
  def to_ast(meta: nil); end
  def to_s; end
  def try(input); end
  def values; end
  include Anonymous_Dry_Equalizer_27
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Decorator
  include Dry::Types::Type
end
module Anonymous_Dry_Equalizer_27
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Lax
  def [](input); end
  def call(input); end
  def call_safe(input); end
  def call_unsafe(input); end
  def decorate?(response); end
  def lax; end
  def to_ast(meta: nil); end
  def try(input, &block); end
  include Anonymous_Dry_Equalizer_28
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Decorator
  include Dry::Types::Printable
  include Dry::Types::Type
end
module Anonymous_Dry_Equalizer_28
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
module Anonymous_Dry_Core_Deprecations_Tagged_17
end
module Anonymous_Module_18
  def const_missing(missing); end
end
module Dry::Types::Meta
  def initialize(*args, meta: nil, **options); end
  def meta(data = nil); end
  def pristine; end
  def with(**options); end
end
class Dry::Types::Sum
  def call_safe(input, &block); end
  def call_unsafe(input); end
  def constrained(options); end
  def constrained?; end
  def default?; end
  def failure(input, _error = nil); end
  def initialize(left, right, **options); end
  def left; end
  def meta(data = nil); end
  def name; end
  def optional?; end
  def primitive?(value); end
  def right; end
  def success(input); end
  def to_ast(meta: nil); end
  def to_proc; end
  def try(input); end
  include Anonymous_Dry_Equalizer_29
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Meta
  include Dry::Types::Options
  include Dry::Types::Printable
  include Dry::Types::Type
end
module Anonymous_Dry_Equalizer_29
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Sum::Constrained < Dry::Types::Sum
  def constrained?; end
  def rule; end
end
module Dry::Types::Builder
  def <<(constructor = nil, **options, &block); end
  def >>(constructor = nil, **options, &block); end
  def append(constructor = nil, **options, &block); end
  def constrained(options); end
  def constrained_type; end
  def constructor(constructor = nil, **options, &block); end
  def constructor_type; end
  def default(input = nil, options = nil, &block); end
  def enum(*values); end
  def lax; end
  def optional; end
  def prepend(constructor = nil, **options, &block); end
  def |(other); end
  include Dry::Core::Constants
end
class Dry::Types::Result
  def initialize(input); end
  def input; end
  include Anonymous_Dry_Equalizer_30
  include Dry::Equalizer::Methods
end
module Anonymous_Dry_Equalizer_30
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
  def inspect; end
end
class Dry::Types::Result::Success < Dry::Types::Result
  def failure?; end
  def success?; end
end
class Dry::Types::Result::Failure < Dry::Types::Result
  def error; end
  def failure?; end
  def initialize(input, error); end
  def success?; end
  def to_s; end
  include Anonymous_Dry_Equalizer_31
  include Dry::Equalizer::Methods
end
module Anonymous_Dry_Equalizer_31
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
  def inspect; end
end
class Dry::Types::FnContainer
  def self.[](fn_name); end
  def self.container; end
  def self.register(function = nil, &block); end
  def self.register_name(function); end
end
class Dry::Types::Constructor < Dry::Types::Nominal
  def <<(new_fn = nil, **options, &block); end
  def >>(new_fn = nil, **options, &block); end
  def append(new_fn = nil, **options, &block); end
  def call_safe(input); end
  def call_unsafe(input); end
  def constrained_type; end
  def constructor(new_fn = nil, **options, &block); end
  def fn; end
  def initialize(type, fn: nil, **options); end
  def lax; end
  def method_missing(method, *args, &block); end
  def prepend(new_fn = nil, **options, &block); end
  def respond_to_missing?(meth, include_private = nil); end
  def self.new(input, **options, &block); end
  def to_ast(meta: nil); end
  def to_proc; end
  def try(input, &block); end
  def type; end
  include Anonymous_Dry_Equalizer_32
  include Dry::Equalizer::Methods
end
class Dry::Types::Constructor::Function
  def <<(other); end
  def >>(other); end
  def [](input, &block); end
  def call(input, &block); end
  def fn; end
  def initialize(fn); end
  def self.[](fn); end
  def self.yields_block?(fn); end
  def to_ast; end
  include Anonymous_Dry_Equalizer_33
  include Dry::Equalizer::Methods
end
class Dry::Types::Constructor::Function::Safe < Dry::Types::Constructor::Function
  def call(input, &block); end
end
class Dry::Types::Constructor::Function::MethodCall < Dry::Types::Constructor::Function
  def initialize(fn); end
  def name; end
  def self.[](fn, safe); end
  def self.call_class(method, public, safe); end
  def target; end
  def to_ast; end
end
class Dry::Types::Constructor::Function::MethodCall::PublicCall < Dry::Types::Constructor::Function::MethodCall
  def self.call_interface(method, safe); end
end
class Dry::Types::Constructor::Function::MethodCall::PrivateCall < Dry::Types::Constructor::Function::MethodCall
  def call(input, &block); end
end
class Dry::Types::Constructor::Function::MethodCall::PrivateSafeCall < Dry::Types::Constructor::Function::MethodCall::PrivateCall
  def call(input, &block); end
end
module Anonymous_Dry_Equalizer_33
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
  def inspect; end
end
module Anonymous_Dry_Equalizer_32
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Array < Dry::Types::Nominal
  def constructor_type; end
  def of(type); end
end
class Dry::Types::Array::Constructor < Dry::Types::Constructor
  def constructor_type; end
  def lax; end
  def of(member); end
end
class Dry::Types::Array::Member < Dry::Types::Array
  def call_safe(input); end
  def call_unsafe(input); end
  def constructor_type; end
  def initialize(primitive, **options); end
  def lax; end
  def member; end
  def to_ast(meta: nil); end
  def try(input, &block); end
end
class Dry::Types::Hash < Dry::Types::Nominal
  def build_keys(type_map); end
  def constructor_type; end
  def key_name(key); end
  def map(key_type, value_type); end
  def permissive(*arg0); end
  def resolve_type(type); end
  def schema(keys_or_map, meta = nil); end
  def strict(*arg0); end
  def strict_with_defaults(*arg0); end
  def symbolized(*arg0); end
  def to_ast(meta: nil); end
  def transform_types?; end
  def weak(*arg0); end
  def with_type_transform(proc = nil, &block); end
end
class Dry::Types::Hash::Constructor < Dry::Types::Constructor
  def constructor_type; end
  def lax; end
  def schema(*args); end
end
class Dry::Types::Schema < Dry::Types::Hash
  def apply(hash, options = nil); end
  def call_safe(hash, options = nil); end
  def call_unsafe(hash, options = nil); end
  def clear; end
  def constrained?; end
  def each(&block); end
  def initialize(_primitive, **options); end
  def key(name, fallback = nil, &block); end
  def key?(name); end
  def keys; end
  def lax; end
  def merge(other); end
  def merge_keys(*keys); end
  def missing_key(key); end
  def name_key_map; end
  def resolve_missing_keys(hash, options); end
  def resolve_safe(hash, options = nil, &block); end
  def resolve_unsafe(hash, options = nil); end
  def schema(keys_or_map); end
  def strict(strict = nil); end
  def strict?; end
  def to_ast(meta: nil); end
  def transform_key; end
  def transform_keys?; end
  def try(input); end
  def unexpected_keys(hash_keys); end
  def with_key_transform(proc = nil, &block); end
  include Enumerable
end
class Dry::Types::Schema::Key
  def call_safe(input, &block); end
  def call_unsafe(input); end
  def decorate?(response); end
  def initialize(type, name, required: nil, **options); end
  def lax; end
  def meta(data = nil); end
  def name; end
  def omittable; end
  def optional; end
  def required(required = nil); end
  def required?; end
  def to_ast(meta: nil); end
  def try(input, &block); end
  extend Anonymous_Dry_Core_Deprecations_Tagged_34
  extend Dry::Core::Deprecations::Interface
  include Anonymous_Dry_Equalizer_35
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Decorator
  include Dry::Types::Printable
  include Dry::Types::Type
end
module Anonymous_Dry_Core_Deprecations_Tagged_34
end
module Anonymous_Dry_Equalizer_35
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
class Dry::Types::Map < Dry::Types::Nominal
  def call_safe(hash); end
  def call_unsafe(hash); end
  def coerce(input); end
  def constrained?; end
  def initialize(_primitive, key_type: nil, value_type: nil, meta: nil); end
  def key_type; end
  def name; end
  def to_ast(meta: nil); end
  def try(hash); end
  def value_type; end
end
class Dry::Types::Nominal
  def call_safe(input); end
  def call_unsafe(input); end
  def coerce(input, &_block); end
  def constrained?; end
  def default?; end
  def failure(input, error); end
  def initialize(primitive, **options); end
  def lax; end
  def name; end
  def optional?; end
  def primitive; end
  def primitive?(value); end
  def self.[](primitive); end
  def success(input); end
  def to_ast(meta: nil); end
  def to_proc; end
  def try(input); end
  def try_coerce(input); end
  include Anonymous_Dry_Equalizer_36
  include Dry::Equalizer::Methods
  include Dry::Types::Builder
  include Dry::Types::Meta
  include Dry::Types::Options
  include Dry::Types::Printable
  include Dry::Types::Type
end
module Anonymous_Dry_Equalizer_36
  def cmp?(comparator, other); end
  def freeze; end
  def hash; end
end
module Anonymous_Dry_Core_Deprecations_Tagged_19
end
module Anonymous_Module_20
  def const_missing(missing); end
end
module Dry::Types::BuilderMethods
  def Array(type); end
  def Constant(object); end
  def Constructor(klass, cons = nil, &block); end
  def Hash(type_map); end
  def Instance(klass); end
  def Interface(*methods); end
  def Map(key_type, value_type); end
  def Nominal(klass); end
  def Strict(klass); end
  def Value(value); end
  def included(base); end
end
class Dry::Types::Module < Module
  def check_parameters(*namespaces, default: nil, **aliases); end
  def define_constants(constants, mod = nil); end
  def initialize(registry, *args, **kwargs); end
  def registry_tree; end
  def type_constants(*namespaces, default: nil, **aliases); end
end
module Anonymous_Module_21
  def inherited(klass); end
  def namespace(value = nil); end
end
class Dry::Types::CoercionError < StandardError
  def initialize(message, meta: nil, backtrace: nil); end
  def meta; end
  def self.handle(exception, meta: nil); end
end
class Dry::Types::MultipleError < Dry::Types::CoercionError
  def errors; end
  def initialize(errors); end
  def message; end
  def meta; end
end
class Dry::Types::SchemaError < Dry::Types::CoercionError
  def initialize(key, value, result); end
end
class Dry::Types::MapError < Dry::Types::CoercionError
end
class Dry::Types::SchemaKeyError < Dry::Types::CoercionError
end
class Dry::Types::MissingKeyError < Dry::Types::SchemaKeyError
  def initialize(key); end
  def key; end
end
class Dry::Types::UnknownKeysError < Dry::Types::SchemaKeyError
  def initialize(keys); end
  def keys; end
end
class Dry::Types::ConstraintError < Dry::Types::CoercionError
  def initialize(result, input); end
  def input; end
  def message; end
  def result; end
  def to_s; end
end
class Dry::Types::AnyClass < Dry::Types::Nominal
  def initialize(**options); end
  def name; end
  def self.name; end
  def to_ast(meta: nil); end
  def with(**new_options); end
end
module Dry::Types::Coercions
  def empty_str?(value); end
  def to_date(input, &block); end
  def to_date_time(input, &block); end
  def to_nil(input, &_block); end
  def to_symbol(input, &block); end
  def to_time(input, &block); end
  include Dry::Core::Constants
end
module Dry::Types::Coercions::Params
  def self.to_ary(input, &_block); end
  def self.to_decimal(input, &block); end
  def self.to_false(input, &_block); end
  def self.to_float(input, &block); end
  def self.to_hash(input, &_block); end
  def self.to_int(input, &block); end
  def self.to_true(input, &_block); end
  extend Dry::Types::Coercions
end
module Dry::Types::Coercions::JSON
  def self.to_decimal(input, &block); end
  extend Dry::Types::Coercions
end
module Anonymous_Dry_Logic_Rule_Interface_37
  def [](input0, input1); end
  def call(input0, input1); end
end
class Dry::Logic::Rule::Predicate::Predicate2Arity < Dry::Logic::Rule::Predicate
  include Anonymous_Dry_Logic_Rule_Interface_37
end
module Anonymous_Dry_Logic_Rule_Interface_38
  def [](input0); end
  def call(input0); end
  def initialize(*arg0); end
end
class Dry::Logic::Rule::Predicate::Predicate2Arity1Curried < Dry::Logic::Rule::Predicate
  include Anonymous_Dry_Logic_Rule_Interface_38
end
class Dry::Types::Printer
  def call(type); end
  def visit(type, &block); end
  def visit_any(_); end
  def visit_array(type); end
  def visit_array_member(array); end
  def visit_callable(callable); end
  def visit_constrained(constrained); end
  def visit_constructor(constructor); end
  def visit_default(default); end
  def visit_enum(enum); end
  def visit_hash(hash); end
  def visit_key(key); end
  def visit_lax(lax); end
  def visit_map(map); end
  def visit_nominal(type); end
  def visit_options(options, meta = nil); end
  def visit_schema(schema); end
  def visit_sum(sum); end
  def visit_sum_constructors(sum); end
end
module Anonymous_Dry_Core_Deprecations_Tagged_22
end
class Dry::Types::Compiler
  def call(ast); end
  def compile_fn(fn); end
  def initialize(registry); end
  def registry; end
  def visit(node); end
  def visit_any(meta); end
  def visit_array(node); end
  def visit_constrained(node); end
  def visit_constructor(node); end
  def visit_enum(node); end
  def visit_hash(node); end
  def visit_json_array(node); end
  def visit_json_hash(node); end
  def visit_key(node); end
  def visit_lax(node); end
  def visit_map(node); end
  def visit_nominal(node); end
  def visit_params_array(node); end
  def visit_params_hash(node); end
  def visit_rule(node); end
  def visit_safe(*args, &block); end
  def visit_schema(node); end
  def visit_sum(node); end
  extend Anonymous_Dry_Core_Deprecations_Tagged_39
  extend Dry::Core::Deprecations::Interface
end
module Anonymous_Dry_Core_Deprecations_Tagged_39
end
class Dry::Types::PredicateRegistry
  def [](name); end
  def has_predicate; end
  def initialize(predicates = nil); end
  def key?(name); end
  def predicates; end
end
class Dry::Types::PredicateInferrer
  def [](type); end
  def compiler; end
  def initialize(registry = nil); end
  extend Dry::Core::Cache
  include Dry::Core::Cache::Methods
end
class Dry::Types::PredicateInferrer::Compiler
  def infer_predicate(type); end
  def initialize(registry); end
  def merge_predicates(nodes); end
  def registry; end
  def visit(node); end
  def visit_and(node); end
  def visit_any(_); end
  def visit_array(_); end
  def visit_constrained(node); end
  def visit_constructor(node); end
  def visit_enum(node); end
  def visit_hash(_); end
  def visit_lax(node); end
  def visit_nominal(node); end
  def visit_predicate(node); end
  def visit_schema(_); end
  def visit_sum(node); end
end
class Dry::Types::PrimitiveInferrer
  def [](type); end
  def compiler; end
  def initialize; end
  extend Dry::Core::Cache
  include Dry::Core::Cache::Methods
end
class Dry::Types::PrimitiveInferrer::Compiler
  def visit(node); end
  def visit_any(_); end
  def visit_array(_); end
  def visit_constrained(node); end
  def visit_constructor(node); end
  def visit_enum(node); end
  def visit_hash(_); end
  def visit_lax(node); end
  def visit_nominal(node); end
  def visit_schema(_); end
  def visit_sum(node); end
end