# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `activerecord` gem.
# Please instead update this file by running `dev typecheck update`.

# typed: true

module ActiveRecord
  extend(::ActiveSupport::Autoload)

  class << self
    def eager_load!; end
    def gem_version; end
    def version; end
  end
end

class ActiveRecord::ActiveRecordError < ::StandardError
end

class ActiveRecord::AdapterNotFound < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::AdapterNotSpecified < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::AdapterTimeout < ::ActiveRecord::QueryAborted
end

class ActiveRecord::AdvisoryLockBase < ::ActiveRecord::Base
  class << self
    def _internal?; end
    def _validators; end
    def attribute_type_decorations; end
    def defined_enums; end
  end
end

module ActiveRecord::Aggregations
  def reload(*_); end

  private

  def clear_aggregation_cache; end
  def init_internals; end
  def initialize_dup(*_); end
end

module ActiveRecord::Aggregations::ClassMethods
  def composed_of(part_id, options = T.unsafe(nil)); end

  private

  def reader_method(name, class_name, mapping, allow_nil, constructor); end
  def writer_method(name, class_name, mapping, allow_nil, converter); end
end

class ActiveRecord::AmbiguousSourceReflectionForThroughAssociation < ::ActiveRecord::ActiveRecordError
  def initialize(klass, macro, association_name, options, possible_sources); end
end

class ActiveRecord::AssociationNotFoundError < ::ActiveRecord::ConfigurationError
  def initialize(record = T.unsafe(nil), association_name = T.unsafe(nil)); end
end

class ActiveRecord::AssociationRelation < ::ActiveRecord::Relation
  def initialize(klass, association, **_); end

  def ==(other); end
  def build(attributes = T.unsafe(nil), &block); end
  def create(attributes = T.unsafe(nil), &block); end
  def create!(attributes = T.unsafe(nil), &block); end
  def insert(attributes, **kwargs); end
  def insert!(attributes, **kwargs); end
  def insert_all(attributes, **kwargs); end
  def insert_all!(attributes, **kwargs); end
  def new(attributes = T.unsafe(nil), &block); end
  def proxy_association; end
  def upsert(attributes, **kwargs); end
  def upsert_all(attributes, **kwargs); end

  private

  def exec_queries; end
end

class ActiveRecord::AssociationTypeMismatch < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::Associations
  extend(::ActiveSupport::Autoload)
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Associations::ClassMethods)

  def association(name); end
  def association_cached?(name); end
  def reload(*_); end

  private

  def association_instance_get(name); end
  def association_instance_set(name, association); end
  def clear_association_cache; end
  def init_internals; end
  def initialize_dup(*_); end

  class << self
    def eager_load!; end
  end
end

class ActiveRecord::Associations::AliasTracker
  def initialize(connection, aliases); end

  def aliased_table_for(table_name, aliased_name, type_caster); end
  def aliases; end

  private

  def truncate(name); end

  class << self
    def create(connection, initial_table, joins); end
    def initial_count_for(connection, name, table_joins); end
  end
end

class ActiveRecord::Associations::Association
  def initialize(owner, reflection); end

  def create(attributes = T.unsafe(nil), &block); end
  def create!(attributes = T.unsafe(nil), &block); end
  def extensions; end
  def initialize_attributes(record, except_from_scope_attributes = T.unsafe(nil)); end
  def inversed_from(record); end
  def inversed_from_queries(record); end
  def klass; end
  def load_target; end
  def loaded!; end
  def loaded?; end
  def marshal_dump; end
  def marshal_load(data); end
  def options(*args, &block); end
  def owner; end
  def reflection; end
  def reload(force = T.unsafe(nil)); end
  def remove_inverse_instance(record); end
  def reset; end
  def reset_negative_cache; end
  def reset_scope; end
  def scope; end
  def set_inverse_instance(record); end
  def set_inverse_instance_from_queries(record); end
  def stale_target?; end
  def target; end
  def target=(target); end

  private

  def association_scope; end
  def build_record(attributes); end
  def creation_attributes; end
  def find_target; end
  def find_target?; end
  def foreign_key_for?(record); end
  def foreign_key_present?; end
  def inverse_association_for(record); end
  def inverse_reflection_for(record); end
  def invertible_for?(record); end
  def raise_on_type_mismatch!(record); end
  def scope_for_create; end
  def set_owner_attributes(record); end
  def skip_statement_cache?(scope); end
  def stale_state; end
  def target_scope; end
end

class ActiveRecord::Associations::AssociationScope
  def initialize(value_transformation); end

  def scope(association); end

  private

  def add_constraints(scope, owner, chain); end
  def apply_scope(scope, table, key, value); end
  def eval_scope(reflection, scope, owner); end
  def get_chain(reflection, association, tracker); end
  def join(table, constraint); end
  def last_chain_scope(scope, reflection, owner); end
  def next_chain_scope(scope, reflection, next_reflection); end
  def transform_value(value); end
  def value_transformation; end

  class << self
    def create(&block); end
    def get_bind_values(owner, chain); end
    def scope(association); end
  end
end

ActiveRecord::Associations::AssociationScope::INSTANCE = T.let(T.unsafe(nil), ActiveRecord::Associations::AssociationScope)

class ActiveRecord::Associations::AssociationScope::ReflectionProxy < ::SimpleDelegator
  def initialize(reflection, aliased_table); end

  def aliased_table; end
  def all_includes; end
end

class ActiveRecord::Associations::BelongsToAssociation < ::ActiveRecord::Associations::SingularAssociation
  def decrement_counters; end
  def decrement_counters_before_last_save; end
  def default(&block); end
  def handle_dependency; end
  def increment_counters; end
  def inversed_from(record); end
  def reset; end
  def target_changed?; end
  def updated?; end

  private

  def find_target?; end
  def foreign_key_present?; end
  def invertible_for?(record); end
  def primary_key(klass); end
  def replace(record); end
  def replace_keys(record); end
  def require_counter_update?; end
  def stale_state; end
  def update_counters(by); end
  def update_counters_via_scope(klass, foreign_key, by); end
end

class ActiveRecord::Associations::BelongsToPolymorphicAssociation < ::ActiveRecord::Associations::BelongsToAssociation
  def klass; end
  def target_changed?; end

  private

  def inverse_reflection_for(record); end
  def raise_on_type_mismatch!(record); end
  def replace_keys(record); end
  def stale_state; end
end

module ActiveRecord::Associations::Builder
end

class ActiveRecord::Associations::Builder::Association
  class << self
    def build(model, name, scope, options, &block); end
    def create_reflection(model, name, scope, options, &block); end
    def extensions; end
    def extensions=(_); end

    private

    def add_destroy_callbacks(model, reflection); end
    def build_scope(scope); end
    def check_dependent_options(dependent); end
    def define_accessors(model, reflection); end
    def define_callbacks(model, reflection); end
    def define_extensions(model, name); end
    def define_readers(mixin, name); end
    def define_validations(model, reflection); end
    def define_writers(mixin, name); end
    def macro; end
    def valid_dependent_options; end
    def valid_options(options); end
    def validate_options(options); end
  end
end

ActiveRecord::Associations::Builder::Association::VALID_OPTIONS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Associations::Builder::BelongsTo < ::ActiveRecord::Associations::Builder::SingularAssociation
  class << self
    def touch_record(o, changes, foreign_key, name, touch, touch_method); end

    private

    def add_counter_cache_callbacks(model, reflection); end
    def add_default_callbacks(model, reflection); end
    def add_destroy_callbacks(model, reflection); end
    def add_touch_callbacks(model, reflection); end
    def define_callbacks(model, reflection); end
    def define_validations(model, reflection); end
    def macro; end
    def valid_dependent_options; end
    def valid_options(options); end
  end
end

class ActiveRecord::Associations::Builder::CollectionAssociation < ::ActiveRecord::Associations::Builder::Association
  class << self
    def define_callbacks(model, reflection); end

    private

    def define_callback(model, callback_name, name, options); end
    def define_extensions(model, name, &block); end
    def define_readers(mixin, name); end
    def define_writers(mixin, name); end
    def valid_options(options); end
  end
end

ActiveRecord::Associations::Builder::CollectionAssociation::CALLBACKS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Associations::Builder::HasAndBelongsToMany
  def initialize(association_name, lhs_model, options); end

  def association_name; end
  def lhs_model; end
  def middle_reflection(join_model); end
  def options; end
  def through_model; end

  private

  def belongs_to_options(options); end
  def middle_options(join_model); end
  def table_name; end
end

class ActiveRecord::Associations::Builder::HasMany < ::ActiveRecord::Associations::Builder::CollectionAssociation
  class << self

    private

    def macro; end
    def valid_dependent_options; end
    def valid_options(options); end
  end
end

class ActiveRecord::Associations::Builder::HasOne < ::ActiveRecord::Associations::Builder::SingularAssociation
  class << self
    def touch_record(record, name, touch); end

    private

    def add_destroy_callbacks(model, reflection); end
    def add_touch_callbacks(model, reflection); end
    def define_callbacks(model, reflection); end
    def define_validations(model, reflection); end
    def macro; end
    def valid_dependent_options; end
    def valid_options(options); end
  end
end

class ActiveRecord::Associations::Builder::SingularAssociation < ::ActiveRecord::Associations::Builder::Association
  class << self

    private

    def define_accessors(model, reflection); end
    def define_constructors(mixin, name); end
    def valid_options(options); end
  end
end

module ActiveRecord::Associations::ClassMethods
  def belongs_to(name, scope = T.unsafe(nil), **options); end
  def has_and_belongs_to_many(name, scope = T.unsafe(nil), **options, &extension); end
  def has_many(name, scope = T.unsafe(nil), **options, &extension); end
  def has_one(name, scope = T.unsafe(nil), **options); end
end

class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associations::Association
  def add_to_target(record, skip_callbacks: T.unsafe(nil), replace: T.unsafe(nil), &block); end
  def build(attributes = T.unsafe(nil), &block); end
  def concat(*records); end
  def delete(*records); end
  def delete_all(dependent = T.unsafe(nil)); end
  def destroy(*records); end
  def destroy_all; end
  def empty?; end
  def find(*args); end
  def find_from_target?; end
  def ids_reader; end
  def ids_writer(ids); end
  def include?(record); end
  def load_target; end
  def null_scope?; end
  def reader; end
  def replace(other_array); end
  def reset; end
  def scope; end
  def size; end
  def target=(record); end
  def transaction(*args); end
  def writer(records); end

  private

  def _create_record(attributes, raise = T.unsafe(nil), &block); end
  def callback(method, record); end
  def callbacks_for(callback_name); end
  def concat_records(records, raise = T.unsafe(nil)); end
  def delete_or_destroy(records, method); end
  def delete_records(records, method); end
  def find_by_scan(*args); end
  def include_in_memory?(record); end
  def insert_record(record, validate = T.unsafe(nil), raise = T.unsafe(nil), &block); end
  def merge_target_lists(persisted, memory); end
  def remove_records(existing_records, records, method); end
  def replace_common_records_in_memory(new_target, original_target); end
  def replace_on_target(record, index, skip_callbacks); end
  def replace_records(new_target, original_target); end
end

class ActiveRecord::Associations::CollectionProxy < ::ActiveRecord::Relation
  def initialize(klass, association, **_); end

  def <<(*records); end
  def ==(other); end
  def _select!(*args, &block); end
  def annotate(*args, &block); end
  def annotate!(*args, &block); end
  def annotate_values(*args, &block); end
  def annotate_values=(arg); end
  def append(*records); end
  def arel(*args, &block); end
  def build(attributes = T.unsafe(nil), &block); end
  def calculate(operation, column_name); end
  def clear; end
  def concat(*records); end
  def construct_join_dependency(*args, &block); end
  def create(attributes = T.unsafe(nil), &block); end
  def create!(attributes = T.unsafe(nil), &block); end
  def create_with(*args, &block); end
  def create_with!(*args, &block); end
  def create_with_value(*args, &block); end
  def create_with_value=(arg); end
  def delete(*records); end
  def delete_all(dependent = T.unsafe(nil)); end
  def destroy(*records); end
  def destroy_all; end
  def distinct(*args, &block); end
  def distinct!(*args, &block); end
  def distinct_value(*args, &block); end
  def distinct_value=(arg); end
  def eager_load(*args, &block); end
  def eager_load!(*args, &block); end
  def eager_load_values(*args, &block); end
  def eager_load_values=(arg); end
  def empty?; end
  def except(*args, &block); end
  def extending(*args, &block); end
  def extending!(*args, &block); end
  def extending_values(*args, &block); end
  def extending_values=(arg); end
  def extensions(*args, &block); end
  def extract_associated(*args, &block); end
  def find(*args); end
  def from(*args, &block); end
  def from!(*args, &block); end
  def from_clause(*args, &block); end
  def from_clause=(arg); end
  def group(*args, &block); end
  def group!(*args, &block); end
  def group_values(*args, &block); end
  def group_values=(arg); end
  def having(*args, &block); end
  def having!(*args, &block); end
  def having_clause(*args, &block); end
  def having_clause=(arg); end
  def include?(record); end
  def includes(*args, &block); end
  def includes!(*args, &block); end
  def includes_values(*args, &block); end
  def includes_values=(arg); end
  def insert(*args, &block); end
  def insert!(*args, &block); end
  def insert_all(*args, &block); end
  def insert_all!(*args, &block); end
  def joins(*args, &block); end
  def joins!(*args, &block); end
  def joins_values(*args, &block); end
  def joins_values=(arg); end
  def last(limit = T.unsafe(nil)); end
  def left_joins(*args, &block); end
  def left_outer_joins(*args, &block); end
  def left_outer_joins!(*args, &block); end
  def left_outer_joins_values(*args, &block); end
  def left_outer_joins_values=(arg); end
  def limit(*args, &block); end
  def limit!(*args, &block); end
  def limit_value(*args, &block); end
  def limit_value=(arg); end
  def load_target; end
  def loaded?; end
  def lock(*args, &block); end
  def lock!(*args, &block); end
  def lock_value(*args, &block); end
  def lock_value=(arg); end
  def merge(*args, &block); end
  def merge!(*args, &block); end
  def new(attributes = T.unsafe(nil), &block); end
  def none(*args, &block); end
  def none!(*args, &block); end
  def offset(*args, &block); end
  def offset!(*args, &block); end
  def offset_value(*args, &block); end
  def offset_value=(arg); end
  def only(*args, &block); end
  def optimizer_hints(*args, &block); end
  def optimizer_hints!(*args, &block); end
  def optimizer_hints_values(*args, &block); end
  def optimizer_hints_values=(arg); end
  def or(*args, &block); end
  def or!(*args, &block); end
  def order(*args, &block); end
  def order!(*args, &block); end
  def order_values(*args, &block); end
  def order_values=(arg); end
  def pluck(*column_names); end
  def preload(*args, &block); end
  def preload!(*args, &block); end
  def preload_values(*args, &block); end
  def preload_values=(arg); end
  def prepend(*args); end
  def proxy_association; end
  def push(*records); end
  def readonly(*args, &block); end
  def readonly!(*args, &block); end
  def readonly_value(*args, &block); end
  def readonly_value=(arg); end
  def records; end
  def references(*args, &block); end
  def references!(*args, &block); end
  def references_values(*args, &block); end
  def references_values=(arg); end
  def reload; end
  def reorder(*args, &block); end
  def reorder!(*args, &block); end
  def reordering_value(*args, &block); end
  def reordering_value=(arg); end
  def replace(other_array); end
  def reselect(*args, &block); end
  def reselect!(*args, &block); end
  def reset; end
  def reset_scope; end
  def reverse_order(*args, &block); end
  def reverse_order!(*args, &block); end
  def reverse_order_value(*args, &block); end
  def reverse_order_value=(arg); end
  def rewhere(*args, &block); end
  def scope; end
  def scoping(*args, &block); end
  def select_values(*args, &block); end
  def select_values=(arg); end
  def size; end
  def skip_preloading!(*args, &block); end
  def skip_query_cache!(*args, &block); end
  def skip_query_cache_value(*args, &block); end
  def skip_query_cache_value=(arg); end
  def spawn(*args, &block); end
  def strict_loading(*args, &block); end
  def strict_loading!(*args, &block); end
  def strict_loading_value(*args, &block); end
  def strict_loading_value=(arg); end
  def take(limit = T.unsafe(nil)); end
  def target; end
  def unscope(*args, &block); end
  def unscope!(*args, &block); end
  def unscope_values(*args, &block); end
  def unscope_values=(arg); end
  def upsert(*args, &block); end
  def upsert_all(*args, &block); end
  def values(*args, &block); end
  def where(*args, &block); end
  def where!(*args, &block); end
  def where_clause(*args, &block); end
  def where_clause=(arg); end

  private

  def exec_queries; end
  def find_from_target?; end
  def find_nth_from_last(index); end
  def find_nth_with_limit(index, limit); end
  def null_scope?; end
end

module ActiveRecord::Associations::ForeignAssociation
  def foreign_key_present?; end
  def nullified_owner_attributes; end
end

class ActiveRecord::Associations::HasManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
  include(::ActiveRecord::Associations::ForeignAssociation)

  def handle_dependency; end
  def insert_record(record, validate = T.unsafe(nil), raise = T.unsafe(nil)); end

  private

  def _create_record(attributes, *_); end
  def concat_records(records, *_); end
  def count_records; end
  def delete_count(method, scope); end
  def delete_or_nullify_all_records(method); end
  def delete_records(records, method); end
  def difference(a, b); end
  def intersection(a, b); end
  def update_counter(difference, reflection = T.unsafe(nil)); end
  def update_counter_if_success(saved_successfully, difference); end
  def update_counter_in_memory(difference, reflection = T.unsafe(nil)); end
end

class ActiveRecord::Associations::HasManyThroughAssociation < ::ActiveRecord::Associations::HasManyAssociation
  include(::ActiveRecord::Associations::ThroughAssociation)

  def initialize(owner, reflection); end

  def concat(*records); end
  def insert_record(record, validate = T.unsafe(nil), raise = T.unsafe(nil)); end

  private

  def build_record(attributes); end
  def build_through_record(record); end
  def concat_records(records); end
  def delete_or_nullify_all_records(method); end
  def delete_records(records, method); end
  def delete_through_records(records); end
  def difference(a, b); end
  def distribution(array); end
  def find_target; end
  def intersection(a, b); end
  def invertible_for?(record); end
  def mark_occurrence(distribution, record); end
  def remove_records(existing_records, records, method); end
  def save_through_record(record); end
  def target_reflection_has_associated_record?; end
  def through_records_for(record); end
  def through_scope_attributes; end
  def update_through_counter?(method); end
end

class ActiveRecord::Associations::HasOneAssociation < ::ActiveRecord::Associations::SingularAssociation
  include(::ActiveRecord::Associations::ForeignAssociation)

  def delete(method = T.unsafe(nil)); end
  def handle_dependency; end

  private

  def _create_record(attributes, raise_error = T.unsafe(nil), &block); end
  def nullify_owner_attributes(record); end
  def remove_target!(method); end
  def replace(record, save = T.unsafe(nil)); end
  def set_new_record(record); end
  def transaction_if(value); end
end

class ActiveRecord::Associations::HasOneThroughAssociation < ::ActiveRecord::Associations::HasOneAssociation
  include(::ActiveRecord::Associations::ThroughAssociation)


  private

  def create_through_record(record, save); end
  def replace(record, save = T.unsafe(nil)); end
end

class ActiveRecord::Associations::JoinDependency
  def initialize(base, table, associations, join_type); end

  def apply_column_aliases(relation); end
  def base_klass; end
  def instantiate(result_set, strict_loading_value, &block); end
  def join_constraints(joins_to_add, alias_tracker); end
  def reflections; end

  protected

  def join_root; end
  def join_type; end

  private

  def alias_tracker; end
  def aliases; end
  def build(associations, base_klass); end
  def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value); end
  def construct_model(record, node, row, model_cache, id, strict_loading_value); end
  def construct_tables!(join_root); end
  def explicit_selections(root_column_aliases, result_set); end
  def find_reflection(klass, name); end
  def make_constraints(parent, child, join_type); end
  def make_join_constraints(join_root, join_type); end
  def table_alias_for(reflection, parent, join); end
  def table_aliases_for(parent, node); end
  def walk(left, right, join_type); end

  class << self
    def make_tree(associations); end
    def walk_tree(associations, hash); end
  end
end

class ActiveRecord::Associations::JoinDependency::Aliases
  def initialize(tables); end

  def column_alias(node, column); end
  def column_aliases(node); end
  def columns; end
end

class ActiveRecord::Associations::JoinDependency::Aliases::Column < ::Struct
  def alias; end
  def alias=(_); end
  def name; end
  def name=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::Associations::JoinDependency::Aliases::Table < ::Struct
  def column_aliases; end
  def columns; end
  def columns=(_); end
  def node; end
  def node=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::Associations::JoinDependency::JoinAssociation < ::ActiveRecord::Associations::JoinDependency::JoinPart
  def initialize(reflection, children); end

  def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker); end
  def match?(other); end
  def readonly?; end
  def reflection; end
  def strict_loading?; end
  def table; end
  def table=(_); end
  def tables; end
  def tables=(tables); end

  private

  def append_constraints(join, constraints); end
end

class ActiveRecord::Associations::JoinDependency::JoinBase < ::ActiveRecord::Associations::JoinDependency::JoinPart
  def initialize(base_klass, table, children); end

  def match?(other); end
  def table; end
end

class ActiveRecord::Associations::Preloader
  extend(::ActiveSupport::Autoload)

  def preload(records, associations, preload_scope = T.unsafe(nil)); end

  private

  def grouped_records(association, records, polymorphic_parent); end
  def preloader_for(reflection, owners); end
  def preloaders_for_hash(association, records, scope, polymorphic_parent); end
  def preloaders_for_one(association, records, scope, polymorphic_parent); end
  def preloaders_for_reflection(reflection, records, scope); end
  def preloaders_on(association, records, scope, polymorphic_parent = T.unsafe(nil)); end
end

class ActiveRecord::Associations::Preloader::AlreadyLoaded
  def initialize(klass, owners, reflection, preload_scope); end

  def preloaded_records; end
  def records_by_owner; end
  def run; end

  private

  def owners; end
  def reflection; end
end

class ActiveRecord::Associations::Preloader::Association
  def initialize(klass, owners, reflection, preload_scope); end

  def preloaded_records; end
  def records_by_owner; end
  def run; end

  private

  def associate_records_to_owner(owner, records); end
  def association_key_name; end
  def association_key_type; end
  def build_scope; end
  def convert_key(key); end
  def key_conversion_required?; end
  def klass; end
  def load_records; end
  def model; end
  def owner_key_name; end
  def owner_key_type; end
  def owner_keys; end
  def owners; end
  def owners_by_key; end
  def preload_scope; end
  def records_for(ids); end
  def reflection; end
  def reflection_scope; end
  def scope; end
end

class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord::Associations::Preloader::Association
  def initialize(*_); end

  def preloaded_records; end
  def records_by_owner; end

  private

  def middle_records; end
  def preload_index; end
  def source_preloaders; end
  def source_reflection; end
  def through_preloaders; end
  def through_reflection; end
  def through_scope; end
end

ActiveRecord::Associations::Preloader::ThroughAssociation::PRELOADER = T.let(T.unsafe(nil), ActiveRecord::Associations::Preloader)

class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associations::Association
  def build(attributes = T.unsafe(nil), &block); end
  def force_reload_reader; end
  def reader; end
  def writer(record); end

  private

  def _create_record(attributes, raise_error = T.unsafe(nil), &block); end
  def find_target; end
  def replace(record); end
  def scope_for_create; end
  def set_new_record(record); end
end

module ActiveRecord::Associations::ThroughAssociation
  def source_reflection(*args, &block); end

  private

  def build_record(attributes); end
  def construct_join_attributes(*records); end
  def ensure_mutable; end
  def ensure_not_nested; end
  def foreign_key_present?; end
  def stale_state; end
  def target_scope; end
  def through_association; end
  def through_reflection; end
end

module ActiveRecord::AttributeAssignment
  include(::ActiveModel::ForbiddenAttributesProtection)
  include(::ActiveModel::AttributeAssignment)


  private

  def _assign_attributes(attributes); end
  def assign_multiparameter_attributes(pairs); end
  def assign_nested_parameter_attributes(pairs); end
  def execute_callstack_for_multiparameter_attributes(callstack); end
  def extract_callstack_for_multiparameter_attributes(pairs); end
  def find_parameter_position(multiparameter_name); end
  def type_cast_attribute_value(multiparameter_name, value); end
end

class ActiveRecord::AttributeAssignmentError < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil), exception = T.unsafe(nil), attribute = T.unsafe(nil)); end

  def attribute; end
  def exception; end
end

module ActiveRecord::AttributeDecorators
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeDecorators::ClassMethods)
end

module ActiveRecord::AttributeDecorators::ClassMethods
  def decorate_attribute_type(column_name, decorator_name, &block); end
  def decorate_matching_attribute_types(matcher, decorator_name, &block); end

  private

  def load_schema!; end
end

class ActiveRecord::AttributeDecorators::TypeDecorator
  def initialize(decorations = T.unsafe(nil)); end

  def apply(name, type); end
  def clear(*args, &block); end
  def merge(*args); end

  private

  def decorators_for(name, type); end
  def matching(name, type); end
end

module ActiveRecord::AttributeMethods
  extend(::ActiveSupport::Concern)
  extend(::ActiveSupport::Autoload)

  include(::ActiveModel::AttributeMethods)
  include(::ActiveRecord::AttributeMethods::Read)
  include(::ActiveRecord::AttributeMethods::Write)
  include(::ActiveRecord::AttributeMethods::BeforeTypeCast)
  include(::ActiveRecord::AttributeMethods::Query)
  include(::ActiveRecord::AttributeMethods::PrimaryKey)
  include(::ActiveRecord::AttributeMethods::TimeZoneConversion)
  include(::ActiveModel::Dirty)
  include(::ActiveRecord::AttributeMethods::Dirty)
  include(::ActiveRecord::AttributeMethods::Serialization)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::ClassMethods)

  def [](attr_name); end
  def []=(attr_name, value); end
  def accessed_fields; end
  def attribute_for_inspect(attr_name); end
  def attribute_names; end
  def attribute_present?(attribute); end
  def attributes; end
  def has_attribute?(attr_name); end
  def respond_to?(name, include_private = T.unsafe(nil)); end

  private

  def attribute_method?(attr_name); end
  def attributes_for_create(attribute_names); end
  def attributes_for_update(attribute_names); end
  def attributes_with_values(attribute_names); end
  def format_for_inspect(value); end
  def pk_attribute?(name); end
end

module ActiveRecord::AttributeMethods::BeforeTypeCast
  extend(::ActiveSupport::Concern)

  def attributes_before_type_cast; end
  def read_attribute_before_type_cast(attr_name); end

  private

  def attribute_before_type_cast(attribute_name); end
  def attribute_came_from_user?(attribute_name); end
end

module ActiveRecord::AttributeMethods::ClassMethods
  def attribute_method?(attribute); end
  def attribute_names; end
  def column_for_attribute(name); end
  def dangerous_attribute_method?(name); end
  def dangerous_class_method?(method_name); end
  def define_attribute_methods; end
  def has_attribute?(attr_name); end
  def inherited(child_class); end
  def initialize_generated_modules; end
  def instance_method_already_implemented?(method_name); end
  def method_defined_within?(name, klass, superklass = T.unsafe(nil)); end
  def undefine_attribute_methods; end
end

module ActiveRecord::AttributeMethods::Dirty
  extend(::ActiveSupport::Concern)

  include(::ActiveModel::AttributeMethods)
  include(::ActiveModel::Dirty)

  def attribute_before_last_save(attr_name); end
  def attribute_change_to_be_saved(attr_name); end
  def attribute_in_database(attr_name); end
  def attributes_in_database; end
  def changed_attribute_names_to_save; end
  def changes_to_save; end
  def has_changes_to_save?; end
  def reload(*_); end
  def saved_change_to_attribute(attr_name); end
  def saved_change_to_attribute?(attr_name, **options); end
  def saved_changes; end
  def saved_changes?; end
  def will_save_change_to_attribute?(attr_name, **options); end

  private

  def _create_record(attribute_names = T.unsafe(nil)); end
  def _touch_row(attribute_names, time); end
  def _update_record(attribute_names = T.unsafe(nil)); end
  def attribute_names_for_partial_writes; end
  def mutations_before_last_save; end
  def mutations_from_database; end
  def write_attribute_without_type_cast(attr_name, value); end
end

class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module
  include(::Mutex_m)

  def lock; end
  def locked?; end
  def synchronize(&block); end
  def try_lock; end
  def unlock; end
end

module ActiveRecord::AttributeMethods::PrimaryKey
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods)

  def id; end
  def id=(value); end
  def id?; end
  def id_before_type_cast; end
  def id_in_database; end
  def id_was; end
  def to_key; end

  private

  def attribute_method?(attr_name); end
end

module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
  def dangerous_attribute_method?(method_name); end
  def get_primary_key(base_name); end
  def instance_method_already_implemented?(method_name); end
  def primary_key; end
  def primary_key=(value); end
  def quoted_primary_key; end
  def reset_primary_key; end

  private

  def suppress_composite_primary_key(pk); end
end

ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods::ID_ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Set)

module ActiveRecord::AttributeMethods::Query
  extend(::ActiveSupport::Concern)

  def query_attribute(attr_name); end

  private

  def attribute?(attribute_name); end
end

ActiveRecord::AttributeMethods::RESTRICTED_CLASS_METHODS = T.let(T.unsafe(nil), Array)

module ActiveRecord::AttributeMethods::Read
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::Read::ClassMethods)

  def _read_attribute(attr_name, &block); end
  def read_attribute(attr_name, &block); end

  private

  def attribute(attr_name, &block); end
end

module ActiveRecord::AttributeMethods::Read::ClassMethods

  private

  def define_method_attribute(name, owner:); end
end

module ActiveRecord::AttributeMethods::Serialization
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::Serialization::ClassMethods)
end

module ActiveRecord::AttributeMethods::Serialization::ClassMethods
  def serialize(attr_name, class_name_or_coder = T.unsafe(nil)); end

  private

  def type_incompatible_with_serialize?(type, class_name); end
end

class ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError < ::StandardError
  def initialize(name, type); end
end

module ActiveRecord::AttributeMethods::TimeZoneConversion
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods)
end

module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods

  private

  def create_time_zone_conversion_attribute?(name, cast_type); end
  def inherited(subclass); end
end

class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
  def cast(value); end
  def deserialize(value); end

  private

  def convert_time_to_time_zone(value); end
  def map_avoiding_infinite_recursion(value); end
  def set_time_zone_without_conversion(value); end
end

module ActiveRecord::AttributeMethods::Write
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AttributeMethods::Write::ClassMethods)

  def _write_attribute(attr_name, value); end
  def write_attribute(attr_name, value); end

  private

  def attribute=(attribute_name, value); end
  def write_attribute_without_type_cast(attr_name, value); end
end

module ActiveRecord::AttributeMethods::Write::ClassMethods

  private

  def define_method_attribute=(name, owner:); end
end

module ActiveRecord::Attributes
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Attributes::ClassMethods)
end

module ActiveRecord::Attributes::ClassMethods
  def attribute(name, cast_type = T.unsafe(nil), **options); end
  def define_attribute(name, cast_type, default: T.unsafe(nil), user_provided_default: T.unsafe(nil)); end
  def load_schema!; end

  private

  def define_default_attribute(name, value, type, from_user:); end
end

module ActiveRecord::AutosaveAssociation
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::AutosaveAssociation::ClassMethods)

  def changed_for_autosave?; end
  def destroyed_by_association; end
  def destroyed_by_association=(reflection); end
  def mark_for_destruction; end
  def marked_for_destruction?; end
  def reload(options = T.unsafe(nil)); end

  private

  def _ensure_no_duplicate_errors; end
  def after_save_collection_association; end
  def associated_records_to_validate_or_save(association, new_record, autosave); end
  def association_foreign_key_changed?(reflection, record, key); end
  def association_valid?(reflection, record, index = T.unsafe(nil)); end
  def before_save_collection_association; end
  def custom_validation_context?; end
  def nested_records_changed_for_autosave?; end
  def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end
  def record_changed?(reflection, record, key); end
  def save_belongs_to_association(reflection); end
  def save_collection_association(reflection); end
  def save_has_one_association(reflection); end
  def validate_collection_association(reflection); end
  def validate_single_association(reflection); end
end

module ActiveRecord::AutosaveAssociation::AssociationBuilderExtension
  class << self
    def build(model, reflection); end
    def valid_options; end
  end
end

module ActiveRecord::AutosaveAssociation::ClassMethods

  private

  def add_autosave_association_callbacks(reflection); end
  def define_autosave_validation_callbacks(reflection); end
  def define_non_cyclic_method(name, &block); end
end

class ActiveRecord::Base
  include(::ActiveRecord::Core)
  include(::ActiveRecord::Persistence)
  include(::ActiveRecord::ReadonlyAttributes)
  include(::ActiveRecord::ModelSchema)
  include(::ActiveRecord::Inheritance)
  include(::ActiveRecord::Scoping)
  include(::ActiveRecord::Scoping::Default)
  include(::ActiveRecord::Scoping::Named)
  include(::ActiveRecord::Sanitization)
  include(::ActiveModel::ForbiddenAttributesProtection)
  include(::ActiveModel::AttributeAssignment)
  include(::ActiveRecord::AttributeAssignment)
  include(::ActiveModel::Conversion)
  include(::ActiveRecord::Integration)
  include(::ActiveModel::Validations)
  include(::ActiveSupport::Callbacks)
  include(::ActiveModel::Validations::HelperMethods)
  include(::ActiveRecord::Validations)
  include(::ActiveRecord::CounterCache)
  include(::ActiveRecord::Attributes)
  include(::ActiveRecord::AttributeDecorators)
  include(::ActiveRecord::Locking::Optimistic)
  include(::ActiveRecord::Locking::Pessimistic)
  include(::ActiveModel::AttributeMethods)
  include(::ActiveRecord::AttributeMethods)
  include(::ActiveRecord::AttributeMethods::Read)
  include(::ActiveRecord::AttributeMethods::Write)
  include(::ActiveRecord::AttributeMethods::BeforeTypeCast)
  include(::ActiveRecord::AttributeMethods::Query)
  include(::ActiveRecord::AttributeMethods::PrimaryKey)
  include(::ActiveRecord::AttributeMethods::TimeZoneConversion)
  include(::ActiveModel::Dirty)
  include(::ActiveRecord::AttributeMethods::Dirty)
  include(::ActiveRecord::AttributeMethods::Serialization)
  include(::ActiveRecord::Callbacks)
  include(::ActiveModel::Validations::Callbacks)
  include(::ActiveRecord::Timestamp)
  include(::ActiveRecord::Associations)
  include(::ActiveModel::SecurePassword)
  include(::ActiveRecord::AutosaveAssociation)
  include(::ActiveRecord::NestedAttributes)
  include(::ActiveRecord::Transactions)
  include(::ActiveRecord::TouchLater)
  include(::ActiveRecord::NoTouching)
  include(::ActiveRecord::Reflection)
  include(::ActiveModel::Serialization)
  include(::ActiveModel::Serializers::JSON)
  include(::ActiveRecord::Serialization)
  include(::ActiveRecord::Store)
  include(::ActiveRecord::SecureToken)
  include(::ActiveRecord::Suppressor)
  extend(::ActiveModel::Naming)
  extend(::ActiveSupport::Benchmarkable)
  extend(::ActiveSupport::DescendantsTracker)
  extend(::ActiveRecord::ConnectionHandling)
  extend(::ActiveRecord::QueryCache::ClassMethods)
  extend(::ActiveRecord::Querying)
  extend(::ActiveModel::Translation)
  extend(::ActiveRecord::Translation)
  extend(::ActiveRecord::DynamicMatchers)
  extend(::ActiveRecord::Explain)
  extend(::ActiveRecord::Enum)
  extend(::ActiveRecord::Delegation::DelegateCache)
  extend(::ActiveRecord::Aggregations::ClassMethods)
  extend(::ActiveRecord::Core::ClassMethods)
  extend(::ActiveRecord::Persistence::ClassMethods)
  extend(::ActiveRecord::ReadonlyAttributes::ClassMethods)
  extend(::ActiveRecord::ModelSchema::ClassMethods)
  extend(::ActiveRecord::Inheritance::ClassMethods)
  extend(::ActiveRecord::Scoping::ClassMethods)
  extend(::ActiveRecord::Scoping::Default::ClassMethods)
  extend(::ActiveRecord::Scoping::Named::ClassMethods)
  extend(::ActiveRecord::Sanitization::ClassMethods)
  extend(::ActiveModel::Conversion::ClassMethods)
  extend(::ActiveRecord::Integration::ClassMethods)
  extend(::ActiveModel::Validations::ClassMethods)
  extend(::ActiveModel::Callbacks)
  extend(::ActiveSupport::Callbacks::ClassMethods)
  extend(::ActiveModel::Validations::HelperMethods)
  extend(::ActiveRecord::Validations::ClassMethods)
  extend(::ActiveRecord::CounterCache::ClassMethods)
  extend(::ActiveRecord::Attributes::ClassMethods)
  extend(::ActiveRecord::AttributeDecorators::ClassMethods)
  extend(::ActiveRecord::Locking::Optimistic::ClassMethods)
  extend(::ActiveModel::AttributeMethods::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::Read::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::Write::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods)
  extend(::ActiveRecord::AttributeMethods::Serialization::ClassMethods)
  extend(::ActiveRecord::Callbacks::ClassMethods)
  extend(::ActiveModel::Validations::Callbacks::ClassMethods)
  extend(::ActiveRecord::Timestamp::ClassMethods)
  extend(::ActiveRecord::Associations::ClassMethods)
  extend(::ActiveModel::SecurePassword::ClassMethods)
  extend(::ActiveRecord::AutosaveAssociation::ClassMethods)
  extend(::ActiveRecord::NestedAttributes::ClassMethods)
  extend(::ActiveRecord::Transactions::ClassMethods)
  extend(::ActiveRecord::NoTouching::ClassMethods)
  extend(::ActiveRecord::Reflection::ClassMethods)
  extend(::ActiveRecord::Store::ClassMethods)
  extend(::ActiveRecord::SecureToken::ClassMethods)
  extend(::ActiveRecord::Suppressor::ClassMethods)

  def __callbacks; end
  def __callbacks?; end
  def _before_commit_callbacks; end
  def _commit_callbacks; end
  def _create_callbacks; end
  def _destroy_callbacks; end
  def _find_callbacks; end
  def _initialize_callbacks; end
  def _reflections; end
  def _reflections?; end
  def _rollback_callbacks; end
  def _run_before_commit_callbacks(&block); end
  def _run_commit_callbacks(&block); end
  def _run_create_callbacks(&block); end
  def _run_destroy_callbacks(&block); end
  def _run_find_callbacks(&block); end
  def _run_initialize_callbacks(&block); end
  def _run_rollback_callbacks(&block); end
  def _run_save_callbacks(&block); end
  def _run_touch_callbacks(&block); end
  def _run_update_callbacks(&block); end
  def _run_validate_callbacks(&block); end
  def _run_validation_callbacks(&block); end
  def _save_callbacks; end
  def _touch_callbacks; end
  def _update_callbacks; end
  def _validate_callbacks; end
  def _validation_callbacks; end
  def _validators; end
  def _validators?; end
  def aggregate_reflections; end
  def aggregate_reflections?; end
  def allow_unsafe_raw_sql; end
  def attribute_aliases; end
  def attribute_aliases?; end
  def attribute_method_matchers; end
  def attribute_method_matchers?; end
  def cache_timestamp_format; end
  def cache_timestamp_format?; end
  def cache_versioning; end
  def cache_versioning?; end
  def collection_cache_versioning; end
  def collection_cache_versioning?; end
  def column_for_attribute(*args, &block); end
  def default_connection_handler; end
  def default_connection_handler?; end
  def default_pool_key; end
  def default_pool_key?; end
  def default_scope_override; end
  def default_scopes; end
  def default_timezone; end
  def defined_enums; end
  def defined_enums?; end
  def dump_schema_after_migration; end
  def dump_schemas; end
  def error_on_ignored_order; end
  def include_root_in_json; end
  def include_root_in_json?; end
  def index_nested_attribute_errors; end
  def lock_optimistically; end
  def lock_optimistically?; end
  def logger; end
  def model_name(*args, &block); end
  def nested_attributes_options; end
  def nested_attributes_options?; end
  def partial_writes; end
  def partial_writes?; end
  def pluralize_table_names; end
  def pluralize_table_names?; end
  def primary_key_prefix_type; end
  def record_timestamps; end
  def record_timestamps=(_); end
  def record_timestamps?; end
  def schema_format; end
  def skip_time_zone_conversion_for_attributes; end
  def skip_time_zone_conversion_for_attributes?; end
  def store_full_sti_class; end
  def store_full_sti_class?; end
  def table_name_prefix; end
  def table_name_prefix?; end
  def table_name_suffix; end
  def table_name_suffix?; end
  def time_zone_aware_attributes; end
  def time_zone_aware_types; end
  def time_zone_aware_types?; end
  def timestamped_migrations; end
  def type_for_attribute(*args, &block); end
  def validation_context; end
  def verbose_query_logs; end
  def warn_on_records_fetched_greater_than; end

  private

  def validation_context=(_); end

  class << self
    def __callbacks; end
    def __callbacks=(value); end
    def __callbacks?; end
    def _attr_readonly; end
    def _attr_readonly=(value); end
    def _attr_readonly?; end
    def _before_commit_callbacks; end
    def _before_commit_callbacks=(value); end
    def _commit_callbacks; end
    def _commit_callbacks=(value); end
    def _create_callbacks; end
    def _create_callbacks=(value); end
    def _destroy_callbacks; end
    def _destroy_callbacks=(value); end
    def _find_callbacks; end
    def _find_callbacks=(value); end
    def _initialize_callbacks; end
    def _initialize_callbacks=(value); end
    def _reflections; end
    def _reflections=(value); end
    def _reflections?; end
    def _rollback_callbacks; end
    def _rollback_callbacks=(value); end
    def _save_callbacks; end
    def _save_callbacks=(value); end
    def _touch_callbacks; end
    def _touch_callbacks=(value); end
    def _update_callbacks; end
    def _update_callbacks=(value); end
    def _validate_callbacks; end
    def _validate_callbacks=(value); end
    def _validation_callbacks; end
    def _validation_callbacks=(value); end
    def _validators; end
    def _validators=(value); end
    def _validators?; end
    def after_create(*args, **options, &block); end
    def after_destroy(*args, **options, &block); end
    def after_find(*args, **options, &block); end
    def after_initialize(*args, **options, &block); end
    def after_save(*args, **options, &block); end
    def after_touch(*args, **options, &block); end
    def after_update(*args, **options, &block); end
    def aggregate_reflections; end
    def aggregate_reflections=(value); end
    def aggregate_reflections?; end
    def allow_unsafe_raw_sql; end
    def allow_unsafe_raw_sql=(val); end
    def around_create(*args, **options, &block); end
    def around_destroy(*args, **options, &block); end
    def around_save(*args, **options, &block); end
    def around_update(*args, **options, &block); end
    def attribute_aliases; end
    def attribute_aliases=(value); end
    def attribute_aliases?; end
    def attribute_method_matchers; end
    def attribute_method_matchers=(value); end
    def attribute_method_matchers?; end
    def attribute_type_decorations; end
    def attribute_type_decorations=(value); end
    def attribute_type_decorations?; end
    def attributes_to_define_after_schema_loads; end
    def attributes_to_define_after_schema_loads=(value); end
    def attributes_to_define_after_schema_loads?; end
    def before_create(*args, **options, &block); end
    def before_destroy(*args, **options, &block); end
    def before_save(*args, **options, &block); end
    def before_update(*args, **options, &block); end
    def belongs_to_required_by_default; end
    def belongs_to_required_by_default=(value); end
    def belongs_to_required_by_default?; end
    def cache_timestamp_format; end
    def cache_timestamp_format=(value); end
    def cache_timestamp_format?; end
    def cache_versioning; end
    def cache_versioning=(value); end
    def cache_versioning?; end
    def collection_cache_versioning; end
    def collection_cache_versioning=(value); end
    def collection_cache_versioning?; end
    def configurations; end
    def configurations=(config); end
    def connection_handler; end
    def connection_handler=(handler); end
    def connection_handlers; end
    def connection_handlers=(val); end
    def current_pool_key; end
    def current_pool_key=(pool_key); end
    def default_connection_handler; end
    def default_connection_handler=(value); end
    def default_connection_handler?; end
    def default_pool_key; end
    def default_pool_key=(value); end
    def default_pool_key?; end
    def default_scope_override; end
    def default_scope_override=(value); end
    def default_scopes; end
    def default_scopes=(value); end
    def default_timezone; end
    def default_timezone=(val); end
    def defined_enums; end
    def defined_enums=(value); end
    def defined_enums?; end
    def dump_schema_after_migration; end
    def dump_schema_after_migration=(val); end
    def dump_schemas; end
    def dump_schemas=(val); end
    def error_on_ignored_order; end
    def error_on_ignored_order=(val); end
    def has_many_inversing; end
    def has_many_inversing=(val); end
    def implicit_order_column; end
    def implicit_order_column=(value); end
    def implicit_order_column?; end
    def include_root_in_json; end
    def include_root_in_json=(value); end
    def include_root_in_json?; end
    def index_nested_attribute_errors; end
    def index_nested_attribute_errors=(val); end
    def internal_metadata_table_name; end
    def internal_metadata_table_name=(value); end
    def internal_metadata_table_name?; end
    def local_stored_attributes; end
    def local_stored_attributes=(_); end
    def lock_optimistically; end
    def lock_optimistically=(value); end
    def lock_optimistically?; end
    def logger; end
    def logger=(val); end
    def maintain_test_schema; end
    def maintain_test_schema=(val); end
    def nested_attributes_options; end
    def nested_attributes_options=(value); end
    def nested_attributes_options?; end
    def partial_writes; end
    def partial_writes=(value); end
    def partial_writes?; end
    def pluralize_table_names; end
    def pluralize_table_names=(value); end
    def pluralize_table_names?; end
    def primary_key_prefix_type; end
    def primary_key_prefix_type=(val); end
    def reading_role; end
    def reading_role=(val); end
    def record_timestamps; end
    def record_timestamps=(value); end
    def record_timestamps?; end
    def schema_format; end
    def schema_format=(val); end
    def schema_migrations_table_name; end
    def schema_migrations_table_name=(value); end
    def schema_migrations_table_name?; end
    def skip_time_zone_conversion_for_attributes; end
    def skip_time_zone_conversion_for_attributes=(value); end
    def skip_time_zone_conversion_for_attributes?; end
    def store_full_sti_class; end
    def store_full_sti_class=(value); end
    def store_full_sti_class?; end
    def table_name_prefix; end
    def table_name_prefix=(value); end
    def table_name_prefix?; end
    def table_name_suffix; end
    def table_name_suffix=(value); end
    def table_name_suffix?; end
    def time_zone_aware_attributes; end
    def time_zone_aware_attributes=(val); end
    def time_zone_aware_types; end
    def time_zone_aware_types=(value); end
    def time_zone_aware_types?; end
    def timestamped_migrations; end
    def timestamped_migrations=(val); end
    def verbose_query_logs; end
    def verbose_query_logs=(val); end
    def warn_on_records_fetched_greater_than; end
    def warn_on_records_fetched_greater_than=(val); end
    def writing_role; end
    def writing_role=(val); end
  end
end

module ActiveRecord::Batches
  def find_each(start: T.unsafe(nil), finish: T.unsafe(nil), batch_size: T.unsafe(nil), error_on_ignore: T.unsafe(nil), order: T.unsafe(nil)); end
  def find_in_batches(start: T.unsafe(nil), finish: T.unsafe(nil), batch_size: T.unsafe(nil), error_on_ignore: T.unsafe(nil), order: T.unsafe(nil)); end
  def in_batches(of: T.unsafe(nil), start: T.unsafe(nil), finish: T.unsafe(nil), load: T.unsafe(nil), error_on_ignore: T.unsafe(nil), order: T.unsafe(nil)); end

  private

  def act_on_ignored_order(error_on_ignore); end
  def apply_finish_limit(relation, finish, order); end
  def apply_limits(relation, start, finish, order); end
  def apply_start_limit(relation, start, order); end
  def batch_order(order); end
end

class ActiveRecord::Batches::BatchEnumerator
  include(::Enumerable)

  def initialize(relation:, of: T.unsafe(nil), start: T.unsafe(nil), finish: T.unsafe(nil)); end

  def delete_all(*args, &block); end
  def destroy_all(*args, &block); end
  def each; end
  def each_record; end
  def update_all(*args, &block); end
end

ActiveRecord::Batches::ORDER_IGNORE_MESSAGE = T.let(T.unsafe(nil), String)

module ActiveRecord::Calculations
  def average(column_name); end
  def calculate(operation, column_name); end
  def count(column_name = T.unsafe(nil)); end
  def ids; end
  def maximum(column_name); end
  def minimum(column_name); end
  def pick(*column_names); end
  def pluck(*column_names); end
  def sum(column_name = T.unsafe(nil)); end

  private

  def aggregate_column(column_name); end
  def all_attributes?(column_names); end
  def build_count_subquery(relation, column_name, distinct); end
  def column_alias_for(field); end
  def distinct_select?(column_name); end
  def execute_grouped_calculation(operation, column_name, distinct); end
  def execute_simple_calculation(operation, column_name, distinct); end
  def has_include?(column_name); end
  def operation_over_aggregate_column(column_name, operation, distinct); end
  def perform_calculation(operation, column_name); end
  def select_for_count; end
  def type_cast_calculated_value(value, operation); end
  def type_for(field, &block); end
end

module ActiveRecord::Callbacks
  extend(::ActiveSupport::Concern)

  include(::ActiveSupport::Callbacks)
  include(::ActiveModel::Validations::Callbacks)

  mixes_in_class_methods(::ActiveRecord::Callbacks::ClassMethods)

  def destroy; end
  def increment!(attribute, by = T.unsafe(nil), touch: T.unsafe(nil)); end
  def touch(*_, **_); end

  private

  def _create_record; end
  def _update_record; end
  def create_or_update(**_); end
end

ActiveRecord::Callbacks::CALLBACKS = T.let(T.unsafe(nil), Array)

module ActiveRecord::Callbacks::ClassMethods
  include(::ActiveModel::Callbacks)
end

module ActiveRecord::Coders
end

class ActiveRecord::Coders::JSON
  class << self
    def dump(obj); end
    def load(json); end
  end
end

class ActiveRecord::Coders::YAMLColumn
  def initialize(attr_name, object_class = T.unsafe(nil)); end

  def assert_valid_value(obj, action:); end
  def dump(obj); end
  def load(yaml); end
  def object_class; end
  def object_class=(_); end

  private

  def check_arity_of_constructor; end
end

class ActiveRecord::ConfigurationError < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::ConnectionAdapters
  extend(::ActiveSupport::Autoload)
end

class ActiveRecord::ConnectionAdapters::AbstractAdapter
  include(::ActiveSupport::Callbacks)
  include(::ActiveRecord::Migration::JoinTable)
  include(::ActiveRecord::ConnectionAdapters::SchemaStatements)
  include(::ActiveRecord::ConnectionAdapters::DatabaseStatements)
  include(::ActiveRecord::ConnectionAdapters::Quoting)
  include(::ActiveRecord::ConnectionAdapters::DatabaseLimits)
  include(::ActiveRecord::ConnectionAdapters::QueryCache)
  include(::ActiveRecord::ConnectionAdapters::Savepoints)
  extend(::ActiveSupport::Callbacks::ClassMethods)
  extend(::ActiveSupport::DescendantsTracker)

  def initialize(connection, logger = T.unsafe(nil), config = T.unsafe(nil)); end

  def __callbacks; end
  def __callbacks?; end
  def _checkin_callbacks; end
  def _checkout_callbacks; end
  def _run_checkin_callbacks(&block); end
  def _run_checkout_callbacks(&block); end
  def active?; end
  def adapter_name; end
  def advisory_locks_enabled?; end
  def build_insert_sql(insert); end
  def case_insensitive_comparison(attribute, value); end
  def case_sensitive_comparison(attribute, value); end
  def check_version; end
  def clear_cache!; end
  def close; end
  def database_version; end
  def default_index_type?(index); end
  def default_uniqueness_comparison(attribute, value, klass); end
  def delete(*_); end
  def disable_extension(name); end
  def disable_referential_integrity; end
  def discard!; end
  def disconnect!; end
  def enable_extension(name); end
  def exec_insert_all(*_); end
  def expire; end
  def extensions; end
  def get_advisory_lock(lock_id); end
  def get_database_version; end
  def in_use?; end
  def index_algorithms; end
  def insert(*_); end
  def lease; end
  def lock; end
  def logger; end
  def migration_context; end
  def migrations_paths; end
  def owner; end
  def pool; end
  def pool=(_); end
  def prefetch_primary_key?(table_name = T.unsafe(nil)); end
  def prepared_statements; end
  def prepared_statements_disabled_cache; end
  def preventing_writes?; end
  def raw_connection; end
  def reconnect!; end
  def release_advisory_lock(lock_id); end
  def replica?; end
  def requires_reloading?; end
  def reset!; end
  def rollback_db_transaction(*_); end
  def rollback_to_savepoint(*_); end
  def schema_cache; end
  def schema_cache=(cache); end
  def schema_migration; end
  def seconds_idle; end
  def steal!; end
  def supports_advisory_locks?; end
  def supports_bulk_alter?; end
  def supports_comments?; end
  def supports_comments_in_create?; end
  def supports_common_table_expressions?; end
  def supports_datetime_with_precision?; end
  def supports_ddl_transactions?; end
  def supports_explain?; end
  def supports_expression_index?; end
  def supports_extensions?; end
  def supports_foreign_keys?; end
  def supports_foreign_keys_in_create?(*args, &block); end
  def supports_foreign_tables?; end
  def supports_index_sort_order?; end
  def supports_indexes_in_create?; end
  def supports_insert_conflict_target?; end
  def supports_insert_on_duplicate_skip?; end
  def supports_insert_on_duplicate_update?; end
  def supports_insert_returning?; end
  def supports_json?; end
  def supports_lazy_transactions?; end
  def supports_materialized_views?; end
  def supports_multi_insert?(*args, &block); end
  def supports_optimizer_hints?; end
  def supports_partial_index?; end
  def supports_partitioned_indexes?; end
  def supports_savepoints?; end
  def supports_transaction_isolation?; end
  def supports_validate_constraints?; end
  def supports_views?; end
  def supports_virtual_columns?; end
  def truncate(*_); end
  def truncate_tables(*_); end
  def unprepared_statement; end
  def update(*_); end
  def use_metadata_table?; end
  def valid_type?(type); end
  def verify!; end
  def visitor; end

  private

  def arel_visitor; end
  def build_result(columns:, rows:, column_types: T.unsafe(nil)); end
  def build_statement_pool; end
  def can_perform_case_insensitive_comparison_for?(column); end
  def collector; end
  def column_for(table_name, column_name); end
  def column_for_attribute(attribute); end
  def extract_limit(sql_type); end
  def extract_precision(sql_type); end
  def extract_scale(sql_type); end
  def initialize_type_map(m = T.unsafe(nil)); end
  def log(sql, name = T.unsafe(nil), binds = T.unsafe(nil), type_casted_binds = T.unsafe(nil), statement_name = T.unsafe(nil)); end
  def register_class_with_limit(mapping, key, klass); end
  def register_class_with_precision(mapping, key, klass); end
  def reload_type_map; end
  def translate_exception(exception, message:, sql:, binds:); end
  def translate_exception_class(e, sql, binds); end
  def type_map; end
  def without_prepared_statement?(binds); end

  class << self
    def __callbacks; end
    def __callbacks=(value); end
    def __callbacks?; end
    def _checkin_callbacks; end
    def _checkin_callbacks=(value); end
    def _checkout_callbacks; end
    def _checkout_callbacks=(value); end
    def build_read_query_regexp(*parts); end
    def database_exists?(config); end
    def quoted_column_names; end
    def quoted_table_names; end
    def type_cast_config_to_boolean(config); end
    def type_cast_config_to_integer(config); end
  end
end

ActiveRecord::ConnectionAdapters::AbstractAdapter::ADAPTER_NAME = T.let(T.unsafe(nil), String)

ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX = T.let(T.unsafe(nil), Regexp)

ActiveRecord::ConnectionAdapters::AbstractAdapter::SIMPLE_INT = T.let(T.unsafe(nil), Regexp)

class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
  include(::Comparable)

  def initialize(version_string, full_version_string = T.unsafe(nil)); end

  def <=>(version_string); end
  def full_version_string; end
  def to_s; end
end

module ActiveRecord::ConnectionAdapters::AbstractPool
  def get_schema_cache(connection); end
  def set_schema_cache(cache); end
end

class ActiveRecord::ConnectionAdapters::AlterTable
  def initialize(td); end

  def add_column(name, type, **options); end
  def add_foreign_key(to_table, options); end
  def adds; end
  def drop_foreign_key(name); end
  def foreign_key_adds; end
  def foreign_key_drops; end
  def name; end
end

class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < ::Struct
  def column; end
  def column=(_); end
  def name; end
  def name=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::ConnectionAdapters::Column
  include(::ActiveRecord::ConnectionAdapters::Deduplicable)
  extend(::ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods)

  def initialize(name, default, sql_type_metadata = T.unsafe(nil), null = T.unsafe(nil), default_function = T.unsafe(nil), collation: T.unsafe(nil), comment: T.unsafe(nil), **_); end

  def ==(other); end
  def bigint?; end
  def collation; end
  def comment; end
  def default; end
  def default_function; end
  def encode_with(coder); end
  def eql?(other); end
  def has_default?; end
  def hash; end
  def human_name; end
  def init_with(coder); end
  def limit(*args, &block); end
  def name; end
  def null; end
  def precision(*args, &block); end
  def scale(*args, &block); end
  def sql_type(*args, &block); end
  def sql_type_metadata; end
  def type(*args, &block); end

  private

  def deduplicated; end
end

class ActiveRecord::ConnectionAdapters::ColumnDefinition < ::Struct
  def collation; end
  def collation=(value); end
  def comment; end
  def comment=(value); end
  def default; end
  def default=(value); end
  def limit; end
  def limit=(value); end
  def name; end
  def name=(_); end
  def null; end
  def null=(value); end
  def options; end
  def options=(_); end
  def precision; end
  def precision=(value); end
  def primary_key?; end
  def scale; end
  def scale=(value); end
  def sql_type; end
  def sql_type=(_); end
  def type; end
  def type=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::ConnectionAdapters::ConnectionHandler
  def initialize; end

  def active_connections?; end
  def clear_active_connections!; end
  def clear_all_connections!; end
  def clear_reloadable_connections!; end
  def connected?(spec_name, pool_key = T.unsafe(nil)); end
  def connection_pool_list; end
  def connection_pool_names; end
  def connection_pools; end
  def establish_connection(config, pool_key = T.unsafe(nil), owner_name = T.unsafe(nil)); end
  def flush_idle_connections!; end
  def prevent_writes; end
  def prevent_writes=(prevent_writes); end
  def remove_connection(*args, &block); end
  def remove_connection_pool(owner, pool_key = T.unsafe(nil)); end
  def retrieve_connection(spec_name, pool_key = T.unsafe(nil)); end
  def retrieve_connection_pool(owner, pool_key = T.unsafe(nil)); end
  def while_preventing_writes(enabled = T.unsafe(nil)); end

  private

  def get_pool_manager(owner); end
  def owner_to_pool_manager; end
  def resolve_pool_config(config, owner_name); end
end

class ActiveRecord::ConnectionAdapters::ConnectionPool
  include(::MonitorMixin)
  include(::ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration)
  include(::ActiveRecord::ConnectionAdapters::AbstractPool)

  def initialize(pool_config); end

  def active_connection?; end
  def automatic_reconnect; end
  def automatic_reconnect=(_); end
  def checkin(conn); end
  def checkout(checkout_timeout = T.unsafe(nil)); end
  def checkout_timeout; end
  def checkout_timeout=(_); end
  def clear_reloadable_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
  def clear_reloadable_connections!; end
  def connected?; end
  def connection; end
  def connections; end
  def db_config; end
  def discard!; end
  def discarded?; end
  def disconnect(raise_on_acquisition_timeout = T.unsafe(nil)); end
  def disconnect!; end
  def flush(minimum_idle = T.unsafe(nil)); end
  def flush!; end
  def lock_thread=(lock_thread); end
  def num_waiting_in_queue; end
  def pool_config; end
  def reap; end
  def reaper; end
  def release_connection(owner_thread = T.unsafe(nil)); end
  def remove(conn); end
  def schema_cache(*args, &block); end
  def schema_cache=(arg); end
  def size; end
  def stat; end
  def with_connection; end

  private

  def acquire_connection(checkout_timeout); end
  def adopt_connection(conn); end
  def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
  def bulk_make_new_connections(num_new_conns_needed); end
  def checkout_and_verify(c); end
  def checkout_for_exclusive_access(checkout_timeout); end
  def checkout_new_connection; end
  def connection_cache_key(thread); end
  def current_thread; end
  def new_connection; end
  def release(conn, owner_thread = T.unsafe(nil)); end
  def remove_connection_from_thread_cache(conn, owner_thread = T.unsafe(nil)); end
  def try_to_checkout_new_connection; end
  def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
  def with_new_connections_blocked; end
end

module ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue
  def with_a_bias_for(thread); end
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue::BiasedConditionVariable
  def initialize(lock, other_cond, preferred_thread); end

  def broadcast; end
  def broadcast_on_biased; end
  def signal; end
  def wait(timeout); end
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::ConnectionLeasingQueue < ::ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
  include(::ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue)


  private

  def internal_poll(timeout); end
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
  def initialize(lock = T.unsafe(nil)); end

  def add(element); end
  def any_waiting?; end
  def clear; end
  def delete(element); end
  def num_waiting; end
  def poll(timeout = T.unsafe(nil)); end

  private

  def any?; end
  def can_remove_no_wait?; end
  def internal_poll(timeout); end
  def no_wait_poll; end
  def remove; end
  def synchronize(&block); end
  def wait_poll(timeout); end
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
  def initialize(pool, frequency); end

  def frequency; end
  def pool; end
  def run; end

  class << self
    def register_pool(pool, frequency); end

    private

    def spawn_thread(frequency); end
  end
end

module ActiveRecord::ConnectionAdapters::DatabaseLimits
  def allowed_index_name_length(*args, &block); end
  def column_name_length(*args, &block); end
  def columns_per_multicolumn_index(*args, &block); end
  def columns_per_table(*args, &block); end
  def in_clause_length(*args, &block); end
  def index_name_length; end
  def indexes_per_table(*args, &block); end
  def joins_per_query(*args, &block); end
  def max_identifier_length; end
  def sql_query_length(*args, &block); end
  def table_alias_length; end
  def table_name_length(*args, &block); end

  private

  def bind_params_length; end
end

module ActiveRecord::ConnectionAdapters::DatabaseStatements
  def initialize; end

  def add_transaction_record(record); end
  def begin_db_transaction; end
  def begin_isolated_db_transaction(isolation); end
  def begin_transaction(*args, &block); end
  def cacheable_query(klass, arel); end
  def commit_db_transaction; end
  def commit_transaction(*args, &block); end
  def create(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def current_transaction(*args, &block); end
  def default_sequence_name(table, column); end
  def delete(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def disable_lazy_transactions!(*args, &block); end
  def empty_insert_statement_value(primary_key = T.unsafe(nil)); end
  def enable_lazy_transactions!(*args, &block); end
  def exec_delete(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def exec_insert(sql, name = T.unsafe(nil), binds = T.unsafe(nil), pk = T.unsafe(nil), sequence_name = T.unsafe(nil)); end
  def exec_insert_all(sql, name); end
  def exec_query(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil)); end
  def exec_rollback_db_transaction; end
  def exec_update(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def execute(sql, name = T.unsafe(nil)); end
  def insert(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def insert_fixture(fixture, table_name); end
  def insert_fixtures_set(fixture_set, tables_to_delete = T.unsafe(nil)); end
  def materialize_transactions(*args, &block); end
  def open_transactions(*args, &block); end
  def query(sql, name = T.unsafe(nil)); end
  def query_value(sql, name = T.unsafe(nil)); end
  def query_values(sql, name = T.unsafe(nil)); end
  def reset_sequence!(table, column, sequence = T.unsafe(nil)); end
  def reset_transaction; end
  def rollback_db_transaction; end
  def rollback_to_savepoint(name = T.unsafe(nil)); end
  def rollback_transaction(*args, &block); end
  def sanitize_limit(limit); end
  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
  def select_one(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def select_rows(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def select_value(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def select_values(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def to_sql(arel_or_sql_string, binds = T.unsafe(nil)); end
  def transaction(requires_new: T.unsafe(nil), isolation: T.unsafe(nil), joinable: T.unsafe(nil)); end
  def transaction_isolation_levels; end
  def transaction_manager; end
  def transaction_open?; end
  def transaction_state; end
  def truncate(table_name, name = T.unsafe(nil)); end
  def truncate_tables(*table_names); end
  def update(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def with_yaml_fallback(value); end
  def within_new_transaction(*args, &block); end
  def write_query?(sql); end

  private

  def arel_from_relation(relation); end
  def build_fixture_sql(fixtures, table_name); end
  def build_fixture_statements(fixture_set); end
  def build_truncate_statement(table_name); end
  def build_truncate_statements(table_names); end
  def combine_multi_statements(total_sql); end
  def default_insert_value(column); end
  def execute_batch(statements, name = T.unsafe(nil)); end
  def last_inserted_id(result); end
  def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def select_prepared(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
  def single_value_from_rows(rows); end
  def sql_for_insert(sql, pk, binds); end
  def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil)); end
  def with_multi_statements; end
end

class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < ::Struct
  def column; end
  def custom_primary_key?; end
  def defined_for?(to_table: T.unsafe(nil), validate: T.unsafe(nil), **options); end
  def export_name_on_schema_dump?; end
  def from_table; end
  def from_table=(_); end
  def name; end
  def on_delete; end
  def on_update; end
  def options; end
  def options=(_); end
  def primary_key; end
  def to_table; end
  def to_table=(_); end
  def validate?; end
  def validated?; end

  private

  def default_primary_key; end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::ConnectionAdapters::IndexDefinition
  def initialize(table, name, unique = T.unsafe(nil), columns = T.unsafe(nil), lengths: T.unsafe(nil), orders: T.unsafe(nil), opclasses: T.unsafe(nil), where: T.unsafe(nil), type: T.unsafe(nil), using: T.unsafe(nil), comment: T.unsafe(nil)); end

  def columns; end
  def comment; end
  def lengths; end
  def name; end
  def opclasses; end
  def orders; end
  def table; end
  def type; end
  def unique; end
  def using; end
  def where; end

  private

  def concise_options(options); end
end

class ActiveRecord::ConnectionAdapters::NullPool
  include(::ActiveRecord::ConnectionAdapters::AbstractPool)

  def schema_cache; end
  def schema_cache=(_); end
end

class ActiveRecord::ConnectionAdapters::NullTransaction
  def initialize; end

  def add_record(record); end
  def closed?; end
  def joinable?; end
  def open?; end
  def state; end
end

class ActiveRecord::ConnectionAdapters::PoolConfig
  include(::Mutex_m)

  def initialize(connection_specification_name, db_config); end

  def connection_specification_name; end
  def db_config; end
  def discard_pool!; end
  def disconnect!; end
  def lock; end
  def locked?; end
  def pool; end
  def schema_cache; end
  def schema_cache=(_); end
  def synchronize(&block); end
  def try_lock; end
  def unlock; end

  class << self
    def discard_pools!; end
  end
end

class ActiveRecord::ConnectionAdapters::PoolManager
  def initialize; end

  def get_pool_config(key); end
  def pool_configs; end
  def remove_pool_config(key); end
  def set_pool_config(key, pool_config); end
end

module ActiveRecord::ConnectionAdapters::QueryCache
  def initialize(*_); end

  def cache; end
  def clear_query_cache; end
  def disable_query_cache!; end
  def enable_query_cache!; end
  def query_cache; end
  def query_cache_enabled; end
  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
  def uncached; end

  private

  def cache_notification_info(sql, name, binds); end
  def cache_sql(sql, name, binds); end
  def configure_query_cache!; end
  def locked?(arel); end

  class << self
    def dirties_query_cache(base, *method_names); end
    def included(base); end
  end
end

module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
  def initialize(*_); end

  def disable_query_cache!; end
  def enable_query_cache!; end
  def query_cache_enabled; end
end

module ActiveRecord::ConnectionAdapters::Quoting
  def column_name_matcher; end
  def column_name_with_order_matcher; end
  def lookup_cast_type_from_column(column); end
  def quote(value); end
  def quote_column_name(column_name); end
  def quote_default_expression(value, column); end
  def quote_string(s); end
  def quote_table_name(table_name); end
  def quote_table_name_for_assignment(table, attr); end
  def quoted_binary(value); end
  def quoted_date(value); end
  def quoted_false; end
  def quoted_time(value); end
  def quoted_true; end
  def sanitize_as_sql_comment(value); end
  def type_cast(value, column = T.unsafe(nil)); end
  def unquoted_false; end
  def unquoted_true; end

  private

  def _quote(value); end
  def _type_cast(value); end
  def id_value_for_database(value); end
  def lookup_cast_type(sql_type); end
  def type_casted_binds(binds); end
end

class ActiveRecord::ConnectionAdapters::RealTransaction < ::ActiveRecord::ConnectionAdapters::Transaction
  def commit; end
  def materialize!; end
  def rollback; end
end

class ActiveRecord::ConnectionAdapters::ReferenceDefinition
  def initialize(name, polymorphic: T.unsafe(nil), index: T.unsafe(nil), foreign_key: T.unsafe(nil), type: T.unsafe(nil), **options); end

  def add_to(table); end

  private

  def as_options(value); end
  def column_name; end
  def column_names; end
  def columns; end
  def foreign_key; end
  def foreign_key_options; end
  def foreign_table_name; end
  def index; end
  def index_options; end
  def name; end
  def options; end
  def polymorphic; end
  def polymorphic_options; end
  def type; end
end

class ActiveRecord::ConnectionAdapters::SavepointTransaction < ::ActiveRecord::ConnectionAdapters::Transaction
  def initialize(connection, savepoint_name, parent_transaction, **options); end

  def commit; end
  def full_rollback?; end
  def materialize!; end
  def rollback; end
end

module ActiveRecord::ConnectionAdapters::Savepoints
  def create_savepoint(name = T.unsafe(nil)); end
  def current_savepoint_name; end
  def exec_rollback_to_savepoint(name = T.unsafe(nil)); end
  def release_savepoint(name = T.unsafe(nil)); end
end

module ActiveRecord::ConnectionAdapters::SchemaStatements
  include(::ActiveRecord::Migration::JoinTable)

  def add_belongs_to(table_name, ref_name, **options); end
  def add_column(table_name, column_name, type, **options); end
  def add_foreign_key(from_table, to_table, **options); end
  def add_index(table_name, column_name, options = T.unsafe(nil)); end
  def add_index_options(table_name, column_name, comment: T.unsafe(nil), **options); end
  def add_reference(table_name, ref_name, **options); end
  def add_timestamps(table_name, **options); end
  def assume_migrated_upto_version(version, migrations_paths = T.unsafe(nil)); end
  def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
  def change_column_comment(table_name, column_name, comment_or_changes); end
  def change_column_default(table_name, column_name, default_or_changes); end
  def change_column_null(table_name, column_name, null, default = T.unsafe(nil)); end
  def change_table(table_name, **options); end
  def change_table_comment(table_name, comment_or_changes); end
  def column_exists?(table_name, column_name, type = T.unsafe(nil), **options); end
  def columns(table_name); end
  def columns_for_distinct(columns, orders); end
  def create_join_table(table_1, table_2, column_options: T.unsafe(nil), **options); end
  def create_schema_dumper(options); end
  def create_table(table_name, id: T.unsafe(nil), primary_key: T.unsafe(nil), force: T.unsafe(nil), **options); end
  def data_source_exists?(name); end
  def data_sources; end
  def drop_join_table(table_1, table_2, **options); end
  def drop_table(table_name, **options); end
  def dump_schema_information; end
  def foreign_key_column_for(table_name); end
  def foreign_key_exists?(from_table, to_table = T.unsafe(nil), **options); end
  def foreign_key_options(from_table, to_table, options); end
  def foreign_keys(table_name); end
  def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
  def index_name(table_name, options); end
  def index_name_exists?(table_name, index_name); end
  def indexes(table_name); end
  def internal_string_options_for_primary_key; end
  def native_database_types; end
  def options_include_default?(options); end
  def primary_key(table_name); end
  def remove_belongs_to(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
  def remove_column(table_name, column_name, type = T.unsafe(nil), **options); end
  def remove_columns(table_name, *column_names, **options); end
  def remove_foreign_key(from_table, to_table = T.unsafe(nil), **options); end
  def remove_index(table_name, column_name = T.unsafe(nil), options = T.unsafe(nil)); end
  def remove_reference(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
  def remove_timestamps(table_name, **options); end
  def rename_column(table_name, column_name, new_column_name); end
  def rename_index(table_name, old_name, new_name); end
  def rename_table(table_name, new_name); end
  def table_alias_for(table_name); end
  def table_comment(table_name); end
  def table_exists?(table_name); end
  def table_options(table_name); end
  def tables; end
  def type_to_sql(type, limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil), **_); end
  def update_table_definition(table_name, base); end
  def view_exists?(view_name); end
  def views; end

  private

  def add_column_for_alter(table_name, column_name, type, **options); end
  def add_index_sort_order(quoted_columns, **options); end
  def add_options_for_index_columns(quoted_columns, **options); end
  def add_timestamps_for_alter(table_name, **options); end
  def bulk_change_table(table_name, operations); end
  def can_remove_index_by_name?(column_name, options); end
  def column_options_keys; end
  def create_alter_table(name); end
  def create_table_definition(*args, **options); end
  def data_source_sql(name = T.unsafe(nil), type: T.unsafe(nil)); end
  def extract_foreign_key_action(specifier); end
  def extract_new_comment_value(default_or_changes); end
  def extract_new_default_value(default_or_changes); end
  def fetch_type_metadata(sql_type); end
  def foreign_key_for(from_table, **options); end
  def foreign_key_for!(from_table, to_table: T.unsafe(nil), **options); end
  def foreign_key_name(table_name, options); end
  def index_column_names(column_names); end
  def index_name_for_remove(table_name, column_name, options); end
  def index_name_options(column_names); end
  def insert_versions_sql(versions); end
  def options_for_index_columns(options); end
  def quoted_columns_for_index(column_names, **options); end
  def quoted_scope(name = T.unsafe(nil), type: T.unsafe(nil)); end
  def remove_column_for_alter(table_name, column_name, type = T.unsafe(nil), **options); end
  def remove_columns_for_alter(table_name, *column_names, **options); end
  def remove_timestamps_for_alter(table_name, **options); end
  def rename_column_indexes(table_name, column_name, new_column_name); end
  def rename_table_indexes(table_name, new_name); end
  def schema_creation; end
  def strip_table_name_prefix_and_suffix(table_name); end
  def validate_index_length!(table_name, new_name, internal = T.unsafe(nil)); end
end

class ActiveRecord::ConnectionAdapters::Table
  include(::ActiveRecord::ConnectionAdapters::ColumnMethods)
  extend(::ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods)

  def initialize(table_name, base); end

  def belongs_to(*args, **options); end
  def bigint(*names, **options); end
  def binary(*names, **options); end
  def boolean(*names, **options); end
  def change(column_name, type, options = T.unsafe(nil)); end
  def change_default(column_name, default_or_changes); end
  def change_null(column_name, null, default = T.unsafe(nil)); end
  def column(column_name, type, **options); end
  def column_exists?(column_name, type = T.unsafe(nil), **options); end
  def date(*names, **options); end
  def datetime(*names, **options); end
  def decimal(*names, **options); end
  def float(*names, **options); end
  def foreign_key(*args, **options); end
  def foreign_key_exists?(*args, **options); end
  def index(column_name, options = T.unsafe(nil)); end
  def index_exists?(column_name, options = T.unsafe(nil)); end
  def integer(*names, **options); end
  def json(*names, **options); end
  def name; end
  def numeric(*names, **options); end
  def references(*args, **options); end
  def remove(*column_names, **options); end
  def remove_belongs_to(*args, **options); end
  def remove_foreign_key(*args, **options); end
  def remove_index(column_name = T.unsafe(nil), options = T.unsafe(nil)); end
  def remove_references(*args, **options); end
  def remove_timestamps(**options); end
  def rename(column_name, new_column_name); end
  def rename_index(index_name, new_index_name); end
  def string(*names, **options); end
  def text(*names, **options); end
  def time(*names, **options); end
  def timestamp(*names, **options); end
  def timestamps(**options); end
  def virtual(*names, **options); end
end

class ActiveRecord::ConnectionAdapters::TableDefinition
  include(::ActiveRecord::ConnectionAdapters::ColumnMethods)
  extend(::ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods)

  def initialize(conn, name, temporary: T.unsafe(nil), if_not_exists: T.unsafe(nil), options: T.unsafe(nil), as: T.unsafe(nil), comment: T.unsafe(nil)); end

  def [](name); end
  def as; end
  def belongs_to(*args, **options); end
  def bigint(*names, **options); end
  def binary(*names, **options); end
  def boolean(*names, **options); end
  def column(name, type, **options); end
  def columns; end
  def comment; end
  def date(*names, **options); end
  def datetime(*names, **options); end
  def decimal(*names, **options); end
  def float(*names, **options); end
  def foreign_key(table_name, **options); end
  def foreign_keys; end
  def if_not_exists; end
  def index(column_name, options = T.unsafe(nil)); end
  def indexes; end
  def integer(*names, **options); end
  def json(*names, **options); end
  def name; end
  def new_column_definition(name, type, **options); end
  def numeric(*names, **options); end
  def options; end
  def primary_keys(name = T.unsafe(nil)); end
  def references(*args, **options); end
  def remove_column(name); end
  def string(*names, **options); end
  def temporary; end
  def text(*names, **options); end
  def time(*names, **options); end
  def timestamp(*names, **options); end
  def timestamps(**options); end
  def virtual(*names, **options); end

  private

  def aliased_types(name, fallback); end
  def create_column_definition(name, type, options); end
  def integer_like_primary_key?(type, options); end
  def integer_like_primary_key_type(type, options); end
end

class ActiveRecord::ConnectionAdapters::TransactionManager
  def initialize(connection); end

  def begin_transaction(isolation: T.unsafe(nil), joinable: T.unsafe(nil), _lazy: T.unsafe(nil)); end
  def commit_transaction; end
  def current_transaction; end
  def disable_lazy_transactions!; end
  def enable_lazy_transactions!; end
  def lazy_transactions_enabled?; end
  def materialize_transactions; end
  def open_transactions; end
  def rollback_transaction(transaction = T.unsafe(nil)); end
  def within_new_transaction(isolation: T.unsafe(nil), joinable: T.unsafe(nil)); end

  private

  def after_failure_actions(transaction, error); end
end

ActiveRecord::ConnectionAdapters::TransactionManager::NULL_TRANSACTION = T.let(T.unsafe(nil), ActiveRecord::ConnectionAdapters::NullTransaction)

class ActiveRecord::ConnectionAdapters::TransactionState
  def initialize(state = T.unsafe(nil)); end

  def add_child(state); end
  def commit!; end
  def committed?; end
  def completed?; end
  def finalized?; end
  def full_commit!; end
  def full_rollback!; end
  def fully_committed?; end
  def fully_completed?; end
  def fully_rolledback?; end
  def nullify!; end
  def rollback!; end
  def rolledback?; end
end

module ActiveRecord::ConnectionHandling
  def clear_active_connections!(*args, &block); end
  def clear_all_connections!(*args, &block); end
  def clear_cache!; end
  def clear_query_caches_for_current_thread; end
  def clear_reloadable_connections!(*args, &block); end
  def connected?; end
  def connected_to(database: T.unsafe(nil), role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end
  def connected_to?(role:, shard: T.unsafe(nil)); end
  def connection; end
  def connection_config(*args, &block); end
  def connection_db_config; end
  def connection_pool; end
  def connection_specification_name; end
  def connection_specification_name=(_); end
  def connects_to(database: T.unsafe(nil), shards: T.unsafe(nil)); end
  def current_role; end
  def establish_connection(config_or_env = T.unsafe(nil)); end
  def flush_idle_connections!(*args, &block); end
  def lookup_connection_handler(handler_key); end
  def primary_class?; end
  def remove_connection(name = T.unsafe(nil)); end
  def retrieve_connection; end

  private

  def resolve_config_for_connection(config_or_env); end
  def swap_connection_handler(handler, &blk); end
  def with_handler(handler_key, &blk); end
  def with_role(role, prevent_writes, &blk); end
  def with_shard(pool_key, role, prevent_writes); end
end

ActiveRecord::ConnectionHandling::DEFAULT_ENV = T.let(T.unsafe(nil), Proc)

ActiveRecord::ConnectionHandling::RAILS_ENV = T.let(T.unsafe(nil), Proc)

class ActiveRecord::ConnectionNotEstablished < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::ConnectionTimeoutError < ::ActiveRecord::ConnectionNotEstablished
end

module ActiveRecord::Core
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Core::ClassMethods)

  def initialize(attributes = T.unsafe(nil)); end

  def <=>(other_object); end
  def ==(comparison_object); end
  def blank?; end
  def connection_handler; end
  def encode_with(coder); end
  def eql?(comparison_object); end
  def freeze; end
  def frozen?; end
  def hash; end
  def init_with(coder, &block); end
  def init_with_attributes(attributes, new_record = T.unsafe(nil)); end
  def inspect; end
  def present?; end
  def pretty_print(pp); end
  def readonly!; end
  def readonly?; end
  def slice(*methods); end
  def strict_loading!; end
  def strict_loading?; end

  private

  def custom_inspect_method_defined?; end
  def init_internals; end
  def initialize_dup(other); end
  def initialize_internals_callback; end
  def inspection_filter; end
  def to_ary; end
end

module ActiveRecord::Core::ClassMethods
  def ===(object); end
  def _internal?; end
  def arel_attribute(name, table = T.unsafe(nil)); end
  def arel_table; end
  def filter_attributes; end
  def filter_attributes=(_); end
  def find(*ids); end
  def find_by(*args); end
  def find_by!(*args); end
  def generated_association_methods; end
  def inherited(child_class); end
  def initialize_find_by_cache; end
  def initialize_generated_modules; end
  def inspect; end
  def predicate_builder; end
  def type_caster; end

  private

  def cached_find_by_statement(key, &block); end
  def relation; end
  def table_metadata; end
end

module ActiveRecord::CounterCache
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::CounterCache::ClassMethods)


  private

  def _create_record(attribute_names = T.unsafe(nil)); end
  def destroy_row; end
  def each_counter_cached_associations; end
end

module ActiveRecord::CounterCache::ClassMethods
  def decrement_counter(counter_name, id, touch: T.unsafe(nil)); end
  def increment_counter(counter_name, id, touch: T.unsafe(nil)); end
  def reset_counters(id, *counters, touch: T.unsafe(nil)); end
  def update_counters(id, counters); end
end

class ActiveRecord::DangerousAttributeError < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::DatabaseAlreadyExists < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::DatabaseConfigurations
  def initialize(configurations = T.unsafe(nil)); end

  def [](*args, &block); end
  def any?(*args, &block); end
  def blank?; end
  def configs_for(env_name: T.unsafe(nil), spec_name: T.unsafe(nil), name: T.unsafe(nil), include_replicas: T.unsafe(nil)); end
  def configurations; end
  def default_hash(*args, &block); end
  def each; end
  def empty?; end
  def find_db_config(env); end
  def first; end
  def resolve(config); end
  def to_h(*args, &block); end

  private

  def build_configs(configs); end
  def build_configuration_sentence; end
  def build_db_config_from_hash(env_name, name, config); end
  def build_db_config_from_raw_config(env_name, name, config); end
  def build_db_config_from_string(env_name, name, config); end
  def default_env; end
  def env_with_configs(env = T.unsafe(nil)); end
  def environment_url_config(env, name, config); end
  def environment_value_for(name); end
  def merge_db_environment_variables(current_env, configs); end
  def method_missing(method, *args, &blk); end
  def resolve_symbol_connection(name); end
  def throw_getter_deprecation(method); end
  def throw_setter_deprecation(method); end
  def walk_configs(env_name, config); end
end

class ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver
  def initialize(url); end

  def to_hash; end

  private

  def database_from_path; end
  def query_hash; end
  def raw_config; end
  def uri; end
  def uri_parser; end
end

class ActiveRecord::DatabaseConfigurations::DatabaseConfig
  def initialize(env_name, name); end

  def _database=(database); end
  def adapter; end
  def adapter_method; end
  def checkout_timeout; end
  def config; end
  def database; end
  def env_name; end
  def for_current_env?; end
  def host; end
  def idle_timeout; end
  def migrations_paths; end
  def name; end
  def owner_name; end
  def owner_name=(_); end
  def pool; end
  def reaping_frequency; end
  def replica?; end
  def schema_cache_path; end
  def spec_name(*args, &block); end
end

class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::DatabaseConfigurations::DatabaseConfig
  def initialize(env_name, name, configuration_hash); end

  def _database=(database); end
  def adapter; end
  def checkout_timeout; end
  def config; end
  def configuration_hash; end
  def database; end
  def host; end
  def idle_timeout; end
  def migrations_paths; end
  def pool; end
  def reaping_frequency; end
  def replica?; end
  def schema_cache_path; end
end

class ActiveRecord::DatabaseConfigurations::InvalidConfigurationError < ::StandardError
end

class ActiveRecord::DatabaseConfigurations::UrlConfig < ::ActiveRecord::DatabaseConfigurations::HashConfig
  def initialize(env_name, name, url, configuration_hash = T.unsafe(nil)); end

  def url; end

  private

  def build_url_hash; end
end

class ActiveRecord::Deadlocked < ::ActiveRecord::TransactionRollbackError
end

module ActiveRecord::Delegation
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Delegation::ClassMethods)

  def &(*args, &block); end
  def +(*args, &block); end
  def -(*args, &block); end
  def [](*args, &block); end
  def as_json(*args, &block); end
  def compact(*args, &block); end
  def connection(*args, &block); end
  def each(*args, &block); end
  def encode_with(*args, &block); end
  def in_groups(*args, &block); end
  def in_groups_of(*args, &block); end
  def index(*args, &block); end
  def join(*args, &block); end
  def length(*args, &block); end
  def primary_key(*args, &block); end
  def reverse(*args, &block); end
  def rindex(*args, &block); end
  def rotate(*args, &block); end
  def sample(*args, &block); end
  def shuffle(*args, &block); end
  def slice(*args, &block); end
  def split(*args, &block); end
  def to_formatted_s(*args, &block); end
  def to_sentence(*args, &block); end
  def to_xml(*args, &block); end
  def |(*args, &block); end

  private

  def respond_to_missing?(method, _); end
end

module ActiveRecord::Delegation::ClassMethods
  def create(klass, *args, **kwargs); end

  private

  def relation_class_for(klass); end
end

module ActiveRecord::Delegation::ClassSpecificRelation
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods)


  private

  def method_missing(method, *args, &block); end
end

module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
  def name; end
end

module ActiveRecord::Delegation::DelegateCache
  def generate_relation_method(method); end
  def inherited(child_class); end
  def initialize_relation_delegate_cache; end
  def relation_delegate_class(klass); end

  protected

  def include_relation_methods(delegate); end

  private

  def generated_relation_methods; end
end

class ActiveRecord::DeleteRestrictionError < ::ActiveRecord::ActiveRecordError
  def initialize(name = T.unsafe(nil)); end
end

module ActiveRecord::DynamicMatchers

  private

  def method_missing(name, *arguments, &block); end
  def respond_to_missing?(name, _); end
end

class ActiveRecord::DynamicMatchers::FindBy < ::ActiveRecord::DynamicMatchers::Method
  def finder; end

  class << self
    def prefix; end
  end
end

class ActiveRecord::DynamicMatchers::FindByBang < ::ActiveRecord::DynamicMatchers::Method
  def finder; end

  class << self
    def prefix; end
    def suffix; end
  end
end

class ActiveRecord::DynamicMatchers::Method
  def initialize(model, method_name); end

  def attribute_names; end
  def define; end
  def model; end
  def name; end
  def valid?; end

  private

  def attributes_hash; end
  def body; end
  def finder; end
  def signature; end

  class << self
    def match(model, name); end
    def matchers; end
    def pattern; end
    def prefix; end
    def suffix; end
  end
end

class ActiveRecord::EagerLoadPolymorphicError < ::ActiveRecord::ActiveRecordError
  def initialize(reflection = T.unsafe(nil)); end
end

module ActiveRecord::Enum
  def enum(definitions); end
  def inherited(base); end

  private

  def _enum_methods_module; end
  def assert_valid_enum_definition_values(values); end
  def detect_enum_conflict!(enum_name, method_name, klass_method = T.unsafe(nil)); end
  def detect_negative_condition!(method_name); end
  def raise_conflict_error(enum_name, method_name, type: T.unsafe(nil), source: T.unsafe(nil)); end

  class << self
    def extended(base); end
  end
end

class ActiveRecord::Enum::EnumType < ::ActiveModel::Type::Value
  def initialize(name, mapping, subtype); end

  def assert_valid_value(value); end
  def cast(value); end
  def deserialize(value); end
  def serializable?(value); end
  def serialize(value); end
  def type(*args, &block); end
  def unchecked_serialize(value); end

  private

  def mapping; end
  def name; end
  def subtype; end
end

class ActiveRecord::ExclusiveConnectionTimeoutError < ::ActiveRecord::ConnectionTimeoutError
end

module ActiveRecord::Explain
  def collecting_queries_for_explain; end
  def exec_explain(queries); end

  private

  def render_bind(attr); end
end

class ActiveRecord::ExplainRegistry
  extend(::ActiveSupport::PerThreadRegistry)

  def initialize; end

  def collect; end
  def collect=(_); end
  def collect?; end
  def queries; end
  def queries=(_); end
  def reset; end
end

class ActiveRecord::ExplainSubscriber
  def finish(name, id, payload); end
  def ignore_payload?(payload); end
  def start(name, id, payload); end
end

ActiveRecord::ExplainSubscriber::EXPLAINED_SQLS = T.let(T.unsafe(nil), Regexp)

ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS = T.let(T.unsafe(nil), Array)

module ActiveRecord::FinderMethods
  def exists?(conditions = T.unsafe(nil)); end
  def fifth; end
  def fifth!; end
  def find(*args); end
  def find_by(arg, *args); end
  def find_by!(arg, *args); end
  def first(limit = T.unsafe(nil)); end
  def first!; end
  def forty_two; end
  def forty_two!; end
  def fourth; end
  def fourth!; end
  def last(limit = T.unsafe(nil)); end
  def last!; end
  def raise_record_not_found_exception!(ids = T.unsafe(nil), result_size = T.unsafe(nil), expected_size = T.unsafe(nil), key = T.unsafe(nil), not_found_ids = T.unsafe(nil)); end
  def second; end
  def second!; end
  def second_to_last; end
  def second_to_last!; end
  def take(limit = T.unsafe(nil)); end
  def take!; end
  def third; end
  def third!; end
  def third_to_last; end
  def third_to_last!; end

  private

  def apply_join_dependency(eager_loading: T.unsafe(nil)); end
  def construct_relation_for_exists(conditions); end
  def find_last(limit); end
  def find_nth(index); end
  def find_nth_from_last(index); end
  def find_nth_with_limit(index, limit); end
  def find_one(id); end
  def find_some(ids); end
  def find_some_ordered(ids); end
  def find_take; end
  def find_take_with_limit(limit); end
  def find_with_ids(*ids); end
  def limited_ids_for(relation); end
  def offset_index; end
  def ordered_relation; end
  def using_limitable_reflections?(reflections); end
end

ActiveRecord::FinderMethods::ONE_AS_ONE = T.let(T.unsafe(nil), String)

class ActiveRecord::HasManyThroughAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil), source_reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasManyThroughAssociationPolymorphicSourceError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil), source_reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasManyThroughAssociationPolymorphicThroughError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection < ::ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
end

class ActiveRecord::HasManyThroughNestedAssociationsAreReadonly < ::ActiveRecord::ThroughNestedAssociationsAreReadonly
end

class ActiveRecord::HasManyThroughOrderError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil), through_reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasManyThroughSourceAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
  def initialize(reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasOneAssociationPolymorphicThroughError < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasOneThroughCantAssociateThroughCollection < ::ActiveRecord::ActiveRecordError
  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil), through_reflection = T.unsafe(nil)); end
end

class ActiveRecord::HasOneThroughCantAssociateThroughHasOneOrManyReflection < ::ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
end

class ActiveRecord::HasOneThroughNestedAssociationsAreReadonly < ::ActiveRecord::ThroughNestedAssociationsAreReadonly
end

class ActiveRecord::ImmutableRelation < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::Inheritance
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Inheritance::ClassMethods)


  private

  def ensure_proper_type; end
  def initialize_dup(other); end
  def initialize_internals_callback; end
end

module ActiveRecord::Inheritance::ClassMethods
  def abstract_class; end
  def abstract_class=(_); end
  def abstract_class?; end
  def base_class; end
  def base_class?; end
  def descends_from_active_record?; end
  def finder_needs_type_condition?; end
  def inherited(subclass); end
  def new(attributes = T.unsafe(nil), &block); end
  def polymorphic_class_for(name); end
  def polymorphic_name; end
  def sti_class_for(type_name); end
  def sti_name; end

  protected

  def compute_type(type_name); end

  private

  def discriminate_class_for_record(record); end
  def find_sti_class(type_name); end
  def subclass_from_attributes(attrs); end
  def type_condition(table = T.unsafe(nil)); end
  def using_single_table_inheritance?(record); end
end

class ActiveRecord::InsertAll
  def initialize(model, inserts, on_duplicate:, returning: T.unsafe(nil), unique_by: T.unsafe(nil)); end

  def connection; end
  def execute; end
  def inserts; end
  def keys; end
  def map_key_with_value; end
  def model; end
  def on_duplicate; end
  def primary_keys; end
  def returning; end
  def skip_duplicates?; end
  def unique_by; end
  def updatable_columns; end
  def update_duplicates?; end

  private

  def ensure_valid_options_for_connection!; end
  def find_unique_index_for(unique_by); end
  def readonly_columns; end
  def scope_attributes; end
  def to_sql; end
  def unique_by_columns; end
  def unique_indexes; end
  def verify_attributes(attributes); end
end

class ActiveRecord::InsertAll::Builder
  def initialize(insert_all); end

  def conflict_target; end
  def into; end
  def keys(*args, &block); end
  def model; end
  def returning; end
  def skip_duplicates?(*args, &block); end
  def touch_model_timestamps_unless(&block); end
  def updatable_columns; end
  def update_duplicates?(*args, &block); end
  def values_list; end

  private

  def columns_list; end
  def connection; end
  def extract_types_from_columns_on(table_name, keys:); end
  def format_columns(columns); end
  def insert_all; end
  def quote_columns(columns); end
  def touch_timestamp_attribute?(column_name); end
end

module ActiveRecord::Integration
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Integration::ClassMethods)

  def cache_key; end
  def cache_key_with_version; end
  def cache_version; end
  def to_param; end

  private

  def can_use_fast_cache_version?(timestamp); end
  def raw_timestamp_to_cache_version(timestamp); end
end

module ActiveRecord::Integration::ClassMethods
  def collection_cache_key(collection = T.unsafe(nil), timestamp_column = T.unsafe(nil)); end
  def to_param(method_name = T.unsafe(nil)); end
end

class ActiveRecord::InternalMetadata < ::ActiveRecord::Base
  class << self
    def [](key); end
    def []=(key, value); end
    def _internal?; end
    def _validators; end
    def attribute_type_decorations; end
    def create_table; end
    def defined_enums; end
    def drop_table; end
    def enabled?; end
    def primary_key; end
    def table_name; end
  end
end

class ActiveRecord::InvalidForeignKey < ::ActiveRecord::WrappedDatabaseException
end

class ActiveRecord::InverseOfAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
  def initialize(reflection = T.unsafe(nil), associated_class = T.unsafe(nil)); end
end

class ActiveRecord::IrreversibleOrderError < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::LegacyYamlAdapter
  class << self
    def convert(klass, coder); end
  end
end

module ActiveRecord::LegacyYamlAdapter::Rails41
  class << self
    def convert(klass, coder); end
  end
end

module ActiveRecord::LegacyYamlAdapter::Rails420
  class << self
    def convert(klass, coder); end
  end
end

class ActiveRecord::LockWaitTimeout < ::ActiveRecord::StatementInvalid
end

module ActiveRecord::Locking
  extend(::ActiveSupport::Autoload)
end

class ActiveRecord::Locking::LockingType
  def deserialize(value); end
  def encode_with(coder); end
  def init_with(coder); end
  def serialize(value); end
end

module ActiveRecord::Locking::Optimistic
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Locking::Optimistic::ClassMethods)

  def locking_enabled?; end

  private

  def _create_record(attribute_names = T.unsafe(nil)); end
  def _touch_row(attribute_names, time); end
  def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
  def destroy_row; end
end

module ActiveRecord::Locking::Optimistic::ClassMethods
  def locking_column; end
  def locking_column=(value); end
  def locking_enabled?; end
  def reset_locking_column; end
  def update_counters(id, counters); end

  private

  def inherited(subclass); end
end

ActiveRecord::Locking::Optimistic::ClassMethods::DEFAULT_LOCKING_COLUMN = T.let(T.unsafe(nil), String)

module ActiveRecord::Locking::Pessimistic
  def lock!(lock = T.unsafe(nil)); end
  def with_lock(lock = T.unsafe(nil)); end
end

class ActiveRecord::LogSubscriber < ::ActiveSupport::LogSubscriber
  def backtrace_cleaner; end
  def backtrace_cleaner=(_); end
  def backtrace_cleaner?; end
  def sql(event); end

  private

  def colorize_payload_name(name, payload_name); end
  def debug(progname = T.unsafe(nil), &block); end
  def extract_query_source_location(locations); end
  def log_query_source; end
  def logger; end
  def render_bind(attr, value); end
  def sql_color(sql); end
  def type_casted_binds(casted_binds); end

  class << self
    def backtrace_cleaner; end
    def backtrace_cleaner=(value); end
    def backtrace_cleaner?; end
    def reset_runtime; end
    def runtime; end
    def runtime=(value); end
  end
end

ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES = T.let(T.unsafe(nil), Array)

module ActiveRecord::Middleware
  extend(::ActiveSupport::Autoload)
end

class ActiveRecord::Middleware::DatabaseSelector
  def initialize(app, resolver_klass = T.unsafe(nil), context_klass = T.unsafe(nil), options = T.unsafe(nil)); end

  def call(env); end
  def context_klass; end
  def options; end
  def resolver_klass; end

  private

  def reading_request?(request); end
  def select_database(request, &blk); end
end

class ActiveRecord::Middleware::DatabaseSelector::Resolver
  def initialize(context, options = T.unsafe(nil)); end

  def context; end
  def delay; end
  def instrumenter; end
  def read(&blk); end
  def update_context(response); end
  def write(&blk); end

  private

  def read_from_primary(&blk); end
  def read_from_primary?; end
  def read_from_replica(&blk); end
  def send_to_replica_delay; end
  def time_since_last_write_ok?; end
  def write_to_primary(&blk); end

  class << self
    def call(context, options = T.unsafe(nil)); end
  end
end

ActiveRecord::Middleware::DatabaseSelector::Resolver::SEND_TO_REPLICA_DELAY = T.let(T.unsafe(nil), ActiveSupport::Duration)

class ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
  def initialize(session); end

  def last_write_timestamp; end
  def save(response); end
  def session; end
  def update_last_write_timestamp; end

  class << self
    def call(request); end
    def convert_time_to_timestamp(time); end
    def convert_timestamp_to_time(timestamp); end
  end
end

class ActiveRecord::Migration
  def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end

  def announce(message); end
  def connection; end
  def copy(destination, sources, options = T.unsafe(nil)); end
  def disable_ddl_transaction; end
  def down; end
  def exec_migration(conn, direction); end
  def method_missing(method, *arguments, &block); end
  def migrate(direction); end
  def name; end
  def name=(_); end
  def next_migration_number(number); end
  def proper_table_name(name, options = T.unsafe(nil)); end
  def reversible; end
  def revert(*migration_classes); end
  def reverting?; end
  def run(*migration_classes); end
  def say(message, subitem = T.unsafe(nil)); end
  def say_with_time(message); end
  def suppress_messages; end
  def table_name_options(config = T.unsafe(nil)); end
  def up; end
  def up_only; end
  def verbose; end
  def verbose=(val); end
  def version; end
  def version=(_); end
  def write(text = T.unsafe(nil)); end

  private

  def command_recorder; end
  def execute_block; end

  class << self
    def [](version); end
    def check_pending!(connection = T.unsafe(nil)); end
    def current_version; end
    def delegate; end
    def delegate=(_); end
    def disable_ddl_transaction; end
    def disable_ddl_transaction!; end
    def disable_ddl_transaction=(_); end
    def inherited(subclass); end
    def load_schema_if_pending!; end
    def maintain_test_schema!; end
    def method_missing(name, *args, &block); end
    def migrate(direction); end
    def nearest_delegate; end
    def verbose; end
    def verbose=(val); end
  end
end

class ActiveRecord::Migration::CheckPending
  def initialize(app, file_watcher: T.unsafe(nil)); end

  def call(env); end

  private

  def build_watcher(&block); end
  def connection; end
end

class ActiveRecord::Migration::CommandRecorder
  include(::ActiveRecord::Migration::JoinTable)
  include(::ActiveRecord::Migration::CommandRecorder::StraightReversions)

  def initialize(delegate = T.unsafe(nil)); end

  def add_belongs_to(*args, &block); end
  def add_column(*args, &block); end
  def add_foreign_key(*args, &block); end
  def add_index(*args, &block); end
  def add_reference(*args, &block); end
  def add_timestamps(*args, &block); end
  def change_column(*args, &block); end
  def change_column_comment(*args, &block); end
  def change_column_default(*args, &block); end
  def change_column_null(*args, &block); end
  def change_table(table_name, **options); end
  def change_table_comment(*args, &block); end
  def commands; end
  def commands=(_); end
  def create_join_table(*args, &block); end
  def create_table(*args, &block); end
  def delegate; end
  def delegate=(_); end
  def disable_extension(*args, &block); end
  def drop_join_table(*args, &block); end
  def drop_table(*args, &block); end
  def enable_extension(*args, &block); end
  def execute(*args, &block); end
  def execute_block(*args, &block); end
  def inverse_of(command, args, &block); end
  def invert_add_belongs_to(args, &block); end
  def invert_remove_belongs_to(args, &block); end
  def record(*command, &block); end
  def remove_belongs_to(*args, &block); end
  def remove_column(*args, &block); end
  def remove_columns(*args, &block); end
  def remove_foreign_key(*args, &block); end
  def remove_index(*args, &block); end
  def remove_reference(*args, &block); end
  def remove_timestamps(*args, &block); end
  def rename_column(*args, &block); end
  def rename_index(*args, &block); end
  def rename_table(*args, &block); end
  def replay(migration); end
  def revert; end
  def reverting; end
  def reverting=(_); end
  def transaction(*args, &block); end

  private

  def invert_add_index(args); end
  def invert_change_column_comment(args); end
  def invert_change_column_default(args); end
  def invert_change_column_null(args); end
  def invert_change_table_comment(args); end
  def invert_drop_table(args, &block); end
  def invert_remove_column(args); end
  def invert_remove_columns(args); end
  def invert_remove_foreign_key(args); end
  def invert_remove_index(args); end
  def invert_rename_column(args); end
  def invert_rename_index(args); end
  def invert_rename_table(args); end
  def invert_transaction(args); end
  def method_missing(method, *args, &block); end
  def respond_to_missing?(method, _); end
end

ActiveRecord::Migration::CommandRecorder::ReversibleAndIrreversibleMethods = T.let(T.unsafe(nil), Array)

module ActiveRecord::Migration::CommandRecorder::StraightReversions
  def invert_add_column(args, &block); end
  def invert_add_foreign_key(args, &block); end
  def invert_add_reference(args, &block); end
  def invert_add_timestamps(args, &block); end
  def invert_create_join_table(args, &block); end
  def invert_create_table(args, &block); end
  def invert_disable_extension(args, &block); end
  def invert_drop_join_table(args, &block); end
  def invert_drop_table(args, &block); end
  def invert_enable_extension(args, &block); end
  def invert_execute_block(args, &block); end
  def invert_remove_column(args, &block); end
  def invert_remove_foreign_key(args, &block); end
  def invert_remove_reference(args, &block); end
  def invert_remove_timestamps(args, &block); end
end

module ActiveRecord::Migration::Compatibility
  class << self
    def find(version); end
  end
end

class ActiveRecord::Migration::Compatibility::V4_2 < ::ActiveRecord::Migration::Compatibility::V5_0
  def add_belongs_to(table_name, ref_name, **options); end
  def add_reference(table_name, ref_name, **options); end
  def add_timestamps(table_name, **options); end
  def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
  def remove_index(table_name, options = T.unsafe(nil)); end

  private

  def compatible_table_definition(t); end
  def index_name_for_remove(table_name, options = T.unsafe(nil)); end
end

module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
  def belongs_to(*_, **options); end
  def references(*_, **options); end
  def timestamps(**options); end
end

class ActiveRecord::Migration::Compatibility::V5_0 < ::ActiveRecord::Migration::Compatibility::V5_1
  def add_belongs_to(table_name, ref_name, **options); end
  def add_column(table_name, column_name, type, **options); end
  def add_reference(table_name, ref_name, **options); end
  def create_join_table(table_1, table_2, column_options: T.unsafe(nil), **options); end
  def create_table(table_name, **options); end

  private

  def compatible_table_definition(t); end
end

module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
  def belongs_to(*args, **options); end
  def primary_key(name, type = T.unsafe(nil), **options); end
  def references(*args, **options); end
end

class ActiveRecord::Migration::Compatibility::V5_1 < ::ActiveRecord::Migration::Compatibility::V5_2
  def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
  def create_table(table_name, **options); end
end

class ActiveRecord::Migration::Compatibility::V5_2 < ::ActiveRecord::Migration::Compatibility::V6_0
  def add_timestamps(table_name, **options); end
  def change_table(table_name, **options); end
  def create_join_table(table_1, table_2, **options); end
  def create_table(table_name, **options); end

  private

  def command_recorder; end
  def compatible_table_definition(t); end
end

module ActiveRecord::Migration::Compatibility::V5_2::CommandRecorder
  def invert_change_column_comment(args); end
  def invert_change_table_comment(args); end
  def invert_transaction(args, &block); end
end

module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
  def timestamps(**options); end
end

class ActiveRecord::Migration::Compatibility::V6_0 < ::ActiveRecord::Migration::Current
end

ActiveRecord::Migration::Compatibility::V6_1 = ActiveRecord::Migration::Current

class ActiveRecord::Migration::Current < ::ActiveRecord::Migration
end

module ActiveRecord::Migration::JoinTable

  private

  def find_join_table_name(table_1, table_2, options = T.unsafe(nil)); end
  def join_table_name(table_1, table_2); end
end

ActiveRecord::Migration::MigrationFilenameRegexp = T.let(T.unsafe(nil), Regexp)

class ActiveRecord::Migration::ReversibleBlockHelper < ::Struct
  def down; end
  def reverting; end
  def reverting=(_); end
  def up; end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::Migrator
  def initialize(direction, migrations, schema_migration, target_version = T.unsafe(nil)); end

  def current; end
  def current_migration; end
  def current_version; end
  def load_migrated; end
  def migrate; end
  def migrated; end
  def migrations; end
  def pending_migrations; end
  def run; end
  def runnable; end

  private

  def ddl_transaction(migration); end
  def down?; end
  def execute_migration_in_transaction(migration); end
  def finish; end
  def generate_migrator_advisory_lock_id; end
  def invalid_target?; end
  def migrate_without_lock; end
  def ran?(migration); end
  def record_environment; end
  def record_version_state_after_migrating(version); end
  def run_without_lock; end
  def start; end
  def target; end
  def up?; end
  def use_advisory_lock?; end
  def use_transaction?(migration); end
  def validate(migrations); end
  def with_advisory_lock; end

  class << self
    def current_version; end
    def migrations_paths; end
    def migrations_paths=(_); end
  end
end

ActiveRecord::Migrator::MIGRATOR_SALT = T.let(T.unsafe(nil), Integer)

class ActiveRecord::MismatchedForeignKey < ::ActiveRecord::StatementInvalid
  def initialize(message: T.unsafe(nil), sql: T.unsafe(nil), binds: T.unsafe(nil), table: T.unsafe(nil), foreign_key: T.unsafe(nil), target_table: T.unsafe(nil), primary_key: T.unsafe(nil), primary_key_column: T.unsafe(nil)); end
end

module ActiveRecord::ModelSchema
  extend(::ActiveSupport::Concern)

  class << self
    def derive_join_table_name(first_table, second_table); end
  end
end

module ActiveRecord::ModelSchema::ClassMethods
  def _default_attributes; end
  def attribute_types; end
  def attributes_builder; end
  def column_defaults; end
  def column_names; end
  def columns; end
  def columns_hash; end
  def content_columns; end
  def full_table_name_prefix; end
  def full_table_name_suffix; end
  def ignored_columns; end
  def ignored_columns=(columns); end
  def inheritance_column; end
  def inheritance_column=(value); end
  def next_sequence_value; end
  def prefetch_primary_key?; end
  def protected_environments; end
  def protected_environments=(environments); end
  def quoted_table_name; end
  def reset_column_information; end
  def reset_sequence_name; end
  def reset_table_name; end
  def sequence_name; end
  def sequence_name=(value); end
  def symbol_column_to_string(name_symbol); end
  def table_exists?; end
  def table_name; end
  def table_name=(value); end
  def type_for_attribute(attr_name, &block); end
  def yaml_encoder; end

  protected

  def initialize_load_schema_monitor; end

  private

  def compute_table_name; end
  def inherited(child_class); end
  def load_schema; end
  def load_schema!; end
  def reload_schema_from_cache; end
  def schema_loaded?; end
  def undecorated_table_name(class_name = T.unsafe(nil)); end
end

class ActiveRecord::MultiparameterAssignmentErrors < ::ActiveRecord::ActiveRecordError
  def initialize(errors = T.unsafe(nil)); end

  def errors; end
end

module ActiveRecord::NestedAttributes
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::NestedAttributes::ClassMethods)

  def _destroy; end

  private

  def allow_destroy?(association_name); end
  def assign_nested_attributes_for_collection_association(association_name, attributes_collection); end
  def assign_nested_attributes_for_one_to_one_association(association_name, attributes); end
  def assign_to_or_mark_for_destruction(record, attributes, allow_destroy); end
  def call_reject_if(association_name, attributes); end
  def check_record_limit!(limit, attributes_collection); end
  def has_destroy_flag?(hash); end
  def raise_nested_attributes_record_not_found!(association_name, record_id); end
  def reject_new_record?(association_name, attributes); end
  def will_be_destroyed?(association_name, attributes); end
end

module ActiveRecord::NestedAttributes::ClassMethods
  def accepts_nested_attributes_for(*attr_names); end

  private

  def generate_association_writer(association_name, type); end
end

ActiveRecord::NestedAttributes::ClassMethods::REJECT_ALL_BLANK_PROC = T.let(T.unsafe(nil), Proc)

class ActiveRecord::NestedAttributes::TooManyRecords < ::ActiveRecord::ActiveRecordError
end

ActiveRecord::NestedAttributes::UNASSIGNABLE_KEYS = T.let(T.unsafe(nil), Array)

class ActiveRecord::NoDatabaseError < ::ActiveRecord::StatementInvalid
end

module ActiveRecord::NoTouching
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::NoTouching::ClassMethods)

  def no_touching?; end
  def touch(*_, **_); end
  def touch_later(*_); end

  class << self
    def applied_to?(klass); end
    def apply_to(klass); end

    private

    def klasses; end
  end
end

module ActiveRecord::NoTouching::ClassMethods
  def no_touching(&block); end
end

class ActiveRecord::NotNullViolation < ::ActiveRecord::StatementInvalid
end

module ActiveRecord::NullRelation
  def any?; end
  def calculate(operation, _column_name); end
  def delete(_id_or_array); end
  def delete_all; end
  def empty?; end
  def exists?(_conditions = T.unsafe(nil)); end
  def many?; end
  def none?; end
  def one?; end
  def or(other); end
  def pluck(*column_names); end
  def to_sql; end
  def update_all(_updates); end

  private

  def exec_queries; end
end

module ActiveRecord::Persistence
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Persistence::ClassMethods)

  def becomes(klass); end
  def becomes!(klass); end
  def decrement(attribute, by = T.unsafe(nil)); end
  def decrement!(attribute, by = T.unsafe(nil), touch: T.unsafe(nil)); end
  def delete; end
  def destroy; end
  def destroy!; end
  def destroyed?; end
  def increment(attribute, by = T.unsafe(nil)); end
  def increment!(attribute, by = T.unsafe(nil), touch: T.unsafe(nil)); end
  def new_record?; end
  def persisted?; end
  def previously_new_record?; end
  def reload(options = T.unsafe(nil)); end
  def save(**options, &block); end
  def save!(**options, &block); end
  def toggle(attribute); end
  def toggle!(attribute); end
  def touch(*names, time: T.unsafe(nil)); end
  def update(attributes); end
  def update!(attributes); end
  def update_attribute(name, value); end
  def update_attributes(*args, &block); end
  def update_attributes!(*args, &block); end
  def update_column(name, value); end
  def update_columns(attributes); end

  private

  def _create_record(attribute_names = T.unsafe(nil)); end
  def _delete_row; end
  def _raise_readonly_record_error; end
  def _raise_record_not_destroyed; end
  def _raise_record_not_touched_error; end
  def _touch_row(attribute_names, time); end
  def _update_record(attribute_names = T.unsafe(nil)); end
  def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
  def belongs_to_touch_method; end
  def create_or_update(**_, &block); end
  def destroy_associations; end
  def destroy_row; end
  def verify_readonly_attribute(name); end
end

module ActiveRecord::Persistence::ClassMethods
  def _delete_record(constraints); end
  def _insert_record(values); end
  def _update_record(values, constraints); end
  def create(attributes = T.unsafe(nil), &block); end
  def create!(attributes = T.unsafe(nil), &block); end
  def delete(id_or_array); end
  def destroy(id); end
  def insert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil)); end
  def insert!(attributes, returning: T.unsafe(nil)); end
  def insert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil)); end
  def insert_all!(attributes, returning: T.unsafe(nil)); end
  def instantiate(attributes, column_types = T.unsafe(nil), &block); end
  def update(id = T.unsafe(nil), attributes); end
  def upsert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil)); end
  def upsert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil)); end

  private

  def _substitute_values(values); end
  def discriminate_class_for_record(record); end
  def instantiate_instance_of(klass, attributes, column_types = T.unsafe(nil), &block); end
end

class ActiveRecord::PredicateBuilder
  def initialize(table); end

  def build(attribute, value); end
  def build_bind_attribute(column_name, value); end
  def build_from_hash(attributes); end
  def register_handler(klass, handler); end
  def resolve_arel_attribute(table_name, column_name); end

  protected

  def expand_from_hash(attributes); end

  private

  def convert_dot_notation_to_hash(attributes); end
  def handler_for(object); end
  def table; end

  class << self
    def references(attributes); end
  end
end

class ActiveRecord::PredicateBuilder::ArrayHandler
  def initialize(predicate_builder); end

  def call(attribute, value); end

  private

  def predicate_builder; end
end

module ActiveRecord::PredicateBuilder::ArrayHandler::NullPredicate
  class << self
    def or(other); end
  end
end

class ActiveRecord::PredicateBuilder::AssociationQueryValue
  def initialize(associated_table, value); end

  def queries; end

  private

  def associated_table; end
  def convert_to_id(value); end
  def ids; end
  def primary_key; end
  def value; end
end

class ActiveRecord::PredicateBuilder::BaseHandler
  def initialize(predicate_builder); end

  def call(attribute, value); end

  private

  def predicate_builder; end
end

class ActiveRecord::PredicateBuilder::BasicObjectHandler
  def initialize(predicate_builder); end

  def call(attribute, value); end

  private

  def predicate_builder; end
end

class ActiveRecord::PredicateBuilder::PolymorphicArrayValue
  def initialize(associated_table, values); end

  def queries; end

  private

  def associated_table; end
  def convert_to_id(value); end
  def klass(value); end
  def primary_key(value); end
  def type_to_ids_mapping; end
  def values; end
end

class ActiveRecord::PredicateBuilder::RangeHandler
  def initialize(predicate_builder); end

  def call(attribute, value); end

  private

  def predicate_builder; end
end

class ActiveRecord::PredicateBuilder::RangeHandler::RangeWithBinds < ::Struct
  def begin; end
  def begin=(_); end
  def end; end
  def end=(_); end
  def exclude_end?; end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::PredicateBuilder::RelationHandler
  def call(attribute, value); end
end

class ActiveRecord::PreparedStatementCacheExpired < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::PreparedStatementInvalid < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::QueryAborted < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::QueryCache
  class << self
    def complete(pools); end
    def install_executor_hooks(executor = T.unsafe(nil)); end
    def run; end
  end
end

module ActiveRecord::QueryCache::ClassMethods
  def cache(&block); end
  def uncached(&block); end
end

class ActiveRecord::QueryCanceled < ::ActiveRecord::QueryAborted
end

module ActiveRecord::QueryMethods
  include(::ActiveModel::ForbiddenAttributesProtection)
  extend(::ActiveSupport::Concern)

  def _select!(*fields); end
  def annotate(*args); end
  def annotate!(*args); end
  def annotate_values; end
  def annotate_values=(value); end
  def arel(aliases = T.unsafe(nil)); end
  def construct_join_dependency(associations, join_type); end
  def create_with(value); end
  def create_with!(value); end
  def create_with_value; end
  def create_with_value=(value); end
  def distinct(value = T.unsafe(nil)); end
  def distinct!(value = T.unsafe(nil)); end
  def distinct_value; end
  def distinct_value=(value); end
  def eager_load(*args); end
  def eager_load!(*args); end
  def eager_load_values; end
  def eager_load_values=(value); end
  def extending(*modules, &block); end
  def extending!(*modules, &block); end
  def extending_values; end
  def extending_values=(value); end
  def extensions; end
  def extract_associated(association); end
  def from(value, subquery_name = T.unsafe(nil)); end
  def from!(value, subquery_name = T.unsafe(nil)); end
  def from_clause; end
  def from_clause=(value); end
  def group(*args); end
  def group!(*args); end
  def group_values; end
  def group_values=(value); end
  def having(opts, *rest); end
  def having!(opts, *rest); end
  def having_clause; end
  def having_clause=(value); end
  def includes(*args); end
  def includes!(*args); end
  def includes_values; end
  def includes_values=(value); end
  def joins(*args); end
  def joins!(*args); end
  def joins_values; end
  def joins_values=(value); end
  def left_joins(*args); end
  def left_outer_joins(*args); end
  def left_outer_joins!(*args); end
  def left_outer_joins_values; end
  def left_outer_joins_values=(value); end
  def limit(value); end
  def limit!(value); end
  def limit_value; end
  def limit_value=(value); end
  def lock(locks = T.unsafe(nil)); end
  def lock!(locks = T.unsafe(nil)); end
  def lock_value; end
  def lock_value=(value); end
  def none; end
  def none!; end
  def offset(value); end
  def offset!(value); end
  def offset_value; end
  def offset_value=(value); end
  def optimizer_hints(*args); end
  def optimizer_hints!(*args); end
  def optimizer_hints_values; end
  def optimizer_hints_values=(value); end
  def or(other); end
  def or!(other); end
  def order(*args); end
  def order!(*args); end
  def order_values; end
  def order_values=(value); end
  def preload(*args); end
  def preload!(*args); end
  def preload_values; end
  def preload_values=(value); end
  def readonly(value = T.unsafe(nil)); end
  def readonly!(value = T.unsafe(nil)); end
  def readonly_value; end
  def readonly_value=(value); end
  def references(*table_names); end
  def references!(*table_names); end
  def references_values; end
  def references_values=(value); end
  def reorder(*args); end
  def reorder!(*args); end
  def reordering_value; end
  def reordering_value=(value); end
  def reselect(*args); end
  def reselect!(*args); end
  def reverse_order; end
  def reverse_order!; end
  def reverse_order_value; end
  def reverse_order_value=(value); end
  def rewhere(conditions); end
  def select(*fields); end
  def select_values; end
  def select_values=(value); end
  def skip_preloading!; end
  def skip_query_cache!(value = T.unsafe(nil)); end
  def skip_query_cache_value; end
  def skip_query_cache_value=(value); end
  def strict_loading(value = T.unsafe(nil)); end
  def strict_loading!(value = T.unsafe(nil)); end
  def strict_loading_value; end
  def strict_loading_value=(value); end
  def unscope(*args); end
  def unscope!(*args); end
  def unscope_values; end
  def unscope_values=(value); end
  def where(opts = T.unsafe(nil), *rest); end
  def where!(opts, *rest); end
  def where_clause; end
  def where_clause=(value); end

  protected

  def build_subquery(subquery_alias, select_value); end
  def build_where_clause(opts, *rest); end

  private

  def arel_column(field); end
  def arel_columns(columns); end
  def assert_mutability!; end
  def build_arel(aliases); end
  def build_cast_value(name, value); end
  def build_from; end
  def build_join_query(manager, buckets, join_type, aliases); end
  def build_joins(manager, joins, aliases); end
  def build_left_outer_joins(manager, outer_joins, aliases); end
  def build_order(arel); end
  def build_select(arel); end
  def check_if_method_has_arguments!(method_name, args); end
  def column_references(order_args); end
  def does_not_support_reverse?(order); end
  def having_clause_factory; end
  def order_column(field); end
  def preprocess_order_args(order_args); end
  def resolve_arel_attributes(attrs); end
  def reverse_sql_order(order_query); end
  def sanitize_order_arguments(order_args); end
  def select_association_list(associations); end
  def structurally_incompatible_values_for_or(other); end
  def table_name_matches?(from); end
  def valid_association_list(associations); end
  def validate_order_args(args); end
  def where_clause_factory; end
end

ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY = T.let(T.unsafe(nil), Array)

ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH = T.let(T.unsafe(nil), Hash)

ActiveRecord::QueryMethods::STRUCTURAL_OR_METHODS = T.let(T.unsafe(nil), Array)

ActiveRecord::QueryMethods::VALID_DIRECTIONS = T.let(T.unsafe(nil), Set)

ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES = T.let(T.unsafe(nil), Set)

class ActiveRecord::QueryMethods::WhereChain
  include(::ActiveModel::ForbiddenAttributesProtection)

  def initialize(scope); end

  def missing(*args); end
  def not(opts, *rest); end

  private

  def not_behaves_as_nor?(opts); end
end

module ActiveRecord::Querying
  def annotate(*args, &block); end
  def any?(*args, &block); end
  def average(*args, &block); end
  def calculate(*args, &block); end
  def count(*args, &block); end
  def count_by_sql(sql); end
  def create_or_find_by(*args, &block); end
  def create_or_find_by!(*args, &block); end
  def create_with(*args, &block); end
  def delete_all(*args, &block); end
  def delete_by(*args, &block); end
  def destroy_all(*args, &block); end
  def destroy_by(*args, &block); end
  def distinct(*args, &block); end
  def eager_load(*args, &block); end
  def except(*args, &block); end
  def exists?(*args, &block); end
  def extending(*args, &block); end
  def extract_associated(*args, &block); end
  def fifth(*args, &block); end
  def fifth!(*args, &block); end
  def find(*args, &block); end
  def find_by(*args, &block); end
  def find_by!(*args, &block); end
  def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), &block); end
  def find_each(*args, &block); end
  def find_in_batches(*args, &block); end
  def find_or_create_by(*args, &block); end
  def find_or_create_by!(*args, &block); end
  def find_or_initialize_by(*args, &block); end
  def first(*args, &block); end
  def first!(*args, &block); end
  def first_or_create(*args, &block); end
  def first_or_create!(*args, &block); end
  def first_or_initialize(*args, &block); end
  def forty_two(*args, &block); end
  def forty_two!(*args, &block); end
  def fourth(*args, &block); end
  def fourth!(*args, &block); end
  def from(*args, &block); end
  def group(*args, &block); end
  def having(*args, &block); end
  def ids(*args, &block); end
  def in_batches(*args, &block); end
  def includes(*args, &block); end
  def joins(*args, &block); end
  def last(*args, &block); end
  def last!(*args, &block); end
  def left_joins(*args, &block); end
  def left_outer_joins(*args, &block); end
  def limit(*args, &block); end
  def lock(*args, &block); end
  def many?(*args, &block); end
  def maximum(*args, &block); end
  def merge(*args, &block); end
  def minimum(*args, &block); end
  def none(*args, &block); end
  def none?(*args, &block); end
  def offset(*args, &block); end
  def one?(*args, &block); end
  def only(*args, &block); end
  def optimizer_hints(*args, &block); end
  def or(*args, &block); end
  def order(*args, &block); end
  def pick(*args, &block); end
  def pluck(*args, &block); end
  def preload(*args, &block); end
  def readonly(*args, &block); end
  def references(*args, &block); end
  def reorder(*args, &block); end
  def reselect(*args, &block); end
  def rewhere(*args, &block); end
  def second(*args, &block); end
  def second!(*args, &block); end
  def second_to_last(*args, &block); end
  def second_to_last!(*args, &block); end
  def select(*args, &block); end
  def strict_loading(*args, &block); end
  def sum(*args, &block); end
  def take(*args, &block); end
  def take!(*args, &block); end
  def third(*args, &block); end
  def third!(*args, &block); end
  def third_to_last(*args, &block); end
  def third_to_last!(*args, &block); end
  def touch_all(*args, &block); end
  def unscope(*args, &block); end
  def update_all(*args, &block); end
  def where(*args, &block); end
end

ActiveRecord::Querying::QUERYING_METHODS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Railtie < ::Rails::Railtie
end

class ActiveRecord::RangeError < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::ReadOnlyError < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::ReadOnlyRecord < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::ReadonlyAttributes
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::ReadonlyAttributes::ClassMethods)
end

module ActiveRecord::ReadonlyAttributes::ClassMethods
  def attr_readonly(*attributes); end
  def readonly_attribute?(name); end
  def readonly_attributes; end
end

class ActiveRecord::RecordInvalid < ::ActiveRecord::ActiveRecordError
  def initialize(record = T.unsafe(nil)); end

  def record; end
end

class ActiveRecord::RecordNotDestroyed < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil), record = T.unsafe(nil)); end

  def record; end
end

class ActiveRecord::RecordNotFound < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil), model = T.unsafe(nil), primary_key = T.unsafe(nil), id = T.unsafe(nil)); end

  def id; end
  def model; end
  def primary_key; end
end

class ActiveRecord::RecordNotSaved < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil), record = T.unsafe(nil)); end

  def record; end
end

class ActiveRecord::RecordNotUnique < ::ActiveRecord::WrappedDatabaseException
end

module ActiveRecord::Reflection
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Reflection::ClassMethods)

  class << self
    def add_aggregate_reflection(ar, name, reflection); end
    def add_reflection(ar, name, reflection); end
    def create(macro, name, scope, options, ar); end

    private

    def reflection_class_for(macro); end
  end
end

class ActiveRecord::Reflection::AbstractReflection
  def alias_candidate(name); end
  def build_association(attributes, &block); end
  def build_scope(table, predicate_builder = T.unsafe(nil)); end
  def chain; end
  def check_validity_of_inverse!; end
  def class_name; end
  def constraints; end
  def counter_cache_column; end
  def counter_must_be_updated_by_has_many?; end
  def get_join_keys(association_klass); end
  def has_cached_counter?; end
  def inverse_of; end
  def inverse_updates_counter_cache?; end
  def inverse_updates_counter_in_memory?; end
  def inverse_which_updates_counter_cache; end
  def join_foreign_key; end
  def join_keys; end
  def join_primary_key(*_); end
  def join_scope(table, foreign_table, foreign_klass); end
  def join_scopes(table, predicate_builder); end
  def klass_join_scope(table, predicate_builder); end
  def scopes; end
  def strict_loading?; end
  def table_name; end
  def through_reflection?; end

  protected

  def actual_source_reflection; end

  private

  def predicate_builder(table); end
  def primary_key(klass); end
end

class ActiveRecord::Reflection::AbstractReflection::JoinKeys < ::Struct
  def foreign_key; end
  def foreign_key=(_); end
  def key; end
  def key=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::Reflection::AggregateReflection < ::ActiveRecord::Reflection::MacroReflection
  def mapping; end
end

class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflection::MacroReflection
  def initialize(name, scope, options, active_record); end

  def active_record_primary_key; end
  def add_as_polymorphic_through(reflection, seed); end
  def add_as_source(seed); end
  def add_as_through(seed); end
  def association_class; end
  def association_foreign_key; end
  def association_primary_key(klass = T.unsafe(nil)); end
  def association_scope_cache(conn, owner, &block); end
  def belongs_to?; end
  def check_eager_loadable!; end
  def check_preloadable!; end
  def check_validity!; end
  def clear_association_scope_cache; end
  def collect_join_chain; end
  def collection?; end
  def compute_class(name); end
  def constructable?; end
  def extensions; end
  def foreign_key; end
  def foreign_type; end
  def has_inverse?; end
  def has_one?; end
  def has_scope?; end
  def join_id_for(owner); end
  def join_table; end
  def macro; end
  def nested?; end
  def parent_reflection; end
  def parent_reflection=(_); end
  def polymorphic?; end
  def polymorphic_inverse_of(associated_class); end
  def source_reflection; end
  def through_reflection; end
  def type; end
  def validate?; end

  private

  def automatic_inverse_of; end
  def calculate_constructable(macro, options); end
  def can_find_inverse_of_automatically?(reflection); end
  def derive_class_name; end
  def derive_foreign_key; end
  def derive_join_table; end
  def inverse_name; end
  def valid_inverse_reflection?(reflection); end
end

ActiveRecord::Reflection::AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS = T.let(T.unsafe(nil), Array)

ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Reflection::BelongsToReflection < ::ActiveRecord::Reflection::AssociationReflection
  def association_class; end
  def belongs_to?; end
  def join_foreign_key; end
  def join_primary_key(klass = T.unsafe(nil)); end
  def macro; end

  private

  def calculate_constructable(macro, options); end
  def can_find_inverse_of_automatically?(_); end
end

module ActiveRecord::Reflection::ClassMethods
  def _reflect_on_association(association); end
  def clear_reflections_cache; end
  def reflect_on_aggregation(aggregation); end
  def reflect_on_all_aggregations; end
  def reflect_on_all_associations(macro = T.unsafe(nil)); end
  def reflect_on_all_autosave_associations; end
  def reflect_on_association(association); end
  def reflections; end
end

class ActiveRecord::Reflection::HasAndBelongsToManyReflection < ::ActiveRecord::Reflection::AssociationReflection
  def collection?; end
  def macro; end
end

class ActiveRecord::Reflection::HasManyReflection < ::ActiveRecord::Reflection::AssociationReflection
  def association_class; end
  def association_primary_key(klass = T.unsafe(nil)); end
  def collection?; end
  def macro; end
end

class ActiveRecord::Reflection::HasOneReflection < ::ActiveRecord::Reflection::AssociationReflection
  def association_class; end
  def has_one?; end
  def macro; end

  private

  def calculate_constructable(macro, options); end
end

class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::AbstractReflection
  def initialize(name, scope, options, active_record); end

  def ==(other_aggregation); end
  def active_record; end
  def autosave=(autosave); end
  def compute_class(name); end
  def klass; end
  def name; end
  def options; end
  def plural_name; end
  def scope; end
  def scope_for(relation, owner = T.unsafe(nil)); end

  private

  def derive_class_name; end
end

class ActiveRecord::Reflection::PolymorphicReflection < ::ActiveRecord::Reflection::AbstractReflection
  def initialize(reflection, previous_reflection); end

  def constraints; end
  def get_join_keys(*args, &block); end
  def join_scopes(table, predicate_builder); end
  def klass(*args, &block); end
  def plural_name(*args, &block); end
  def scope(*args, &block); end
  def scope_for(*args, &block); end
  def type(*args, &block); end

  private

  def source_type_scope; end
end

class ActiveRecord::Reflection::RuntimeReflection < ::ActiveRecord::Reflection::AbstractReflection
  def initialize(reflection, association); end

  def aliased_table; end
  def all_includes; end
  def constraints(*args, &block); end
  def get_join_keys(*args, &block); end
  def klass; end
  def scope(*args, &block); end
  def type(*args, &block); end
end

class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::AbstractReflection
  def initialize(delegate_reflection); end

  def active_record(*args, &block); end
  def active_record_primary_key(*args, &block); end
  def add_as_polymorphic_through(reflection, seed); end
  def add_as_source(seed); end
  def add_as_through(seed); end
  def association_class(*args, &block); end
  def association_foreign_key(*args, &block); end
  def association_primary_key(klass = T.unsafe(nil)); end
  def association_scope_cache(*args, &block); end
  def autosave=(arg); end
  def belongs_to?(*args, &block); end
  def check_eager_loadable!(*args, &block); end
  def check_preloadable!(*args, &block); end
  def check_validity!; end
  def clear_association_scope_cache; end
  def collect_join_chain; end
  def collection?(*args, &block); end
  def compute_class(*args, &block); end
  def constraints; end
  def constructable?(*args, &block); end
  def extensions(*args, &block); end
  def foreign_key(*args, &block); end
  def foreign_type(*args, &block); end
  def get_join_keys(*args, &block); end
  def has_inverse?(*args, &block); end
  def has_one?(*args, &block); end
  def has_scope?; end
  def join_id_for(*args, &block); end
  def join_scopes(table, predicate_builder); end
  def join_table(*args, &block); end
  def klass; end
  def macro(*args, &block); end
  def name(*args, &block); end
  def nested?; end
  def options(*args, &block); end
  def parent_reflection(*args, &block); end
  def parent_reflection=(arg); end
  def plural_name(*args, &block); end
  def polymorphic?(*args, &block); end
  def polymorphic_inverse_of(*args, &block); end
  def scope(*args, &block); end
  def scope_for(*args, &block); end
  def scopes; end
  def source_options; end
  def source_reflection; end
  def source_reflection_name; end
  def source_reflection_names; end
  def through_options; end
  def through_reflection; end
  def through_reflection?; end
  def type(*args, &block); end
  def validate?(*args, &block); end

  protected

  def actual_source_reflection; end

  private

  def collect_join_reflections(seed); end
  def delegate_reflection; end
  def derive_class_name; end
  def inverse_name; end
end

class ActiveRecord::Relation
  include(::Enumerable)
  include(::ActiveRecord::Delegation)
  include(::ActiveRecord::Explain)
  include(::ActiveRecord::Batches)
  include(::ActiveModel::ForbiddenAttributesProtection)
  include(::ActiveRecord::QueryMethods)
  include(::ActiveRecord::SpawnMethods)
  include(::ActiveRecord::Calculations)
  include(::ActiveRecord::FinderMethods)
  extend(::ActiveRecord::Delegation::ClassMethods)

  def initialize(klass, table: T.unsafe(nil), predicate_builder: T.unsafe(nil), values: T.unsafe(nil)); end

  def ==(other); end
  def _deprecated_scope_source; end
  def _exec_scope(name, *args, &block); end
  def alias_tracker(joins = T.unsafe(nil), aliases = T.unsafe(nil)); end
  def any?; end
  def arel_attribute(name); end
  def bind_attribute(name, value); end
  def blank?; end
  def build(attributes = T.unsafe(nil), &block); end
  def cache_key(timestamp_column = T.unsafe(nil)); end
  def cache_key_with_version; end
  def cache_version(timestamp_column = T.unsafe(nil)); end
  def create(attributes = T.unsafe(nil), &block); end
  def create!(attributes = T.unsafe(nil), &block); end
  def create_or_find_by(attributes, &block); end
  def create_or_find_by!(attributes, &block); end
  def delete_all; end
  def delete_by(*args); end
  def destroy_all; end
  def destroy_by(*args); end
  def eager_loading?; end
  def empty?; end
  def empty_scope?; end
  def encode_with(coder); end
  def explain; end
  def find_or_create_by(attributes, &block); end
  def find_or_create_by!(attributes, &block); end
  def find_or_initialize_by(attributes, &block); end
  def first_or_create(attributes = T.unsafe(nil), &block); end
  def first_or_create!(attributes = T.unsafe(nil), &block); end
  def first_or_initialize(attributes = T.unsafe(nil), &block); end
  def has_limit_or_offset?; end
  def inspect; end
  def joined_includes_values; end
  def klass; end
  def load(&block); end
  def loaded; end
  def loaded?; end
  def locked?; end
  def many?; end
  def model; end
  def new(attributes = T.unsafe(nil), &block); end
  def none?; end
  def one?; end
  def predicate_builder; end
  def preload_associations(records); end
  def pretty_print(q); end
  def records; end
  def reload; end
  def reset; end
  def scope_for_create; end
  def scoping; end
  def size; end
  def skip_preloading_value; end
  def skip_preloading_value=(_); end
  def table; end
  def to_a; end
  def to_ary; end
  def to_sql; end
  def touch_all(*names, time: T.unsafe(nil)); end
  def update(id = T.unsafe(nil), attributes); end
  def update_all(updates); end
  def update_counters(counters); end
  def values; end
  def where_values_hash(relation_table_name = T.unsafe(nil)); end

  protected

  def _deprecated_scope_source=(_); end
  def load_records(records); end
  def null_relation?; end

  private

  def _deprecated_scope_block(name, &block); end
  def _deprecated_spawn(name); end
  def _increment_attribute(attribute, value = T.unsafe(nil)); end
  def _scoping(scope); end
  def _substitute_values(values); end
  def already_in_scope?; end
  def build_preloader; end
  def compute_cache_key(timestamp_column = T.unsafe(nil)); end
  def compute_cache_version(timestamp_column); end
  def exec_queries(&block); end
  def initialize_copy(other); end
  def references_eager_loaded_tables?; end
  def skip_query_cache_if_necessary; end
  def tables_in_string(string); end
end

ActiveRecord::Relation::CLAUSE_METHODS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::FromClause
  def initialize(value, name); end

  def ==(other); end
  def empty?; end
  def merge(other); end
  def name; end
  def value; end

  class << self
    def empty; end
  end
end

class ActiveRecord::Relation::HashMerger
  def initialize(relation, hash); end

  def hash; end
  def merge; end
  def other; end
  def relation; end
end

ActiveRecord::Relation::INVALID_METHODS_FOR_DELETE_ALL = T.let(T.unsafe(nil), Array)

ActiveRecord::Relation::MULTI_VALUE_METHODS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::Merger
  def initialize(relation, other); end

  def merge; end
  def normal_values; end
  def other; end
  def relation; end
  def values; end

  private

  def merge_clauses; end
  def merge_joins; end
  def merge_multi_values; end
  def merge_outer_joins; end
  def merge_preloads; end
  def merge_single_values; end
  def replace_from_clause?; end
end

ActiveRecord::Relation::Merger::NORMAL_VALUES = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::QueryAttribute < ::ActiveModel::Attribute
  def infinite?; end
  def nil?; end
  def type_cast(value); end
  def unboundable?; end
  def value_for_database; end
  def with_cast_value(value); end

  private

  def infinity?(value); end
end

ActiveRecord::Relation::SINGLE_VALUE_METHODS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::StrictLoadingScope
  class << self
    def empty_scope?; end
    def strict_loading_value; end
  end
end

ActiveRecord::Relation::VALUE_METHODS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::WhereClause
  def initialize(predicates); end

  def +(other); end
  def -(other); end
  def ==(other); end
  def any?(*args, &block); end
  def ast; end
  def contradiction?; end
  def each_attribute(&block); end
  def empty?(*args, &block); end
  def except(*columns); end
  def invert(as = T.unsafe(nil)); end
  def merge(other); end
  def or(other); end
  def to_h(table_name = T.unsafe(nil)); end

  protected

  def predicates; end
  def referenced_columns; end

  private

  def equalities(predicates); end
  def equality_node?(node); end
  def except_predicates(columns); end
  def extract_node_value(node); end
  def invert_predicate(node); end
  def non_empty_predicates; end
  def predicates_unreferenced_by(other); end
  def predicates_with_wrapped_sql_literals; end
  def wrap_sql_literal(node); end

  class << self
    def empty; end
  end
end

ActiveRecord::Relation::WhereClause::ARRAY_WITH_EMPTY_STRING = T.let(T.unsafe(nil), Array)

class ActiveRecord::Relation::WhereClauseFactory
  def initialize(klass, predicate_builder); end

  def build(opts, other); end

  private

  def klass; end
  def predicate_builder; end
end

class ActiveRecord::Result
  include(::Enumerable)

  def initialize(columns, rows, column_types = T.unsafe(nil)); end

  def [](idx); end
  def cast_values(type_overrides = T.unsafe(nil)); end
  def collect!; end
  def column_types; end
  def columns; end
  def each; end
  def empty?; end
  def first; end
  def includes_column?(name); end
  def last; end
  def length; end
  def map!; end
  def rows; end
  def to_a; end
  def to_ary; end
  def to_hash; end

  private

  def column_type(name, type_overrides = T.unsafe(nil)); end
  def hash_rows; end
  def initialize_copy(other); end
end

class ActiveRecord::Rollback < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::RuntimeRegistry
  extend(::ActiveSupport::PerThreadRegistry)

  def connection_handler; end
  def connection_handler=(_); end
  def sql_runtime; end
  def sql_runtime=(_); end

  class << self
    def connection_handler; end
    def connection_handler=(x); end
    def sql_runtime; end
    def sql_runtime=(x); end
  end
end

module ActiveRecord::Sanitization
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Sanitization::ClassMethods)
end

module ActiveRecord::Sanitization::ClassMethods
  def disallow_raw_sql!(args, permit: T.unsafe(nil)); end
  def sanitize_sql(condition); end
  def sanitize_sql_array(ary); end
  def sanitize_sql_for_assignment(assignments, default_table_name = T.unsafe(nil)); end
  def sanitize_sql_for_conditions(condition); end
  def sanitize_sql_for_order(condition); end
  def sanitize_sql_hash_for_assignment(attrs, table); end
  def sanitize_sql_like(string, escape_character = T.unsafe(nil)); end

  private

  def quote_bound_value(value, c = T.unsafe(nil)); end
  def raise_if_bind_arity_mismatch(statement, expected, provided); end
  def replace_bind_variable(value, c = T.unsafe(nil)); end
  def replace_bind_variables(statement, values); end
  def replace_named_bind_variables(statement, bind_vars); end
end

class ActiveRecord::Schema < ::ActiveRecord::Migration::Current
  def define(info, &block); end

  class << self
    def define(info = T.unsafe(nil), &block); end
  end
end

class ActiveRecord::SchemaDumper
  def initialize(connection, options = T.unsafe(nil)); end

  def dump(stream); end
  def fk_ignore_pattern; end
  def fk_ignore_pattern=(val); end
  def ignore_tables; end
  def ignore_tables=(val); end

  private

  def define_params; end
  def extensions(stream); end
  def foreign_keys(table, stream); end
  def format_colspec(colspec); end
  def format_index_parts(options); end
  def format_options(options); end
  def formatted_version; end
  def header(stream); end
  def ignored?(table_name); end
  def index_parts(index); end
  def indexes(table, stream); end
  def indexes_in_create(table, stream); end
  def remove_prefix_and_suffix(table); end
  def table(table, stream); end
  def table_name; end
  def table_name=(_); end
  def tables(stream); end
  def trailer(stream); end

  class << self
    def dump(connection = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end
    def fk_ignore_pattern; end
    def fk_ignore_pattern=(val); end
    def ignore_tables; end
    def ignore_tables=(val); end

    private

    def generate_options(config); end
  end
end

class ActiveRecord::SchemaMigration < ::ActiveRecord::Base
  def version; end

  class << self
    def _internal?; end
    def _validators; end
    def all_versions; end
    def attribute_type_decorations; end
    def create_table; end
    def defined_enums; end
    def drop_table; end
    def normalize_migration_number(number); end
    def normalized_versions; end
    def primary_key; end
    def table_name; end
  end
end

module ActiveRecord::Scoping
  extend(::ActiveSupport::Concern)
  extend(::ActiveSupport::Autoload)

  include(::ActiveRecord::Scoping::Default)
  include(::ActiveRecord::Scoping::Named)

  mixes_in_class_methods(::ActiveRecord::Scoping::ClassMethods)

  def initialize_internals_callback; end
  def populate_with_current_scope_attributes; end
end

module ActiveRecord::Scoping::ClassMethods
  def current_scope(skip_inherited_scope = T.unsafe(nil)); end
  def current_scope=(scope); end
  def scope_attributes; end
  def scope_attributes?; end
end

module ActiveRecord::Scoping::Default
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Scoping::Default::ClassMethods)
end

module ActiveRecord::Scoping::Default::ClassMethods
  def before_remove_const; end
  def scope_attributes?; end
  def unscoped; end

  private

  def build_default_scope(relation = T.unsafe(nil)); end
  def default_scope(scope = T.unsafe(nil), &block); end
  def evaluate_default_scope; end
  def ignore_default_scope=(ignore); end
  def ignore_default_scope?; end
end

module ActiveRecord::Scoping::Named
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Scoping::Named::ClassMethods)
end

module ActiveRecord::Scoping::Named::ClassMethods
  def all; end
  def default_extensions; end
  def default_scoped(scope = T.unsafe(nil)); end
  def scope(name, body, &block); end
  def scope_for_association(scope = T.unsafe(nil)); end

  private

  def valid_scope_name?(name); end
end

class ActiveRecord::Scoping::ScopeRegistry
  extend(::ActiveSupport::PerThreadRegistry)

  def initialize; end

  def set_value_for(scope_type, model, value); end
  def value_for(scope_type, model, skip_inherited_scope = T.unsafe(nil)); end

  private

  def raise_invalid_scope_type!(scope_type); end
end

ActiveRecord::Scoping::ScopeRegistry::VALID_SCOPE_TYPES = T.let(T.unsafe(nil), Array)

module ActiveRecord::SecureToken
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::SecureToken::ClassMethods)
end

module ActiveRecord::SecureToken::ClassMethods
  def generate_unique_secure_token(length: T.unsafe(nil)); end
  def has_secure_token(attribute = T.unsafe(nil), length: T.unsafe(nil)); end
end

ActiveRecord::SecureToken::MINIMUM_TOKEN_LENGTH = T.let(T.unsafe(nil), Integer)

class ActiveRecord::SecureToken::MinimumLengthError < ::StandardError
end

module ActiveRecord::Serialization
  extend(::ActiveSupport::Concern)

  include(::ActiveModel::Serializers::JSON)

  def serializable_hash(options = T.unsafe(nil)); end
end

class ActiveRecord::SerializationFailure < ::ActiveRecord::TransactionRollbackError
end

class ActiveRecord::SerializationTypeMismatch < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::SpawnMethods
  def except(*skips); end
  def merge(other); end
  def merge!(other); end
  def only(*onlies); end
  def spawn; end

  private

  def relation_with(values); end
end

class ActiveRecord::StaleObjectError < ::ActiveRecord::ActiveRecordError
  def initialize(record = T.unsafe(nil), attempted_action = T.unsafe(nil)); end

  def attempted_action; end
  def record; end
end

class ActiveRecord::StatementCache
  def initialize(query_builder, bind_map, klass); end

  def execute(params, connection, &block); end

  private

  def bind_map; end
  def klass; end
  def query_builder; end

  class << self
    def create(connection, callable = T.unsafe(nil), &block); end
    def partial_query(values); end
    def partial_query_collector; end
    def query(sql); end
    def unsupported_value?(value); end
  end
end

class ActiveRecord::StatementCache::BindMap
  def initialize(bound_attributes); end

  def bind(values); end
end

class ActiveRecord::StatementCache::Params
  def bind; end
end

class ActiveRecord::StatementCache::PartialQuery < ::ActiveRecord::StatementCache::Query
  def initialize(values); end

  def sql_for(binds, connection); end
end

class ActiveRecord::StatementCache::PartialQueryCollector
  def initialize; end

  def <<(str); end
  def add_bind(obj); end
  def preparable; end
  def preparable=(_); end
  def value; end
end

class ActiveRecord::StatementCache::Query
  def initialize(sql); end

  def sql_for(binds, connection); end
end

class ActiveRecord::StatementCache::Substitute
end

class ActiveRecord::StatementInvalid < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil), sql: T.unsafe(nil), binds: T.unsafe(nil)); end

  def binds; end
  def sql; end
end

class ActiveRecord::StatementTimeout < ::ActiveRecord::QueryAborted
end

module ActiveRecord::Store
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Store::ClassMethods)


  private

  def read_store_attribute(store_attribute, key); end
  def store_accessor_for(store_attribute); end
  def write_store_attribute(store_attribute, key, value); end
end

module ActiveRecord::Store::ClassMethods
  def _store_accessors_module; end
  def store(store_attribute, options = T.unsafe(nil)); end
  def store_accessor(store_attribute, *keys, prefix: T.unsafe(nil), suffix: T.unsafe(nil)); end
  def stored_attributes; end
end

class ActiveRecord::Store::HashAccessor
  class << self
    def prepare(object, attribute); end
    def read(object, attribute, key); end
    def write(object, attribute, key, value); end
  end
end

class ActiveRecord::Store::IndifferentCoder
  def initialize(attr_name, coder_or_class_name); end

  def dump(obj); end
  def load(yaml); end

  class << self
    def as_indifferent_hash(obj); end
  end
end

class ActiveRecord::Store::IndifferentHashAccessor < ::ActiveRecord::Store::HashAccessor
  class << self
    def prepare(object, store_attribute); end
  end
end

class ActiveRecord::Store::StringKeyedHashAccessor < ::ActiveRecord::Store::HashAccessor
  class << self
    def read(object, attribute, key); end
    def write(object, attribute, key, value); end
  end
end

class ActiveRecord::StrictLoadingViolationError < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::SubclassNotFound < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::Suppressor
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Suppressor::ClassMethods)

  def save(**_); end
  def save!(**_); end
end

module ActiveRecord::Suppressor::ClassMethods
  def suppress(&block); end
end

class ActiveRecord::SuppressorRegistry
  extend(::ActiveSupport::PerThreadRegistry)

  def initialize; end

  def suppressed; end
end

class ActiveRecord::TableMetadata
  def initialize(klass, arel_table, association = T.unsafe(nil), types = T.unsafe(nil)); end

  def aggregated_with?(aggregation_name); end
  def arel_attribute(column_name); end
  def associated_predicate_builder(table_name); end
  def associated_table(table_name); end
  def associated_with?(association_name); end
  def association_foreign_key(*args, &block); end
  def association_foreign_type(*args, &block); end
  def association_join_foreign_key(*args, &block); end
  def association_join_primary_key(*args, &block); end
  def has_column?(column_name); end
  def polymorphic_association?; end
  def reflect_on_aggregation(aggregation_name); end
  def resolve_column_aliases(hash); end
  def type(column_name); end

  protected

  def predicate_builder; end

  private

  def arel_table; end
  def association; end
  def klass; end
  def types; end
end

class ActiveRecord::TableNotSpecified < ::ActiveRecord::ActiveRecordError
end

module ActiveRecord::Tasks
  extend(::ActiveSupport::Autoload)
end

module ActiveRecord::Tasks::DatabaseTasks
  extend(::ActiveRecord::Tasks::DatabaseTasks)

  def cache_dump_filename(name, schema_cache_path: T.unsafe(nil)); end
  def charset(configuration, *arguments); end
  def charset_current(env_name = T.unsafe(nil), db_name = T.unsafe(nil)); end
  def check_protected_environments!; end
  def check_schema_file(filename); end
  def check_target_version; end
  def clear_schema_cache(filename); end
  def collation(configuration, *arguments); end
  def collation_current(env_name = T.unsafe(nil), db_name = T.unsafe(nil)); end
  def create(configuration, *arguments); end
  def create_all; end
  def create_current(environment = T.unsafe(nil), name = T.unsafe(nil)); end
  def current_config(*args, &block); end
  def current_config=(*args, &block); end
  def database_configuration; end
  def database_configuration=(_); end
  def db_dir; end
  def db_dir=(_); end
  def drop(configuration, *arguments); end
  def drop_all; end
  def drop_current(environment = T.unsafe(nil)); end
  def dump_filename(name, format = T.unsafe(nil)); end
  def dump_schema(db_config, format = T.unsafe(nil)); end
  def dump_schema_cache(conn, filename); end
  def env; end
  def env=(_); end
  def fixtures_path; end
  def fixtures_path=(_); end
  def for_each(databases); end
  def load_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
  def load_schema_current(format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil)); end
  def load_seed; end
  def migrate; end
  def migrate_status; end
  def migrations_paths; end
  def migrations_paths=(_); end
  def name; end
  def purge(configuration); end
  def purge_all; end
  def purge_current(environment = T.unsafe(nil)); end
  def raise_for_multi_db(environment = T.unsafe(nil), command:); end
  def reconstruct_from_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
  def register_task(pattern, task); end
  def root; end
  def root=(_); end
  def schema_file(format = T.unsafe(nil)); end
  def schema_file_type(format = T.unsafe(nil)); end
  def schema_up_to_date?(configuration, format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil), name = T.unsafe(nil)); end
  def seed_loader; end
  def seed_loader=(_); end
  def setup_initial_database_yaml; end
  def spec(*args, &block); end
  def structure_dump(configuration, *arguments); end
  def structure_load(configuration, *arguments); end
  def target_version; end
  def truncate_all(environment = T.unsafe(nil)); end

  private

  def class_for_adapter(adapter); end
  def database_adapter_for(db_config, *arguments); end
  def each_current_configuration(environment, name = T.unsafe(nil)); end
  def each_local_configuration; end
  def local_database?(db_config); end
  def resolve_configuration(configuration); end
  def schema_sha1(file); end
  def truncate_tables(db_config); end
  def verbose?; end

  class << self
    def structure_dump_flags; end
    def structure_dump_flags=(val); end
    def structure_load_flags; end
    def structure_load_flags=(val); end
  end
end

ActiveRecord::Tasks::DatabaseTasks::LOCAL_HOSTS = T.let(T.unsafe(nil), Array)

class ActiveRecord::Tasks::MySQLDatabaseTasks
  def initialize(db_config); end

  def charset; end
  def collation; end
  def connection(*args, &block); end
  def create; end
  def drop; end
  def establish_connection(*args, &block); end
  def purge; end
  def structure_dump(filename, extra_flags); end
  def structure_load(filename, extra_flags); end

  private

  def configuration_hash; end
  def configuration_hash_without_database; end
  def creation_options; end
  def db_config; end
  def prepare_command_options; end
  def run_cmd(cmd, args, action); end
  def run_cmd_error(cmd, args, action); end

  class << self
    def using_database_configurations?; end
  end
end

ActiveRecord::Tasks::MySQLDatabaseTasks::ER_DB_CREATE_EXISTS = T.let(T.unsafe(nil), Integer)

class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
  def initialize(db_config); end

  def charset; end
  def clear_active_connections!(*args, &block); end
  def collation; end
  def connection(*args, &block); end
  def create(master_established = T.unsafe(nil)); end
  def drop; end
  def establish_connection(*args, &block); end
  def purge; end
  def structure_dump(filename, extra_flags); end
  def structure_load(filename, extra_flags); end

  private

  def configuration_hash; end
  def db_config; end
  def encoding; end
  def establish_master_connection; end
  def remove_sql_header_comments(filename); end
  def run_cmd(cmd, args, action); end
  def run_cmd_error(cmd, args, action); end
  def set_psql_env; end

  class << self
    def using_database_configurations?; end
  end
end

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::DEFAULT_ENCODING = T.let(T.unsafe(nil), String)

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::ON_ERROR_STOP_1 = T.let(T.unsafe(nil), String)

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::SQL_COMMENT_BEGIN = T.let(T.unsafe(nil), String)

class ActiveRecord::Tasks::SQLiteDatabaseTasks
  def initialize(db_config, root = T.unsafe(nil)); end

  def charset; end
  def connection(*args, &block); end
  def create; end
  def drop; end
  def establish_connection(*args, &block); end
  def purge; end
  def structure_dump(filename, extra_flags); end
  def structure_load(filename, extra_flags); end

  private

  def db_config; end
  def root; end
  def run_cmd(cmd, args, out); end
  def run_cmd_error(cmd, args); end

  class << self
    def using_database_configurations?; end
  end
end

module ActiveRecord::TestDatabases
  class << self
    def create_and_load_schema(i, env_name:); end
  end
end

module ActiveRecord::TestFixtures
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::TestFixtures::ClassMethods)

  def after_teardown; end
  def before_setup; end
  def enlist_fixture_connections; end
  def run_in_transaction?; end
  def setup_fixtures(config = T.unsafe(nil)); end
  def teardown_fixtures; end

  private

  def instantiate_fixtures; end
  def load_fixtures(config); end
  def load_instances?; end
  def setup_shared_connection_pool; end
end

module ActiveRecord::TestFixtures::ClassMethods
  def fixtures(*fixture_set_names); end
  def set_fixture_class(class_names = T.unsafe(nil)); end
  def setup_fixture_accessors(fixture_set_names = T.unsafe(nil)); end
  def uses_transaction(*methods); end
  def uses_transaction?(method); end
end

class ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection < ::ActiveRecord::ActiveRecordError
  def initialize(owner = T.unsafe(nil), reflection = T.unsafe(nil)); end
end

class ActiveRecord::ThroughNestedAssociationsAreReadonly < ::ActiveRecord::ActiveRecordError
  def initialize(owner = T.unsafe(nil), reflection = T.unsafe(nil)); end
end

module ActiveRecord::Timestamp
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Timestamp::ClassMethods)


  private

  def _create_record; end
  def _update_record; end
  def all_timestamp_attributes_in_model; end
  def clear_timestamp_attributes; end
  def create_or_update(touch: T.unsafe(nil), **_); end
  def current_time_from_proper_timezone; end
  def initialize_dup(other); end
  def max_updated_column_timestamp; end
  def should_record_timestamps?; end
  def timestamp_attributes_for_create_in_model; end
  def timestamp_attributes_for_update_in_model; end
end

module ActiveRecord::Timestamp::ClassMethods
  def all_timestamp_attributes_in_model; end
  def current_time_from_proper_timezone; end
  def timestamp_attributes_for_create_in_model; end
  def timestamp_attributes_for_update_in_model; end
  def touch_attributes_with_time(*names, time: T.unsafe(nil)); end

  private

  def reload_schema_from_cache; end
  def timestamp_attributes_for_create; end
  def timestamp_attributes_for_update; end
end

module ActiveRecord::TouchLater
  def before_committed!; end
  def touch(*names, time: T.unsafe(nil)); end
  def touch_later(*names); end

  private

  def belongs_to_touch_method; end
  def has_defer_touch_attrs?; end
  def surreptitiously_touch(attrs); end
  def touch_deferred_attributes; end
end

class ActiveRecord::TransactionIsolationError < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::TransactionRollbackError < ::ActiveRecord::StatementInvalid
end

module ActiveRecord::Transactions
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::Transactions::ClassMethods)

  def before_committed!; end
  def committed!(should_run_callbacks: T.unsafe(nil)); end
  def destroy; end
  def rolledback!(force_restore_state: T.unsafe(nil), should_run_callbacks: T.unsafe(nil)); end
  def save(**_); end
  def save!(**_); end
  def touch(*_, **_); end
  def transaction(**options, &block); end
  def trigger_transactional_callbacks?; end
  def with_transaction_returning_status; end

  private

  def _committed_already_called; end
  def _trigger_destroy_callback; end
  def _trigger_update_callback; end
  def add_to_transaction; end
  def clear_transaction_record_state; end
  def force_clear_transaction_record_state; end
  def has_transactional_callbacks?; end
  def remember_transaction_record_state; end
  def restore_transaction_record_state(force_restore_state = T.unsafe(nil)); end
  def sync_with_transaction_state; end
  def transaction_include_any_action?(actions); end
end

ActiveRecord::Transactions::ACTIONS = T.let(T.unsafe(nil), Array)

module ActiveRecord::Transactions::ClassMethods
  def after_commit(*args, &block); end
  def after_create_commit(*args, &block); end
  def after_destroy_commit(*args, &block); end
  def after_rollback(*args, &block); end
  def after_save_commit(*args, &block); end
  def after_update_commit(*args, &block); end
  def before_commit(*args, &block); end
  def transaction(**options, &block); end

  private

  def assert_valid_transaction_action(actions); end
  def set_options_for_callbacks!(args, enforced_options = T.unsafe(nil)); end
end

module ActiveRecord::Translation
  include(::ActiveModel::Naming)
  include(::ActiveModel::Translation)

  def i18n_scope; end
  def lookup_ancestors; end
end

module ActiveRecord::Type
  class << self
    def adapter_name_from(model); end
    def add_modifier(*args, &block); end
    def default_value; end
    def lookup(*args, adapter: T.unsafe(nil), **kwargs); end
    def register(type_name, klass = T.unsafe(nil), **options, &block); end
    def registry; end
    def registry=(_); end

    private

    def current_adapter_name; end
  end
end

class ActiveRecord::Type::AdapterSpecificRegistry < ::ActiveModel::Type::Registry
  def add_modifier(options, klass, **args); end

  private

  def find_registration(symbol, *args, **kwargs); end
  def registration_klass; end
end

ActiveRecord::Type::BigInteger = ActiveModel::Type::BigInteger

ActiveRecord::Type::Binary = ActiveModel::Type::Binary

ActiveRecord::Type::Boolean = ActiveModel::Type::Boolean

class ActiveRecord::Type::Date < ::ActiveModel::Type::Date
  include(::ActiveRecord::Type::Internal::Timezone)
end

class ActiveRecord::Type::DateTime < ::ActiveModel::Type::DateTime
  include(::ActiveRecord::Type::Internal::Timezone)
end

ActiveRecord::Type::Decimal = ActiveModel::Type::Decimal

class ActiveRecord::Type::DecimalWithoutScale < ::ActiveModel::Type::BigInteger
  def type; end
  def type_cast_for_schema(value); end
end

class ActiveRecord::Type::DecorationRegistration < ::ActiveRecord::Type::Registration
  def initialize(options, klass, adapter: T.unsafe(nil)); end

  def call(registry, *args, **kwargs); end
  def matches?(*args, **kwargs); end
  def priority; end

  private

  def klass; end
  def matches_options?(**kwargs); end
  def options; end
end

ActiveRecord::Type::Float = ActiveModel::Type::Float

class ActiveRecord::Type::HashLookupTypeMap < ::ActiveRecord::Type::TypeMap
  def alias_type(type, alias_type); end
  def key?(key); end
  def keys; end

  private

  def perform_fetch(type, *args, &block); end
end

ActiveRecord::Type::Integer = ActiveModel::Type::Integer

module ActiveRecord::Type::Internal
end

module ActiveRecord::Type::Internal::Timezone
  def default_timezone; end
  def is_utc?; end
end

class ActiveRecord::Type::Json < ::ActiveModel::Type::Value
  include(::ActiveModel::Type::Helpers::Mutable)

  def accessor; end
  def changed_in_place?(raw_old_value, new_value); end
  def deserialize(value); end
  def serialize(value); end
  def type; end
end

class ActiveRecord::Type::Registration
  def initialize(name, block, adapter: T.unsafe(nil), override: T.unsafe(nil)); end

  def <=>(other); end
  def call(_registry, *args, adapter: T.unsafe(nil), **kwargs); end
  def matches?(type_name, *args, **kwargs); end

  protected

  def adapter; end
  def block; end
  def name; end
  def override; end
  def priority; end
  def priority_except_adapter; end

  private

  def conflicts_with?(other); end
  def has_adapter_conflict?(other); end
  def matches_adapter?(adapter: T.unsafe(nil), **_); end
  def same_priority_except_adapter?(other); end
end

class ActiveRecord::Type::Serialized
  include(::ActiveModel::Type::Helpers::Mutable)

  def initialize(subtype, coder); end

  def accessor; end
  def assert_valid_value(value); end
  def changed_in_place?(raw_old_value, value); end
  def coder; end
  def deserialize(value); end
  def force_equality?(value); end
  def inspect; end
  def serialize(value); end
  def subtype; end

  private

  def default_value?(value); end
  def encoded(value); end
end

ActiveRecord::Type::String = ActiveModel::Type::String

class ActiveRecord::Type::Text < ::ActiveModel::Type::String
  def type; end
end

class ActiveRecord::Type::Time < ::ActiveModel::Type::Time
  include(::ActiveRecord::Type::Internal::Timezone)

  def serialize(value); end
end

class ActiveRecord::Type::Time::Value
end

class ActiveRecord::Type::TypeMap
  def initialize; end

  def alias_type(key, target_key); end
  def clear; end
  def fetch(lookup_key, *args, &block); end
  def lookup(lookup_key, *args); end
  def register_type(key, value = T.unsafe(nil), &block); end

  private

  def perform_fetch(lookup_key, *args); end
end

class ActiveRecord::Type::UnsignedInteger < ::ActiveModel::Type::Integer

  private

  def max_value; end
  def min_value; end
end

ActiveRecord::Type::Value = ActiveModel::Type::Value

module ActiveRecord::TypeCaster
end

class ActiveRecord::TypeCaster::Connection
  def initialize(klass, table_name); end

  def type_cast_for_database(attr_name, value); end
  def type_for_attribute(attr_name); end

  private

  def connection(*args, &block); end
  def table_name; end
end

class ActiveRecord::TypeCaster::Map
  def initialize(types); end

  def type_cast_for_database(attr_name, value); end
  def type_for_attribute(name); end

  private

  def types; end
end

class ActiveRecord::TypeConflictError < ::StandardError
end

ActiveRecord::UnknownAttributeError = ActiveModel::UnknownAttributeError

class ActiveRecord::UnknownAttributeReference < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::UnknownPrimaryKey < ::ActiveRecord::ActiveRecordError
  def initialize(model = T.unsafe(nil), description = T.unsafe(nil)); end

  def model; end
end

module ActiveRecord::VERSION
end

ActiveRecord::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)

ActiveRecord::VERSION::MINOR = T.let(T.unsafe(nil), Integer)

ActiveRecord::VERSION::PRE = T.let(T.unsafe(nil), String)

ActiveRecord::VERSION::STRING = T.let(T.unsafe(nil), String)

ActiveRecord::VERSION::TINY = T.let(T.unsafe(nil), Integer)

module ActiveRecord::Validations
  extend(::ActiveSupport::Concern)

  include(::ActiveSupport::Callbacks)
  include(::ActiveModel::Validations::HelperMethods)
  include(::ActiveModel::Validations)

  mixes_in_class_methods(::ActiveRecord::Validations::ClassMethods)

  def save(**options); end
  def save!(**options); end
  def valid?(context = T.unsafe(nil)); end
  def validate(context = T.unsafe(nil)); end

  private

  def default_validation_context; end
  def perform_validations(options = T.unsafe(nil)); end
  def raise_validation_error; end
end

class ActiveRecord::Validations::AbsenceValidator < ::ActiveModel::Validations::AbsenceValidator
  def validate_each(record, attribute, association_or_value); end
end

class ActiveRecord::Validations::AssociatedValidator < ::ActiveModel::EachValidator
  def validate_each(record, attribute, value); end

  private

  def valid_object?(record); end
end

module ActiveRecord::Validations::ClassMethods
  def validates_absence_of(*attr_names); end
  def validates_associated(*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
  def validates_uniqueness_of(*attr_names); end
end

class ActiveRecord::Validations::LengthValidator < ::ActiveModel::Validations::LengthValidator
  def validate_each(record, attribute, association_or_value); end
end

class ActiveRecord::Validations::NumericalityValidator < ::ActiveModel::Validations::NumericalityValidator
  def validate_each(record, attribute, value, precision: T.unsafe(nil), scale: T.unsafe(nil)); end

  private

  def column_precision_for(record, attribute); end
  def column_scale_for(record, attribute); end
end

class ActiveRecord::Validations::PresenceValidator < ::ActiveModel::Validations::PresenceValidator
  def validate_each(record, attribute, association_or_value); end
end

class ActiveRecord::Validations::UniquenessValidator < ::ActiveModel::EachValidator
  def initialize(options); end

  def validate_each(record, attribute, value); end

  private

  def build_relation(klass, attribute, value); end
  def find_finder_class_for(record); end
  def map_enum_attribute(klass, attribute, value); end
  def scope_relation(record, relation); end
end

class ActiveRecord::ValueTooLong < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::WrappedDatabaseException < ::ActiveRecord::StatementInvalid
end

class ActiveRecord::Associations::JoinDependency::JoinPart
  include(::Enumerable)

  def initialize(base_klass, children); end

  def base_klass; end
  def children; end
  def column_names(*args, &block); end
  def each(&block); end
  def each_children(&block); end
  def extract_record(row, column_names_with_alias); end
  def instantiate(row, aliases, &block); end
  def match?(other); end
  def primary_key(*args, &block); end
  def table; end
  def table_name(*args, &block); end
end

class ActiveRecord::ConcurrentMigrationError < ::ActiveRecord::MigrationError
  def initialize(message = T.unsafe(nil)); end
end

ActiveRecord::ConcurrentMigrationError::DEFAULT_MESSAGE = T.let(T.unsafe(nil), String)

ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE = T.let(T.unsafe(nil), String)

class ActiveRecord::ConnectionAdapters::AddColumnDefinition < ::Struct
  def column; end
  def column=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

module ActiveRecord::ConnectionAdapters::ColumnMethods
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods)

  def primary_key(name, type = T.unsafe(nil), **options); end
end

module ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods

  private

  def define_column_methods(*column_types); end
end

module ActiveRecord::ConnectionAdapters::Deduplicable
  extend(::ActiveSupport::Concern)

  mixes_in_class_methods(::ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods)

  def -@; end
  def deduplicate; end

  private

  def deduplicated; end
end

module ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods
  def new(*_, **_); end
  def registry; end
end

class ActiveRecord::ConnectionAdapters::NullColumn < ::ActiveRecord::ConnectionAdapters::Column
  def initialize(name, **_); end
end

class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < ::Struct
  def name; end
  def name=(_); end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::ConnectionAdapters::SchemaCache
  def initialize(conn); end

  def add(table_name); end
  def clear!; end
  def clear_data_source_cache!(name); end
  def columns(table_name); end
  def columns_hash(table_name); end
  def columns_hash?(table_name); end
  def connection; end
  def connection=(_); end
  def data_source_exists?(name); end
  def data_sources(name); end
  def database_version; end
  def dump_to(filename); end
  def encode_with(coder); end
  def indexes(table_name); end
  def init_with(coder); end
  def marshal_dump; end
  def marshal_load(array); end
  def primary_keys(table_name); end
  def size; end
  def version; end

  private

  def deep_deduplicate(value); end
  def derive_columns_hash_and_deduplicate_values; end
  def initialize_dup(other); end
  def open(filename); end
  def prepare_data_sources; end
  def reset_version!; end

  class << self
    def load_from(filename); end

    private

    def read(filename, &block); end
  end
end

class ActiveRecord::ConnectionAdapters::SchemaCreation
  def initialize(conn); end

  def accept(o); end

  private

  def action_sql(action, dependency); end
  def add_column_options!(sql, options); end
  def add_table_options!(create_sql, options); end
  def column_options(o); end
  def foreign_key_in_create(from_table, to_table, options); end
  def foreign_key_options(*args, &block); end
  def options_include_default?(*args, &block); end
  def quote_column_name(*args, &block); end
  def quote_default_expression(*args, &block); end
  def quote_table_name(*args, &block); end
  def supports_foreign_keys?(*args, &block); end
  def supports_indexes_in_create?(*args, &block); end
  def table_modifier_in_create(o); end
  def table_options(o); end
  def to_sql(sql); end
  def type_to_sql(*args, &block); end
  def visit_AddColumnDefinition(o); end
  def visit_AddForeignKey(o); end
  def visit_AlterTable(o); end
  def visit_ColumnDefinition(o); end
  def visit_DropForeignKey(name); end
  def visit_ForeignKeyDefinition(o); end
  def visit_PrimaryKeyDefinition(o); end
  def visit_TableDefinition(o); end
end

class ActiveRecord::ConnectionAdapters::SchemaDumper < ::ActiveRecord::SchemaDumper

  private

  def column_spec(column); end
  def column_spec_for_primary_key(column); end
  def default_primary_key?(column); end
  def explicit_primary_key_default?(column); end
  def prepare_column_options(column); end
  def schema_collation(column); end
  def schema_default(column); end
  def schema_expression(column); end
  def schema_limit(column); end
  def schema_precision(column); end
  def schema_scale(column); end
  def schema_type(column); end
  def schema_type_with_virtual(column); end

  class << self
    def create(connection, options); end
  end
end

class ActiveRecord::ConnectionAdapters::SqlTypeMetadata
  include(::ActiveRecord::ConnectionAdapters::Deduplicable)
  extend(::ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods)

  def initialize(sql_type: T.unsafe(nil), type: T.unsafe(nil), limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil)); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def limit; end
  def precision; end
  def scale; end
  def sql_type; end
  def type; end

  private

  def deduplicated; end
end

class ActiveRecord::ConnectionAdapters::Transaction
  def initialize(connection, isolation: T.unsafe(nil), joinable: T.unsafe(nil), run_commit_callbacks: T.unsafe(nil)); end

  def add_record(record); end
  def before_commit_records; end
  def closed?; end
  def commit_records; end
  def connection; end
  def full_rollback?; end
  def isolation_level; end
  def joinable?; end
  def materialize!; end
  def materialized?; end
  def open?; end
  def records; end
  def rollback_records; end
  def savepoint_name; end
  def state; end
end

class ActiveRecord::DuplicateMigrationNameError < ::ActiveRecord::MigrationError
  def initialize(name = T.unsafe(nil)); end
end

class ActiveRecord::DuplicateMigrationVersionError < ::ActiveRecord::MigrationError
  def initialize(version = T.unsafe(nil)); end
end

class ActiveRecord::EnvironmentMismatchError < ::ActiveRecord::ActiveRecordError
  def initialize(current: T.unsafe(nil), stored: T.unsafe(nil)); end
end

class ActiveRecord::EnvironmentStorageError < ::ActiveRecord::ActiveRecordError
  def initialize; end
end

class ActiveRecord::Fixture
  include(::Enumerable)

  def initialize(fixture, model_class); end

  def [](key); end
  def class_name; end
  def each; end
  def find; end
  def fixture; end
  def model_class; end
  def to_hash; end
end

class ActiveRecord::Fixture::FixtureError < ::StandardError
end

class ActiveRecord::Fixture::FormatError < ::ActiveRecord::Fixture::FixtureError
end

class ActiveRecord::FixtureClassNotFound < ::ActiveRecord::ActiveRecordError
end

class ActiveRecord::FixtureSet
  def initialize(_, name, class_name, path, config = T.unsafe(nil)); end

  def [](x); end
  def []=(k, v); end
  def all_loaded_fixtures; end
  def all_loaded_fixtures=(val); end
  def config; end
  def each(&block); end
  def fixtures; end
  def ignored_fixtures; end
  def model_class; end
  def name; end
  def size; end
  def table_name; end
  def table_rows; end

  private

  def ignored_fixtures=(base); end
  def model_class=(class_name); end
  def read_fixture_files(path); end
  def yaml_file_path(path); end

  class << self
    def all_loaded_fixtures; end
    def all_loaded_fixtures=(val); end
    def cache_fixtures(connection, fixtures_map); end
    def cache_for_connection(connection); end
    def cached_fixtures(connection, keys_to_fetch = T.unsafe(nil)); end
    def context_class; end
    def create_fixtures(fixtures_directory, fixture_set_names, class_names = T.unsafe(nil), config = T.unsafe(nil), &block); end
    def default_fixture_model_name(fixture_set_name, config = T.unsafe(nil)); end
    def default_fixture_table_name(fixture_set_name, config = T.unsafe(nil)); end
    def fixture_is_cached?(connection, table_name); end
    def identify(label, column_type = T.unsafe(nil)); end
    def instantiate_all_loaded_fixtures(object, load_instances = T.unsafe(nil)); end
    def instantiate_fixtures(object, fixture_set, load_instances = T.unsafe(nil)); end
    def reset_cache; end

    private

    def insert(fixture_sets, connection); end
    def read_and_insert(fixtures_directory, fixture_files, class_names, connection); end
    def update_all_loaded_fixtures(fixtures_map); end
  end
end

class ActiveRecord::FixtureSet::ClassCache
  def initialize(class_names, config); end

  def [](fs_name); end

  private

  def default_fixture_model(fs_name, config); end
  def insert_class(class_names, name, klass); end
end

class ActiveRecord::FixtureSet::File
  include(::Enumerable)

  def initialize(file); end

  def each(&block); end
  def ignored_fixtures; end
  def model_class; end

  private

  def config_row; end
  def raw_rows; end
  def rows; end
  def validate(data); end

  class << self
    def open(file); end
  end
end

ActiveRecord::FixtureSet::MAX_ID = T.let(T.unsafe(nil), Integer)

class ActiveRecord::FixtureSet::ModelMetadata
  def initialize(model_class); end

  def has_primary_key_column?; end
  def inheritance_column_name; end
  def primary_key_name; end
  def primary_key_type; end
  def timestamp_column_names; end
end

class ActiveRecord::FixtureSet::RenderContext
  class << self
    def create_subclass; end
  end
end

class ActiveRecord::FixtureSet::TableRow
  def initialize(fixture, table_rows:, label:, now:); end

  def to_hash; end

  private

  def add_join_records(association); end
  def fill_row_model_attributes; end
  def fill_timestamps; end
  def generate_primary_key; end
  def interpolate_label; end
  def model_class; end
  def model_metadata; end
  def reflection_class; end
  def resolve_enums; end
  def resolve_sti_reflections; end
end

class ActiveRecord::FixtureSet::TableRow::HasManyThroughProxy < ::ActiveRecord::FixtureSet::TableRow::ReflectionProxy
  def join_table; end
  def lhs_key; end
  def rhs_key; end
end

class ActiveRecord::FixtureSet::TableRow::ReflectionProxy
  def initialize(association); end

  def join_table; end
  def name; end
  def primary_key_type; end
end

class ActiveRecord::FixtureSet::TableRows
  def initialize(table_name, model_class:, fixtures:, config:); end

  def model_class; end
  def model_metadata; end
  def tables; end
  def to_hash; end

  private

  def build_table_rows_from(table_name, fixtures, config); end
end

class ActiveRecord::IllegalMigrationNameError < ::ActiveRecord::MigrationError
  def initialize(name = T.unsafe(nil)); end
end

class ActiveRecord::IrreversibleMigration < ::ActiveRecord::MigrationError
end

class ActiveRecord::MigrationContext
  def initialize(migrations_paths, schema_migration); end

  def any_migrations?; end
  def current_environment; end
  def current_version; end
  def down(target_version = T.unsafe(nil)); end
  def forward(steps = T.unsafe(nil)); end
  def get_all_versions; end
  def last_stored_environment; end
  def migrate(target_version = T.unsafe(nil), &block); end
  def migrations; end
  def migrations_paths; end
  def migrations_status; end
  def needs_migration?; end
  def open; end
  def protected_environment?; end
  def rollback(steps = T.unsafe(nil)); end
  def run(direction, target_version); end
  def schema_migration; end
  def up(target_version = T.unsafe(nil)); end

  private

  def migration_files; end
  def move(direction, steps); end
  def parse_migration_filename(filename); end
end

class ActiveRecord::MigrationError < ::ActiveRecord::ActiveRecordError
  def initialize(message = T.unsafe(nil)); end
end

class ActiveRecord::MigrationProxy < ::Struct
  def initialize(name, version, filename, scope); end

  def announce(*args, &block); end
  def basename; end
  def disable_ddl_transaction(*args, &block); end
  def filename; end
  def filename=(_); end
  def migrate(*args, &block); end
  def name; end
  def name=(_); end
  def scope; end
  def scope=(_); end
  def version; end
  def version=(_); end
  def write(*args, &block); end

  private

  def load_migration; end
  def migration; end

  class << self
    def [](*_); end
    def inspect; end
    def members; end
    def new(*_); end
  end
end

class ActiveRecord::NoEnvironmentInSchemaError < ::ActiveRecord::MigrationError
  def initialize; end
end

class ActiveRecord::PendingMigrationError < ::ActiveRecord::MigrationError
  include(::ActiveSupport::ActionableError)
  extend(::ActiveSupport::ActionableError::ClassMethods)

  def initialize(message = T.unsafe(nil)); end

  def _actions; end
  def _actions=(_); end
  def _actions?; end

  class << self
    def _actions; end
    def _actions=(value); end
    def _actions?; end
  end
end

class ActiveRecord::ProtectedEnvironmentError < ::ActiveRecord::ActiveRecordError
  def initialize(env = T.unsafe(nil)); end
end

class ActiveRecord::Tasks::DatabaseNotSupported < ::StandardError
end

class ActiveRecord::UnknownMigrationVersionError < ::ActiveRecord::MigrationError
  def initialize(version = T.unsafe(nil)); end
end

module Arel
  class << self
    def arel_node?(value); end
    def fetch_attribute(value, &block); end
    def sql(raw_sql); end
    def star; end
  end
end

module Arel::AliasPredication
  def as(other); end
end

class Arel::ArelError < ::StandardError
end

Arel::Attribute = Arel::Attributes::Attribute

module Arel::Attributes
end

class Arel::Attributes::Attribute < ::Struct
  include(::Arel::Expressions)
  include(::Arel::Predications)
  include(::Arel::AliasPredication)
  include(::Arel::OrderPredications)
  include(::Arel::Math)

  def able_to_type_cast?; end
  def lower; end
  def type_cast_for_database(value); end
  def type_caster; end
end

class Arel::Attributes::Boolean < ::Arel::Attributes::Attribute
end

class Arel::Attributes::Decimal < ::Arel::Attributes::Attribute
end

class Arel::Attributes::Float < ::Arel::Attributes::Attribute
end

class Arel::Attributes::Integer < ::Arel::Attributes::Attribute
end

class Arel::Attributes::String < ::Arel::Attributes::Attribute
end

class Arel::Attributes::Time < ::Arel::Attributes::Attribute
end

class Arel::Attributes::Undefined < ::Arel::Attributes::Attribute
end

module Arel::Collectors
end

class Arel::Collectors::Bind
  def initialize; end

  def <<(str); end
  def add_bind(bind); end
  def value; end
end

class Arel::Collectors::Composite
  def initialize(left, right); end

  def <<(str); end
  def add_bind(bind, &block); end
  def preparable; end
  def preparable=(_); end
  def value; end

  private

  def left; end
  def right; end
end

class Arel::Collectors::PlainString
  def initialize; end

  def <<(str); end
  def value; end
end

class Arel::Collectors::SQLString < ::Arel::Collectors::PlainString
  def initialize(*_); end

  def add_bind(bind); end
  def preparable; end
  def preparable=(_); end
end

class Arel::Collectors::SubstituteBinds
  def initialize(quoter, delegate_collector); end

  def <<(str); end
  def add_bind(bind); end
  def preparable; end
  def preparable=(_); end
  def value; end

  private

  def delegate; end
  def quoter; end
end

module Arel::Crud
  def compile_delete; end
  def compile_insert(values); end
  def compile_update(values, pk); end
  def create_insert; end
end

class Arel::DeleteManager < ::Arel::TreeManager
  include(::Arel::TreeManager::StatementMethods)

  def initialize; end

  def from(relation); end
end

class Arel::EmptyJoinError < ::Arel::ArelError
end

module Arel::Expressions
  def average; end
  def count(distinct = T.unsafe(nil)); end
  def extract(field); end
  def maximum; end
  def minimum; end
  def sum; end
end

module Arel::FactoryMethods
  def coalesce(*exprs); end
  def create_and(clauses); end
  def create_false; end
  def create_join(to, constraint = T.unsafe(nil), klass = T.unsafe(nil)); end
  def create_on(expr); end
  def create_string_join(to); end
  def create_table_alias(relation, name); end
  def create_true; end
  def grouping(expr); end
  def lower(column); end
end

class Arel::InsertManager < ::Arel::TreeManager
  def initialize; end

  def columns; end
  def create_values(values); end
  def create_values_list(rows); end
  def insert(fields); end
  def into(table); end
  def select(select); end
  def values=(val); end
end

module Arel::Math
  def &(other); end
  def *(other); end
  def +(other); end
  def -(other); end
  def /(other); end
  def <<(other); end
  def >>(other); end
  def ^(other); end
  def |(other); end
  def ~; end
end

module Arel::Nodes
  class << self
    def build_quoted(other, attribute = T.unsafe(nil)); end
  end
end

class Arel::Nodes::Addition < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::And < ::Arel::Nodes::NodeExpression
  def initialize(children); end

  def ==(other); end
  def children; end
  def eql?(other); end
  def hash; end
  def left; end
  def right; end
end

class Arel::Nodes::As < ::Arel::Nodes::Binary
end

class Arel::Nodes::Ascending < ::Arel::Nodes::Ordering
  def ascending?; end
  def descending?; end
  def direction; end
  def reverse; end
end

class Arel::Nodes::Assignment < ::Arel::Nodes::Binary
end

class Arel::Nodes::Avg < ::Arel::Nodes::Function
end

class Arel::Nodes::Between < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::Bin < ::Arel::Nodes::Unary
end

class Arel::Nodes::Binary < ::Arel::Nodes::NodeExpression
  def initialize(left, right); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def left; end
  def left=(_); end
  def right; end
  def right=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::BindParam < ::Arel::Nodes::Node
  def initialize(value); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def infinite?; end
  def nil?; end
  def unboundable?; end
  def value; end
  def value_before_type_cast; end
end

class Arel::Nodes::BitwiseAnd < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::BitwiseNot < ::Arel::Nodes::UnaryOperation
  def initialize(operand); end
end

class Arel::Nodes::BitwiseOr < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::BitwiseShiftLeft < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::BitwiseShiftRight < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::BitwiseXor < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::Case < ::Arel::Nodes::NodeExpression
  def initialize(expression = T.unsafe(nil), default = T.unsafe(nil)); end

  def ==(other); end
  def case; end
  def case=(_); end
  def conditions; end
  def conditions=(_); end
  def default; end
  def default=(_); end
  def else(expression); end
  def eql?(other); end
  def hash; end
  def then(expression); end
  def when(condition, expression = T.unsafe(nil)); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::Casted < ::Arel::Nodes::NodeExpression
  def initialize(value, attribute); end

  def ==(other); end
  def attribute; end
  def eql?(other); end
  def hash; end
  def nil?; end
  def value; end
  def value_before_type_cast; end
  def value_for_database; end
end

class Arel::Nodes::Comment < ::Arel::Nodes::Node
  def initialize(values); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def values; end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::Concat < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::Count < ::Arel::Nodes::Function
  def initialize(expr, distinct = T.unsafe(nil), aliaz = T.unsafe(nil)); end
end

class Arel::Nodes::Cube < ::Arel::Nodes::Unary
end

class Arel::Nodes::CurrentRow < ::Arel::Nodes::Node
  def ==(other); end
  def eql?(other); end
  def hash; end
end

class Arel::Nodes::DeleteStatement < ::Arel::Nodes::Node
  def initialize(relation = T.unsafe(nil), wheres = T.unsafe(nil)); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def key; end
  def key=(_); end
  def left; end
  def left=(_); end
  def limit; end
  def limit=(_); end
  def offset; end
  def offset=(_); end
  def orders; end
  def orders=(_); end
  def relation; end
  def relation=(_); end
  def right; end
  def right=(_); end
  def wheres; end
  def wheres=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::Descending < ::Arel::Nodes::Ordering
  def ascending?; end
  def descending?; end
  def direction; end
  def reverse; end
end

class Arel::Nodes::Distinct < ::Arel::Nodes::NodeExpression
  def ==(other); end
  def eql?(other); end
  def hash; end
end

class Arel::Nodes::DistinctOn < ::Arel::Nodes::Unary
end

class Arel::Nodes::Division < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::DoesNotMatch < ::Arel::Nodes::Matches
end

class Arel::Nodes::Else < ::Arel::Nodes::Unary
end

class Arel::Nodes::Equality < ::Arel::Nodes::Binary
  def equality?; end
  def fetch_attribute; end
  def invert; end
  def operator; end
end

class Arel::Nodes::Except < ::Arel::Nodes::Binary
end

class Arel::Nodes::Exists < ::Arel::Nodes::Function
end

class Arel::Nodes::Extract < ::Arel::Nodes::Unary
  def initialize(expr, field); end

  def ==(other); end
  def eql?(other); end
  def field; end
  def field=(_); end
  def hash; end
end

class Arel::Nodes::False < ::Arel::Nodes::NodeExpression
  def ==(other); end
  def eql?(other); end
  def hash; end
end

module Arel::Nodes::FetchAttribute
  def fetch_attribute; end
end

class Arel::Nodes::Following < ::Arel::Nodes::Unary
  def initialize(expr = T.unsafe(nil)); end
end

class Arel::Nodes::FullOuterJoin < ::Arel::Nodes::Join
end

class Arel::Nodes::Function < ::Arel::Nodes::NodeExpression
  include(::Arel::WindowPredications)

  def initialize(expr, aliaz = T.unsafe(nil)); end

  def ==(other); end
  def alias; end
  def alias=(_); end
  def as(aliaz); end
  def distinct; end
  def distinct=(_); end
  def eql?(other); end
  def expressions; end
  def expressions=(_); end
  def hash; end
end

class Arel::Nodes::GreaterThan < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::GreaterThanOrEqual < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::Group < ::Arel::Nodes::Unary
end

class Arel::Nodes::Grouping < ::Arel::Nodes::Unary
  def fetch_attribute(&block); end
end

class Arel::Nodes::GroupingElement < ::Arel::Nodes::Unary
end

class Arel::Nodes::GroupingSet < ::Arel::Nodes::Unary
end

class Arel::Nodes::HomogeneousIn < ::Arel::Nodes::Node
  def initialize(values, attribute, type); end

  def ==(other); end
  def attribute; end
  def casted_values; end
  def column_name; end
  def eql?(other); end
  def equality?; end
  def fetch_attribute(&block); end
  def hash; end
  def invert; end
  def left; end
  def table_name; end
  def type; end
  def values; end

  protected

  def ivars; end
end

class Arel::Nodes::In < ::Arel::Nodes::Equality
  def invert; end
end

class Arel::Nodes::InfixOperation < ::Arel::Nodes::Binary
  def initialize(operator, left, right); end

  def operator; end
end

class Arel::Nodes::InnerJoin < ::Arel::Nodes::Join
end

class Arel::Nodes::InsertStatement < ::Arel::Nodes::Node
  def initialize; end

  def ==(other); end
  def columns; end
  def columns=(_); end
  def eql?(other); end
  def hash; end
  def relation; end
  def relation=(_); end
  def select; end
  def select=(_); end
  def values; end
  def values=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::Intersect < ::Arel::Nodes::Binary
end

class Arel::Nodes::IsDistinctFrom < ::Arel::Nodes::Equality
  def invert; end
end

class Arel::Nodes::IsNotDistinctFrom < ::Arel::Nodes::Equality
  def invert; end
end

class Arel::Nodes::Join < ::Arel::Nodes::Binary
end

class Arel::Nodes::JoinSource < ::Arel::Nodes::Binary
  def initialize(single_source, joinop = T.unsafe(nil)); end

  def empty?; end
end

class Arel::Nodes::Lateral < ::Arel::Nodes::Unary
end

class Arel::Nodes::LessThan < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::LessThanOrEqual < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::Limit < ::Arel::Nodes::Unary
end

class Arel::Nodes::Lock < ::Arel::Nodes::Unary
end

class Arel::Nodes::Matches < ::Arel::Nodes::Binary
  def initialize(left, right, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end

  def case_sensitive; end
  def case_sensitive=(_); end
  def escape; end
end

class Arel::Nodes::Max < ::Arel::Nodes::Function
end

class Arel::Nodes::Min < ::Arel::Nodes::Function
end

class Arel::Nodes::Multiplication < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::NamedFunction < ::Arel::Nodes::Function
  def initialize(name, expr, aliaz = T.unsafe(nil)); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def name; end
  def name=(_); end
end

class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
  def initialize(name); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def name; end
  def name=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::Node
  include(::Arel::FactoryMethods)

  def and(right); end
  def equality?; end
  def fetch_attribute; end
  def invert; end
  def not; end
  def or(right); end
  def to_sql(engine = T.unsafe(nil)); end
end

class Arel::Nodes::NodeExpression < ::Arel::Nodes::Node
  include(::Arel::Expressions)
  include(::Arel::Predications)
  include(::Arel::AliasPredication)
  include(::Arel::OrderPredications)
  include(::Arel::Math)
end

class Arel::Nodes::Not < ::Arel::Nodes::Unary
end

class Arel::Nodes::NotEqual < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::NotIn < ::Arel::Nodes::Binary
  include(::Arel::Nodes::FetchAttribute)
end

class Arel::Nodes::NotRegexp < ::Arel::Nodes::Regexp
end

class Arel::Nodes::NullsFirst < ::Arel::Nodes::Ordering
end

class Arel::Nodes::NullsLast < ::Arel::Nodes::Ordering
end

class Arel::Nodes::Offset < ::Arel::Nodes::Unary
end

class Arel::Nodes::On < ::Arel::Nodes::Unary
end

class Arel::Nodes::OptimizerHints < ::Arel::Nodes::Unary
end

class Arel::Nodes::Or < ::Arel::Nodes::Binary
  def fetch_attribute(&block); end
end

class Arel::Nodes::Ordering < ::Arel::Nodes::Unary
  def nulls_first; end
  def nulls_last; end
end

class Arel::Nodes::OuterJoin < ::Arel::Nodes::Join
end

class Arel::Nodes::Over < ::Arel::Nodes::Binary
  def initialize(left, right = T.unsafe(nil)); end

  def operator; end
end

class Arel::Nodes::Preceding < ::Arel::Nodes::Unary
  def initialize(expr = T.unsafe(nil)); end
end

class Arel::Nodes::Quoted < ::Arel::Nodes::Unary
  def infinite?; end
  def nil?; end
  def value_before_type_cast; end
  def value_for_database; end
end

class Arel::Nodes::Range < ::Arel::Nodes::Unary
  def initialize(expr = T.unsafe(nil)); end
end

class Arel::Nodes::Regexp < ::Arel::Nodes::Binary
  def initialize(left, right, case_sensitive = T.unsafe(nil)); end

  def case_sensitive; end
  def case_sensitive=(_); end
end

class Arel::Nodes::RightOuterJoin < ::Arel::Nodes::Join
end

class Arel::Nodes::RollUp < ::Arel::Nodes::Unary
end

class Arel::Nodes::Rows < ::Arel::Nodes::Unary
  def initialize(expr = T.unsafe(nil)); end
end

class Arel::Nodes::SelectCore < ::Arel::Nodes::Node
  def initialize; end

  def ==(other); end
  def comment; end
  def comment=(_); end
  def eql?(other); end
  def from; end
  def from=(value); end
  def froms; end
  def froms=(value); end
  def groups; end
  def groups=(_); end
  def hash; end
  def havings; end
  def havings=(_); end
  def optimizer_hints; end
  def optimizer_hints=(_); end
  def projections; end
  def projections=(_); end
  def set_quantifier; end
  def set_quantifier=(_); end
  def source; end
  def source=(_); end
  def wheres; end
  def wheres=(_); end
  def windows; end
  def windows=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::SelectStatement < ::Arel::Nodes::NodeExpression
  def initialize(cores = T.unsafe(nil)); end

  def ==(other); end
  def cores; end
  def eql?(other); end
  def hash; end
  def limit; end
  def limit=(_); end
  def lock; end
  def lock=(_); end
  def offset; end
  def offset=(_); end
  def orders; end
  def orders=(_); end
  def with; end
  def with=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::SqlLiteral < ::String
  include(::Arel::Expressions)
  include(::Arel::Predications)
  include(::Arel::AliasPredication)
  include(::Arel::OrderPredications)

  def encode_with(coder); end
  def fetch_attribute; end
end

class Arel::Nodes::StringJoin < ::Arel::Nodes::Join
  def initialize(left, right = T.unsafe(nil)); end
end

class Arel::Nodes::Subtraction < ::Arel::Nodes::InfixOperation
  def initialize(left, right); end
end

class Arel::Nodes::Sum < ::Arel::Nodes::Function
end

class Arel::Nodes::TableAlias < ::Arel::Nodes::Binary
  def [](name); end
  def able_to_type_cast?; end
  def name; end
  def relation; end
  def table_alias; end
  def table_name; end
  def type_cast_for_database(*args); end
  def type_for_attribute(name); end
end

class Arel::Nodes::True < ::Arel::Nodes::NodeExpression
  def ==(other); end
  def eql?(other); end
  def hash; end
end

class Arel::Nodes::Unary < ::Arel::Nodes::NodeExpression
  def initialize(expr); end

  def ==(other); end
  def eql?(other); end
  def expr; end
  def expr=(_); end
  def hash; end
  def value; end
end

class Arel::Nodes::UnaryOperation < ::Arel::Nodes::Unary
  def initialize(operator, operand); end

  def operator; end
end

class Arel::Nodes::Union < ::Arel::Nodes::Binary
end

class Arel::Nodes::UnionAll < ::Arel::Nodes::Binary
end

class Arel::Nodes::UnqualifiedColumn < ::Arel::Nodes::Unary
  def attribute; end
  def attribute=(_); end
  def column; end
  def name; end
  def relation; end
end

class Arel::Nodes::UpdateStatement < ::Arel::Nodes::Node
  def initialize; end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def key; end
  def key=(_); end
  def limit; end
  def limit=(_); end
  def offset; end
  def offset=(_); end
  def orders; end
  def orders=(_); end
  def relation; end
  def relation=(_); end
  def values; end
  def values=(_); end
  def wheres; end
  def wheres=(_); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::ValuesList < ::Arel::Nodes::Unary
  def rows; end
end

class Arel::Nodes::When < ::Arel::Nodes::Binary
end

class Arel::Nodes::Window < ::Arel::Nodes::Node
  def initialize; end

  def ==(other); end
  def eql?(other); end
  def frame(expr); end
  def framing; end
  def framing=(_); end
  def hash; end
  def order(*expr); end
  def orders; end
  def orders=(_); end
  def partition(*expr); end
  def partitions; end
  def partitions=(_); end
  def range(expr = T.unsafe(nil)); end
  def rows(expr = T.unsafe(nil)); end

  private

  def initialize_copy(other); end
end

class Arel::Nodes::With < ::Arel::Nodes::Unary
  def children; end
end

class Arel::Nodes::WithRecursive < ::Arel::Nodes::With
end

module Arel::OrderPredications
  def asc; end
  def desc; end
end

module Arel::Predications
  def between(other); end
  def concat(other); end
  def does_not_match(other, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
  def does_not_match_all(others, escape = T.unsafe(nil)); end
  def does_not_match_any(others, escape = T.unsafe(nil)); end
  def does_not_match_regexp(other, case_sensitive = T.unsafe(nil)); end
  def eq(other); end
  def eq_all(others); end
  def eq_any(others); end
  def gt(right); end
  def gt_all(others); end
  def gt_any(others); end
  def gteq(right); end
  def gteq_all(others); end
  def gteq_any(others); end
  def in(other); end
  def in_all(others); end
  def in_any(others); end
  def is_distinct_from(other); end
  def is_not_distinct_from(other); end
  def lt(right); end
  def lt_all(others); end
  def lt_any(others); end
  def lteq(right); end
  def lteq_all(others); end
  def lteq_any(others); end
  def matches(other, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
  def matches_all(others, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
  def matches_any(others, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
  def matches_regexp(other, case_sensitive = T.unsafe(nil)); end
  def not_between(other); end
  def not_eq(other); end
  def not_eq_all(others); end
  def not_eq_any(others); end
  def not_in(other); end
  def not_in_all(others); end
  def not_in_any(others); end
  def when(right); end

  private

  def grouping_all(method_id, others, *extras); end
  def grouping_any(method_id, others, *extras); end
  def infinity?(value); end
  def open_ended?(value); end
  def quoted_array(others); end
  def quoted_node(other); end
  def unboundable?(value); end
end

class Arel::SelectManager < ::Arel::TreeManager
  include(::Arel::Crud)

  def initialize(table = T.unsafe(nil)); end

  def as(other); end
  def comment(*values); end
  def constraints; end
  def distinct(value = T.unsafe(nil)); end
  def distinct_on(value); end
  def except(other); end
  def exists; end
  def from(table); end
  def froms; end
  def group(*columns); end
  def having(expr); end
  def intersect(other); end
  def join(relation, klass = T.unsafe(nil)); end
  def join_sources; end
  def lateral(table_name = T.unsafe(nil)); end
  def limit; end
  def limit=(limit); end
  def lock(locking = T.unsafe(nil)); end
  def locked; end
  def minus(other); end
  def offset; end
  def offset=(amount); end
  def on(*exprs); end
  def optimizer_hints(*hints); end
  def order(*expr); end
  def orders; end
  def outer_join(relation); end
  def project(*projections); end
  def projections; end
  def projections=(projections); end
  def skip(amount); end
  def source; end
  def take(limit); end
  def taken; end
  def union(operation, other = T.unsafe(nil)); end
  def where_sql(engine = T.unsafe(nil)); end
  def window(name); end
  def with(*subqueries); end

  private

  def collapse(exprs); end
  def initialize_copy(other); end
end

Arel::SelectManager::STRING_OR_SYMBOL_CLASS = T.let(T.unsafe(nil), Array)

class Arel::Table
  include(::Arel::Crud)
  include(::Arel::FactoryMethods)

  def initialize(name, as: T.unsafe(nil), type_caster: T.unsafe(nil)); end

  def ==(other); end
  def [](name); end
  def able_to_type_cast?; end
  def alias(name = T.unsafe(nil)); end
  def eql?(other); end
  def from; end
  def group(*columns); end
  def hash; end
  def having(expr); end
  def join(relation, klass = T.unsafe(nil)); end
  def name; end
  def name=(_); end
  def order(*expr); end
  def outer_join(relation); end
  def project(*things); end
  def skip(amount); end
  def table_alias; end
  def table_alias=(_); end
  def table_name; end
  def take(amount); end
  def type_cast_for_database(attribute_name, value); end
  def type_for_attribute(name); end
  def where(condition); end

  private

  def type_caster; end

  class << self
    def engine; end
    def engine=(_); end
  end
end

class Arel::TreeManager
  include(::Arel::FactoryMethods)

  def initialize; end

  def ast; end
  def to_dot; end
  def to_sql(engine = T.unsafe(nil)); end
  def where(expr); end

  private

  def initialize_copy(other); end
end

module Arel::TreeManager::StatementMethods
  def key; end
  def key=(key); end
  def offset(offset); end
  def order(*expr); end
  def take(limit); end
  def where(expr); end
  def wheres=(exprs); end
end

class Arel::UpdateManager < ::Arel::TreeManager
  include(::Arel::TreeManager::StatementMethods)

  def initialize; end

  def set(values); end
  def table(table); end
end

Arel::VERSION = T.let(T.unsafe(nil), String)

module Arel::Visitors
end

class Arel::Visitors::Dot < ::Arel::Visitors::Visitor
  def initialize; end

  def accept(object, collector); end

  private

  def binary(o); end
  def edge(name); end
  def extract(o); end
  def function(o); end
  def named_window(o); end
  def nary(o); end
  def quote(string); end
  def to_dot; end
  def unary(o); end
  def visit(o); end
  def visit_ActiveModel_Attribute(o); end
  def visit_Arel_Attribute(o); end
  def visit_Arel_Attributes_Attribute(o); end
  def visit_Arel_Attributes_Boolean(o); end
  def visit_Arel_Attributes_Float(o); end
  def visit_Arel_Attributes_Integer(o); end
  def visit_Arel_Attributes_String(o); end
  def visit_Arel_Attributes_Time(o); end
  def visit_Arel_Nodes_And(o); end
  def visit_Arel_Nodes_As(o); end
  def visit_Arel_Nodes_Assignment(o); end
  def visit_Arel_Nodes_Avg(o); end
  def visit_Arel_Nodes_Between(o); end
  def visit_Arel_Nodes_BindParam(o); end
  def visit_Arel_Nodes_Casted(o); end
  def visit_Arel_Nodes_Comment(o); end
  def visit_Arel_Nodes_Concat(o); end
  def visit_Arel_Nodes_Count(o); end
  def visit_Arel_Nodes_Cube(o); end
  def visit_Arel_Nodes_DeleteStatement(o); end
  def visit_Arel_Nodes_DoesNotMatch(o); end
  def visit_Arel_Nodes_Equality(o); end
  def visit_Arel_Nodes_Exists(o); end
  def visit_Arel_Nodes_Extract(o); end
  def visit_Arel_Nodes_Following(o); end
  def visit_Arel_Nodes_FullOuterJoin(o); end
  def visit_Arel_Nodes_GreaterThan(o); end
  def visit_Arel_Nodes_GreaterThanOrEqual(o); end
  def visit_Arel_Nodes_Group(o); end
  def visit_Arel_Nodes_Grouping(o); end
  def visit_Arel_Nodes_GroupingElement(o); end
  def visit_Arel_Nodes_GroupingSet(o); end
  def visit_Arel_Nodes_Having(o); end
  def visit_Arel_Nodes_HomogeneousIn(o); end
  def visit_Arel_Nodes_In(o); end
  def visit_Arel_Nodes_InnerJoin(o); end
  def visit_Arel_Nodes_InsertStatement(o); end
  def visit_Arel_Nodes_IsDistinctFrom(o); end
  def visit_Arel_Nodes_IsNotDistinctFrom(o); end
  def visit_Arel_Nodes_JoinSource(o); end
  def visit_Arel_Nodes_LessThan(o); end
  def visit_Arel_Nodes_LessThanOrEqual(o); end
  def visit_Arel_Nodes_Limit(o); end
  def visit_Arel_Nodes_Matches(o); end
  def visit_Arel_Nodes_Max(o); end
  def visit_Arel_Nodes_Min(o); end
  def visit_Arel_Nodes_NamedFunction(o); end
  def visit_Arel_Nodes_NamedWindow(o); end
  def visit_Arel_Nodes_Not(o); end
  def visit_Arel_Nodes_NotEqual(o); end
  def visit_Arel_Nodes_NotIn(o); end
  def visit_Arel_Nodes_Offset(o); end
  def visit_Arel_Nodes_On(o); end
  def visit_Arel_Nodes_OptimizerHints(o); end
  def visit_Arel_Nodes_Or(o); end
  def visit_Arel_Nodes_Ordering(o); end
  def visit_Arel_Nodes_OuterJoin(o); end
  def visit_Arel_Nodes_Over(o); end
  def visit_Arel_Nodes_Preceding(o); end
  def visit_Arel_Nodes_Range(o); end
  def visit_Arel_Nodes_RightOuterJoin(o); end
  def visit_Arel_Nodes_RollUp(o); end
  def visit_Arel_Nodes_Rows(o); end
  def visit_Arel_Nodes_SelectCore(o); end
  def visit_Arel_Nodes_SelectStatement(o); end
  def visit_Arel_Nodes_SqlLiteral(o); end
  def visit_Arel_Nodes_StringJoin(o); end
  def visit_Arel_Nodes_Sum(o); end
  def visit_Arel_Nodes_TableAlias(o); end
  def visit_Arel_Nodes_UnqualifiedColumn(o); end
  def visit_Arel_Nodes_UpdateStatement(o); end
  def visit_Arel_Nodes_ValuesList(o); end
  def visit_Arel_Nodes_Window(o); end
  def visit_Arel_Table(o); end
  def visit_Array(o); end
  def visit_BigDecimal(o); end
  def visit_Date(o); end
  def visit_DateTime(o); end
  def visit_FalseClass(o); end
  def visit_Float(o); end
  def visit_Hash(o); end
  def visit_Integer(o); end
  def visit_NilClass(o); end
  def visit_Set(o); end
  def visit_String(o); end
  def visit_Symbol(o); end
  def visit_Time(o); end
  def visit_TrueClass(o); end
  def visit_edge(o, method); end
  def window(o); end
  def with_node(node); end
end

class Arel::Visitors::Dot::Edge < ::Struct
end

class Arel::Visitors::Dot::Node
  def initialize(name, id, fields = T.unsafe(nil)); end

  def fields; end
  def fields=(_); end
  def id; end
  def id=(_); end
  def name; end
  def name=(_); end
end

class Arel::Visitors::MySQL < ::Arel::Visitors::ToSql

  private

  def build_subselect(key, o); end
  def prepare_delete_statement(o); end
  def prepare_update_statement(o); end
  def visit_Arel_Nodes_Bin(o, collector); end
  def visit_Arel_Nodes_Concat(o, collector); end
  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
  def visit_Arel_Nodes_NotRegexp(o, collector); end
  def visit_Arel_Nodes_Regexp(o, collector); end
  def visit_Arel_Nodes_SelectCore(o, collector); end
  def visit_Arel_Nodes_SelectStatement(o, collector); end
  def visit_Arel_Nodes_UnqualifiedColumn(o, collector); end
end

class Arel::Visitors::PostgreSQL < ::Arel::Visitors::ToSql

  private

  def grouping_array_or_grouping_element(o, collector); end
  def grouping_parentheses(o, collector); end
  def visit_Arel_Nodes_BindParam(o, collector); end
  def visit_Arel_Nodes_Cube(o, collector); end
  def visit_Arel_Nodes_DistinctOn(o, collector); end
  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
  def visit_Arel_Nodes_GroupingElement(o, collector); end
  def visit_Arel_Nodes_GroupingSet(o, collector); end
  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
  def visit_Arel_Nodes_Lateral(o, collector); end
  def visit_Arel_Nodes_Matches(o, collector); end
  def visit_Arel_Nodes_NotRegexp(o, collector); end
  def visit_Arel_Nodes_NullsFirst(o, collector); end
  def visit_Arel_Nodes_NullsLast(o, collector); end
  def visit_Arel_Nodes_Regexp(o, collector); end
  def visit_Arel_Nodes_RollUp(o, collector); end
end

class Arel::Visitors::SQLite < ::Arel::Visitors::ToSql

  private

  def visit_Arel_Nodes_False(o, collector); end
  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
  def visit_Arel_Nodes_Lock(o, collector); end
  def visit_Arel_Nodes_SelectStatement(o, collector); end
  def visit_Arel_Nodes_True(o, collector); end
end

class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
  def initialize(connection); end

  def compile(node, collector = T.unsafe(nil)); end

  private

  def aggregate(name, o, collector); end
  def build_subselect(key, o); end
  def collect_nodes_for(nodes, collector, spacer, connector = T.unsafe(nil)); end
  def collect_optimizer_hints(o, collector); end
  def has_join_sources?(o); end
  def has_limit_or_offset_or_orders?(o); end
  def infix_value(o, collector, value); end
  def infix_value_with_paren(o, collector, value, suppress_parens = T.unsafe(nil)); end
  def inject_join(list, collector, join_str); end
  def is_distinct_from(o, collector); end
  def maybe_visit(thing, collector); end
  def prepare_delete_statement(o); end
  def prepare_update_statement(o); end
  def quote(value); end
  def quote_column_name(name); end
  def quote_table_name(name); end
  def sanitize_as_sql_comment(value); end
  def unboundable?(value); end
  def unsupported(o, collector); end
  def visit_ActiveSupport_Multibyte_Chars(o, collector); end
  def visit_ActiveSupport_StringInquirer(o, collector); end
  def visit_Arel_Attributes_Attribute(o, collector); end
  def visit_Arel_Nodes_Addition(o, collector); end
  def visit_Arel_Nodes_And(o, collector); end
  def visit_Arel_Nodes_As(o, collector); end
  def visit_Arel_Nodes_Ascending(o, collector); end
  def visit_Arel_Nodes_Assignment(o, collector); end
  def visit_Arel_Nodes_Avg(o, collector); end
  def visit_Arel_Nodes_Between(o, collector); end
  def visit_Arel_Nodes_Bin(o, collector); end
  def visit_Arel_Nodes_BindParam(o, collector); end
  def visit_Arel_Nodes_Case(o, collector); end
  def visit_Arel_Nodes_Casted(o, collector); end
  def visit_Arel_Nodes_Comment(o, collector); end
  def visit_Arel_Nodes_Count(o, collector); end
  def visit_Arel_Nodes_CurrentRow(o, collector); end
  def visit_Arel_Nodes_DeleteStatement(o, collector); end
  def visit_Arel_Nodes_Descending(o, collector); end
  def visit_Arel_Nodes_Distinct(o, collector); end
  def visit_Arel_Nodes_DistinctOn(o, collector); end
  def visit_Arel_Nodes_Division(o, collector); end
  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
  def visit_Arel_Nodes_Else(o, collector); end
  def visit_Arel_Nodes_Equality(o, collector); end
  def visit_Arel_Nodes_Except(o, collector); end
  def visit_Arel_Nodes_Exists(o, collector); end
  def visit_Arel_Nodes_Extract(o, collector); end
  def visit_Arel_Nodes_False(o, collector); end
  def visit_Arel_Nodes_Following(o, collector); end
  def visit_Arel_Nodes_FullOuterJoin(o, collector); end
  def visit_Arel_Nodes_GreaterThan(o, collector); end
  def visit_Arel_Nodes_GreaterThanOrEqual(o, collector); end
  def visit_Arel_Nodes_Group(o, collector); end
  def visit_Arel_Nodes_Grouping(o, collector); end
  def visit_Arel_Nodes_HomogeneousIn(o, collector); end
  def visit_Arel_Nodes_In(o, collector); end
  def visit_Arel_Nodes_InfixOperation(o, collector); end
  def visit_Arel_Nodes_InnerJoin(o, collector); end
  def visit_Arel_Nodes_InsertStatement(o, collector); end
  def visit_Arel_Nodes_Intersect(o, collector); end
  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
  def visit_Arel_Nodes_JoinSource(o, collector); end
  def visit_Arel_Nodes_LessThan(o, collector); end
  def visit_Arel_Nodes_LessThanOrEqual(o, collector); end
  def visit_Arel_Nodes_Limit(o, collector); end
  def visit_Arel_Nodes_Lock(o, collector); end
  def visit_Arel_Nodes_Matches(o, collector); end
  def visit_Arel_Nodes_Max(o, collector); end
  def visit_Arel_Nodes_Min(o, collector); end
  def visit_Arel_Nodes_Multiplication(o, collector); end
  def visit_Arel_Nodes_NamedFunction(o, collector); end
  def visit_Arel_Nodes_NamedWindow(o, collector); end
  def visit_Arel_Nodes_Not(o, collector); end
  def visit_Arel_Nodes_NotEqual(o, collector); end
  def visit_Arel_Nodes_NotIn(o, collector); end
  def visit_Arel_Nodes_NotRegexp(o, collector); end
  def visit_Arel_Nodes_Offset(o, collector); end
  def visit_Arel_Nodes_On(o, collector); end
  def visit_Arel_Nodes_OptimizerHints(o, collector); end
  def visit_Arel_Nodes_Or(o, collector); end
  def visit_Arel_Nodes_OuterJoin(o, collector); end
  def visit_Arel_Nodes_Over(o, collector); end
  def visit_Arel_Nodes_Preceding(o, collector); end
  def visit_Arel_Nodes_Quoted(o, collector); end
  def visit_Arel_Nodes_Range(o, collector); end
  def visit_Arel_Nodes_Regexp(o, collector); end
  def visit_Arel_Nodes_RightOuterJoin(o, collector); end
  def visit_Arel_Nodes_Rows(o, collector); end
  def visit_Arel_Nodes_SelectCore(o, collector); end
  def visit_Arel_Nodes_SelectOptions(o, collector); end
  def visit_Arel_Nodes_SelectStatement(o, collector); end
  def visit_Arel_Nodes_SqlLiteral(o, collector); end
  def visit_Arel_Nodes_StringJoin(o, collector); end
  def visit_Arel_Nodes_Subtraction(o, collector); end
  def visit_Arel_Nodes_Sum(o, collector); end
  def visit_Arel_Nodes_TableAlias(o, collector); end
  def visit_Arel_Nodes_True(o, collector); end
  def visit_Arel_Nodes_UnaryOperation(o, collector); end
  def visit_Arel_Nodes_Union(o, collector); end
  def visit_Arel_Nodes_UnionAll(o, collector); end
  def visit_Arel_Nodes_UnqualifiedColumn(o, collector); end
  def visit_Arel_Nodes_UpdateStatement(o, collector); end
  def visit_Arel_Nodes_ValuesList(o, collector); end
  def visit_Arel_Nodes_When(o, collector); end
  def visit_Arel_Nodes_Window(o, collector); end
  def visit_Arel_Nodes_With(o, collector); end
  def visit_Arel_Nodes_WithRecursive(o, collector); end
  def visit_Arel_SelectManager(o, collector); end
  def visit_Arel_Table(o, collector); end
  def visit_Array(o, collector); end
  def visit_BigDecimal(o, collector); end
  def visit_Class(o, collector); end
  def visit_Date(o, collector); end
  def visit_DateTime(o, collector); end
  def visit_FalseClass(o, collector); end
  def visit_Float(o, collector); end
  def visit_Hash(o, collector); end
  def visit_Integer(o, collector); end
  def visit_NilClass(o, collector); end
  def visit_Set(o, collector); end
  def visit_String(o, collector); end
  def visit_Symbol(o, collector); end
  def visit_Time(o, collector); end
  def visit_TrueClass(o, collector); end
end

class Arel::Visitors::UnsupportedVisitError < ::StandardError
  def initialize(object); end
end

class Arel::Visitors::Visitor
  def initialize; end

  def accept(object, collector = T.unsafe(nil)); end

  private

  def dispatch; end
  def get_dispatch_cache; end
  def visit(object, collector = T.unsafe(nil)); end

  class << self
    def dispatch_cache; end
  end
end

class Arel::Visitors::WhereSql < ::Arel::Visitors::ToSql
  def initialize(inner_visitor, *args, &block); end


  private

  def visit_Arel_Nodes_SelectCore(o, collector); end
end

module Arel::WindowPredications
  def over(expr = T.unsafe(nil)); end
end