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

# typed: strict
#
# 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/activemodel/all/activemodel.rbi
#
# activemodel-6.1.4.4

module ActiveModel
  def self.eager_load!; end
  def self.gem_version; end
  def self.version; end
  extend ActiveSupport::Autoload
end
module ActiveModel::VERSION
end
module ActiveModel::Serializers
  extend ActiveSupport::Autoload
end
class ActiveModel::Error
  def ==(other); end
  def attribute; end
  def attributes_for_hash; end
  def base; end
  def detail; end
  def details; end
  def eql?(other); end
  def full_message; end
  def hash; end
  def i18n_customize_full_message; end
  def i18n_customize_full_message=(arg0); end
  def i18n_customize_full_message?; end
  def initialize(base, attribute, type = nil, **options); end
  def initialize_dup(other); end
  def inspect; end
  def match?(attribute, type = nil, **options); end
  def message; end
  def options; end
  def raw_type; end
  def self.full_message(attribute, message, base); end
  def self.generate_message(attribute, type, base, options); end
  def self.i18n_customize_full_message; end
  def self.i18n_customize_full_message=(value); end
  def self.i18n_customize_full_message?; end
  def strict_match?(attribute, type, **options); end
  def type; end
end
class ActiveModel::NestedError < ActiveModel::Error
  def initialize(base, inner_error, override_options = nil); end
  def inner_error; end
  def message(*args, &block); end
  extend Forwardable
end
class ActiveModel::Errors
  def [](attribute); end
  def add(attribute, type = nil, **options); end
  def add_from_legacy_details_hash(details); end
  def added?(attribute, type = nil, options = nil); end
  def any?(*args, &block); end
  def as_json(options = nil); end
  def attribute_names; end
  def blank?(*args, &block); end
  def clear(*args, &block); end
  def copy!(other); end
  def count(*args, &block); end
  def delete(attribute, type = nil, **options); end
  def deprecation_removal_warning(method_name, alternative_message = nil); end
  def deprecation_rename_warning(old_method_name, new_method_name); end
  def details; end
  def each(&block); end
  def empty?(*args, &block); end
  def errors; end
  def full_message(attribute, message); end
  def full_messages; end
  def full_messages_for(attribute); end
  def generate_message(attribute, type = nil, options = nil); end
  def group_by_attribute; end
  def has_key?(attribute); end
  def import(error, override_options = nil); end
  def include?(attribute); end
  def init_with(coder); end
  def initialize(base); end
  def initialize_dup(other); end
  def key?(attribute); end
  def keys; end
  def marshal_load(array); end
  def merge!(other); end
  def messages; end
  def messages_for(attribute); end
  def normalize_arguments(attribute, type, **options); end
  def objects; end
  def of_kind?(attribute, type = nil); end
  def size(*args, &block); end
  def slice!(*keys); end
  def to_a; end
  def to_h; end
  def to_hash(full_messages = nil); end
  def to_xml(options = nil); end
  def uniq!(*args, &block); end
  def values; end
  def where(attribute, type = nil, **options); end
  extend Forwardable
  include Enumerable
end
class ActiveModel::DeprecationHandlingMessageHash < SimpleDelegator
  def []=(attribute, value); end
  def delete(attribute); end
  def initialize(errors); end
  def prepare_content; end
end
class ActiveModel::DeprecationHandlingMessageArray < SimpleDelegator
  def <<(message); end
  def clear; end
  def initialize(content, errors, attribute); end
end
class ActiveModel::DeprecationHandlingDetailsHash < SimpleDelegator
  def initialize(details); end
end
class ActiveModel::StrictValidationFailed < StandardError
end
class ActiveModel::RangeError < RangeError
end
class ActiveModel::UnknownAttributeError < NoMethodError
  def attribute; end
  def initialize(record, attribute); end
  def record; end
end
module ActiveModel::Conversion
  def to_key; end
  def to_model; end
  def to_param; end
  def to_partial_path; end
  extend ActiveSupport::Concern
end
module ActiveModel::Conversion::ClassMethods
  def _to_partial_path; end
end
module ActiveModel::Validations
  def errors; end
  def initialize_dup(other); end
  def invalid?(context = nil); end
  def raise_validation_error; end
  def read_attribute_for_validation(*arg0); end
  def run_validations!; end
  def valid?(context = nil); end
  def validate!(context = nil); end
  def validate(context = nil); end
  def validates_with(*args, &block); end
  extend ActiveSupport::Concern
end
module ActiveModel::Validations::Callbacks
  def run_validations!; end
  extend ActiveSupport::Concern
end
module ActiveModel::Validations::Callbacks::ClassMethods
  def after_validation(*args, &block); end
  def before_validation(*args, &block); end
  def set_options_for_callback(options); end
end
class ActiveModel::Validator
  def initialize(options = nil); end
  def kind; end
  def options; end
  def self.kind; end
  def validate(record); end
end
class ActiveModel::EachValidator < ActiveModel::Validator
  def attributes; end
  def check_validity!; end
  def initialize(options); end
  def prepare_value_for_validation(value, record, attr_name); end
  def validate(record); end
  def validate_each(record, attribute, value); end
end
class ActiveModel::BlockValidator < ActiveModel::EachValidator
  def initialize(options, &block); end
  def validate_each(record, attribute, value); end
end
class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
  def confirmation_value_equal?(record, attribute, value, confirmed); end
  def initialize(options); end
  def setup!(klass); end
  def validate_each(record, attribute, value); end
end
module ActiveModel::Validations::HelperMethods
  def _merge_attributes(attr_names); end
  def validates_absence_of(*attr_names); end
  def validates_acceptance_of(*attr_names); end
  def validates_confirmation_of(*attr_names); end
  def validates_exclusion_of(*attr_names); end
  def validates_format_of(*attr_names); end
  def validates_inclusion_of(*attr_names); end
  def validates_length_of(*attr_names); end
  def validates_numericality_of(*attr_names); end
  def validates_presence_of(*attr_names); end
  def validates_size_of(*attr_names); end
end
module ActiveModel::Validations::Clusivity
  def check_validity!; end
  def delimiter; end
  def include?(record, value); end
  def inclusion_method(enumerable); end
end
class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value); end
  include ActiveModel::Validations::Clusivity
end
class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
  def check_options_validity(name); end
  def check_validity!; end
  def option_call(record, name); end
  def record_error(record, attribute, name, value); end
  def regexp_using_multiline_anchors?(regexp); end
  def validate_each(record, attribute, value); end
end
class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
  def validate_each(record, attr_name, value); end
end
class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
  def acceptable_option?(value); end
  def initialize(options); end
  def setup!(klass); end
  def validate_each(record, attribute, value); end
end
class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
  def ==(other); end
  def attributes; end
  def define_on(klass); end
  def included(klass); end
  def initialize(attributes); end
  def matches?(method_name); end
end
class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
  def validate_each(record, attr, val); end
end
module ActiveModel::Validations::ClassMethods
  def _parse_validates_options(options); end
  def _validates_default_keys; end
  def attribute_method?(attribute); end
  def clear_validators!; end
  def inherited(base); end
  def validate(*args, &block); end
  def validates!(*attributes); end
  def validates(*attributes); end
  def validates_each(*attr_names, &block); end
  def validates_with(*args, &block); end
  def validators; end
  def validators_on(*attributes); end
end
class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
  def check_validity!; end
  def initialize(options); end
  def skip_nil_check?(key); end
  def validate_each(record, attribute, value); end
end
class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
  def allow_only_integer?(record); end
  def check_validity!; end
  def filtered_options(value); end
  def is_hexadecimal_literal?(raw_value); end
  def is_integer?(raw_value); end
  def is_number?(raw_value, precision, scale); end
  def parse_as_number(raw_value, precision, scale); end
  def parse_float(raw_value, precision, scale); end
  def prepare_value_for_validation(value, record, attr_name); end
  def record_attribute_changed_in_place?(record, attr_name); end
  def round(raw_value, scale); end
  def validate_each(record, attr_name, value, precision: nil, scale: nil); end
end
class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
  def validate_each(record, attr_name, value); end
end
class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value); end
  include ActiveModel::Validations::Clusivity
end
class ActiveModel::ValidationError < StandardError
  def initialize(model); end
  def model; end
end
class ActiveModel::Name
  def !~(*args, &block); end
  def <=>(*args, &block); end
  def ==(arg); end
  def ===(arg); end
  def =~(*args, &block); end
  def _singularize(string); end
  def as_json(*args, &block); end
  def cache_key; end
  def collection; end
  def collection=(arg0); end
  def element; end
  def element=(arg0); end
  def eql?(*args, &block); end
  def human(options = nil); end
  def i18n_key; end
  def i18n_key=(arg0); end
  def initialize(klass, namespace = nil, name = nil); end
  def match?(*args, &block); end
  def name; end
  def name=(arg0); end
  def param_key; end
  def param_key=(arg0); end
  def plural; end
  def plural=(arg0); end
  def route_key; end
  def route_key=(arg0); end
  def singular; end
  def singular=(arg0); end
  def singular_route_key; end
  def singular_route_key=(arg0); end
  def to_s(*args, &block); end
  def to_str(*args, &block); end
  include Comparable
end
module ActiveModel::Naming
  def model_name; end
  def self.extended(base); end
  def self.model_name_from_record_or_class(record_or_class); end
  def self.param_key(record_or_class); end
  def self.plural(record_or_class); end
  def self.route_key(record_or_class); end
  def self.singular(record_or_class); end
  def self.singular_route_key(record_or_class); end
  def self.uncountable?(record_or_class); end
end
module ActiveModel::Callbacks
  def _define_after_model_callback(klass, callback); end
  def _define_around_model_callback(klass, callback); end
  def _define_before_model_callback(klass, callback); end
  def define_model_callbacks(*callbacks); end
  def self.extended(base); end
end
module ActiveModel::Translation
  def human_attribute_name(attribute, options = nil); end
  def i18n_scope; end
  def lookup_ancestors; end
  include ActiveModel::Naming
end