clean-architecture 5.0.2 → 6.0.0

data/sorbet/rbi/gems/dry-schema.rbi

@@ -1,786 +0,0 @@
-# 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-schema/all/dry-schema.rbi
-#
-# dry-schema-1.4.3
-
-module Dry
-end
-module Dry::Schema
-  def self.Form(**options, &block); end
-  def self.JSON(**options, &block); end
-  def self.Params(**options, &block); end
-  def self.define(**options, &block); end
-  extend Dry::Core::Extensions
-  include Dry::Core::Constants
-end
-class Dry::Schema::InvalidSchemaError < StandardError
-end
-class Dry::Schema::MissingMessageError < StandardError
-  def initialize(path, paths = nil); end
-end
-class Dry::Schema::Path
-  def <=>(other); end
-  def each(&block); end
-  def include?(other); end
-  def index(key); end
-  def index?; end
-  def initialize(keys); end
-  def key_matches(other); end
-  def keys; end
-  def last; end
-  def root(*arg0); end
-  def same_root?(other); end
-  def self.[](spec); end
-  def self.keys_from_hash(hash); end
-  include Comparable
-  include Enumerable
-end
-class Dry::Schema::PredicateRegistry < Dry::Types::PredicateRegistry
-  def arg_list(name, *values); end
-end
-class Dry::Schema::TypeContainer
-  def config; end
-  def initialize(*args, &block); end
-  def registered?(key); end
-  extend Dry::Configurable
-  extend Dry::Configurable::ClassMethods
-  include Dry::Container::Mixin
-end
-class Dry::Schema::Config
-  def inspect; end
-  def method_missing(meth, *args, &block); end
-  def respond_to_missing?(meth, include_private = nil); end
-  extend Dry::Configurable::ClassMethods
-  include Anonymous_Dry_Equalizer_61
-  include Dry::Configurable
-  include Dry::Configurable::InstanceMethods
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_61
-  def cmp?(comparator, other); end
-  def hash; end
-end
-class Dry::Schema::Message
-  def <=>(other); end
-  def dump; end
-  def eql?(other); end
-  def to_s; end
-  extend Dry::Initializer
-  include Anonymous_Dry_Equalizer_62
-  include Anonymous_Module_63
-  include Dry::Equalizer::Methods
-  include Dry::Initializer::Mixin::Root
-end
-class Dry::Schema::Message::Or
-  def dump; end
-  def initialize(left, right, messages); end
-  def left; end
-  def messages; end
-  def path; end
-  def right; end
-  def to_a; end
-  def to_s; end
-end
-module Anonymous_Dry_Equalizer_62
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Module_63
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def args; end
-  def input; end
-  def meta; end
-  def path; end
-  def predicate; end
-  def text; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::MessageSet
-  def [](key); end
-  def each(&block); end
-  def empty?; end
-  def fetch(key); end
-  def freeze; end
-  def initialize(messages, options = nil); end
-  def initialize_placeholders!; end
-  def messages; end
-  def messages_map(messages = nil); end
-  def options; end
-  def paths; end
-  def placeholders; end
-  def self.[](messages, options = nil); end
-  def to_h; end
-  def to_hash; end
-  include Anonymous_Dry_Equalizer_64
-  include Dry::Equalizer::Methods
-  include Enumerable
-end
-module Anonymous_Dry_Equalizer_64
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::NamespacedRule
-  def ast(input = nil); end
-  def call(input); end
-  def initialize(namespace, rule); end
-  def namespace; end
-  def rule; end
-  def to_ast(input = nil); end
-end
-class Dry::Schema::Compiler < Dry::Logic::RuleCompiler
-  def self.new(predicates = nil); end
-  def supports?(predicate); end
-  def visit_and(node); end
-  def visit_namespace(node, opts = nil); end
-end
-module Dry::Schema::Types
-  extend Anonymous_Dry_Core_Deprecations_Tagged_65
-  extend Anonymous_Module_66
-  extend Dry::Core::Deprecations::Interface
-  extend Dry::Types::BuilderMethods
-  include Anonymous_Dry_Types_Module_67
-end
-module Dry::Schema::Types::Definition
-end
-module Anonymous_Dry_Types_Module_67
-  def self.included(base); end
-  extend Dry::Types::BuilderMethods
-end
-module Anonymous_Dry_Core_Deprecations_Tagged_65
-end
-module Anonymous_Module_66
-  def const_missing(missing); end
-end
-class Dry::Schema::Predicate
-  def !; end
-  def args; end
-  def ast(*arg0); end
-  def block; end
-  def compiler; end
-  def ensure_valid; end
-  def initialize(compiler, name, args, block); end
-  def name; end
-  def to_ast(*arg0); end
-  def to_rule; end
-  include Anonymous_Dry_Equalizer_68
-  include Dry::Equalizer::Methods
-  include Dry::Logic::Operators
-end
-class Dry::Schema::Predicate::Negation
-  def ast(*args); end
-  def initialize(predicate); end
-  def predicate; end
-  def to_ast(*args); end
-end
-module Anonymous_Dry_Equalizer_68
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Trace < BasicObject
-  def <<(op); end
-  def append(op); end
-  def captures; end
-  def class; end
-  def compiler; end
-  def evaluate(*args, type_spec: nil, **opts); end
-  def evaluate_predicates(predicates); end
-  def initialize(compiler = nil); end
-  def method_missing(meth, *args, &block); end
-  def reduced_rule; end
-  def to_ast; end
-  def to_rule(name = nil); end
-  include Anonymous_Dry_Equalizer_69
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_69
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Dry::Schema::Macros
-end
-class Dry::Schema::Macros::Core
-  def ast(*arg0); end
-  def new(**options); end
-  def operation; end
-  def to_ast(*arg0); end
-  def to_rule; end
-  extend Dry::Initializer
-  include Anonymous_Module_70
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_70
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def compiler; end
-  def name; end
-  def schema_dsl; end
-  def trace; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Module_71
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def chain; end
-  def predicate_inferrer; end
-  def primitive_inferrer; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::DSL < Dry::Schema::Macros::Core
-  def append_macro(macro_type); end
-  def array(*args, &block); end
-  def each(*args, &block); end
-  def extract_type_spec(*args, nullable: nil, set_type: nil); end
-  def filled(*args, &block); end
-  def hash(*args, &block); end
-  def resolve_type(type_spec, nullable); end
-  def schema(*args, &block); end
-  def type(spec); end
-  def value(*predicates, &block); end
-  include Anonymous_Module_71
-  include Dry::Logic::Operators
-end
-module Anonymous_Module_72
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Array < Dry::Schema::Macros::DSL
-  def ast(*arg0); end
-  def to_ast(*arg0); end
-  def value(*args, **opts, &block); end
-  include Anonymous_Module_72
-end
-module Anonymous_Module_73
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Each < Dry::Schema::Macros::DSL
-  def ast(*arg0); end
-  def to_ast(*arg0); end
-  def value(*args, **opts); end
-  include Anonymous_Module_73
-end
-module Anonymous_Module_74
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Value < Dry::Schema::Macros::DSL
-  def array_type?(type); end
-  def build_array_type(array_type, member); end
-  def call(*predicates, **opts, &block); end
-  def method_missing(meth, *args, &block); end
-  def respond_to_missing?(meth, include_private = nil); end
-  include Anonymous_Module_74
-end
-module Anonymous_Module_75
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Filled < Dry::Schema::Macros::Value
-  def call(*predicates, **opts, &block); end
-  def ensure_valid_predicates(predicates); end
-  def expected_primitives; end
-  def filter_empty_string?; end
-  def processor_config; end
-  def schema_type; end
-  include Anonymous_Module_75
-end
-module Anonymous_Module_76
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Schema < Dry::Schema::Macros::Value
-  def call(*args, &block); end
-  def define(*args, &block); end
-  def optional?; end
-  def parent_type; end
-  def redefined_schema?(args); end
-  def schema?; end
-  include Anonymous_Module_76
-end
-module Anonymous_Module_77
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Hash < Dry::Schema::Macros::Schema
-  def call(*args, &block); end
-  include Anonymous_Module_77
-end
-module Anonymous_Module_78
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Maybe < Dry::Schema::Macros::DSL
-  def call(*args, **opts, &block); end
-  def to_ast; end
-  include Anonymous_Module_78
-end
-class Dry::Schema::TypeRegistry
-  def [](name); end
-  def initialize(types, namespace = nil); end
-  def namespace; end
-  def namespaced(ns); end
-  def self.new(types = nil, namespace = nil); end
-  def types; end
-end
-class Dry::Schema::ProcessorSteps
-  def [](name); end
-  def []=(name, value); end
-  def after(name, &block); end
-  def before(name, &block); end
-  def call(result); end
-  def initialize_copy(source); end
-  def process_step(step, result); end
-  def validate_step_name(name); end
-  extend Dry::Initializer
-  include Anonymous_Module_79
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_79
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def after_steps; end
-  def before_steps; end
-  def steps; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Result
-  def [](name); end
-  def concat(other); end
-  def error?(spec); end
-  def errors(options = nil); end
-  def failure?; end
-  def inspect; end
-  def key?(name); end
-  def message_set(options = nil); end
-  def replace(hash); end
-  def result_ast; end
-  def self.new(*arg0, **arg1); end
-  def success?; end
-  def to_h; end
-  extend Dry::Initializer
-  include Anonymous_Dry_Equalizer_80
-  include Anonymous_Module_81
-  include Dry::Equalizer::Methods
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Dry_Equalizer_80
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-module Anonymous_Module_81
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(output, results = nil, *arg2, **__dry_initializer_options__); end
-  def message_compiler; end
-  def output; end
-  def results; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Dry::Schema::Messages
-  def self.setup(config); end
-  def setup(config); end
-end
-class Dry::Schema::Messages::Template
-  def [](data = nil); end
-  def call(data = nil); end
-  def data(input); end
-  def evaluator; end
-  def initialize(text, tokens, evaluator); end
-  def self.[](input); end
-  def self.parse(input); end
-  def text; end
-  def tokens; end
-  include Anonymous_Dry_Equalizer_82
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_82
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Messages::Abstract
-  def [](predicate, options); end
-  def cache; end
-  def cache_key(predicate, options); end
-  def call(predicate, options); end
-  def custom_top_namespace?(path); end
-  def default_locale; end
-  def filled_lookup_paths(tokens); end
-  def looked_up_paths(predicate, options); end
-  def lookup(predicate, options); end
-  def lookup_paths(predicate, options); end
-  def lookup_tokens(predicate, options); end
-  def namespaced(namespace); end
-  def root; end
-  def rule(name, options = nil); end
-  def rule_lookup_paths(tokens); end
-  def self.build(options = nil); end
-  def self.cache; end
-  def translate(key, locale: nil); end
-  extend Dry::Configurable::ClassMethods
-  include Anonymous_Dry_Equalizer_83
-  include Dry::Configurable
-  include Dry::Configurable::InstanceMethods
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_83
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Messages::Namespaced < Dry::Schema::Messages::Abstract
-  def [](key, options = nil); end
-  def cache_key(predicate, options); end
-  def call(key, options = nil); end
-  def call_opts; end
-  def config; end
-  def filled_lookup_paths(tokens); end
-  def get(key, options = nil); end
-  def initialize(namespace, messages); end
-  def key?(key, *args); end
-  def messages; end
-  def namespace; end
-  def rule_lookup_paths(tokens); end
-end
-class Dry::Schema::Messages::YAML < Dry::Schema::Messages::Abstract
-  def data; end
-  def evaluated_key(key, options); end
-  def get(key, options = nil); end
-  def initialize(data: nil, config: nil); end
-  def key?(key, options = nil); end
-  def load_translations(path); end
-  def looked_up_paths(predicate, options); end
-  def merge(overrides); end
-  def prepare; end
-  def self.build(options = nil); end
-  def self.flat_hash(hash, path = nil, keys = nil); end
-  def t; end
-  include Anonymous_Dry_Equalizer_84
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_84
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::MessageCompiler
-  def call(ast); end
-  def default_lookup_options; end
-  def initialize(messages, **options); end
-  def lookup_options(arg_vals:, input:); end
-  def message_text(template, tokens, options); end
-  def message_tokens(args); end
-  def message_type(*arg0); end
-  def options; end
-  def visit(node, opts = nil); end
-  def visit_and(node, opts); end
-  def visit_failure(node, opts); end
-  def visit_hint(*arg0); end
-  def visit_implication(node, *args); end
-  def visit_key(node, opts); end
-  def visit_namespace(node, opts); end
-  def visit_not(node, opts); end
-  def visit_or(node, opts); end
-  def visit_predicate(node, opts); end
-  def visit_set(node, opts); end
-  def visit_xor(node, opts); end
-  def with(new_options); end
-  extend Dry::Initializer
-  include Anonymous_Module_85
-  include Dry::Initializer::Mixin::Root
-end
-class Dry::Schema::MessageCompiler::VisitorOpts < Hash
-  def call(other); end
-  def current_messages; end
-  def dup(current_messages = nil); end
-  def failures; end
-  def hints; end
-  def key_failure?(path); end
-  def path; end
-  def self.new; end
-end
-module Anonymous_Module_85
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(messages, *arg1, **__dry_initializer_options__); end
-  def full; end
-  def locale; end
-  def messages; end
-  def predicate_resolvers; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::RuleApplier
-  def call(input); end
-  def to_ast; end
-  extend Dry::Initializer
-  include Anonymous_Module_86
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_86
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(rules, *arg1, **__dry_initializer_options__); end
-  def config; end
-  def message_compiler; end
-  def rules; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::KeyCoercer
-  def [](source); end
-  def call(source); end
-  def coercer; end
-  def initialize(key_map, &coercer); end
-  def key_map; end
-  def self.new(*args, &coercer); end
-  def self.symbolized(*args); end
-  extend Dry::Core::Cache
-  include Anonymous_Dry_Equalizer_87
-  include Dry::Core::Cache::Methods
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_87
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::ValueCoercer
-  def call(input); end
-  extend Dry::Initializer
-  include Anonymous_Dry_Equalizer_89
-  include Anonymous_Module_88
-  include Dry::Equalizer::Methods
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_88
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(type_schema, *arg1); end
-  def type_schema; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Dry_Equalizer_89
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Processor
-  def [](input); end
-  def call(input); end
-  def config; end
-  def filter_rules?; end
-  def filter_schema; end
-  def inspect; end
-  def key_map; end
-  def message_compiler; end
-  def rule_applier; end
-  def rules; end
-  def self.define(&block); end
-  def self.definition; end
-  def self.new(options = nil, &block); end
-  def to_ast; end
-  def to_proc; end
-  def to_rule; end
-  def type_schema; end
-  extend Dry::Configurable
-  extend Dry::Configurable::ClassMethods
-  extend Dry::Initializer
-  include Anonymous_Module_90
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_90
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def schema_dsl; end
-  def steps; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Module_91
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def filter_schema_dsl; end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Key < Dry::Schema::Macros::DSL
-  def filled(*args, **opts, &block); end
-  def filter(*args, &block); end
-  def maybe(*args, **opts, &block); end
-  def to_ast; end
-  def to_rule; end
-  def value(*args, **opts, &block); end
-  include Anonymous_Module_91
-end
-module Anonymous_Module_92
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Optional < Dry::Schema::Macros::Key
-  def operation; end
-  def to_rule; end
-  include Anonymous_Module_92
-end
-module Anonymous_Module_93
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Macros::Required < Dry::Schema::Macros::Key
-  def operation; end
-  include Anonymous_Module_93
-end
-class Dry::Schema::Key
-  def coerced_name; end
-  def coercer; end
-  def coercible(&coercer); end
-  def dump; end
-  def id; end
-  def initialize(id, name: nil, coercer: nil); end
-  def name; end
-  def new(**new_opts); end
-  def read(source); end
-  def self.[](name, **opts); end
-  def self.new(*args, **kwargs); end
-  def stringified; end
-  def write(source, target); end
-  extend Dry::Core::Cache
-  include Anonymous_Dry_Equalizer_94
-  include Dry::Core::Cache::Methods
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_94
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Key::Hash < Dry::Schema::Key
-  def coercible(&coercer); end
-  def dump; end
-  def initialize(id, members:, **opts); end
-  def members; end
-  def read(source); end
-  def stringified; end
-  def write(source, target); end
-  include Anonymous_Dry_Equalizer_95
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_95
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::Key::Array < Dry::Schema::Key
-  def coercible(&coercer); end
-  def dump; end
-  def initialize(id, member:, **opts); end
-  def member; end
-  def stringified; end
-  def write(source, target); end
-  include Anonymous_Dry_Equalizer_96
-  include Dry::Equalizer::Methods
-end
-module Anonymous_Dry_Equalizer_96
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::KeyMap
-  def +(other); end
-  def coercible(&coercer); end
-  def dump; end
-  def each(&block); end
-  def initialize(keys); end
-  def inspect; end
-  def keys; end
-  def self.[](*keys); end
-  def self.new(*args); end
-  def stringified; end
-  def write(source, target = nil); end
-  extend Dry::Core::Cache
-  include Anonymous_Dry_Equalizer_97
-  include Dry::Core::Cache::Methods
-  include Dry::Equalizer::Methods
-  include Enumerable
-end
-module Anonymous_Dry_Equalizer_97
-  def cmp?(comparator, other); end
-  def hash; end
-  def inspect; end
-end
-class Dry::Schema::DSL
-  def [](name); end
-  def after(key, &block); end
-  def array; end
-  def before(key, &block); end
-  def call; end
-  def configure(&block); end
-  def filter_rules?; end
-  def filter_schema; end
-  def filter_schema_dsl; end
-  def key(name, macro:, &block); end
-  def key_coercer; end
-  def key_map(types = nil); end
-  def key_map_type; end
-  def key_spec(name, type); end
-  def new(**options, &block); end
-  def optional(name, &block); end
-  def parent; end
-  def parent_filter_schemas; end
-  def parent_key_map; end
-  def parent_rules; end
-  def required(name, &block); end
-  def resolve_type(spec); end
-  def rule_applier; end
-  def rules; end
-  def self.new(**options, &block); end
-  def set_type(name, spec); end
-  def to_rule; end
-  def type_registry; end
-  def type_schema; end
-  def value_coercer; end
-  extend Dry::Initializer
-  include Anonymous_Module_98
-  include Dry::Initializer::Mixin::Root
-end
-module Anonymous_Module_98
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  def compiler; end
-  def config; end
-  def macros; end
-  def parents; end
-  def processor_type; end
-  def steps; end
-  def types; end
-  extend Dry::Initializer::Mixin::Local
-end
-module Anonymous_Module_99
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::Params < Dry::Schema::Processor
-  include Anonymous_Module_99
-end
-module Anonymous_Module_100
-  def __dry_initializer_config__; end
-  def __dry_initializer_initialize__(*arg0, **__dry_initializer_options__); end
-  extend Dry::Initializer::Mixin::Local
-end
-class Dry::Schema::JSON < Dry::Schema::Processor
-  include Anonymous_Module_100
-end