active_record.rbs

module ActiveRecord
  def self.eager_load!: () -> untyped

  def self.gem_version: () -> untyped

  def self.version: () -> untyped
end

class ActiveRecord::ActiveRecordError < StandardError
end

class ActiveRecord::AdapterNotFound < ActiveRecord::ActiveRecordError
end

class ActiveRecord::AdapterNotSpecified < ActiveRecord::ActiveRecordError
end

class ActiveRecord::AdvisoryLockBase < ActiveRecord::Base
  include ActiveRecord::AdvisoryLockBase::GeneratedAssociationMethods

  include ActiveRecord::AdvisoryLockBase::GeneratedAttributeMethods

  def self._internal?: () -> untyped

  def self._validators: () -> untyped

  def self.attribute_type_decorations: () -> untyped

  def self.defined_enums: () -> untyped
end

module ActiveRecord::AdvisoryLockBase::GeneratedAssociationMethods
end

module ActiveRecord::AdvisoryLockBase::GeneratedAttributeMethods
end

module ActiveRecord::AdvisoryLockBase::GeneratedRelationMethods
end

module ActiveRecord::Aggregations
  public

  def reload: (*untyped) -> untyped

  private

  def clear_aggregation_cache: () -> untyped

  def init_internals: () -> untyped

  def initialize_dup: (*untyped) -> untyped
end

module ActiveRecord::Aggregations::ClassMethods
  public

  def composed_of: (untyped part_id, ?untyped options) -> untyped

  private

  def reader_method: (untyped name, untyped class_name, untyped mapping, untyped allow_nil, untyped constructor) -> untyped

  def writer_method: (untyped name, untyped class_name, untyped mapping, untyped allow_nil, untyped converter) -> untyped
end

class ActiveRecord::AmbiguousSourceReflectionForThroughAssociation < ActiveRecord::ActiveRecordError
  private

  def initialize: (untyped klass, untyped macro, untyped association_name, untyped options, untyped possible_sources) -> untyped
end

class ActiveRecord::AssociationNotFoundError < ActiveRecord::ConfigurationError
  include DidYouMean::Correctable

  public

  def association_name: () -> untyped

  def record: () -> untyped

  private

  def initialize: (?untyped record, ?untyped association_name) -> untyped
end

class ActiveRecord::AssociationRelation < ActiveRecord::AssociationRelation
  include ActiveRecord::InternalMetadata::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::AssociationRelation < ActiveRecord::AssociationRelation
  include ActiveRecord::SchemaMigration::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::AssociationRelation < ActiveRecord::Relation
  public

  def ==: (untyped other) -> untyped

  def build: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def insert: (untyped attributes, **untyped) -> untyped

  def insert!: (untyped attributes, **untyped) -> untyped

  def insert_all: (untyped attributes, **untyped) -> untyped

  def insert_all!: (untyped attributes, **untyped) -> untyped

  alias new build

  def proxy_association: () -> untyped

  def upsert: (untyped attributes, **untyped) -> untyped

  def upsert_all: (untyped attributes, **untyped) -> untyped

  private

  def exec_queries: () -> untyped

  def initialize: (untyped klass, untyped association, **untyped) -> untyped
end

class ActiveRecord::AssociationRelation < ActiveRecord::AssociationRelation
  include ActiveRecord::AdvisoryLockBase::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::AssociationTypeMismatch < ActiveRecord::ActiveRecordError
end

module ActiveRecord::Associations
  def self.eager_load!: () -> untyped

  public

  def association: (untyped name) -> untyped

  def association_cached?: (untyped name) -> untyped

  def reload: (*untyped) -> untyped

  private

  def association_instance_get: (untyped name) -> untyped

  def association_instance_set: (untyped name, untyped association) -> untyped

  def clear_association_cache: () -> untyped

  def init_internals: () -> untyped

  def initialize_dup: (*untyped) -> untyped
end

class ActiveRecord::Associations::AliasTracker
  def self.create: (untyped connection, untyped initial_table, untyped joins, ?untyped aliases) -> untyped

  def self.initial_count_for: (untyped connection, untyped name, untyped table_joins) -> untyped

  public

  def aliased_table_for: (untyped table_name, untyped aliased_name, untyped type_caster) -> untyped

  def aliases: () -> untyped

  private

  def initialize: (untyped connection, untyped aliases) -> untyped

  def truncate: (untyped name) -> untyped
end

class ActiveRecord::Associations::Association
  public

  def create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def extensions: () -> untyped

  def initialize_attributes: (untyped record, ?untyped except_from_scope_attributes) -> untyped

  def inversed_from: (untyped record) -> untyped

  alias inversed_from_queries inversed_from

  def klass: () -> untyped

  def load_target: () -> untyped

  def loaded!: () -> untyped

  def loaded?: () -> untyped

  def marshal_dump: () -> untyped

  def marshal_load: (untyped data) -> untyped

  def options: (*untyped *) { (*untyped) -> untyped } -> untyped

  def owner: () -> untyped

  def reflection: () -> untyped

  def reload: (?untyped force) -> untyped

  def remove_inverse_instance: (untyped record) -> untyped

  def reset: () -> untyped

  def reset_negative_cache: () -> untyped

  def reset_scope: () -> untyped

  def scope: () -> untyped

  def set_inverse_instance: (untyped record) -> untyped

  def set_inverse_instance_from_queries: (untyped record) -> untyped

  def stale_target?: () -> untyped

  def target: () -> untyped

  def target=: (untyped target) -> untyped

  private

  def association_scope: () -> untyped

  def build_record: (untyped attributes) -> untyped

  def creation_attributes: () -> untyped

  def find_target: () -> untyped

  def find_target?: () -> untyped

  def foreign_key_for?: (untyped record) -> untyped

  def foreign_key_present?: () -> untyped

  def initialize: (untyped owner, untyped reflection) -> untyped

  def inverse_association_for: (untyped record) -> untyped

  def inverse_reflection_for: (untyped record) -> untyped

  def invertible_for?: (untyped record) -> untyped

  def raise_on_type_mismatch!: (untyped record) -> untyped

  def scope_for_create: () -> untyped

  def set_owner_attributes: (untyped record) -> untyped

  def skip_statement_cache?: (untyped scope) -> untyped

  def stale_state: () -> untyped

  def target_scope: () -> untyped
end

class ActiveRecord::Associations::AssociationScope
  def self.create: () { (*untyped) -> untyped } -> untyped

  def self.get_bind_values: (untyped owner, untyped chain) -> untyped

  def self.scope: (untyped association) -> untyped

  public

  def scope: (untyped association) -> untyped

  private

  def add_constraints: (untyped scope, untyped owner, untyped chain) -> untyped

  def apply_scope: (untyped scope, untyped table, untyped key, untyped value) -> untyped

  def eval_scope: (untyped reflection, untyped scope, untyped owner) -> untyped

  def get_chain: (untyped reflection, untyped association, untyped tracker) -> untyped

  def initialize: (untyped value_transformation) -> untyped

  def join: (untyped table, untyped constraint) -> untyped

  def last_chain_scope: (untyped scope, untyped reflection, untyped owner) -> untyped

  def next_chain_scope: (untyped scope, untyped reflection, untyped next_reflection) -> untyped

  def transform_value: (untyped value) -> untyped

  def value_transformation: () -> untyped
end

ActiveRecord::Associations::AssociationScope::INSTANCE: ActiveRecord::Associations::AssociationScope

class ActiveRecord::Associations::AssociationScope::ReflectionProxy < SimpleDelegator
  public

  def aliased_table: () -> untyped

  def all_includes: () -> untyped

  private

  def initialize: (untyped reflection, untyped aliased_table) -> untyped
end

class ActiveRecord::Associations::BelongsToAssociation < ActiveRecord::Associations::SingularAssociation
  public

  def decrement_counters: () -> untyped

  def decrement_counters_before_last_save: () -> untyped

  def default: () { (*untyped) -> untyped } -> untyped

  def handle_dependency: () -> untyped

  def increment_counters: () -> untyped

  def inversed_from: (untyped record) -> untyped

  def reset: () -> untyped

  def target_changed?: () -> untyped

  def updated?: () -> untyped

  private

  def find_target?: () -> untyped

  def foreign_key_present?: () -> untyped

  def invertible_for?: (untyped record) -> untyped

  def primary_key: (untyped klass) -> untyped

  def replace: (untyped record) -> untyped

  def replace_keys: (untyped record) -> untyped

  def require_counter_update?: () -> untyped

  def stale_state: () -> untyped

  def update_counters: (untyped by) -> untyped

  def update_counters_via_scope: (untyped klass, untyped foreign_key, untyped by) -> untyped
end

class ActiveRecord::Associations::BelongsToPolymorphicAssociation < ActiveRecord::Associations::BelongsToAssociation
  public

  def klass: () -> untyped

  def target_changed?: () -> untyped

  private

  def inverse_reflection_for: (untyped record) -> untyped

  def raise_on_type_mismatch!: (untyped record) -> untyped

  def replace_keys: (untyped record) -> untyped

  def stale_state: () -> untyped
end

module ActiveRecord::Associations::Builder
end

class ActiveRecord::Associations::Builder::Association
  def self.build: (untyped model, untyped name, untyped scope, untyped options) { (*untyped) -> untyped } -> untyped

  def self.create_reflection: (untyped model, untyped name, untyped scope, untyped options) { (*untyped) -> untyped } -> untyped

  def self.extensions: () -> untyped

  def self.extensions=: (untyped) -> untyped
end

ActiveRecord::Associations::Builder::Association::VALID_OPTIONS: Array

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

class ActiveRecord::Associations::Builder::CollectionAssociation < ActiveRecord::Associations::Builder::Association
  def self.define_callbacks: (untyped model, untyped reflection) -> untyped
end

ActiveRecord::Associations::Builder::CollectionAssociation::CALLBACKS: Array

class ActiveRecord::Associations::Builder::HasAndBelongsToMany
  public

  def association_name: () -> untyped

  def lhs_model: () -> untyped

  def middle_reflection: (untyped join_model) -> untyped

  def options: () -> untyped

  def through_model: () -> untyped

  private

  def belongs_to_options: (untyped options) -> untyped

  def initialize: (untyped association_name, untyped lhs_model, untyped options) -> untyped

  def middle_options: (untyped join_model) -> untyped

  def table_name: () -> untyped
end

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

class ActiveRecord::Associations::Builder::HasOne < ActiveRecord::Associations::Builder::SingularAssociation
  def self.touch_record: (untyped record, untyped name, untyped touch) -> untyped
end

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

module ActiveRecord::Associations::ClassMethods
  public

  def belongs_to: (untyped name, ?untyped scope, **untyped) -> untyped

  def has_and_belongs_to_many: (untyped name, ?untyped scope, **untyped) { (*untyped) -> untyped } -> untyped

  def has_many: (untyped name, ?untyped scope, **untyped) { (*untyped) -> untyped } -> untyped

  def has_one: (untyped name, ?untyped scope, **untyped) -> untyped
end

class ActiveRecord::Associations::CollectionAssociation < ActiveRecord::Associations::Association
  public

  def add_to_target: (untyped record, ?skip_callbacks: untyped, ?replace: untyped) { (*untyped) -> untyped } -> untyped

  def build: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def concat: (*untyped records) -> untyped

  def delete: (*untyped records) -> untyped

  def delete_all: (?untyped dependent) -> untyped

  def destroy: (*untyped records) -> untyped

  def destroy_all: () -> untyped

  def empty?: () -> untyped

  def find: (*untyped args) -> untyped

  def find_from_target?: () -> untyped

  def ids_reader: () -> untyped

  def ids_writer: (untyped ids) -> untyped

  def include?: (untyped record) -> untyped

  def load_target: () -> untyped

  def null_scope?: () -> untyped

  def reader: () -> untyped

  def replace: (untyped other_array) -> untyped

  def reset: () -> untyped

  def scope: () -> untyped

  def size: () -> untyped

  def target=: (untyped record) -> untyped

  def transaction: (*untyped args) -> untyped

  def writer: (untyped records) -> untyped

  private

  def _create_record: (untyped attributes, ?untyped raise) { (*untyped) -> untyped } -> untyped

  def callback: (untyped method, untyped record) -> untyped

  def callbacks_for: (untyped callback_name) -> untyped

  def concat_records: (untyped records, ?untyped raise) -> untyped

  def delete_or_destroy: (untyped records, untyped method) -> untyped

  def delete_records: (untyped records, untyped method) -> untyped

  def find_by_scan: (*untyped args) -> untyped

  def include_in_memory?: (untyped record) -> untyped

  def insert_record: (untyped record, ?untyped validate, ?untyped raise) { (*untyped) -> untyped } -> untyped

  def merge_target_lists: (untyped persisted, untyped memory) -> untyped

  def remove_records: (untyped existing_records, untyped records, untyped method) -> untyped

  def replace_common_records_in_memory: (untyped new_target, untyped original_target) -> untyped

  def replace_on_target: (untyped record, untyped index, untyped skip_callbacks) -> untyped

  def replace_records: (untyped new_target, untyped original_target) -> untyped
end

class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Associations::CollectionProxy
  include ActiveRecord::InternalMetadata::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Associations::CollectionProxy
  include ActiveRecord::SchemaMigration::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
  public

  def <<: (*untyped records) -> untyped

  def ==: (untyped other) -> untyped

  def _select!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def and: (*untyped *) { (*untyped) -> untyped } -> untyped

  def and!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def annotate: (*untyped *) { (*untyped) -> untyped } -> untyped

  def annotate!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def annotate_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def annotate_values=: (untyped arg) -> untyped

  alias append <<

  def arel: (*untyped *) { (*untyped) -> untyped } -> untyped

  def build: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def calculate: (untyped operation, untyped column_name) -> untyped

  def clear: () -> untyped

  alias concat <<

  def construct_join_dependency: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create_with: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create_with!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create_with_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create_with_value=: (untyped arg) -> untyped

  def delete: (*untyped records) -> untyped

  def delete_all: (?untyped dependent) -> untyped

  def destroy: (*untyped records) -> untyped

  def destroy_all: () -> untyped

  def distinct: (*untyped *) { (*untyped) -> untyped } -> untyped

  def distinct!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def distinct_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def distinct_value=: (untyped arg) -> untyped

  def eager_load: (*untyped *) { (*untyped) -> untyped } -> untyped

  def eager_load!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def eager_load_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def eager_load_values=: (untyped arg) -> untyped

  def empty?: () -> untyped

  def except: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extending: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extending!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extending_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extending_values=: (untyped arg) -> untyped

  def extensions: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extract_associated: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find: (*untyped args) -> untyped

  def from: (*untyped *) { (*untyped) -> untyped } -> untyped

  def from!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def from_clause: (*untyped *) { (*untyped) -> untyped } -> untyped

  def from_clause=: (untyped arg) -> untyped

  def group: (*untyped *) { (*untyped) -> untyped } -> untyped

  def group!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def group_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def group_values=: (untyped arg) -> untyped

  def having: (*untyped *) { (*untyped) -> untyped } -> untyped

  def having!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def having_clause: (*untyped *) { (*untyped) -> untyped } -> untyped

  def having_clause=: (untyped arg) -> untyped

  def include?: (untyped record) -> untyped

  def includes: (*untyped *) { (*untyped) -> untyped } -> untyped

  def includes!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def includes_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def includes_values=: (untyped arg) -> untyped

  def insert: (*untyped *) { (*untyped) -> untyped } -> untyped

  def insert!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def insert_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def insert_all!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def joins!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def joins_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def joins_values=: (untyped arg) -> untyped

  def last: (?untyped limit) -> untyped

  def left_joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_outer_joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_outer_joins!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_outer_joins_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_outer_joins_values=: (untyped arg) -> untyped

  def limit: (*untyped *) { (*untyped) -> untyped } -> untyped

  def limit!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def limit_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def limit_value=: (untyped arg) -> untyped

  def load_target: () -> untyped

  alias loaded loaded?

  def loaded?: () -> untyped

  def lock: (*untyped *) { (*untyped) -> untyped } -> untyped

  def lock!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def lock_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def lock_value=: (untyped arg) -> untyped

  def merge: (*untyped *) { (*untyped) -> untyped } -> untyped

  def merge!: (*untyped *) { (*untyped) -> untyped } -> untyped

  alias new build

  def none: (*untyped *) { (*untyped) -> untyped } -> untyped

  def none!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def offset: (*untyped *) { (*untyped) -> untyped } -> untyped

  def offset!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def offset_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def offset_value=: (untyped arg) -> untyped

  def only: (*untyped *) { (*untyped) -> untyped } -> untyped

  def optimizer_hints: (*untyped *) { (*untyped) -> untyped } -> untyped

  def optimizer_hints!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def optimizer_hints_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def optimizer_hints_values=: (untyped arg) -> untyped

  def or: (*untyped *) { (*untyped) -> untyped } -> untyped

  def or!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def order: (*untyped *) { (*untyped) -> untyped } -> untyped

  def order!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def order_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def order_values=: (untyped arg) -> untyped

  def pluck: (*untyped column_names) -> untyped

  def preload: (*untyped *) { (*untyped) -> untyped } -> untyped

  def preload!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def preload_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def preload_values=: (untyped arg) -> untyped

  def `prepend`: (*untyped args) -> untyped

  def proxy_association: () -> untyped

  alias push <<

  def readonly: (*untyped *) { (*untyped) -> untyped } -> untyped

  def readonly!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def readonly_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def readonly_value=: (untyped arg) -> untyped

  def records: () -> untyped

  def references: (*untyped *) { (*untyped) -> untyped } -> untyped

  def references!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def references_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def references_values=: (untyped arg) -> untyped

  def reload: () -> untyped

  def reorder: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reorder!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reordering_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reordering_value=: (untyped arg) -> untyped

  def replace: (untyped other_array) -> untyped

  def reselect: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reselect!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reset: () -> untyped

  def reset_scope: () -> untyped

  def reverse_order: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reverse_order!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reverse_order_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reverse_order_value=: (untyped arg) -> untyped

  def rewhere: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scope: () -> untyped

  def scoping: (*untyped *) { (*untyped) -> untyped } -> untyped

  def select_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def select_values=: (untyped arg) -> untyped

  def size: () -> untyped

  def skip_preloading!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def skip_query_cache!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def skip_query_cache_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def skip_query_cache_value=: (untyped arg) -> untyped

  def spawn: (*untyped *) { (*untyped) -> untyped } -> untyped

  def strict_loading: (*untyped *) { (*untyped) -> untyped } -> untyped

  def strict_loading!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def strict_loading_value: (*untyped *) { (*untyped) -> untyped } -> untyped

  def strict_loading_value=: (untyped arg) -> untyped

  def take: (?untyped limit) -> untyped

  def target: () -> untyped

  def uniq!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def unscope: (*untyped *) { (*untyped) -> untyped } -> untyped

  def unscope!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def unscope_values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def unscope_values=: (untyped arg) -> untyped

  def upsert: (*untyped *) { (*untyped) -> untyped } -> untyped

  def upsert_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def values: (*untyped *) { (*untyped) -> untyped } -> untyped

  def where: (*untyped *) { (*untyped) -> untyped } -> untyped

  def where!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def where_clause: (*untyped *) { (*untyped) -> untyped } -> untyped

  def where_clause=: (untyped arg) -> untyped

  private

  def exec_queries: () -> untyped

  def find_from_target?: () -> untyped

  def find_nth_from_last: (untyped index) -> untyped

  def find_nth_with_limit: (untyped index, untyped limit) -> untyped

  def initialize: (untyped klass, untyped association, **untyped) -> untyped

  def null_scope?: () -> untyped
end

class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Associations::CollectionProxy
  include ActiveRecord::AdvisoryLockBase::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

module ActiveRecord::Associations::ForeignAssociation
  public

  def foreign_key_present?: () -> untyped

  def nullified_owner_attributes: () -> untyped
end

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

  public

  def handle_dependency: () -> untyped

  def insert_record: (untyped record, ?untyped validate, ?untyped raise) -> untyped

  private

  def _create_record: (untyped attributes, *untyped) -> untyped

  def concat_records: (untyped records, *untyped) -> untyped

  def count_records: () -> untyped

  def delete_count: (untyped method, untyped scope) -> untyped

  def delete_or_nullify_all_records: (untyped method) -> untyped

  def delete_records: (untyped records, untyped method) -> untyped

  def difference: (untyped a, untyped b) -> untyped

  def intersection: (untyped a, untyped b) -> untyped

  def update_counter: (untyped difference, ?untyped reflection) -> untyped

  def update_counter_if_success: (untyped saved_successfully, untyped difference) -> untyped

  def update_counter_in_memory: (untyped difference, ?untyped reflection) -> untyped
end

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

  public

  def concat: (*untyped records) -> untyped

  def insert_record: (untyped record, ?untyped validate, ?untyped raise) -> untyped

  private

  def build_record: (untyped attributes) -> untyped

  def build_through_record: (untyped record) -> untyped

  def concat_records: (untyped records) -> untyped

  def delete_or_nullify_all_records: (untyped method) -> untyped

  def delete_records: (untyped records, untyped method) -> untyped

  def delete_through_records: (untyped records) -> untyped

  def difference: (untyped a, untyped b) -> untyped

  def distribution: (untyped array) -> untyped

  def find_target: () -> untyped

  def initialize: (untyped owner, untyped reflection) -> untyped

  def intersection: (untyped a, untyped b) -> untyped

  def invertible_for?: (untyped record) -> untyped

  def mark_occurrence: (untyped distribution, untyped record) -> untyped

  def remove_records: (untyped existing_records, untyped records, untyped method) -> untyped

  def save_through_record: (untyped record) -> untyped

  def target_reflection_has_associated_record?: () -> untyped

  def through_records_for: (untyped record) -> untyped

  def through_scope_attributes: () -> untyped

  def update_through_counter?: (untyped method) -> untyped
end

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

  public

  def delete: (?untyped method) -> untyped

  def handle_dependency: () -> untyped

  private

  def _create_record: (untyped attributes, ?untyped raise_error) { (*untyped) -> untyped } -> untyped

  def nullify_owner_attributes: (untyped record) -> untyped

  def remove_target!: (untyped method) -> untyped

  def replace: (untyped record, ?untyped save) -> untyped

  def set_new_record: (untyped record) -> untyped

  def transaction_if: (untyped value) -> untyped
end

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

  private

  def create_through_record: (untyped record, untyped save) -> untyped

  def replace: (untyped record, ?untyped save) -> untyped
end

class ActiveRecord::Associations::JoinDependency
  def self.make_tree: (untyped associations) -> untyped

  def self.walk_tree: (untyped associations, untyped hash) -> untyped

  public

  def apply_column_aliases: (untyped relation) -> untyped

  def base_klass: () -> untyped

  def each: () { (*untyped) -> untyped } -> untyped

  def instantiate: (untyped result_set, untyped strict_loading_value) { (*untyped) -> untyped } -> untyped

  def join_constraints: (untyped joins_to_add, untyped alias_tracker) -> untyped

  def reflections: () -> untyped

  private

  def alias_tracker: () -> untyped

  def aliases: () -> untyped

  def build: (untyped associations, untyped base_klass) -> untyped

  def construct: (untyped ar_parent, untyped parent, untyped row, untyped seen, untyped model_cache, untyped strict_loading_value) -> untyped

  def construct_model: (untyped record, untyped node, untyped row, untyped model_cache, untyped id, untyped strict_loading_value) -> untyped

  def explicit_selections: (untyped root_column_aliases, untyped result_set) -> untyped

  def find_reflection: (untyped klass, untyped name) -> untyped

  def initialize: (untyped base, untyped table, untyped associations, untyped join_type) -> untyped

  def make_constraints: (untyped parent, untyped child, untyped join_type) -> untyped

  def make_join_constraints: (untyped join_root, untyped join_type) -> untyped

  def table_alias_for: (untyped reflection, untyped parent, untyped join) -> untyped

  def walk: (untyped left, untyped right, untyped join_type) -> untyped
end

class ActiveRecord::Associations::JoinDependency::Aliases
  public

  def column_alias: (untyped node, untyped column) -> untyped

  def column_aliases: (untyped node) -> untyped

  def columns: () -> untyped

  private

  def initialize: (untyped tables) -> untyped
end

class ActiveRecord::Associations::JoinDependency::Aliases::Column < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def `alias`: () -> untyped

  def alias=: (untyped _) -> untyped

  def name: () -> untyped

  def name=: (untyped _) -> untyped
end

class ActiveRecord::Associations::JoinDependency::Aliases::Table < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def column_aliases: () -> untyped

  def columns: () -> untyped

  def columns=: (untyped _) -> untyped

  def node: () -> untyped

  def node=: (untyped _) -> untyped
end

class ActiveRecord::Associations::JoinDependency::JoinAssociation < ActiveRecord::Associations::JoinDependency::JoinPart
  public

  def join_constraints: (untyped foreign_table, untyped foreign_klass, untyped join_type, untyped alias_tracker) { (*untyped) -> untyped } -> untyped

  def match?: (untyped other) -> untyped

  def readonly?: () -> untyped

  def reflection: () -> untyped

  def strict_loading?: () -> untyped

  def table: () -> untyped

  def table=: (untyped) -> untyped

  def tables: () -> untyped

  private

  def append_constraints: (untyped join, untyped constraints) -> untyped

  def initialize: (untyped reflection, untyped children) -> untyped
end

class ActiveRecord::Associations::JoinDependency::JoinBase < ActiveRecord::Associations::JoinDependency::JoinPart
  public

  def match?: (untyped other) -> untyped

  def table: () -> untyped

  private

  def initialize: (untyped base_klass, untyped table, untyped children) -> untyped
end

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

  include Enumerable

  public

  def base_klass: () -> untyped

  def children: () -> untyped

  def column_names: (*untyped *) { (*untyped) -> untyped } -> untyped

  def each: () { (*untyped) -> untyped } -> untyped

  def each_children: () { (*untyped) -> untyped } -> untyped

  def extract_record: (untyped row, untyped column_names_with_alias) -> untyped

  def instantiate: (untyped row, untyped aliases) { (*untyped) -> untyped } -> untyped

  def match?: (untyped other) -> untyped

  def primary_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def table: () -> untyped

  def table_name: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped base_klass, untyped children) -> untyped
end

class ActiveRecord::Associations::Preloader
  public

  def preload: (untyped records, untyped associations, ?untyped preload_scope) -> untyped

  private

  def grouped_records: (untyped association, untyped records, untyped polymorphic_parent) -> untyped

  def preloader_for: (untyped reflection, untyped owners) -> untyped

  def preloaders_for_hash: (untyped association, untyped records, untyped scope, untyped polymorphic_parent) -> untyped

  def preloaders_for_one: (untyped association, untyped records, untyped scope, untyped polymorphic_parent) -> untyped

  def preloaders_for_reflection: (untyped reflection, untyped records, untyped scope) -> untyped

  def preloaders_on: (untyped association, untyped records, untyped scope, ?untyped polymorphic_parent) -> untyped
end

class ActiveRecord::Associations::Preloader::AlreadyLoaded
  public

  def preloaded_records: () -> untyped

  def records_by_owner: () -> untyped

  def run: () -> untyped

  private

  def initialize: (untyped klass, untyped owners, untyped reflection, untyped preload_scope) -> untyped

  def owners: () -> untyped

  def reflection: () -> untyped
end

class ActiveRecord::Associations::Preloader::Association
  public

  def preloaded_records: () -> untyped

  def records_by_owner: () -> untyped

  def run: () -> untyped

  private

  def associate_records_to_owner: (untyped owner, untyped records) -> untyped

  def association_key_name: () -> untyped

  def association_key_type: () -> untyped

  def build_scope: () -> untyped

  def convert_key: (untyped key) -> untyped

  def initialize: (untyped klass, untyped owners, untyped reflection, untyped preload_scope) -> untyped

  def key_conversion_required?: () -> untyped

  def klass: () -> untyped

  def load_records: () -> untyped

  def model: () -> untyped

  def owner_key_name: () -> untyped

  def owner_key_type: () -> untyped

  def owner_keys: () -> untyped

  def owners: () -> untyped

  def owners_by_key: () -> untyped

  def preload_scope: () -> untyped

  def records_for: (untyped ids) -> untyped

  def reflection: () -> untyped

  def reflection_scope: () -> untyped

  def scope: () -> untyped
end

class ActiveRecord::Associations::Preloader::ThroughAssociation < ActiveRecord::Associations::Preloader::Association
  public

  def preloaded_records: () -> untyped

  def records_by_owner: () -> untyped

  private

  def initialize: (*untyped) -> untyped

  def middle_records: () -> untyped

  def preload_index: () -> untyped

  def source_preloaders: () -> untyped

  def source_reflection: () -> untyped

  def through_preloaders: () -> untyped

  def through_reflection: () -> untyped

  def through_scope: () -> untyped
end

ActiveRecord::Associations::Preloader::ThroughAssociation::PRELOADER: ActiveRecord::Associations::Preloader

class ActiveRecord::Associations::SingularAssociation < ActiveRecord::Associations::Association
  public

  def build: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def force_reload_reader: () -> untyped

  def reader: () -> untyped

  def writer: (untyped record) -> untyped

  private

  def _create_record: (untyped attributes, ?untyped raise_error) { (*untyped) -> untyped } -> untyped

  def find_target: () -> untyped

  def replace: (untyped record) -> untyped

  def scope_for_create: () -> untyped

  def set_new_record: (untyped record) -> untyped
end

module ActiveRecord::Associations::ThroughAssociation
  public

  def source_reflection: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def build_record: (untyped attributes) -> untyped

  def construct_join_attributes: (*untyped records) -> untyped

  def ensure_mutable: () -> untyped

  def ensure_not_nested: () -> untyped

  def foreign_key_present?: () -> untyped

  def stale_state: () -> untyped

  def target_scope: () -> untyped

  def through_association: () -> untyped

  def through_reflection: () -> untyped
end

module ActiveRecord::AttributeAssignment
  include ActiveModel::AttributeAssignment

  private

  def _assign_attributes: (untyped attributes) -> untyped

  def assign_multiparameter_attributes: (untyped pairs) -> untyped

  def assign_nested_parameter_attributes: (untyped pairs) -> untyped

  def execute_callstack_for_multiparameter_attributes: (untyped callstack) -> untyped

  def extract_callstack_for_multiparameter_attributes: (untyped pairs) -> untyped

  def find_parameter_position: (untyped multiparameter_name) -> untyped

  def type_cast_attribute_value: (untyped multiparameter_name, untyped value) -> untyped
end

class ActiveRecord::AttributeAssignmentError < ActiveRecord::ActiveRecordError
  public

  def attribute: () -> untyped

  def exception: () -> untyped

  private

  def initialize: (?untyped message, ?untyped exception, ?untyped attribute) -> untyped
end

module ActiveRecord::AttributeDecorators
end

module ActiveRecord::AttributeDecorators::ClassMethods
  public

  def decorate_attribute_type: (untyped column_name, untyped decorator_name) { (*untyped) -> untyped } -> untyped

  def decorate_matching_attribute_types: (untyped matcher, untyped decorator_name) { (*untyped) -> untyped } -> untyped

  private

  def load_schema!: () -> untyped
end

class ActiveRecord::AttributeDecorators::TypeDecorator
  public

  def apply: (untyped name, untyped `type`) -> untyped

  def clear: (*untyped *) { (*untyped) -> untyped } -> untyped

  def merge: (*untyped args) -> untyped

  private

  def decorators_for: (untyped name, untyped `type`) -> untyped

  def initialize: (?untyped decorations) -> untyped

  def matching: (untyped name, untyped `type`) -> untyped
end

module ActiveRecord::AttributeMethods
  def self.dangerous_attribute_methods: () -> untyped

  public

  def []: (untyped attr_name) -> untyped

  def []=: (untyped attr_name, untyped value) -> untyped

  def _has_attribute?: (untyped attr_name) -> untyped

  def accessed_fields: () -> untyped

  def attribute_for_inspect: (untyped attr_name) -> untyped

  def attribute_names: () -> untyped

  def attribute_present?: (untyped attr_name) -> untyped

  def attributes: () -> untyped

  def has_attribute?: (untyped attr_name) -> untyped

  def respond_to?: (untyped name, ?untyped include_private) -> untyped

  private

  def attribute_method?: (untyped attr_name) -> untyped

  def attributes_for_create: (untyped attribute_names) -> untyped

  def attributes_for_update: (untyped attribute_names) -> untyped

  def attributes_with_values: (untyped attribute_names) -> untyped

  def format_for_inspect: (untyped value) -> untyped

  def pk_attribute?: (untyped name) -> untyped
end

ActiveRecord::AttributeMethods::RESTRICTED_CLASS_METHODS: Array

module ActiveRecord::AttributeMethods::BeforeTypeCast
  public

  def attributes_before_type_cast: () -> untyped

  def read_attribute_before_type_cast: (untyped attr_name) -> untyped

  private

  def attribute_before_type_cast: (untyped attr_name) -> untyped

  def attribute_came_from_user?: (untyped attr_name) -> untyped
end

module ActiveRecord::AttributeMethods::ClassMethods
  public

  def _has_attribute?: (untyped attr_name) -> untyped

  def attribute_method?: (untyped attribute) -> untyped

  def attribute_names: () -> untyped

  def column_for_attribute: (untyped name) -> untyped

  def dangerous_attribute_method?: (untyped name) -> untyped

  def dangerous_class_method?: (untyped method_name) -> untyped

  def define_attribute_methods: () -> untyped

  def has_attribute?: (untyped attr_name) -> untyped

  def inherited: (untyped child_class) -> untyped

  def initialize_generated_modules: () -> untyped

  def instance_method_already_implemented?: (untyped method_name) -> untyped

  def method_defined_within?: (untyped name, untyped klass, ?untyped superklass) -> untyped

  def undefine_attribute_methods: () -> untyped
end

module ActiveRecord::AttributeMethods::Dirty
  public

  def attribute_before_last_save: (untyped attr_name) -> untyped

  def attribute_change_to_be_saved: (untyped attr_name) -> untyped

  def attribute_in_database: (untyped attr_name) -> untyped

  def attributes_in_database: () -> untyped

  def changed_attribute_names_to_save: () -> untyped

  def changes_to_save: () -> untyped

  def has_changes_to_save?: () -> untyped

  def reload: (*untyped) -> untyped

  def saved_change_to_attribute: (untyped attr_name) -> untyped

  def saved_change_to_attribute?: (untyped attr_name, **untyped) -> untyped

  def saved_changes: () -> untyped

  def saved_changes?: () -> untyped

  def will_save_change_to_attribute?: (untyped attr_name, **untyped) -> untyped

  private

  def _create_record: (?untyped attribute_names) -> untyped

  def _touch_row: (untyped attribute_names, untyped time) -> untyped

  def _update_record: (?untyped attribute_names) -> untyped

  def attribute_names_for_partial_writes: () -> untyped

  def write_attribute_without_type_cast: (untyped attr_name, untyped value) -> untyped
end

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

  public

  alias lock mu_lock

  alias locked? mu_locked?

  alias synchronize mu_synchronize

  alias try_lock mu_try_lock

  alias unlock mu_unlock
end

module ActiveRecord::AttributeMethods::PrimaryKey
  public

  def id: () -> untyped

  def id=: (untyped value) -> untyped

  def id?: () -> untyped

  def id_before_type_cast: () -> untyped

  def id_for_database: () -> untyped

  def id_in_database: () -> untyped

  def id_was: () -> untyped

  def to_key: () -> untyped

  private

  def attribute_method?: (untyped attr_name) -> untyped
end

module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
  public

  def dangerous_attribute_method?: (untyped method_name) -> untyped

  def get_primary_key: (untyped base_name) -> untyped

  def instance_method_already_implemented?: (untyped method_name) -> untyped

  def primary_key: () -> untyped

  def primary_key=: (untyped value) -> untyped

  def quoted_primary_key: () -> untyped

  def reset_primary_key: () -> untyped

  private

  def suppress_composite_primary_key: (untyped pk) -> untyped
end

ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods::ID_ATTRIBUTE_METHODS: Set

module ActiveRecord::AttributeMethods::Query
  public

  def query_attribute: (untyped attr_name) -> untyped

  private

  alias attribute? query_attribute
end

module ActiveRecord::AttributeMethods::Read
  public

  def _read_attribute: (untyped attr_name) { (*untyped) -> untyped } -> untyped

  def read_attribute: (untyped attr_name) { (*untyped) -> untyped } -> untyped

  private

  alias attribute _read_attribute
end

module ActiveRecord::AttributeMethods::Read::ClassMethods
  private

  def define_method_attribute: (untyped name, owner: untyped) -> untyped
end

module ActiveRecord::AttributeMethods::Serialization
end

module ActiveRecord::AttributeMethods::Serialization::ClassMethods
  public

  def serialize: (untyped attr_name, ?untyped class_name_or_coder) -> untyped

  private

  def type_incompatible_with_serialize?: (untyped `type`, untyped class_name) -> untyped
end

class ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError < StandardError
  private

  def initialize: (untyped name, untyped `type`) -> untyped
end

module ActiveRecord::AttributeMethods::TimeZoneConversion
end

module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
  private

  def create_time_zone_conversion_attribute?: (untyped name, untyped cast_type) -> untyped

  def inherited: (untyped subclass) -> untyped
end

module ActiveRecord::AttributeMethods::Write
  public

  def _write_attribute: (untyped attr_name, untyped value) -> untyped

  def write_attribute: (untyped attr_name, untyped value) -> untyped

  private

  alias attribute= _write_attribute

  def write_attribute_without_type_cast: (untyped attr_name, untyped value) -> untyped
end

module ActiveRecord::AttributeMethods::Write::ClassMethods
  private

  def define_method_attribute=: (untyped name, owner: untyped) -> untyped
end

module ActiveRecord::Attributes
end

module ActiveRecord::Attributes::ClassMethods
  public

  def attribute: (untyped name, ?untyped cast_type, **untyped) -> untyped

  def define_attribute: (untyped name, untyped cast_type, ?default: untyped, ?user_provided_default: untyped) -> untyped

  def load_schema!: () -> untyped

  private

  def define_default_attribute: (untyped name, untyped value, untyped `type`, from_user: untyped) -> untyped
end

module ActiveRecord::AutosaveAssociation
  public

  def changed_for_autosave?: () -> untyped

  def destroyed_by_association: () -> untyped

  def destroyed_by_association=: (untyped reflection) -> untyped

  def mark_for_destruction: () -> untyped

  def marked_for_destruction?: () -> untyped

  def reload: (?untyped options) -> untyped

  private

  def _ensure_no_duplicate_errors: () -> untyped

  def after_save_collection_association: () -> untyped

  def associated_records_to_validate_or_save: (untyped association, untyped new_record, untyped autosave) -> untyped

  def association_foreign_key_changed?: (untyped reflection, untyped record, untyped key) -> untyped

  def association_valid?: (untyped reflection, untyped record, ?untyped index) -> untyped

  def before_save_collection_association: () -> untyped

  def custom_validation_context?: () -> untyped

  def nested_records_changed_for_autosave?: () -> untyped

  def normalize_reflection_attribute: (untyped indexed_attribute, untyped reflection, untyped index, untyped attribute) -> untyped

  def record_changed?: (untyped reflection, untyped record, untyped key) -> untyped

  def save_belongs_to_association: (untyped reflection) -> untyped

  def save_collection_association: (untyped reflection) -> untyped

  def save_has_one_association: (untyped reflection) -> untyped

  def validate_collection_association: (untyped reflection) -> untyped

  def validate_single_association: (untyped reflection) -> untyped
end

module ActiveRecord::AutosaveAssociation::AssociationBuilderExtension
  def self.build: (untyped model, untyped reflection) -> untyped

  def self.valid_options: () -> untyped
end

module ActiveRecord::AutosaveAssociation::ClassMethods
  private

  def add_autosave_association_callbacks: (untyped reflection) -> untyped

  def define_autosave_validation_callbacks: (untyped reflection) -> untyped

  def define_non_cyclic_method: (untyped name) { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::Base
  include Suppressor

  include SignedId

  include SecureToken

  include Store

  include Serialization

  include ActiveModel::Serializers::JSON

  include Reflection

  include NoTouching

  include TouchLater

  include Transactions

  include NestedAttributes

  include AutosaveAssociation

  include ActiveModel::SecurePassword

  include Associations

  include Timestamp

  include ActiveModel::Validations::Callbacks

  include Callbacks

  include ActiveRecord::AttributeMethods::Serialization

  include ActiveRecord::AttributeMethods::Dirty

  include ActiveModel::Dirty

  include ActiveRecord::AttributeMethods::TimeZoneConversion

  include ActiveRecord::AttributeMethods::PrimaryKey

  include ActiveRecord::AttributeMethods::Query

  include ActiveRecord::AttributeMethods::BeforeTypeCast

  include ActiveRecord::AttributeMethods::Write

  include ActiveRecord::AttributeMethods::Read

  include ActiveRecord::Base::GeneratedAssociationMethods

  include ActiveRecord::Base::GeneratedAttributeMethods

  include AttributeMethods

  include ActiveModel::AttributeMethods

  include ActiveRecord::Locking::Pessimistic

  include ActiveRecord::Locking::Optimistic

  include AttributeDecorators

  include Attributes

  include CounterCache

  include Validations

  include ActiveModel::Validations::HelperMethods

  include ActiveSupport::Callbacks

  include ActiveModel::Validations

  include Integration

  include ActiveModel::Conversion

  include AttributeAssignment

  include Sanitization

  include ActiveRecord::Scoping::Named

  include ActiveRecord::Scoping::Default

  include Scoping

  include Inheritance

  include ModelSchema

  include ReadonlyAttributes

  include Persistence

  include Core

  def self.__callbacks: () -> untyped

  def self.__callbacks=: (untyped value) -> untyped

  def self.__callbacks?: () -> untyped

  def self._attr_readonly: () -> untyped

  def self._attr_readonly=: (untyped value) -> untyped

  def self._attr_readonly?: () -> untyped

  def self._before_commit_callbacks: () -> untyped

  def self._before_commit_callbacks=: (untyped value) -> untyped

  def self._commit_callbacks: () -> untyped

  def self._commit_callbacks=: (untyped value) -> untyped

  def self._create_callbacks: () -> untyped

  def self._create_callbacks=: (untyped value) -> untyped

  def self._destroy_callbacks: () -> untyped

  def self._destroy_callbacks=: (untyped value) -> untyped

  def self._find_callbacks: () -> untyped

  def self._find_callbacks=: (untyped value) -> untyped

  def self._initialize_callbacks: () -> untyped

  def self._initialize_callbacks=: (untyped value) -> untyped

  def self._reflections: () -> untyped

  def self._reflections=: (untyped value) -> untyped

  def self._reflections?: () -> untyped

  def self._rollback_callbacks: () -> untyped

  def self._rollback_callbacks=: (untyped value) -> untyped

  def self._save_callbacks: () -> untyped

  def self._save_callbacks=: (untyped value) -> untyped

  def self._touch_callbacks: () -> untyped

  def self._touch_callbacks=: (untyped value) -> untyped

  def self._update_callbacks: () -> untyped

  def self._update_callbacks=: (untyped value) -> untyped

  def self._validate_callbacks: () -> untyped

  def self._validate_callbacks=: (untyped value) -> untyped

  def self._validation_callbacks: () -> untyped

  def self._validation_callbacks=: (untyped value) -> untyped

  def self._validators: () -> untyped

  def self._validators=: (untyped value) -> untyped

  def self._validators?: () -> untyped

  def self.after_create: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_destroy: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_find: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_initialize: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_save: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_touch: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.after_update: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.aggregate_reflections: () -> untyped

  def self.aggregate_reflections=: (untyped value) -> untyped

  def self.aggregate_reflections?: () -> untyped

  def self.allow_unsafe_raw_sql: () -> untyped

  def self.allow_unsafe_raw_sql=: (untyped val) -> untyped

  def self.around_create: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.around_destroy: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.around_save: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.around_update: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.attribute_aliases: () -> untyped

  def self.attribute_aliases=: (untyped value) -> untyped

  def self.attribute_aliases?: () -> untyped

  def self.attribute_method_matchers: () -> untyped

  def self.attribute_method_matchers=: (untyped value) -> untyped

  def self.attribute_method_matchers?: () -> untyped

  def self.attribute_type_decorations: () -> untyped

  def self.attribute_type_decorations=: (untyped value) -> untyped

  def self.attribute_type_decorations?: () -> untyped

  def self.attributes_to_define_after_schema_loads: () -> untyped

  def self.attributes_to_define_after_schema_loads=: (untyped value) -> untyped

  def self.attributes_to_define_after_schema_loads?: () -> untyped

  def self.before_create: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.before_destroy: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.before_save: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.before_update: (*untyped args, **untyped) { (*untyped) -> untyped } -> untyped

  def self.belongs_to_required_by_default: () -> untyped

  def self.belongs_to_required_by_default=: (untyped value) -> untyped

  def self.belongs_to_required_by_default?: () -> untyped

  def self.cache_timestamp_format: () -> untyped

  def self.cache_timestamp_format=: (untyped value) -> untyped

  def self.cache_timestamp_format?: () -> untyped

  def self.cache_versioning: () -> untyped

  def self.cache_versioning=: (untyped value) -> untyped

  def self.cache_versioning?: () -> untyped

  def self.collection_cache_versioning: () -> untyped

  def self.collection_cache_versioning=: (untyped value) -> untyped

  def self.collection_cache_versioning?: () -> untyped

  def self.configurations: () -> untyped

  def self.configurations=: (untyped config) -> untyped

  def self.connection_handler: () -> untyped

  def self.connection_handler=: (untyped handler) -> untyped

  def self.connection_handlers: () -> untyped

  def self.connection_handlers=: (untyped val) -> untyped

  def self.current_pool_key: () -> untyped

  def self.current_pool_key=: (untyped pool_key) -> untyped

  def self.default_connection_handler: () -> untyped

  def self.default_connection_handler=: (untyped value) -> untyped

  def self.default_connection_handler?: () -> untyped

  def self.default_pool_key: () -> untyped

  def self.default_pool_key=: (untyped value) -> untyped

  def self.default_pool_key?: () -> untyped

  def self.default_scope_override: () -> untyped

  def self.default_scope_override=: (untyped value) -> untyped

  def self.default_scopes: () -> untyped

  def self.default_scopes=: (untyped value) -> untyped

  def self.default_timezone: () -> untyped

  def self.default_timezone=: (untyped val) -> untyped

  def self.defined_enums: () -> untyped

  def self.defined_enums=: (untyped value) -> untyped

  def self.defined_enums?: () -> untyped

  def self.dump_schema_after_migration: () -> untyped

  def self.dump_schema_after_migration=: (untyped val) -> untyped

  def self.dump_schemas: () -> untyped

  def self.dump_schemas=: (untyped val) -> untyped

  def self.error_on_ignored_order: () -> untyped

  def self.error_on_ignored_order=: (untyped val) -> untyped

  def self.has_many_inversing: () -> untyped

  def self.has_many_inversing=: (untyped val) -> untyped

  def self.implicit_order_column: () -> untyped

  def self.implicit_order_column=: (untyped value) -> untyped

  def self.implicit_order_column?: () -> untyped

  def self.include_root_in_json: () -> untyped

  def self.include_root_in_json=: (untyped value) -> untyped

  def self.include_root_in_json?: () -> untyped

  def self.index_nested_attribute_errors: () -> untyped

  def self.index_nested_attribute_errors=: (untyped val) -> untyped

  def self.internal_metadata_table_name: () -> untyped

  def self.internal_metadata_table_name=: (untyped value) -> untyped

  def self.internal_metadata_table_name?: () -> untyped

  def self.local_stored_attributes: () -> untyped

  def self.local_stored_attributes=: (untyped) -> untyped

  def self.lock_optimistically: () -> untyped

  def self.lock_optimistically=: (untyped value) -> untyped

  def self.lock_optimistically?: () -> untyped

  def self.logger: () -> untyped

  def self.logger=: (untyped val) -> untyped

  def self.maintain_test_schema: () -> untyped

  def self.maintain_test_schema=: (untyped val) -> untyped

  def self.nested_attributes_options: () -> untyped

  def self.nested_attributes_options=: (untyped value) -> untyped

  def self.nested_attributes_options?: () -> untyped

  def self.partial_writes: () -> untyped

  def self.partial_writes=: (untyped value) -> untyped

  def self.partial_writes?: () -> untyped

  def self.pluralize_table_names: () -> untyped

  def self.pluralize_table_names=: (untyped value) -> untyped

  def self.pluralize_table_names?: () -> untyped

  def self.primary_key_prefix_type: () -> untyped

  def self.primary_key_prefix_type=: (untyped val) -> untyped

  def self.reading_role: () -> untyped

  def self.reading_role=: (untyped val) -> untyped

  def self.record_timestamps: () -> untyped

  def self.record_timestamps=: (untyped value) -> untyped

  def self.record_timestamps?: () -> untyped

  def self.schema_format: () -> untyped

  def self.schema_format=: (untyped val) -> untyped

  def self.schema_migrations_table_name: () -> untyped

  def self.schema_migrations_table_name=: (untyped value) -> untyped

  def self.schema_migrations_table_name?: () -> untyped

  def self.signed_id_verifier_secret: () -> untyped

  def self.signed_id_verifier_secret=: (untyped val) -> untyped

  def self.skip_time_zone_conversion_for_attributes: () -> untyped

  def self.skip_time_zone_conversion_for_attributes=: (untyped value) -> untyped

  def self.skip_time_zone_conversion_for_attributes?: () -> untyped

  def self.store_full_sti_class: () -> untyped

  def self.store_full_sti_class=: (untyped value) -> untyped

  def self.store_full_sti_class?: () -> untyped

  def self.strict_loading_by_default: () -> untyped

  def self.strict_loading_by_default=: (untyped value) -> untyped

  def self.strict_loading_by_default?: () -> untyped

  def self.table_name_prefix: () -> untyped

  def self.table_name_prefix=: (untyped value) -> untyped

  def self.table_name_prefix?: () -> untyped

  def self.table_name_suffix: () -> untyped

  def self.table_name_suffix=: (untyped value) -> untyped

  def self.table_name_suffix?: () -> untyped

  def self.time_zone_aware_attributes: () -> untyped

  def self.time_zone_aware_attributes=: (untyped val) -> untyped

  def self.time_zone_aware_types: () -> untyped

  def self.time_zone_aware_types=: (untyped value) -> untyped

  def self.time_zone_aware_types?: () -> untyped

  def self.timestamped_migrations: () -> untyped

  def self.timestamped_migrations=: (untyped val) -> untyped

  def self.verbose_query_logs: () -> untyped

  def self.verbose_query_logs=: (untyped val) -> untyped

  def self.warn_on_records_fetched_greater_than: () -> untyped

  def self.warn_on_records_fetched_greater_than=: (untyped val) -> untyped

  def self.writing_role: () -> untyped

  def self.writing_role=: (untyped val) -> untyped

  public

  def __callbacks: () -> untyped

  def __callbacks?: () -> untyped

  def _before_commit_callbacks: () -> untyped

  def _commit_callbacks: () -> untyped

  def _create_callbacks: () -> untyped

  def _destroy_callbacks: () -> untyped

  def _find_callbacks: () -> untyped

  def _initialize_callbacks: () -> untyped

  def _reflections: () -> untyped

  def _reflections?: () -> untyped

  def _rollback_callbacks: () -> untyped

  def _run_before_commit_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_commit_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_create_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_destroy_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_find_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_initialize_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_rollback_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_save_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_touch_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_update_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_validate_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_validation_callbacks: () { (*untyped) -> untyped } -> untyped

  def _save_callbacks: () -> untyped

  def _touch_callbacks: () -> untyped

  def _update_callbacks: () -> untyped

  def _validate_callbacks: () -> untyped

  def _validation_callbacks: () -> untyped

  def _validators: () -> untyped

  def _validators?: () -> untyped

  def aggregate_reflections: () -> untyped

  def aggregate_reflections?: () -> untyped

  def allow_unsafe_raw_sql: () -> untyped

  def attribute_aliases: () -> untyped

  def attribute_aliases?: () -> untyped

  def attribute_method_matchers: () -> untyped

  def attribute_method_matchers?: () -> untyped

  def cache_timestamp_format: () -> untyped

  def cache_timestamp_format?: () -> untyped

  def cache_versioning: () -> untyped

  def cache_versioning?: () -> untyped

  def collection_cache_versioning: () -> untyped

  def collection_cache_versioning?: () -> untyped

  def column_for_attribute: (*untyped *) { (*untyped) -> untyped } -> untyped

  def default_connection_handler: () -> untyped

  def default_connection_handler?: () -> untyped

  def default_pool_key: () -> untyped

  def default_pool_key?: () -> untyped

  def default_scope_override: () -> untyped

  def default_scopes: () -> untyped

  def default_timezone: () -> untyped

  def defined_enums: () -> untyped

  def defined_enums?: () -> untyped

  def dump_schema_after_migration: () -> untyped

  def dump_schemas: () -> untyped

  def error_on_ignored_order: () -> untyped

  def include_root_in_json: () -> untyped

  def include_root_in_json?: () -> untyped

  def index_nested_attribute_errors: () -> untyped

  def lock_optimistically: () -> untyped

  def lock_optimistically?: () -> untyped

  def logger: () -> untyped

  def model_name: (*untyped *) { (*untyped) -> untyped } -> untyped

  def nested_attributes_options: () -> untyped

  def nested_attributes_options?: () -> untyped

  def partial_writes: () -> untyped

  def partial_writes?: () -> untyped

  def pluralize_table_names: () -> untyped

  def pluralize_table_names?: () -> untyped

  def primary_key_prefix_type: () -> untyped

  def record_timestamps: () -> untyped

  def record_timestamps=: (untyped) -> untyped

  def record_timestamps?: () -> untyped

  def schema_format: () -> untyped

  def signed_id_verifier_secret: () -> untyped

  def skip_time_zone_conversion_for_attributes: () -> untyped

  def skip_time_zone_conversion_for_attributes?: () -> untyped

  def store_full_sti_class: () -> untyped

  def store_full_sti_class?: () -> untyped

  def table_name_prefix: () -> untyped

  def table_name_prefix?: () -> untyped

  def table_name_suffix: () -> untyped

  def table_name_suffix?: () -> untyped

  def time_zone_aware_attributes: () -> untyped

  def time_zone_aware_types: () -> untyped

  def time_zone_aware_types?: () -> untyped

  def timestamped_migrations: () -> untyped

  def type_for_attribute: (*untyped *) { (*untyped) -> untyped } -> untyped

  def validation_context: () -> untyped

  def verbose_query_logs: () -> untyped

  def warn_on_records_fetched_greater_than: () -> untyped

  private

  def validation_context=: (untyped) -> untyped
end

module ActiveRecord::Base::GeneratedAssociationMethods
end

module ActiveRecord::Base::GeneratedAttributeMethods
end

module ActiveRecord::Batches
  public

  def find_each: (?start: untyped, ?finish: untyped, ?batch_size: untyped, ?error_on_ignore: untyped, ?order: untyped) -> untyped

  def find_in_batches: (?start: untyped, ?finish: untyped, ?batch_size: untyped, ?error_on_ignore: untyped, ?order: untyped) -> untyped

  def in_batches: (?of: untyped, ?start: untyped, ?finish: untyped, ?load: untyped, ?error_on_ignore: untyped, ?order: untyped) -> untyped

  private

  def act_on_ignored_order: (untyped error_on_ignore) -> untyped

  def apply_finish_limit: (untyped relation, untyped finish, untyped order) -> untyped

  def apply_limits: (untyped relation, untyped start, untyped finish, untyped order) -> untyped

  def apply_start_limit: (untyped relation, untyped start, untyped order) -> untyped

  def batch_order: (untyped order) -> untyped
end

ActiveRecord::Batches::ORDER_IGNORE_MESSAGE: String

class ActiveRecord::Batches::BatchEnumerator
  include Enumerable

  public

  def delete_all: (*untyped args) { (*untyped) -> untyped } -> untyped

  def destroy_all: (*untyped args) { (*untyped) -> untyped } -> untyped

  def each: () -> untyped

  def each_record: () -> untyped

  def update_all: (*untyped args) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (relation: untyped, ?of: untyped, ?start: untyped, ?finish: untyped) -> untyped
end

module ActiveRecord::Calculations
  public

  def average: (untyped column_name) -> untyped

  def calculate: (untyped operation, untyped column_name) -> untyped

  def count: (?untyped column_name) -> untyped

  def ids: () -> untyped

  def maximum: (untyped column_name) -> untyped

  def minimum: (untyped column_name) -> untyped

  def pick: (*untyped column_names) -> untyped

  def pluck: (*untyped column_names) -> untyped

  def sum: (?untyped column_name) -> untyped

  private

  def aggregate_column: (untyped column_name) -> untyped

  def all_attributes?: (untyped column_names) -> untyped

  def build_count_subquery: (untyped relation, untyped column_name, untyped distinct) -> untyped

  def column_alias_for: (untyped field) -> untyped

  def distinct_select?: (untyped column_name) -> untyped

  def execute_grouped_calculation: (untyped operation, untyped column_name, untyped distinct) -> untyped

  def execute_simple_calculation: (untyped operation, untyped column_name, untyped distinct) -> untyped

  def has_include?: (untyped column_name) -> untyped

  def lookup_cast_type_from_join_dependencies: (untyped name, ?untyped join_dependencies) -> untyped

  def operation_over_aggregate_column: (untyped column, untyped operation, untyped distinct) -> untyped

  def perform_calculation: (untyped operation, untyped column_name) -> untyped

  def select_for_count: () -> untyped

  def type_cast_calculated_value: (untyped value, untyped operation) -> untyped

  def type_cast_pluck_values: (untyped result, untyped columns) -> untyped

  def type_for: (untyped field) { (*untyped) -> untyped } -> untyped
end

module ActiveRecord::Callbacks
  public

  def destroy: () -> untyped

  def increment!: (untyped attribute, ?untyped by, ?touch: untyped) -> untyped

  def touch: (*untyped, **untyped) -> untyped

  private

  def _create_record: () -> untyped

  def _update_record: () -> untyped

  def create_or_update: (**untyped) -> untyped
end

ActiveRecord::Callbacks::CALLBACKS: Array

module ActiveRecord::Coders
end

class ActiveRecord::Coders::JSON
  def self.dump: (untyped obj) -> untyped

  def self.load: (untyped json) -> untyped
end

class ActiveRecord::Coders::YAMLColumn
  public

  def assert_valid_value: (untyped obj, action: untyped) -> untyped

  def dump: (untyped obj) -> untyped

  def load: (untyped yaml) -> untyped

  def object_class: () -> untyped

  def object_class=: (untyped) -> untyped

  private

  def check_arity_of_constructor: () -> untyped

  def initialize: (untyped attr_name, ?untyped object_class) -> untyped
end

class ActiveRecord::ConcurrentMigrationError < ActiveRecord::MigrationError
  private

  def initialize: (?untyped message) -> untyped
end

ActiveRecord::ConcurrentMigrationError::DEFAULT_MESSAGE: String

ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE: String

class ActiveRecord::ConfigurationError < ActiveRecord::ActiveRecordError
end

module ActiveRecord::ConnectionAdapters
end

class ActiveRecord::ConnectionAdapters::AbstractAdapter
  include Savepoints

  include QueryCache

  include DatabaseLimits

  include Quoting

  include DatabaseStatements

  include SchemaStatements

  include ActiveSupport::Callbacks

  def self.__callbacks: () -> untyped

  def self.__callbacks=: (untyped value) -> untyped

  def self.__callbacks?: () -> untyped

  def self._checkin_callbacks: () -> untyped

  def self._checkin_callbacks=: (untyped value) -> untyped

  def self._checkout_callbacks: () -> untyped

  def self._checkout_callbacks=: (untyped value) -> untyped

  def self.build_read_query_regexp: (*untyped parts) -> untyped

  def self.database_exists?: (untyped config) -> untyped

  def self.quoted_column_names: () -> untyped

  def self.quoted_table_names: () -> untyped

  def self.type_cast_config_to_boolean: (untyped config) -> untyped

  def self.type_cast_config_to_integer: (untyped config) -> untyped

  public

  def __callbacks: () -> untyped

  def __callbacks?: () -> untyped

  def _checkin_callbacks: () -> untyped

  def _checkout_callbacks: () -> untyped

  def _run_checkin_callbacks: () { (*untyped) -> untyped } -> untyped

  def _run_checkout_callbacks: () { (*untyped) -> untyped } -> untyped

  def active?: () -> untyped

  def adapter_name: () -> untyped

  def advisory_locks_enabled?: () -> untyped

  def build_insert_sql: (untyped insert) -> untyped

  def case_insensitive_comparison: (untyped attribute, untyped value) -> untyped

  def case_sensitive_comparison: (untyped attribute, untyped value) -> untyped

  def check_version: () -> untyped

  def clear_cache!: () -> untyped

  def close: () -> untyped

  def database_version: () -> untyped

  def default_index_type?: (untyped index) -> untyped

  def default_uniqueness_comparison: (untyped attribute, untyped value, untyped klass) -> untyped

  def delete: (*untyped) -> untyped

  def disable_extension: (untyped name) -> untyped

  def disable_referential_integrity: () -> untyped

  def discard!: () -> untyped

  def disconnect!: () -> untyped

  def enable_extension: (untyped name) -> untyped

  def exec_insert_all: (*untyped) -> untyped

  def expire: () -> untyped

  def extensions: () -> untyped

  def get_advisory_lock: (untyped lock_id) -> untyped

  def get_database_version: () -> untyped

  alias in_use? owner

  def index_algorithms: () -> untyped

  def insert: (*untyped) -> untyped

  def lease: () -> untyped

  def lock: () -> untyped

  def logger: () -> untyped

  def migration_context: () -> untyped

  def migrations_paths: () -> untyped

  def owner: () -> untyped

  def pool: () -> untyped

  def pool=: (untyped) -> untyped

  def prefetch_primary_key?: (?untyped table_name) -> untyped

  def prepared_statements: () -> untyped

  def prepared_statements_disabled_cache: () -> untyped

  def preventing_writes?: () -> untyped

  def raw_connection: () -> untyped

  def reconnect!: () -> untyped

  def release_advisory_lock: (untyped lock_id) -> untyped

  def replica?: () -> untyped

  def requires_reloading?: () -> untyped

  def reset!: () -> untyped

  def rollback_db_transaction: (*untyped) -> untyped

  def rollback_to_savepoint: (*untyped) -> untyped

  def schema_cache: () -> untyped

  def schema_cache=: (untyped cache) -> untyped

  def schema_migration: () -> untyped

  def seconds_idle: () -> untyped

  def steal!: () -> untyped

  def supports_advisory_locks?: () -> untyped

  def supports_bulk_alter?: () -> untyped

  def supports_check_constraints?: () -> untyped

  def supports_comments?: () -> untyped

  def supports_comments_in_create?: () -> untyped

  def supports_common_table_expressions?: () -> untyped

  def supports_datetime_with_precision?: () -> untyped

  def supports_ddl_transactions?: () -> untyped

  def supports_explain?: () -> untyped

  def supports_expression_index?: () -> untyped

  def supports_extensions?: () -> untyped

  def supports_foreign_keys?: () -> untyped

  def supports_foreign_keys_in_create?: (*untyped args) { (*untyped) -> untyped } -> untyped

  def supports_foreign_tables?: () -> untyped

  def supports_index_sort_order?: () -> untyped

  def supports_indexes_in_create?: () -> untyped

  def supports_insert_conflict_target?: () -> untyped

  def supports_insert_on_duplicate_skip?: () -> untyped

  def supports_insert_on_duplicate_update?: () -> untyped

  def supports_insert_returning?: () -> untyped

  def supports_json?: () -> untyped

  def supports_lazy_transactions?: () -> untyped

  def supports_materialized_views?: () -> untyped

  def supports_multi_insert?: (*untyped args) { (*untyped) -> untyped } -> untyped

  def supports_optimizer_hints?: () -> untyped

  def supports_partial_index?: () -> untyped

  def supports_partitioned_indexes?: () -> untyped

  def supports_savepoints?: () -> untyped

  def supports_transaction_isolation?: () -> untyped

  def supports_validate_constraints?: () -> untyped

  def supports_views?: () -> untyped

  def supports_virtual_columns?: () -> untyped

  def truncate: (*untyped) -> untyped

  def truncate_tables: (*untyped) -> untyped

  def unprepared_statement: () -> untyped

  def update: (*untyped) -> untyped

  def use_metadata_table?: () -> untyped

  def valid_type?: (untyped `type`) -> untyped

  def verify!: () -> untyped

  def visitor: () -> untyped

  private

  def arel_visitor: () -> untyped

  def build_result: (columns: untyped, rows: untyped, ?column_types: untyped) -> untyped

  def build_statement_pool: () -> untyped

  def can_perform_case_insensitive_comparison_for?: (untyped column) -> untyped

  def collector: () -> untyped

  def column_for: (untyped table_name, untyped column_name) -> untyped

  def column_for_attribute: (untyped attribute) -> untyped

  def extract_limit: (untyped sql_type) -> untyped

  def extract_precision: (untyped sql_type) -> untyped

  def extract_scale: (untyped sql_type) -> untyped

  def initialize: (untyped connection, ?untyped logger, ?untyped config) -> untyped

  def initialize_type_map: (?untyped m) -> untyped

  def log: (untyped sql, ?untyped name, ?untyped binds, ?untyped type_casted_binds, ?untyped statement_name) -> untyped

  def register_class_with_limit: (untyped mapping, untyped key, untyped klass) -> untyped

  def register_class_with_precision: (untyped mapping, untyped key, untyped klass) -> untyped

  def reload_type_map: () -> untyped

  def translate_exception: (untyped exception, message: untyped, sql: untyped, binds: untyped) -> untyped

  def translate_exception_class: (untyped e, untyped sql, untyped binds) -> untyped

  def type_map: () -> untyped

  def without_prepared_statement?: (untyped binds) -> untyped
end

ActiveRecord::ConnectionAdapters::AbstractAdapter::ADAPTER_NAME: String

ActiveRecord::ConnectionAdapters::AbstractAdapter::COMMENT_REGEX: Regexp

ActiveRecord::ConnectionAdapters::AbstractAdapter::SIMPLE_INT: Regexp

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

  public

  def <=>: (untyped version_string) -> untyped

  def full_version_string: () -> untyped

  def to_s: () -> untyped

  private

  def initialize: (untyped version_string, ?untyped full_version_string) -> untyped
end

module ActiveRecord::ConnectionAdapters::AbstractPool
  public

  def get_schema_cache: (untyped connection) -> untyped

  def set_schema_cache: (untyped cache) -> untyped
end

class ActiveRecord::ConnectionAdapters::AddColumnDefinition < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def column: () -> untyped

  def column=: (untyped _) -> untyped
end

class ActiveRecord::ConnectionAdapters::AlterTable
  public

  def add_check_constraint: (untyped expression, untyped options) -> untyped

  def add_column: (untyped name, untyped `type`, **untyped) -> untyped

  def add_foreign_key: (untyped to_table, untyped options) -> untyped

  def adds: () -> untyped

  def check_constraint_adds: () -> untyped

  def check_constraint_drops: () -> untyped

  def drop_check_constraint: (untyped constraint_name) -> untyped

  def drop_foreign_key: (untyped name) -> untyped

  def foreign_key_adds: () -> untyped

  def foreign_key_drops: () -> untyped

  def name: () -> untyped

  private

  def initialize: (untyped td) -> untyped
end

class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def column: () -> untyped

  def column=: (untyped _) -> untyped

  def name: () -> untyped

  def name=: (untyped _) -> untyped
end

class ActiveRecord::ConnectionAdapters::Column
  include Deduplicable

  public

  def ==: (untyped other) -> untyped

  def bigint?: () -> untyped

  def collation: () -> untyped

  def comment: () -> untyped

  def default: () -> untyped

  def default_function: () -> untyped

  def encode_with: (untyped coder) -> untyped

  alias eql? ==

  def has_default?: () -> untyped

  def hash: () -> untyped

  def human_name: () -> untyped

  def init_with: (untyped coder) -> untyped

  def limit: (*untyped *) { (*untyped) -> untyped } -> untyped

  def name: () -> untyped

  def null: () -> untyped

  def precision: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scale: (*untyped *) { (*untyped) -> untyped } -> untyped

  def sql_type: (*untyped *) { (*untyped) -> untyped } -> untyped

  def sql_type_metadata: () -> untyped

  def `type`: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def deduplicated: () -> untyped

  def initialize: (untyped name, untyped default, ?untyped sql_type_metadata, ?untyped null, ?untyped default_function, ?collation: untyped, ?comment: untyped, **untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::ColumnDefinition < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def collation: () -> untyped

  def collation=: (untyped value) -> untyped

  def comment: () -> untyped

  def comment=: (untyped value) -> untyped

  def default: () -> untyped

  def default=: (untyped value) -> untyped

  def limit: () -> untyped

  def limit=: (untyped value) -> untyped

  def name: () -> untyped

  def name=: (untyped _) -> untyped

  def null: () -> untyped

  def null=: (untyped value) -> untyped

  def options: () -> untyped

  def options=: (untyped _) -> untyped

  def precision: () -> untyped

  def precision=: (untyped value) -> untyped

  def primary_key?: () -> untyped

  def scale: () -> untyped

  def scale=: (untyped value) -> untyped

  def sql_type: () -> untyped

  def sql_type=: (untyped _) -> untyped

  def `type`: () -> untyped

  def type=: (untyped _) -> untyped
end

module ActiveRecord::ConnectionAdapters::ColumnMethods
  public

  def primary_key: (untyped name, ?untyped `type`, **untyped) -> untyped
end

module ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
  private

  def define_column_methods: (*untyped column_types) -> untyped
end

class ActiveRecord::ConnectionAdapters::ConnectionHandler
  public

  def active_connections?: () -> untyped

  def clear_active_connections!: () -> untyped

  def clear_all_connections!: () -> untyped

  def clear_reloadable_connections!: () -> untyped

  def connected?: (untyped spec_name, ?untyped pool_key) -> untyped

  def connection_pool_list: () -> untyped

  def connection_pool_names: () -> untyped

  alias connection_pools connection_pool_list

  def establish_connection: (untyped config, ?untyped pool_key, ?untyped owner_name) -> untyped

  def flush_idle_connections!: () -> untyped

  def prevent_writes: () -> untyped

  def prevent_writes=: (untyped prevent_writes) -> untyped

  def remove_connection: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_connection_pool: (untyped owner, ?untyped pool_key) -> untyped

  def retrieve_connection: (untyped spec_name, ?untyped pool_key) -> untyped

  def retrieve_connection_pool: (untyped owner, ?untyped pool_key) -> untyped

  def while_preventing_writes: (?untyped enabled) -> untyped

  private

  def get_pool_manager: (untyped owner) -> untyped

  def initialize: () -> untyped

  def owner_to_pool_manager: () -> untyped

  def resolve_pool_config: (untyped config, untyped owner_name) -> untyped
end

class ActiveRecord::ConnectionAdapters::ConnectionPool
  include AbstractPool

  include ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration

  include MonitorMixin

  public

  def active_connection?: () -> untyped

  def automatic_reconnect: () -> untyped

  def automatic_reconnect=: (untyped) -> untyped

  def checkin: (untyped conn) -> untyped

  def checkout: (?untyped checkout_timeout) -> untyped

  def checkout_timeout: () -> untyped

  def checkout_timeout=: (untyped) -> untyped

  def clear_reloadable_connections: (?untyped raise_on_acquisition_timeout) -> untyped

  def clear_reloadable_connections!: () -> untyped

  def connected?: () -> untyped

  def connection: () -> untyped

  def connections: () -> untyped

  def db_config: () -> untyped

  def discard!: () -> untyped

  def discarded?: () -> untyped

  def disconnect: (?untyped raise_on_acquisition_timeout) -> untyped

  def disconnect!: () -> untyped

  def flush: (?untyped minimum_idle) -> untyped

  def flush!: () -> untyped

  def lock_thread=: (untyped lock_thread) -> untyped

  def num_waiting_in_queue: () -> untyped

  def pool_config: () -> untyped

  def reap: () -> untyped

  def reaper: () -> untyped

  def release_connection: (?untyped owner_thread) -> untyped

  def remove: (untyped conn) -> untyped

  def schema_cache: (*untyped *) { (*untyped) -> untyped } -> untyped

  def schema_cache=: (untyped arg) -> untyped

  def size: () -> untyped

  def stat: () -> untyped

  def with_connection: () -> untyped

  private

  def acquire_connection: (untyped checkout_timeout) -> untyped

  def adopt_connection: (untyped conn) -> untyped

  def attempt_to_checkout_all_existing_connections: (?untyped raise_on_acquisition_timeout) -> untyped

  def bulk_make_new_connections: (untyped num_new_conns_needed) -> untyped

  def checkout_and_verify: (untyped c) -> untyped

  def checkout_for_exclusive_access: (untyped checkout_timeout) -> untyped

  def checkout_new_connection: () -> untyped

  def connection_cache_key: (untyped thread) -> untyped

  def current_thread: () -> untyped

  def initialize: (untyped pool_config) -> untyped

  def new_connection: () -> untyped

  alias release remove_connection_from_thread_cache

  def remove_connection_from_thread_cache: (untyped conn, ?untyped owner_thread) -> untyped

  def try_to_checkout_new_connection: () -> untyped

  def with_exclusively_acquired_all_connections: (?untyped raise_on_acquisition_timeout) -> untyped

  def with_new_connections_blocked: () -> untyped
end

module ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue
  public

  def with_a_bias_for: (untyped thread) -> untyped
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue::BiasedConditionVariable
  public

  def broadcast: () -> untyped

  def broadcast_on_biased: () -> untyped

  def signal: () -> untyped

  def wait: (untyped timeout) -> untyped

  private

  def initialize: (untyped lock, untyped other_cond, untyped preferred_thread) -> untyped
end

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

  private

  def internal_poll: (untyped timeout) -> untyped
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
  public

  def add: (untyped element) -> untyped

  def any_waiting?: () -> untyped

  def clear: () -> untyped

  def delete: (untyped element) -> untyped

  def num_waiting: () -> untyped

  def poll: (?untyped timeout) -> untyped

  private

  def any?: () -> untyped

  def can_remove_no_wait?: () -> untyped

  def initialize: (?untyped lock) -> untyped

  def internal_poll: (untyped timeout) -> untyped

  def no_wait_poll: () -> untyped

  def remove: () -> untyped

  def synchronize: () { (*untyped) -> untyped } -> untyped

  def wait_poll: (untyped timeout) -> untyped
end

class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
  def self.register_pool: (untyped pool, untyped frequency) -> untyped

  public

  def frequency: () -> untyped

  def pool: () -> untyped

  def run: () -> untyped

  private

  def initialize: (untyped pool, untyped frequency) -> untyped
end

module ActiveRecord::ConnectionAdapters::DatabaseLimits
  public

  def allowed_index_name_length: (*untyped args) { (*untyped) -> untyped } -> untyped

  def column_name_length: (*untyped args) { (*untyped) -> untyped } -> untyped

  def columns_per_multicolumn_index: (*untyped args) { (*untyped) -> untyped } -> untyped

  def columns_per_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def in_clause_length: (*untyped args) { (*untyped) -> untyped } -> untyped

  def index_name_length: () -> untyped

  def indexes_per_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def joins_per_query: (*untyped args) { (*untyped) -> untyped } -> untyped

  def max_identifier_length: () -> untyped

  def sql_query_length: (*untyped args) { (*untyped) -> untyped } -> untyped

  def table_alias_length: () -> untyped

  def table_name_length: (*untyped args) { (*untyped) -> untyped } -> untyped

  private

  def bind_params_length: () -> untyped
end

module ActiveRecord::ConnectionAdapters::DatabaseStatements
  public

  def add_transaction_record: (untyped record, ?untyped ensure_finalize) -> untyped

  def begin_db_transaction: () -> untyped

  def begin_isolated_db_transaction: (untyped isolation) -> untyped

  def begin_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  def cacheable_query: (untyped klass, untyped arel) -> untyped

  def commit_db_transaction: () -> untyped

  def commit_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  alias create insert

  def current_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  def default_sequence_name: (untyped table, untyped column) -> untyped

  def delete: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def disable_lazy_transactions!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def empty_insert_statement_value: (?untyped primary_key) -> untyped

  def enable_lazy_transactions!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def exec_delete: (untyped sql, ?untyped name, ?untyped binds) -> untyped

  def exec_insert: (untyped sql, ?untyped name, ?untyped binds, ?untyped pk, ?untyped sequence_name) -> untyped

  def exec_insert_all: (untyped sql, untyped name) -> untyped

  def exec_query: (untyped sql, ?untyped name, ?untyped binds, ?prepare: untyped) -> untyped

  def exec_rollback_db_transaction: () -> untyped

  def exec_update: (untyped sql, ?untyped name, ?untyped binds) -> untyped

  def execute: (untyped sql, ?untyped name) -> untyped

  def insert: (untyped arel, ?untyped name, ?untyped pk, ?untyped id_value, ?untyped sequence_name, ?untyped binds) -> untyped

  def insert_fixture: (untyped fixture, untyped table_name) -> untyped

  def insert_fixtures_set: (untyped fixture_set, ?untyped tables_to_delete) -> untyped

  def mark_transaction_written_if_write: (untyped sql) -> untyped

  def materialize_transactions: (*untyped *) { (*untyped) -> untyped } -> untyped

  def open_transactions: (*untyped *) { (*untyped) -> untyped } -> untyped

  def query: (untyped sql, ?untyped name) -> untyped

  def query_value: (untyped sql, ?untyped name) -> untyped

  def query_values: (untyped sql, ?untyped name) -> untyped

  def reset_sequence!: (untyped table, untyped column, ?untyped sequence) -> untyped

  def reset_transaction: () -> untyped

  def rollback_db_transaction: () -> untyped

  def rollback_to_savepoint: (?untyped name) -> untyped

  def rollback_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  def sanitize_limit: (untyped limit) -> untyped

  def select_all: (untyped arel, ?untyped name, ?untyped binds, ?preparable: untyped) -> untyped

  def select_one: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def select_rows: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def select_value: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def select_values: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def to_sql: (untyped arel_or_sql_string, ?untyped binds) -> untyped

  def transaction: (?requires_new: untyped, ?isolation: untyped, ?joinable: untyped) -> untyped

  def transaction_isolation_levels: () -> untyped

  def transaction_manager: () -> untyped

  def transaction_open?: () -> untyped

  def truncate: (untyped table_name, ?untyped name) -> untyped

  def truncate_tables: (*untyped table_names) -> untyped

  def update: (untyped arel, ?untyped name, ?untyped binds) -> untyped

  def with_yaml_fallback: (untyped value) -> untyped

  def within_new_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  def write_query?: (untyped sql) -> untyped

  private

  def arel_from_relation: (untyped relation) -> untyped

  def build_fixture_sql: (untyped fixtures, untyped table_name) -> untyped

  def build_fixture_statements: (untyped fixture_set) -> untyped

  def build_truncate_statement: (untyped table_name) -> untyped

  def build_truncate_statements: (untyped table_names) -> untyped

  def combine_multi_statements: (untyped total_sql) -> untyped

  def default_insert_value: (untyped column) -> untyped

  def execute_batch: (untyped statements, ?untyped name) -> untyped

  def initialize: () -> untyped

  def last_inserted_id: (untyped result) -> untyped

  def select: (untyped sql, ?untyped name, ?untyped binds) -> untyped

  def select_prepared: (untyped sql, ?untyped name, ?untyped binds) -> untyped

  def single_value_from_rows: (untyped rows) -> untyped

  def sql_for_insert: (untyped sql, untyped pk, untyped binds) -> untyped

  def to_sql_and_binds: (untyped arel_or_sql_string, ?untyped binds, ?untyped preparable) -> untyped

  def with_multi_statements: () -> untyped
end

class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def column: () -> untyped

  def custom_primary_key?: () -> untyped

  def defined_for?: (?to_table: untyped, ?validate: untyped, **untyped) -> untyped

  def export_name_on_schema_dump?: () -> untyped

  def from_table: () -> untyped

  def from_table=: (untyped _) -> untyped

  def name: () -> untyped

  def on_delete: () -> untyped

  def on_update: () -> untyped

  def options: () -> untyped

  def options=: (untyped _) -> untyped

  def primary_key: () -> untyped

  def to_table: () -> untyped

  def to_table=: (untyped _) -> untyped

  def validate?: () -> untyped

  alias validated? validate?

  private

  def default_primary_key: () -> untyped
end

class ActiveRecord::ConnectionAdapters::IndexDefinition
  public

  def column_options: () -> untyped

  def columns: () -> untyped

  def comment: () -> untyped

  def lengths: () -> untyped

  def name: () -> untyped

  def opclasses: () -> untyped

  def orders: () -> untyped

  def table: () -> untyped

  def `type`: () -> untyped

  def unique: () -> untyped

  def using: () -> untyped

  def where: () -> untyped

  private

  def concise_options: (untyped options) -> untyped

  def initialize: (untyped table, untyped name, ?untyped unique, ?untyped columns, ?lengths: untyped, ?orders: untyped, ?opclasses: untyped, ?where: untyped, ?type: untyped, ?using: untyped, ?comment: untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::NullColumn < ActiveRecord::ConnectionAdapters::Column
  private

  def initialize: (untyped name, **untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::NullPool
  include AbstractPool

  public

  def schema_cache: () -> untyped

  def schema_cache=: (untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::NullTransaction
  public

  def add_record: (untyped record, ?untyped _) -> untyped

  def closed?: () -> untyped

  def joinable?: () -> untyped

  def open?: () -> untyped

  def state: () -> untyped

  private

  def initialize: () -> untyped
end

class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def name: () -> untyped

  def name=: (untyped _) -> untyped
end

module ActiveRecord::ConnectionAdapters::QueryCache
  def self.dirties_query_cache: (untyped base, *untyped method_names) -> untyped

  def self.included: (untyped base) -> untyped

  public

  def cache: () -> untyped

  def clear_query_cache: () -> untyped

  def disable_query_cache!: () -> untyped

  def enable_query_cache!: () -> untyped

  def query_cache: () -> untyped

  def query_cache_enabled: () -> untyped

  def select_all: (untyped arel, ?untyped name, ?untyped binds, ?preparable: untyped) -> untyped

  def uncached: () -> untyped

  private

  def cache_notification_info: (untyped sql, untyped name, untyped binds) -> untyped

  def cache_sql: (untyped sql, untyped name, untyped binds) -> untyped

  def configure_query_cache!: () -> untyped

  def initialize: (*untyped) -> untyped

  def locked?: (untyped arel) -> untyped
end

module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
  public

  def disable_query_cache!: () -> untyped

  def enable_query_cache!: () -> untyped

  def query_cache_enabled: () -> untyped

  private

  def initialize: (*untyped) -> untyped
end

module ActiveRecord::ConnectionAdapters::Quoting
  public

  def column_name_matcher: () -> untyped

  def column_name_with_order_matcher: () -> untyped

  def lookup_cast_type_from_column: (untyped column) -> untyped

  def quote: (untyped value) -> untyped

  def quote_column_name: (untyped column_name) -> untyped

  def quote_default_expression: (untyped value, untyped column) -> untyped

  def quote_string: (untyped s) -> untyped

  def quote_table_name: (untyped table_name) -> untyped

  def quote_table_name_for_assignment: (untyped table, untyped attr) -> untyped

  def quoted_binary: (untyped value) -> untyped

  def quoted_date: (untyped value) -> untyped

  def quoted_false: () -> untyped

  def quoted_time: (untyped value) -> untyped

  def quoted_true: () -> untyped

  def sanitize_as_sql_comment: (untyped value) -> untyped

  def type_cast: (untyped value, ?untyped column) -> untyped

  def unquoted_false: () -> untyped

  def unquoted_true: () -> untyped

  private

  def _quote: (untyped value) -> untyped

  def _type_cast: (untyped value) -> untyped

  def lookup_cast_type: (untyped sql_type) -> untyped

  def type_casted_binds: (untyped binds) -> untyped
end

class ActiveRecord::ConnectionAdapters::RealTransaction < ActiveRecord::ConnectionAdapters::Transaction
  public

  def commit: () -> untyped

  def materialize!: () -> untyped

  def rollback: () -> untyped
end

class ActiveRecord::ConnectionAdapters::ReferenceDefinition
  public

  def add_to: (untyped table) -> untyped

  private

  def as_options: (untyped value) -> untyped

  def column_name: () -> untyped

  def column_names: () -> untyped

  def columns: () -> untyped

  def foreign_key: () -> untyped

  def foreign_key_options: () -> untyped

  def foreign_table_name: () -> untyped

  def index: () -> untyped

  def index_options: () -> untyped

  def initialize: (untyped name, ?polymorphic: untyped, ?index: untyped, ?foreign_key: untyped, ?type: untyped, **untyped) -> untyped

  def name: () -> untyped

  def options: () -> untyped

  def polymorphic: () -> untyped

  def polymorphic_options: () -> untyped

  def `type`: () -> untyped
end

class ActiveRecord::ConnectionAdapters::SavepointTransaction < ActiveRecord::ConnectionAdapters::Transaction
  public

  def commit: () -> untyped

  def full_rollback?: () -> untyped

  def materialize!: () -> untyped

  def rollback: () -> untyped

  private

  def initialize: (untyped connection, untyped savepoint_name, untyped parent_transaction, **untyped) -> untyped
end

module ActiveRecord::ConnectionAdapters::Savepoints
  public

  def create_savepoint: (?untyped name) -> untyped

  def current_savepoint_name: () -> untyped

  def exec_rollback_to_savepoint: (?untyped name) -> untyped

  def release_savepoint: (?untyped name) -> untyped
end

class ActiveRecord::ConnectionAdapters::SchemaCache
  def self.load_from: (untyped filename) -> untyped

  public

  def add: (untyped table_name) -> untyped

  def clear!: () -> untyped

  def clear_data_source_cache!: (untyped name) -> untyped

  def columns: (untyped table_name) -> untyped

  def columns_hash: (untyped table_name) -> untyped

  def columns_hash?: (untyped table_name) -> untyped

  def connection: () -> untyped

  def connection=: (untyped) -> untyped

  def data_source_exists?: (untyped name) -> untyped

  def data_sources: (untyped name) -> untyped

  def database_version: () -> untyped

  def dump_to: (untyped filename) -> untyped

  def encode_with: (untyped coder) -> untyped

  def indexes: (untyped table_name) -> untyped

  def init_with: (untyped coder) -> untyped

  def marshal_dump: () -> untyped

  def marshal_load: (untyped array) -> untyped

  def primary_keys: (untyped table_name) -> untyped

  def size: () -> untyped

  def version: () -> untyped

  private

  def deep_deduplicate: (untyped value) -> untyped

  def derive_columns_hash_and_deduplicate_values: () -> untyped

  def initialize: (untyped conn) -> untyped

  def initialize_dup: (untyped other) -> untyped

  def open: (untyped filename) -> untyped

  def prepare_data_sources: () -> untyped

  def reset_version!: () -> untyped
end

class ActiveRecord::ConnectionAdapters::SchemaDumper < ActiveRecord::SchemaDumper
  def self.create: (untyped connection, untyped options) -> untyped

  private

  def column_spec: (untyped column) -> untyped

  def column_spec_for_primary_key: (untyped column) -> untyped

  def default_primary_key?: (untyped column) -> untyped

  def explicit_primary_key_default?: (untyped column) -> untyped

  def prepare_column_options: (untyped column) -> untyped

  def schema_collation: (untyped column) -> untyped

  def schema_default: (untyped column) -> untyped

  def schema_expression: (untyped column) -> untyped

  def schema_limit: (untyped column) -> untyped

  def schema_precision: (untyped column) -> untyped

  def schema_scale: (untyped column) -> untyped

  def schema_type: (untyped column) -> untyped

  def schema_type_with_virtual: (untyped column) -> untyped
end

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

  public

  alias add_belongs_to add_reference

  def add_check_constraint: (untyped table_name, untyped expression, **untyped) -> untyped

  def add_column: (untyped table_name, untyped column_name, untyped `type`, **untyped) -> untyped

  def add_columns: (untyped table_name, *untyped column_names, type: untyped, **untyped) -> untyped

  def add_foreign_key: (untyped from_table, untyped to_table, **untyped) -> untyped

  def add_index: (untyped table_name, untyped column_name, **untyped) -> untyped

  def add_index_options: (untyped table_name, untyped column_name, ?name: untyped, ?if_not_exists: untyped, ?internal: untyped, **untyped) -> untyped

  def add_reference: (untyped table_name, untyped ref_name, **untyped) -> untyped

  def add_timestamps: (untyped table_name, **untyped) -> untyped

  def assume_migrated_upto_version: (untyped version, ?untyped migrations_paths) -> untyped

  def change_column: (untyped table_name, untyped column_name, untyped `type`, **untyped) -> untyped

  def change_column_comment: (untyped table_name, untyped column_name, untyped comment_or_changes) -> untyped

  def change_column_default: (untyped table_name, untyped column_name, untyped default_or_changes) -> untyped

  def change_column_null: (untyped table_name, untyped column_name, untyped null, ?untyped default) -> untyped

  def change_table: (untyped table_name, **untyped) -> untyped

  def change_table_comment: (untyped table_name, untyped comment_or_changes) -> untyped

  def check_constraint_options: (untyped table_name, untyped expression, untyped options) -> untyped

  def check_constraints: (untyped table_name) -> untyped

  def column_exists?: (untyped table_name, untyped column_name, ?untyped `type`, **untyped) -> untyped

  def columns: (untyped table_name) -> untyped

  def columns_for_distinct: (untyped columns, untyped orders) -> untyped

  def create_join_table: (untyped table_1, untyped table_2, ?column_options: untyped, **untyped) -> untyped

  def create_schema_dumper: (untyped options) -> untyped

  def create_table: (untyped table_name, ?id: untyped, ?primary_key: untyped, ?force: untyped, **untyped) -> untyped

  def data_source_exists?: (untyped name) -> untyped

  def data_sources: () -> untyped

  def drop_join_table: (untyped table_1, untyped table_2, **untyped) -> untyped

  def drop_table: (untyped table_name, **untyped) -> untyped

  def dump_schema_information: () -> untyped

  def foreign_key_column_for: (untyped table_name) -> untyped

  def foreign_key_exists?: (untyped from_table, ?untyped to_table, **untyped) -> untyped

  def foreign_key_options: (untyped from_table, untyped to_table, untyped options) -> untyped

  def foreign_keys: (untyped table_name) -> untyped

  def index_algorithm: (untyped algorithm) -> untyped

  def index_exists?: (untyped table_name, untyped column_name, **untyped) -> untyped

  def index_name: (untyped table_name, untyped options) -> untyped

  def index_name_exists?: (untyped table_name, untyped index_name) -> untyped

  def indexes: (untyped table_name) -> untyped

  def internal_string_options_for_primary_key: () -> untyped

  def native_database_types: () -> untyped

  def options_include_default?: (untyped options) -> untyped

  def primary_key: (untyped table_name) -> untyped

  def quoted_columns_for_index: (untyped column_names, untyped options) -> untyped

  alias remove_belongs_to remove_reference

  def remove_check_constraint: (untyped table_name, ?untyped expression, **untyped) -> untyped

  def remove_column: (untyped table_name, untyped column_name, ?untyped `type`, **untyped) -> untyped

  def remove_columns: (untyped table_name, *untyped column_names, ?type: untyped, **untyped) -> untyped

  def remove_foreign_key: (untyped from_table, ?untyped to_table, **untyped) -> untyped

  def remove_index: (untyped table_name, ?untyped column_name, **untyped) -> untyped

  def remove_reference: (untyped table_name, untyped ref_name, ?foreign_key: untyped, ?polymorphic: untyped, **untyped) -> untyped

  def remove_timestamps: (untyped table_name, **untyped) -> untyped

  def rename_column: (untyped table_name, untyped column_name, untyped new_column_name) -> untyped

  def rename_index: (untyped table_name, untyped old_name, untyped new_name) -> untyped

  def rename_table: (untyped table_name, untyped new_name) -> untyped

  def table_alias_for: (untyped table_name) -> untyped

  def table_comment: (untyped table_name) -> untyped

  def table_exists?: (untyped table_name) -> untyped

  def table_options: (untyped table_name) -> untyped

  def tables: () -> untyped

  def type_to_sql: (untyped `type`, ?limit: untyped, ?precision: untyped, ?scale: untyped, **untyped) -> untyped

  def update_table_definition: (untyped table_name, untyped base) -> untyped

  def view_exists?: (untyped view_name) -> untyped

  def views: () -> untyped

  private

  def add_column_for_alter: (untyped table_name, untyped column_name, untyped `type`, **untyped) -> untyped

  def add_index_sort_order: (untyped quoted_columns, **untyped) -> untyped

  def add_options_for_index_columns: (untyped quoted_columns, **untyped) -> untyped

  def add_timestamps_for_alter: (untyped table_name, **untyped) -> untyped

  def bulk_change_table: (untyped table_name, untyped operations) -> untyped

  def can_remove_index_by_name?: (untyped column_name, untyped options) -> untyped

  def check_constraint_for: (untyped table_name, **untyped) -> untyped

  def check_constraint_for!: (untyped table_name, ?expression: untyped, **untyped) -> untyped

  def check_constraint_name: (untyped table_name, **untyped) -> untyped

  def column_options_keys: () -> untyped

  def create_alter_table: (untyped name) -> untyped

  def create_table_definition: (untyped name, **untyped) -> untyped

  def data_source_sql: (?untyped name, ?type: untyped) -> untyped

  def extract_foreign_key_action: (untyped specifier) -> untyped

  alias extract_new_comment_value extract_new_default_value

  def extract_new_default_value: (untyped default_or_changes) -> untyped

  def extract_table_options!: (untyped options) -> untyped

  def fetch_type_metadata: (untyped sql_type) -> untyped

  def foreign_key_for: (untyped from_table, **untyped) -> untyped

  def foreign_key_for!: (untyped from_table, ?to_table: untyped, **untyped) -> untyped

  def foreign_key_name: (untyped table_name, untyped options) -> untyped

  def index_column_names: (untyped column_names) -> untyped

  def index_name_for_remove: (untyped table_name, untyped column_name, untyped options) -> untyped

  def index_name_options: (untyped column_names) -> untyped

  def insert_versions_sql: (untyped versions) -> untyped

  def options_for_index_columns: (untyped options) -> untyped

  def quoted_scope: (?untyped name, ?type: untyped) -> untyped

  def remove_column_for_alter: (untyped table_name, untyped column_name, ?untyped `type`, **untyped) -> untyped

  def remove_columns_for_alter: (untyped table_name, *untyped column_names, **untyped) -> untyped

  def remove_timestamps_for_alter: (untyped table_name, **untyped) -> untyped

  def rename_column_indexes: (untyped table_name, untyped column_name, untyped new_column_name) -> untyped

  def rename_column_sql: (untyped table_name, untyped column_name, untyped new_column_name) -> untyped

  def rename_table_indexes: (untyped table_name, untyped new_name) -> untyped

  def schema_creation: () -> untyped

  def strip_table_name_prefix_and_suffix: (untyped table_name) -> untyped

  def validate_index_length!: (untyped table_name, untyped new_name, ?untyped internal) -> untyped
end

class ActiveRecord::ConnectionAdapters::SqlTypeMetadata
  include Deduplicable

  public

  def ==: (untyped other) -> untyped

  alias eql? ==

  def hash: () -> untyped

  def limit: () -> untyped

  def precision: () -> untyped

  def scale: () -> untyped

  def sql_type: () -> untyped

  def `type`: () -> untyped

  private

  def deduplicated: () -> untyped

  def initialize: (?sql_type: untyped, ?type: untyped, ?limit: untyped, ?precision: untyped, ?scale: untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::Table
  include ColumnMethods

  public

  alias belongs_to references

  def bigint: (*untyped names, **untyped) -> untyped

  def binary: (*untyped names, **untyped) -> untyped

  def boolean: (*untyped names, **untyped) -> untyped

  def change: (untyped column_name, untyped `type`, **untyped) -> untyped

  def change_default: (untyped column_name, untyped default_or_changes) -> untyped

  def change_null: (untyped column_name, untyped null, ?untyped default) -> untyped

  def check_constraint: (*untyped args) -> untyped

  def column: (untyped column_name, untyped `type`, ?index: untyped, **untyped) -> untyped

  def column_exists?: (untyped column_name, ?untyped `type`, **untyped) -> untyped

  def date: (*untyped names, **untyped) -> untyped

  def datetime: (*untyped names, **untyped) -> untyped

  def decimal: (*untyped names, **untyped) -> untyped

  def float: (*untyped names, **untyped) -> untyped

  def foreign_key: (*untyped args, **untyped) -> untyped

  def foreign_key_exists?: (*untyped args, **untyped) -> untyped

  def index: (untyped column_name, **untyped) -> untyped

  def index_exists?: (untyped column_name, ?untyped options) -> untyped

  def integer: (*untyped names, **untyped) -> untyped

  def json: (*untyped names, **untyped) -> untyped

  def name: () -> untyped

  alias numeric decimal

  def references: (*untyped args, **untyped) -> untyped

  def remove: (*untyped column_names, **untyped) -> untyped

  alias remove_belongs_to remove_references

  def remove_check_constraint: (*untyped args) -> untyped

  def remove_foreign_key: (*untyped args, **untyped) -> untyped

  def remove_index: (?untyped column_name, **untyped) -> untyped

  def remove_references: (*untyped args, **untyped) -> untyped

  def remove_timestamps: (**untyped) -> untyped

  def rename: (untyped column_name, untyped new_column_name) -> untyped

  def rename_index: (untyped index_name, untyped new_index_name) -> untyped

  def string: (*untyped names, **untyped) -> untyped

  def text: (*untyped names, **untyped) -> untyped

  def time: (*untyped names, **untyped) -> untyped

  def timestamp: (*untyped names, **untyped) -> untyped

  def timestamps: (**untyped) -> untyped

  def virtual: (*untyped names, **untyped) -> untyped

  private

  def initialize: (untyped table_name, untyped base) -> untyped
end

class ActiveRecord::ConnectionAdapters::TableDefinition
  include ColumnMethods

  public

  def []: (untyped name) -> untyped

  def as: () -> untyped

  alias belongs_to references

  def bigint: (*untyped names, **untyped) -> untyped

  def binary: (*untyped names, **untyped) -> untyped

  def boolean: (*untyped names, **untyped) -> untyped

  def check_constraint: (untyped expression, **untyped) -> untyped

  def check_constraints: () -> untyped

  def column: (untyped name, untyped `type`, ?index: untyped, **untyped) -> untyped

  def columns: () -> untyped

  def comment: () -> untyped

  def date: (*untyped names, **untyped) -> untyped

  def datetime: (*untyped names, **untyped) -> untyped

  def decimal: (*untyped names, **untyped) -> untyped

  def float: (*untyped names, **untyped) -> untyped

  def foreign_key: (untyped table_name, **untyped) -> untyped

  def foreign_keys: () -> untyped

  def if_not_exists: () -> untyped

  def index: (untyped column_name, **untyped) -> untyped

  def indexes: () -> untyped

  def integer: (*untyped names, **untyped) -> untyped

  def json: (*untyped names, **untyped) -> untyped

  def name: () -> untyped

  def new_column_definition: (untyped name, untyped `type`, **untyped) -> untyped

  alias numeric decimal

  def options: () -> untyped

  def primary_keys: (?untyped name) -> untyped

  def references: (*untyped args, **untyped) -> untyped

  def remove_column: (untyped name) -> untyped

  def string: (*untyped names, **untyped) -> untyped

  def temporary: () -> untyped

  def text: (*untyped names, **untyped) -> untyped

  def time: (*untyped names, **untyped) -> untyped

  def timestamp: (*untyped names, **untyped) -> untyped

  def timestamps: (**untyped) -> untyped

  def virtual: (*untyped names, **untyped) -> untyped

  private

  def aliased_types: (untyped name, untyped fallback) -> untyped

  def create_column_definition: (untyped name, untyped `type`, untyped options) -> untyped

  def initialize: (untyped conn, untyped name, ?temporary: untyped, ?if_not_exists: untyped, ?options: untyped, ?as: untyped, ?comment: untyped, **untyped) -> untyped

  def integer_like_primary_key?: (untyped `type`, untyped options) -> untyped

  def integer_like_primary_key_type: (untyped `type`, untyped options) -> untyped
end

class ActiveRecord::ConnectionAdapters::Transaction
  public

  def add_record: (untyped record, ?untyped ensure_finalize) -> untyped

  def before_commit_records: () -> untyped

  def closed?: () -> untyped

  def commit_records: () -> untyped

  def connection: () -> untyped

  def full_rollback?: () -> untyped

  def isolation_level: () -> untyped

  def joinable?: () -> untyped

  def materialize!: () -> untyped

  def materialized?: () -> untyped

  def open?: () -> untyped

  def records: () -> untyped

  def rollback_records: () -> untyped

  def savepoint_name: () -> untyped

  def state: () -> untyped

  def written: () -> untyped

  def written=: (untyped) -> untyped

  private

  def initialize: (untyped connection, ?isolation: untyped, ?joinable: untyped, ?run_commit_callbacks: untyped) -> untyped
end

class ActiveRecord::ConnectionAdapters::TransactionManager
  public

  def begin_transaction: (?isolation: untyped, ?joinable: untyped, ?_lazy: untyped) -> untyped

  def commit_transaction: () -> untyped

  def current_transaction: () -> untyped

  def disable_lazy_transactions!: () -> untyped

  def enable_lazy_transactions!: () -> untyped

  def lazy_transactions_enabled?: () -> untyped

  def materialize_transactions: () -> untyped

  def open_transactions: () -> untyped

  def rollback_transaction: (?untyped transaction) -> untyped

  def within_new_transaction: (?isolation: untyped, ?joinable: untyped) -> untyped

  private

  def after_failure_actions: (untyped transaction, untyped error) -> untyped

  def initialize: (untyped connection) -> untyped
end

ActiveRecord::ConnectionAdapters::TransactionManager::NULL_TRANSACTION: ActiveRecord::ConnectionAdapters::NullTransaction

class ActiveRecord::ConnectionAdapters::TransactionState
  public

  def add_child: (untyped state) -> untyped

  def commit!: () -> untyped

  def committed?: () -> untyped

  def completed?: () -> untyped

  def finalized?: () -> untyped

  def full_commit!: () -> untyped

  def full_rollback!: () -> untyped

  def fully_committed?: () -> untyped

  def fully_completed?: () -> untyped

  def fully_rolledback?: () -> untyped

  def nullify!: () -> untyped

  def rollback!: () -> untyped

  def rolledback?: () -> untyped

  private

  def initialize: (?untyped state) -> untyped
end

module ActiveRecord::ConnectionHandling
  public

  def clear_active_connections!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def clear_all_connections!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def clear_cache!: () -> untyped

  def clear_query_caches_for_current_thread: () -> untyped

  def clear_reloadable_connections!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def connected?: () -> untyped

  def connected_to: (?database: untyped, ?role: untyped, ?shard: untyped, ?prevent_writes: untyped) { (*untyped) -> untyped } -> untyped

  def connected_to?: (role: untyped, ?shard: untyped) -> untyped

  def connection: () -> untyped

  def connection_config: (*untyped args) { (*untyped) -> untyped } -> untyped

  def connection_db_config: () -> untyped

  def connection_pool: () -> untyped

  def connection_specification_name: () -> untyped

  def connection_specification_name=: (untyped) -> untyped

  def connects_to: (?database: untyped, ?shards: untyped) -> untyped

  def current_role: () -> untyped

  def establish_connection: (?untyped config_or_env) -> untyped

  def flush_idle_connections!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def lookup_connection_handler: (untyped handler_key) -> untyped

  def primary_class?: () -> untyped

  def remove_connection: (?untyped name) -> untyped

  def retrieve_connection: () -> untyped

  private

  def resolve_config_for_connection: (untyped config_or_env) -> untyped

  def swap_connection_handler: (untyped handler) { (*untyped) -> untyped } -> untyped

  def with_handler: (untyped handler_key) { (*untyped) -> untyped } -> untyped

  def with_role: (untyped role, untyped prevent_writes) { (*untyped) -> untyped } -> untyped

  def with_shard: (untyped pool_key, untyped role, untyped prevent_writes) -> untyped
end

ActiveRecord::ConnectionHandling::DEFAULT_ENV: Proc

ActiveRecord::ConnectionHandling::RAILS_ENV: Proc

class ActiveRecord::ConnectionNotEstablished < ActiveRecord::ActiveRecordError
end

class ActiveRecord::ConnectionTimeoutError < ActiveRecord::ConnectionNotEstablished
end

module ActiveRecord::Core
  public

  def <=>: (untyped other_object) -> untyped

  def ==: (untyped comparison_object) -> untyped

  def blank?: () -> untyped

  def connection_handler: () -> untyped

  def encode_with: (untyped coder) -> untyped

  alias eql? ==

  def freeze: () -> untyped

  def frozen?: () -> untyped

  def hash: () -> untyped

  def init_with: (untyped coder) { (*untyped) -> untyped } -> untyped

  def init_with_attributes: (untyped attributes, ?untyped new_record) -> untyped

  def inspect: () -> untyped

  def present?: () -> untyped

  def pretty_print: (untyped pp) -> untyped

  def readonly!: () -> untyped

  def readonly?: () -> untyped

  def slice: (*untyped methods) -> untyped

  def strict_loading!: () -> untyped

  def strict_loading?: () -> untyped

  private

  def custom_inspect_method_defined?: () -> untyped

  def init_internals: () -> untyped

  def initialize: (?untyped attributes) -> untyped

  def initialize_dup: (untyped other) -> untyped

  def initialize_internals_callback: () -> untyped

  def inspection_filter: () -> untyped

  def to_ary: () -> untyped
end

module ActiveRecord::Core::ClassMethods
  public

  def ===: (untyped object) -> untyped

  def _internal?: () -> untyped

  def arel_attribute: (untyped name, ?untyped table) -> untyped

  def arel_table: () -> untyped

  def cached_find_by_statement: (untyped key) { (*untyped) -> untyped } -> untyped

  def filter_attributes: () -> untyped

  def filter_attributes=: (untyped) -> untyped

  def find: (*untyped ids) -> untyped

  def find_by: (*untyped args) -> untyped

  def find_by!: (*untyped args) -> untyped

  def generated_association_methods: () -> untyped

  def inherited: (untyped child_class) -> untyped

  def initialize_find_by_cache: () -> untyped

  def initialize_generated_modules: () -> untyped

  def inspect: () -> untyped

  def predicate_builder: () -> untyped

  def type_caster: () -> untyped

  private

  def relation: () -> untyped

  def table_metadata: () -> untyped
end

module ActiveRecord::CounterCache
  private

  def _create_record: (?untyped attribute_names) -> untyped

  def destroy_row: () -> untyped

  def each_counter_cached_associations: () -> untyped
end

module ActiveRecord::CounterCache::ClassMethods
  public

  def decrement_counter: (untyped counter_name, untyped id, ?touch: untyped) -> untyped

  def increment_counter: (untyped counter_name, untyped id, ?touch: untyped) -> untyped

  def reset_counters: (untyped id, *untyped counters, ?touch: untyped) -> untyped

  def update_counters: (untyped id, untyped counters) -> untyped
end

class ActiveRecord::DangerousAttributeError < ActiveRecord::ActiveRecordError
end

class ActiveRecord::DatabaseConfigurations
  public

  def []: (*untyped args) { (*untyped) -> untyped } -> untyped

  def any?: (*untyped *) { (*untyped) -> untyped } -> untyped

  alias blank? empty?

  def configs_for: (?env_name: untyped, ?spec_name: untyped, ?name: untyped, ?include_replicas: untyped) -> untyped

  def configurations: () -> untyped

  def default_hash: (*untyped args) { (*untyped) -> untyped } -> untyped

  def each: () -> untyped

  def empty?: () -> untyped

  def find_db_config: (untyped env) -> untyped

  def first: () -> untyped

  def resolve: (untyped config) -> untyped

  def to_h: (*untyped args) { (*untyped) -> untyped } -> untyped

  private

  def build_configs: (untyped configs) -> untyped

  def build_configuration_sentence: () -> untyped

  def build_db_config_from_hash: (untyped env_name, untyped name, untyped config) -> untyped

  def build_db_config_from_raw_config: (untyped env_name, untyped name, untyped config) -> untyped

  def build_db_config_from_string: (untyped env_name, untyped name, untyped config) -> untyped

  def default_env: () -> untyped

  def env_with_configs: (?untyped env) -> untyped

  def environment_url_config: (untyped env, untyped name, untyped config) -> untyped

  def environment_value_for: (untyped name) -> untyped

  def initialize: (?untyped configurations) -> untyped

  def merge_db_environment_variables: (untyped current_env, untyped configs) -> untyped

  def method_missing: (untyped method, *untyped args) { (*untyped) -> untyped } -> untyped

  def resolve_symbol_connection: (untyped name) -> untyped

  def throw_getter_deprecation: (untyped method) -> untyped

  def throw_setter_deprecation: (untyped method) -> untyped

  def walk_configs: (untyped env_name, untyped config) -> untyped
end

class ActiveRecord::DatabaseConfigurations::DatabaseConfig
  public

  def _database=: (untyped database) -> untyped

  def adapter: () -> untyped

  def adapter_method: () -> untyped

  def checkout_timeout: () -> untyped

  def config: () -> untyped

  def database: () -> untyped

  def env_name: () -> untyped

  def for_current_env?: () -> untyped

  def host: () -> untyped

  def idle_timeout: () -> untyped

  def migrations_paths: () -> untyped

  def name: () -> untyped

  def owner_name: () -> untyped

  def owner_name=: (untyped) -> untyped

  def pool: () -> untyped

  def reaping_frequency: () -> untyped

  def replica?: () -> untyped

  def schema_cache_path: () -> untyped

  def spec_name: (*untyped args) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped env_name, untyped name) -> untyped
end

class ActiveRecord::DatabaseConfigurations::HashConfig < ActiveRecord::DatabaseConfigurations::DatabaseConfig
  public

  def _database=: (untyped database) -> untyped

  def adapter: () -> untyped

  def checkout_timeout: () -> untyped

  def config: () -> untyped

  def configuration_hash: () -> untyped

  def database: () -> untyped

  def host: () -> untyped

  def idle_timeout: () -> untyped

  def migrations_paths: () -> untyped

  def pool: () -> untyped

  def reaping_frequency: () -> untyped

  def replica?: () -> untyped

  def schema_cache_path: () -> untyped

  private

  def initialize: (untyped env_name, untyped name, untyped configuration_hash) -> untyped
end

class ActiveRecord::DatabaseConfigurations::InvalidConfigurationError < StandardError
end

class ActiveRecord::DatabaseConfigurations::UrlConfig < ActiveRecord::DatabaseConfigurations::HashConfig
  public

  def url: () -> untyped

  private

  def build_url_hash: () -> untyped

  def initialize: (untyped env_name, untyped name, untyped url, ?untyped configuration_hash) -> untyped
end

class ActiveRecord::Deadlocked < ActiveRecord::TransactionRollbackError
end

module ActiveRecord::Delegation
  public

  def &: (*untyped *) { (*untyped) -> untyped } -> untyped

  def +: (*untyped *) { (*untyped) -> untyped } -> untyped

  def -: (*untyped *) { (*untyped) -> untyped } -> untyped

  def []: (*untyped *) { (*untyped) -> untyped } -> untyped

  def as_json: (*untyped *) { (*untyped) -> untyped } -> untyped

  def compact: (*untyped *) { (*untyped) -> untyped } -> untyped

  def connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def each: (*untyped *) { (*untyped) -> untyped } -> untyped

  def encode_with: (*untyped *) { (*untyped) -> untyped } -> untyped

  def in_groups: (*untyped *) { (*untyped) -> untyped } -> untyped

  def in_groups_of: (*untyped *) { (*untyped) -> untyped } -> untyped

  def index: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join: (*untyped *) { (*untyped) -> untyped } -> untyped

  def length: (*untyped *) { (*untyped) -> untyped } -> untyped

  def primary_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reverse: (*untyped *) { (*untyped) -> untyped } -> untyped

  def rindex: (*untyped *) { (*untyped) -> untyped } -> untyped

  def rotate: (*untyped *) { (*untyped) -> untyped } -> untyped

  def sample: (*untyped *) { (*untyped) -> untyped } -> untyped

  def shuffle: (*untyped *) { (*untyped) -> untyped } -> untyped

  def slice: (*untyped *) { (*untyped) -> untyped } -> untyped

  def split: (*untyped *) { (*untyped) -> untyped } -> untyped

  def to_formatted_s: (*untyped *) { (*untyped) -> untyped } -> untyped

  def to_sentence: (*untyped *) { (*untyped) -> untyped } -> untyped

  def to_xml: (*untyped *) { (*untyped) -> untyped } -> untyped

  def |: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def respond_to_missing?: (untyped method, untyped _) -> untyped
end

module ActiveRecord::Delegation::ClassMethods
  public

  def create: (untyped klass, *untyped args, **untyped) -> untyped

  private

  def relation_class_for: (untyped klass) -> untyped
end

module ActiveRecord::Delegation::ClassSpecificRelation
  private

  def method_missing: (untyped method, *untyped args) { (*untyped) -> untyped } -> untyped
end

module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
  public

  def name: () -> untyped
end

module ActiveRecord::Delegation::DelegateCache
  public

  def generate_relation_method: (untyped method) -> untyped

  def inherited: (untyped child_class) -> untyped

  def initialize_relation_delegate_cache: () -> untyped

  def relation_delegate_class: (untyped klass) -> untyped

  private

  def generated_relation_methods: () -> untyped
end

class ActiveRecord::Delegation::GeneratedRelationMethods < Module
  include Mutex_m

  public

  def generate_method: (untyped method) -> untyped

  alias lock mu_lock

  alias locked? mu_locked?

  alias synchronize mu_synchronize

  alias try_lock mu_try_lock

  alias unlock mu_unlock
end

class ActiveRecord::DeleteRestrictionError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped name) -> untyped
end

class ActiveRecord::DuplicateMigrationNameError < ActiveRecord::MigrationError
  private

  def initialize: (?untyped name) -> untyped
end

class ActiveRecord::DuplicateMigrationVersionError < ActiveRecord::MigrationError
  private

  def initialize: (?untyped version) -> untyped
end

module ActiveRecord::DynamicMatchers
  private

  def method_missing: (untyped name, *untyped arguments) { (*untyped) -> untyped } -> untyped

  def respond_to_missing?: (untyped name, untyped _) -> untyped
end

class ActiveRecord::DynamicMatchers::FindBy < ActiveRecord::DynamicMatchers::Method
  def self.prefix: () -> untyped

  public

  def finder: () -> untyped
end

class ActiveRecord::DynamicMatchers::FindByBang < ActiveRecord::DynamicMatchers::Method
  def self.prefix: () -> untyped

  def self.suffix: () -> untyped

  public

  def finder: () -> untyped
end

class ActiveRecord::DynamicMatchers::Method
  def self.match: (untyped model, untyped name) -> untyped

  def self.matchers: () -> untyped

  def self.pattern: () -> untyped

  def self.prefix: () -> untyped

  def self.suffix: () -> untyped

  public

  def attribute_names: () -> untyped

  def define: () -> untyped

  def model: () -> untyped

  def name: () -> untyped

  def valid?: () -> untyped

  private

  def attributes_hash: () -> untyped

  def body: () -> untyped

  def finder: () -> untyped

  def initialize: (untyped model, untyped method_name) -> untyped

  def signature: () -> untyped
end

class ActiveRecord::EagerLoadPolymorphicError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped reflection) -> untyped
end

module ActiveRecord::Enum
  def self.extended: (untyped base) -> untyped

  public

  def enum: (untyped definitions) -> untyped

  def inherited: (untyped base) -> untyped

  private

  def _enum_methods_module: () -> untyped

  def assert_valid_enum_definition_values: (untyped values) -> untyped

  def detect_enum_conflict!: (untyped enum_name, untyped method_name, ?untyped klass_method) -> untyped

  def detect_negative_condition!: (untyped method_name) -> untyped

  def raise_conflict_error: (untyped enum_name, untyped method_name, ?type: untyped, ?source: untyped) -> untyped
end

class ActiveRecord::Enum::EnumType < ActiveModel::Type::Value
  public

  def assert_valid_value: (untyped value) -> untyped

  def cast: (untyped value) -> untyped

  def deserialize: (untyped value) -> untyped

  def serializable?: (untyped value) -> untyped

  def serialize: (untyped value) -> untyped

  def `type`: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped name, untyped mapping, untyped subtype) -> untyped

  def mapping: () -> untyped

  def name: () -> untyped

  def subtype: () -> untyped
end

class ActiveRecord::EnvironmentMismatchError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?current: untyped, ?stored: untyped) -> untyped
end

class ActiveRecord::ExclusiveConnectionTimeoutError < ActiveRecord::ConnectionTimeoutError
end

module ActiveRecord::Explain
  public

  def collecting_queries_for_explain: () -> untyped

  def exec_explain: (untyped queries) -> untyped

  private

  def render_bind: (untyped attr) -> untyped
end

class ActiveRecord::ExplainRegistry
  public

  def collect: () -> untyped

  def collect=: (untyped) -> untyped

  def collect?: () -> untyped

  def queries: () -> untyped

  def queries=: (untyped) -> untyped

  def reset: () -> untyped

  private

  def initialize: () -> untyped
end

class ActiveRecord::ExplainSubscriber
  public

  def finish: (untyped name, untyped id, untyped payload) -> untyped

  def ignore_payload?: (untyped payload) -> untyped

  def start: (untyped name, untyped id, untyped payload) -> untyped
end

ActiveRecord::ExplainSubscriber::EXPLAINED_SQLS: Regexp

ActiveRecord::ExplainSubscriber::IGNORED_PAYLOADS: Array

module ActiveRecord::FinderMethods
  public

  def exists?: (?untyped conditions) -> untyped

  def fifth: () -> untyped

  def fifth!: () -> untyped

  def find: (*untyped args) -> untyped

  def find_by: (untyped arg, *untyped args) -> untyped

  def find_by!: (untyped arg, *untyped args) -> untyped

  def first: (?untyped limit) -> untyped

  def first!: () -> untyped

  def forty_two: () -> untyped

  def forty_two!: () -> untyped

  def fourth: () -> untyped

  def fourth!: () -> untyped

  def last: (?untyped limit) -> untyped

  def last!: () -> untyped

  def raise_record_not_found_exception!: (?untyped ids, ?untyped result_size, ?untyped expected_size, ?untyped key, ?untyped not_found_ids) -> untyped

  def second: () -> untyped

  def second!: () -> untyped

  def second_to_last: () -> untyped

  def second_to_last!: () -> untyped

  def take: (?untyped limit) -> untyped

  def take!: () -> untyped

  def third: () -> untyped

  def third!: () -> untyped

  def third_to_last: () -> untyped

  def third_to_last!: () -> untyped

  private

  def apply_join_dependency: (?eager_loading: untyped) -> untyped

  def check_reorder_deprecation: () -> untyped

  def construct_relation_for_exists: (untyped conditions) -> untyped

  def find_last: (untyped limit) -> untyped

  def find_nth: (untyped index) -> untyped

  def find_nth_from_last: (untyped index) -> untyped

  def find_nth_with_limit: (untyped index, untyped limit) -> untyped

  def find_one: (untyped id) -> untyped

  def find_some: (untyped ids) -> untyped

  def find_some_ordered: (untyped ids) -> untyped

  def find_take: () -> untyped

  def find_take_with_limit: (untyped limit) -> untyped

  def find_with_ids: (*untyped ids) -> untyped

  def limited_ids_for: (untyped relation) -> untyped

  def ordered_relation: () -> untyped

  def using_limitable_reflections?: (untyped reflections) -> untyped
end

ActiveRecord::FinderMethods::ONE_AS_ONE: String

class ActiveRecord::Fixture
  include Enumerable

  include Enumerable

  public

  def []: (untyped key) -> untyped

  def class_name: () -> untyped

  def each: () -> untyped

  def find: () -> untyped

  def fixture: () -> untyped

  def model_class: () -> untyped

  alias to_hash fixture

  private

  def initialize: (untyped fixture, untyped model_class) -> untyped
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 self.all_loaded_fixtures: () -> untyped

  def self.all_loaded_fixtures=: (untyped val) -> untyped

  def self.cache_fixtures: (untyped connection, untyped fixtures_map) -> untyped

  def self.cache_for_connection: (untyped connection) -> untyped

  def self.cached_fixtures: (untyped connection, ?untyped keys_to_fetch) -> untyped

  def self.context_class: () -> untyped

  def self.create_fixtures: (untyped fixtures_directory, untyped fixture_set_names, ?untyped class_names, ?untyped config) { (*untyped) -> untyped } -> untyped

  def self.default_fixture_model_name: (untyped fixture_set_name, ?untyped config) -> untyped

  def self.default_fixture_table_name: (untyped fixture_set_name, ?untyped config) -> untyped

  def self.fixture_is_cached?: (untyped connection, untyped table_name) -> untyped

  def self.identify: (untyped label, ?untyped column_type) -> untyped

  def self.instantiate_all_loaded_fixtures: (untyped object, ?untyped load_instances) -> untyped

  def self.instantiate_fixtures: (untyped object, untyped fixture_set, ?untyped load_instances) -> untyped

  def self.reset_cache: () -> untyped

  public

  def []: (untyped x) -> untyped

  def []=: (untyped k, untyped v) -> untyped

  def all_loaded_fixtures: () -> untyped

  def all_loaded_fixtures=: (untyped val) -> untyped

  def config: () -> untyped

  def each: () { (*untyped) -> untyped } -> untyped

  def fixtures: () -> untyped

  def ignored_fixtures: () -> untyped

  def model_class: () -> untyped

  def name: () -> untyped

  def size: () -> untyped

  def table_name: () -> untyped

  def table_rows: () -> untyped

  private

  def ignored_fixtures=: (untyped base) -> untyped

  def initialize: (untyped _, untyped name, untyped class_name, untyped path, ?untyped config) -> untyped

  def model_class=: (untyped class_name) -> untyped

  def read_fixture_files: (untyped path) -> untyped

  def yaml_file_path: (untyped path) -> untyped
end

ActiveRecord::FixtureSet::MAX_ID: Integer

class ActiveRecord::FixtureSet::ClassCache
  public

  def []: (untyped fs_name) -> untyped

  private

  def default_fixture_model: (untyped fs_name, untyped config) -> untyped

  def initialize: (untyped class_names, untyped config) -> untyped

  def insert_class: (untyped class_names, untyped name, untyped klass) -> untyped
end

class ActiveRecord::FixtureSet::File
  include Enumerable

  include Enumerable

  def self.open: (untyped file) -> untyped

  public

  def each: () { (*untyped) -> untyped } -> untyped

  def ignored_fixtures: () -> untyped

  def model_class: () -> untyped

  private

  def config_row: () -> untyped

  def initialize: (untyped file) -> untyped

  def raw_rows: () -> untyped

  def rows: () -> untyped

  def validate: (untyped data) -> untyped
end

class ActiveRecord::FixtureSet::ModelMetadata
  public

  def has_primary_key_column?: () -> untyped

  def inheritance_column_name: () -> untyped

  def primary_key_name: () -> untyped

  def primary_key_type: () -> untyped

  def timestamp_column_names: () -> untyped

  private

  def initialize: (untyped model_class) -> untyped
end

class ActiveRecord::FixtureSet::RenderContext
  def self.create_subclass: () -> untyped
end

class ActiveRecord::FixtureSet::TableRow
  public

  def to_hash: () -> untyped

  private

  def add_join_records: (untyped association) -> untyped

  def fill_row_model_attributes: () -> untyped

  def fill_timestamps: () -> untyped

  def generate_primary_key: () -> untyped

  def initialize: (untyped fixture, table_rows: untyped, label: untyped, now: untyped) -> untyped

  def interpolate_label: () -> untyped

  def model_class: () -> untyped

  def model_metadata: () -> untyped

  def reflection_class: () -> untyped

  def resolve_enums: () -> untyped

  def resolve_sti_reflections: () -> untyped
end

class ActiveRecord::FixtureSet::TableRow::HasManyThroughProxy < ActiveRecord::FixtureSet::TableRow::ReflectionProxy
  public

  def join_table: () -> untyped

  def lhs_key: () -> untyped

  def rhs_key: () -> untyped
end

class ActiveRecord::FixtureSet::TableRow::ReflectionProxy
  public

  def join_table: () -> untyped

  def name: () -> untyped

  def primary_key_type: () -> untyped

  private

  def initialize: (untyped association) -> untyped
end

class ActiveRecord::FixtureSet::TableRows
  public

  def model_class: () -> untyped

  def model_metadata: () -> untyped

  def tables: () -> untyped

  def to_hash: () -> untyped

  private

  def build_table_rows_from: (untyped table_name, untyped fixtures, untyped config) -> untyped

  def initialize: (untyped table_name, model_class: untyped, fixtures: untyped, config: untyped) -> untyped
end

class ActiveRecord::HasManyThroughAssociationNotFoundError < ActiveRecord::ActiveRecordError
  include DidYouMean::Correctable

  public

  def owner_class: () -> untyped

  def reflection: () -> untyped

  private

  def initialize: (?untyped owner_class, ?untyped reflection) -> untyped
end

class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection, ?untyped source_reflection) -> untyped
end

class ActiveRecord::HasManyThroughAssociationPolymorphicSourceError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection, ?untyped source_reflection) -> untyped
end

class ActiveRecord::HasManyThroughAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection) -> untyped
end

class ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
end

class ActiveRecord::HasManyThroughNestedAssociationsAreReadonly < ActiveRecord::ThroughNestedAssociationsAreReadonly
end

class ActiveRecord::HasManyThroughOrderError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection, ?untyped through_reflection) -> untyped
end

class ActiveRecord::HasManyThroughSourceAssociationNotFoundError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped reflection) -> untyped
end

class ActiveRecord::HasOneAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection) -> untyped
end

class ActiveRecord::HasOneThroughCantAssociateThroughCollection < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner_class_name, ?untyped reflection, ?untyped through_reflection) -> untyped
end

class ActiveRecord::HasOneThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
end

class ActiveRecord::HasOneThroughNestedAssociationsAreReadonly < ActiveRecord::ThroughNestedAssociationsAreReadonly
end

class ActiveRecord::IllegalMigrationNameError < ActiveRecord::MigrationError
  private

  def initialize: (?untyped name) -> untyped
end

class ActiveRecord::ImmutableRelation < ActiveRecord::ActiveRecordError
end

module ActiveRecord::Inheritance
  private

  def ensure_proper_type: () -> untyped

  def initialize_dup: (untyped other) -> untyped

  def initialize_internals_callback: () -> untyped
end

module ActiveRecord::Inheritance::ClassMethods
  public

  def abstract_class: () -> untyped

  def abstract_class=: (untyped) -> untyped

  def abstract_class?: () -> untyped

  def base_class: () -> untyped

  def base_class?: () -> untyped

  def descends_from_active_record?: () -> untyped

  def finder_needs_type_condition?: () -> untyped

  def inherited: (untyped subclass) -> untyped

  def new: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def polymorphic_class_for: (untyped name) -> untyped

  def polymorphic_name: () -> untyped

  def sti_class_for: (untyped type_name) -> untyped

  def sti_name: () -> untyped

  private

  def discriminate_class_for_record: (untyped record) -> untyped

  def find_sti_class: (untyped type_name) -> untyped

  def subclass_from_attributes: (untyped attrs) -> untyped

  def type_condition: (?untyped table) -> untyped

  def using_single_table_inheritance?: (untyped record) -> untyped
end

class ActiveRecord::InsertAll
  public

  def connection: () -> untyped

  def execute: () -> untyped

  def inserts: () -> untyped

  def keys: () -> untyped

  def map_key_with_value: () -> untyped

  def model: () -> untyped

  def on_duplicate: () -> untyped

  def primary_keys: () -> untyped

  def returning: () -> untyped

  def skip_duplicates?: () -> untyped

  def unique_by: () -> untyped

  def updatable_columns: () -> untyped

  def update_duplicates?: () -> untyped

  private

  def ensure_valid_options_for_connection!: () -> untyped

  def find_unique_index_for: (untyped unique_by) -> untyped

  def initialize: (untyped model, untyped inserts, on_duplicate: untyped, ?returning: untyped, ?unique_by: untyped) -> untyped

  def readonly_columns: () -> untyped

  def scope_attributes: () -> untyped

  def to_sql: () -> untyped

  def unique_by_columns: () -> untyped

  def unique_indexes: () -> untyped

  def verify_attributes: (untyped attributes) -> untyped
end

class ActiveRecord::InsertAll::Builder
  public

  def conflict_target: () -> untyped

  def into: () -> untyped

  def keys: (*untyped *) { (*untyped) -> untyped } -> untyped

  def model: () -> untyped

  def returning: () -> untyped

  def skip_duplicates?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def touch_model_timestamps_unless: () { (*untyped) -> untyped } -> untyped

  def updatable_columns: () -> untyped

  def update_duplicates?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def values_list: () -> untyped

  private

  def columns_list: () -> untyped

  def connection: () -> untyped

  def extract_types_from_columns_on: (untyped table_name, keys: untyped) -> untyped

  def format_columns: (untyped columns) -> untyped

  def initialize: (untyped insert_all) -> untyped

  def insert_all: () -> untyped

  def quote_columns: (untyped columns) -> untyped

  def touch_timestamp_attribute?: (untyped column_name) -> untyped
end

module ActiveRecord::Integration
  public

  def cache_key: () -> untyped

  def cache_key_with_version: () -> untyped

  def cache_version: () -> untyped

  def to_param: () -> untyped

  private

  def can_use_fast_cache_version?: (untyped timestamp) -> untyped

  def raw_timestamp_to_cache_version: (untyped timestamp) -> untyped
end

module ActiveRecord::Integration::ClassMethods
  public

  def collection_cache_key: (?untyped collection, ?untyped timestamp_column) -> untyped

  def to_param: (?untyped method_name) -> untyped
end

class ActiveRecord::InternalMetadata < ActiveRecord::Base
  include ActiveRecord::InternalMetadata::GeneratedAssociationMethods

  include ActiveRecord::InternalMetadata::GeneratedAttributeMethods

  def self.[]: (untyped key) -> untyped

  def self.[]=: (untyped key, untyped value) -> untyped

  def self._internal?: () -> untyped

  def self._validators: () -> untyped

  def self.attribute_type_decorations: () -> untyped

  def self.create_table: () -> untyped

  def self.defined_enums: () -> untyped

  def self.drop_table: () -> untyped

  def self.enabled?: () -> untyped

  def self.primary_key: () -> untyped

  def self.table_name: () -> untyped
end

module ActiveRecord::InternalMetadata::GeneratedAssociationMethods
end

module ActiveRecord::InternalMetadata::GeneratedAttributeMethods
end

module ActiveRecord::InternalMetadata::GeneratedRelationMethods
end

class ActiveRecord::InvalidForeignKey < ActiveRecord::WrappedDatabaseException
end

class ActiveRecord::InverseOfAssociationNotFoundError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped reflection, ?untyped associated_class) -> untyped
end

class ActiveRecord::IrreversibleMigration < ActiveRecord::MigrationError
end

class ActiveRecord::IrreversibleOrderError < ActiveRecord::ActiveRecordError
end

module ActiveRecord::LegacyYamlAdapter
  def self.convert: (untyped klass, untyped coder) -> untyped
end

module ActiveRecord::LegacyYamlAdapter::Rails41
  def self.convert: (untyped klass, untyped coder) -> untyped
end

module ActiveRecord::LegacyYamlAdapter::Rails420
  def self.convert: (untyped klass, untyped coder) -> untyped
end

class ActiveRecord::LockWaitTimeout < ActiveRecord::StatementInvalid
end

module ActiveRecord::Locking
end

module ActiveRecord::Locking::Optimistic
  public

  def increment!: (*untyped, **untyped) -> untyped

  def locking_enabled?: () -> untyped

  private

  def _create_record: (?untyped attribute_names) -> untyped

  def _touch_row: (untyped attribute_names, untyped time) -> untyped

  def _update_row: (untyped attribute_names, ?untyped attempted_action) -> untyped

  def destroy_row: () -> untyped
end

module ActiveRecord::Locking::Optimistic::ClassMethods
  public

  def locking_column: () -> untyped

  def locking_column=: (untyped value) -> untyped

  def locking_enabled?: () -> untyped

  def reset_locking_column: () -> untyped

  def update_counters: (untyped id, untyped counters) -> untyped

  private

  def inherited: (untyped subclass) -> untyped
end

ActiveRecord::Locking::Optimistic::ClassMethods::DEFAULT_LOCKING_COLUMN: String

module ActiveRecord::Locking::Pessimistic
  public

  def lock!: (?untyped lock) -> untyped

  def with_lock: (?untyped lock) -> untyped
end

class ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
  def self.backtrace_cleaner: () -> untyped

  def self.backtrace_cleaner=: (untyped value) -> untyped

  def self.backtrace_cleaner?: () -> untyped

  def self.reset_runtime: () -> untyped

  def self.runtime: () -> untyped

  def self.runtime=: (untyped value) -> untyped

  public

  def backtrace_cleaner: () -> untyped

  def backtrace_cleaner=: (untyped) -> untyped

  def backtrace_cleaner?: () -> untyped

  def sql: (untyped event) -> untyped

  private

  def colorize_payload_name: (untyped name, untyped payload_name) -> untyped

  def debug: (?untyped progname) { (*untyped) -> untyped } -> untyped

  def extract_query_source_location: (untyped locations) -> untyped

  def log_query_source: () -> untyped

  def logger: () -> untyped

  def render_bind: (untyped attr, untyped value) -> untyped

  def sql_color: (untyped sql) -> untyped

  def type_casted_binds: (untyped casted_binds) -> untyped
end

ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES: Array

module ActiveRecord::Middleware
end

class ActiveRecord::Middleware::DatabaseSelector
  public

  def call: (untyped env) -> untyped

  def context_klass: () -> untyped

  def options: () -> untyped

  def resolver_klass: () -> untyped

  private

  def initialize: (untyped app, ?untyped resolver_klass, ?untyped context_klass, ?untyped options) -> untyped

  def reading_request?: (untyped request) -> untyped

  def select_database: (untyped request) { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::Middleware::DatabaseSelector::Resolver
  def self.call: (untyped context, ?untyped options) -> untyped

  public

  def context: () -> untyped

  def delay: () -> untyped

  def instrumenter: () -> untyped

  def read: () { (*untyped) -> untyped } -> untyped

  def update_context: (untyped response) -> untyped

  def write: () { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped context, ?untyped options) -> untyped

  def read_from_primary: () { (*untyped) -> untyped } -> untyped

  def read_from_primary?: () -> untyped

  def read_from_replica: () { (*untyped) -> untyped } -> untyped

  def send_to_replica_delay: () -> untyped

  def time_since_last_write_ok?: () -> untyped

  def write_to_primary: () { (*untyped) -> untyped } -> untyped
end

ActiveRecord::Middleware::DatabaseSelector::Resolver::SEND_TO_REPLICA_DELAY: ActiveSupport::Duration

class ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
  def self.call: (untyped request) -> untyped

  def self.convert_time_to_timestamp: (untyped time) -> untyped

  def self.convert_timestamp_to_time: (untyped timestamp) -> untyped

  public

  def last_write_timestamp: () -> untyped

  def save: (untyped response) -> untyped

  def session: () -> untyped

  def update_last_write_timestamp: () -> untyped

  private

  def initialize: (untyped session) -> untyped
end

class ActiveRecord::Migration
  def self.[]: (untyped version) -> untyped

  def self.check_pending!: (?untyped connection) -> untyped

  def self.current_version: () -> untyped

  def self.delegate: () -> untyped

  def self.delegate=: (untyped) -> untyped

  def self.disable_ddl_transaction: () -> untyped

  def self.disable_ddl_transaction!: () -> untyped

  def self.disable_ddl_transaction=: (untyped) -> untyped

  def self.inherited: (untyped subclass) -> untyped

  def self.load_schema_if_pending!: () -> untyped

  def self.maintain_test_schema!: () -> untyped

  def self.method_missing: (untyped name, *untyped args) { (*untyped) -> untyped } -> untyped

  def self.migrate: (untyped direction) -> untyped

  def self.nearest_delegate: () -> untyped

  def self.verbose: () -> untyped

  def self.verbose=: (untyped val) -> untyped

  public

  def announce: (untyped message) -> untyped

  def connection: () -> untyped

  def copy: (untyped destination, untyped sources, ?untyped options) -> untyped

  def disable_ddl_transaction: () -> untyped

  def down: () -> untyped

  def exec_migration: (untyped conn, untyped direction) -> untyped

  def method_missing: (untyped method, *untyped arguments) { (*untyped) -> untyped } -> untyped

  def migrate: (untyped direction) -> untyped

  def name: () -> untyped

  def name=: (untyped) -> untyped

  def next_migration_number: (untyped number) -> untyped

  def proper_table_name: (untyped name, ?untyped options) -> untyped

  def reversible: () -> untyped

  def revert: (*untyped migration_classes) -> untyped

  def reverting?: () -> untyped

  def run: (*untyped migration_classes) -> untyped

  def say: (untyped message, ?untyped subitem) -> untyped

  def say_with_time: (untyped message) -> untyped

  def suppress_messages: () -> untyped

  def table_name_options: (?untyped config) -> untyped

  def up: () -> untyped

  def up_only: () -> untyped

  def verbose: () -> untyped

  def verbose=: (untyped val) -> untyped

  def version: () -> untyped

  def version=: (untyped) -> untyped

  def write: (?untyped text) -> untyped

  private

  def command_recorder: () -> untyped

  def execute_block: () -> untyped

  def initialize: (?untyped name, ?untyped version) -> untyped
end

ActiveRecord::Migration::MigrationFilenameRegexp: Regexp

class ActiveRecord::Migration::CheckPending
  public

  def call: (untyped env) -> untyped

  private

  def build_watcher: () { (*untyped) -> untyped } -> untyped

  def connection: () -> untyped

  def initialize: (untyped app, ?file_watcher: untyped) -> untyped
end

class ActiveRecord::Migration::CommandRecorder
  include ActiveRecord::Migration::CommandRecorder::StraightReversions

  include JoinTable

  public

  alias add_belongs_to add_reference

  def add_check_constraint: (*untyped args) { (*untyped) -> untyped } -> untyped

  def add_column: (*untyped args) { (*untyped) -> untyped } -> untyped

  def add_foreign_key: (*untyped args) { (*untyped) -> untyped } -> untyped

  def add_index: (*untyped args) { (*untyped) -> untyped } -> untyped

  def add_reference: (*untyped args) { (*untyped) -> untyped } -> untyped

  def add_timestamps: (*untyped args) { (*untyped) -> untyped } -> untyped

  def change_column: (*untyped args) { (*untyped) -> untyped } -> untyped

  def change_column_comment: (*untyped args) { (*untyped) -> untyped } -> untyped

  def change_column_default: (*untyped args) { (*untyped) -> untyped } -> untyped

  def change_column_null: (*untyped args) { (*untyped) -> untyped } -> untyped

  def change_table: (untyped table_name, **untyped) -> untyped

  def change_table_comment: (*untyped args) { (*untyped) -> untyped } -> untyped

  def commands: () -> untyped

  def commands=: (untyped) -> untyped

  def create_join_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def create_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def delegate: () -> untyped

  def delegate=: (untyped) -> untyped

  def disable_extension: (*untyped args) { (*untyped) -> untyped } -> untyped

  def drop_join_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def drop_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def enable_extension: (*untyped args) { (*untyped) -> untyped } -> untyped

  def execute: (*untyped args) { (*untyped) -> untyped } -> untyped

  def execute_block: (*untyped args) { (*untyped) -> untyped } -> untyped

  def inverse_of: (untyped command, untyped args) { (*untyped) -> untyped } -> untyped

  alias invert_add_belongs_to invert_add_reference

  alias invert_remove_belongs_to invert_remove_reference

  def record: (*untyped command) { (*untyped) -> untyped } -> untyped

  alias remove_belongs_to remove_reference

  def remove_check_constraint: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_column: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_columns: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_foreign_key: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_index: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_reference: (*untyped args) { (*untyped) -> untyped } -> untyped

  def remove_timestamps: (*untyped args) { (*untyped) -> untyped } -> untyped

  def rename_column: (*untyped args) { (*untyped) -> untyped } -> untyped

  def rename_index: (*untyped args) { (*untyped) -> untyped } -> untyped

  def rename_table: (*untyped args) { (*untyped) -> untyped } -> untyped

  def replay: (untyped migration) -> untyped

  def revert: () -> untyped

  def reverting: () -> untyped

  def reverting=: (untyped) -> untyped

  def transaction: (*untyped args) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (?untyped delegate) -> untyped

  def invert_change_column_comment: (untyped args) -> untyped

  def invert_change_column_default: (untyped args) -> untyped

  def invert_change_column_null: (untyped args) -> untyped

  def invert_change_table_comment: (untyped args) -> untyped

  def invert_drop_table: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_check_constraint: (untyped args) -> untyped

  def invert_remove_column: (untyped args) -> untyped

  def invert_remove_columns: (untyped args) -> untyped

  def invert_remove_foreign_key: (untyped args) -> untyped

  def invert_remove_index: (untyped args) -> untyped

  def invert_rename_column: (untyped args) -> untyped

  def invert_rename_index: (untyped args) -> untyped

  def invert_rename_table: (untyped args) -> untyped

  def invert_transaction: (untyped args) -> untyped

  def method_missing: (untyped method, *untyped args) { (*untyped) -> untyped } -> untyped

  def respond_to_missing?: (untyped method, untyped _) -> untyped
end

ActiveRecord::Migration::CommandRecorder::ReversibleAndIrreversibleMethods: Array

module ActiveRecord::Migration::CommandRecorder::StraightReversions
  public

  def invert_add_check_constraint: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_add_column: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_add_foreign_key: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_add_index: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_add_reference: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_add_timestamps: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_create_join_table: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_create_table: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_disable_extension: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_drop_join_table: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_drop_table: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_enable_extension: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_execute_block: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_check_constraint: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_column: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_foreign_key: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_index: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_reference: (untyped args) { (*untyped) -> untyped } -> untyped

  def invert_remove_timestamps: (untyped args) { (*untyped) -> untyped } -> untyped
end

module ActiveRecord::Migration::Compatibility
  def self.find: (untyped version) -> untyped
end

class ActiveRecord::Migration::Compatibility::V4_2 < ActiveRecord::Migration::Compatibility::V5_0
  public

  alias add_belongs_to add_reference

  def add_reference: (untyped table_name, untyped ref_name, **untyped) -> untyped

  def add_timestamps: (untyped table_name, **untyped) -> untyped

  def index_exists?: (untyped table_name, untyped column_name, **untyped) -> untyped

  def remove_index: (untyped table_name, ?untyped column_name, **untyped) -> untyped

  private

  def compatible_table_definition: (untyped t) -> untyped

  def index_name_for_remove: (untyped table_name, untyped column_name, untyped options) -> untyped
end

module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
  public

  alias belongs_to references

  def references: (*untyped, **untyped) -> untyped

  def timestamps: (**untyped) -> untyped
end

class ActiveRecord::Migration::Compatibility::V5_0 < ActiveRecord::Migration::Compatibility::V5_1
  public

  alias add_belongs_to add_reference

  def add_column: (untyped table_name, untyped column_name, untyped `type`, **untyped) -> untyped

  def add_reference: (untyped table_name, untyped ref_name, **untyped) -> untyped

  def create_join_table: (untyped table_1, untyped table_2, ?column_options: untyped, **untyped) -> untyped

  def create_table: (untyped table_name, **untyped) -> untyped

  private

  def compatible_table_definition: (untyped t) -> untyped
end

module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
  public

  alias belongs_to references

  def primary_key: (untyped name, ?untyped `type`, **untyped) -> untyped

  def references: (*untyped args, **untyped) -> untyped
end

class ActiveRecord::Migration::Compatibility::V5_1 < ActiveRecord::Migration::Compatibility::V5_2
  public

  def change_column: (untyped table_name, untyped column_name, untyped `type`, **untyped) -> untyped

  def create_table: (untyped table_name, **untyped) -> untyped
end

class ActiveRecord::Migration::Compatibility::V5_2 < ActiveRecord::Migration::Compatibility::V6_0
  public

  def add_timestamps: (untyped table_name, **untyped) -> untyped

  def change_table: (untyped table_name, **untyped) -> untyped

  def create_join_table: (untyped table_1, untyped table_2, **untyped) -> untyped

  def create_table: (untyped table_name, **untyped) -> untyped

  private

  def command_recorder: () -> untyped

  def compatible_table_definition: (untyped t) -> untyped
end

module ActiveRecord::Migration::Compatibility::V5_2::CommandRecorder
  public

  def invert_change_column_comment: (untyped args) -> untyped

  def invert_change_table_comment: (untyped args) -> untyped

  def invert_transaction: (untyped args) { (*untyped) -> untyped } -> untyped
end

module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
  public

  def timestamps: (**untyped) -> untyped
end

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

module ActiveRecord::Migration::JoinTable
  private

  def find_join_table_name: (untyped table_1, untyped table_2, ?untyped options) -> untyped

  def join_table_name: (untyped table_1, untyped table_2) -> untyped
end

class ActiveRecord::Migration::ReversibleBlockHelper < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def down: () -> untyped

  def reverting: () -> untyped

  def reverting=: (untyped _) -> untyped

  def up: () -> untyped
end

class ActiveRecord::MigrationContext
  public

  def any_migrations?: () -> untyped

  def current_environment: () -> untyped

  def current_version: () -> untyped

  def down: (?untyped target_version) -> untyped

  def forward: (?untyped steps) -> untyped

  def get_all_versions: () -> untyped

  def last_stored_environment: () -> untyped

  def migrate: (?untyped target_version) { (*untyped) -> untyped } -> untyped

  def migrations: () -> untyped

  def migrations_paths: () -> untyped

  def migrations_status: () -> untyped

  def needs_migration?: () -> untyped

  def open: () -> untyped

  def protected_environment?: () -> untyped

  def rollback: (?untyped steps) -> untyped

  def run: (untyped direction, untyped target_version) -> untyped

  def schema_migration: () -> untyped

  def up: (?untyped target_version) -> untyped

  private

  def initialize: (untyped migrations_paths, untyped schema_migration) -> untyped

  def migration_files: () -> untyped

  def move: (untyped direction, untyped steps) -> untyped

  def parse_migration_filename: (untyped filename) -> untyped
end

class ActiveRecord::MigrationError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped message) -> untyped
end

class ActiveRecord::MigrationProxy < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def announce: (*untyped *) { (*untyped) -> untyped } -> untyped

  def basename: () -> untyped

  def disable_ddl_transaction: (*untyped *) { (*untyped) -> untyped } -> untyped

  def filename: () -> untyped

  def filename=: (untyped _) -> untyped

  def migrate: (*untyped *) { (*untyped) -> untyped } -> untyped

  def name: () -> untyped

  def name=: (untyped _) -> untyped

  def scope: () -> untyped

  def scope=: (untyped _) -> untyped

  def version: () -> untyped

  def version=: (untyped _) -> untyped

  def write: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped name, untyped version, untyped filename, untyped scope) -> untyped

  def load_migration: () -> untyped

  def migration: () -> untyped
end

class ActiveRecord::Migrator
  def self.current_version: () -> untyped

  def self.migrations_paths: () -> untyped

  def self.migrations_paths=: (untyped) -> untyped

  public

  alias current current_migration

  def current_migration: () -> untyped

  def current_version: () -> untyped

  def load_migrated: () -> untyped

  def migrate: () -> untyped

  def migrated: () -> untyped

  def migrations: () -> untyped

  def pending_migrations: () -> untyped

  def run: () -> untyped

  def runnable: () -> untyped

  private

  def ddl_transaction: (untyped migration) -> untyped

  def down?: () -> untyped

  def execute_migration_in_transaction: (untyped migration) -> untyped

  def finish: () -> untyped

  def generate_migrator_advisory_lock_id: () -> untyped

  def initialize: (untyped direction, untyped migrations, untyped schema_migration, ?untyped target_version) -> untyped

  def invalid_target?: () -> untyped

  def migrate_without_lock: () -> untyped

  def ran?: (untyped migration) -> untyped

  def record_environment: () -> untyped

  def record_version_state_after_migrating: (untyped version) -> untyped

  def run_without_lock: () -> untyped

  def start: () -> untyped

  def target: () -> untyped

  def up?: () -> untyped

  def use_advisory_lock?: () -> untyped

  def use_transaction?: (untyped migration) -> untyped

  def validate: (untyped migrations) -> untyped

  def with_advisory_lock: () -> untyped
end

ActiveRecord::Migrator::MIGRATOR_SALT: Integer

class ActiveRecord::MismatchedForeignKey < ActiveRecord::StatementInvalid
  private

  def initialize: (?message: untyped, ?sql: untyped, ?binds: untyped, ?table: untyped, ?foreign_key: untyped, ?target_table: untyped, ?primary_key: untyped, ?primary_key_column: untyped) -> untyped
end

module ActiveRecord::ModelSchema
  def self.derive_join_table_name: (untyped first_table, untyped second_table) -> untyped
end

module ActiveRecord::ModelSchema::ClassMethods
  public

  def _default_attributes: () -> untyped

  def attribute_types: () -> untyped

  def attributes_builder: () -> untyped

  def column_defaults: () -> untyped

  def column_names: () -> untyped

  def columns: () -> untyped

  def columns_hash: () -> untyped

  def content_columns: () -> untyped

  def full_table_name_prefix: () -> untyped

  def full_table_name_suffix: () -> untyped

  def ignored_columns: () -> untyped

  def ignored_columns=: (untyped columns) -> untyped

  def inheritance_column: () -> untyped

  def inheritance_column=: (untyped value) -> untyped

  def next_sequence_value: () -> untyped

  def prefetch_primary_key?: () -> untyped

  def protected_environments: () -> untyped

  def protected_environments=: (untyped environments) -> untyped

  def quoted_table_name: () -> untyped

  def reset_column_information: () -> untyped

  def reset_sequence_name: () -> untyped

  def reset_table_name: () -> untyped

  def sequence_name: () -> untyped

  def sequence_name=: (untyped value) -> untyped

  def symbol_column_to_string: (untyped name_symbol) -> untyped

  def table_exists?: () -> untyped

  def table_name: () -> untyped

  def table_name=: (untyped value) -> untyped

  def type_for_attribute: (untyped attr_name) { (*untyped) -> untyped } -> untyped

  def yaml_encoder: () -> untyped

  private

  def compute_table_name: () -> untyped

  def inherited: (untyped child_class) -> untyped

  def load_schema: () -> untyped

  def load_schema!: () -> untyped

  def reload_schema_from_cache: () -> untyped

  def schema_loaded?: () -> untyped

  def undecorated_table_name: (?untyped class_name) -> untyped
end

class ActiveRecord::MultiparameterAssignmentErrors < ActiveRecord::ActiveRecordError
  public

  def errors: () -> untyped

  private

  def initialize: (?untyped errors) -> untyped
end

module ActiveRecord::NestedAttributes
  public

  def _destroy: () -> untyped

  private

  def allow_destroy?: (untyped association_name) -> untyped

  def assign_nested_attributes_for_collection_association: (untyped association_name, untyped attributes_collection) -> untyped

  def assign_nested_attributes_for_one_to_one_association: (untyped association_name, untyped attributes) -> untyped

  def assign_to_or_mark_for_destruction: (untyped record, untyped attributes, untyped allow_destroy) -> untyped

  def call_reject_if: (untyped association_name, untyped attributes) -> untyped

  def check_record_limit!: (untyped limit, untyped attributes_collection) -> untyped

  def has_destroy_flag?: (untyped hash) -> untyped

  def raise_nested_attributes_record_not_found!: (untyped association_name, untyped record_id) -> untyped

  def reject_new_record?: (untyped association_name, untyped attributes) -> untyped

  def will_be_destroyed?: (untyped association_name, untyped attributes) -> untyped
end

ActiveRecord::NestedAttributes::UNASSIGNABLE_KEYS: Array

module ActiveRecord::NestedAttributes::ClassMethods
  public

  def accepts_nested_attributes_for: (*untyped attr_names) -> untyped

  private

  def generate_association_writer: (untyped association_name, untyped `type`) -> untyped
end

ActiveRecord::NestedAttributes::ClassMethods::REJECT_ALL_BLANK_PROC: Proc

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

class ActiveRecord::NoDatabaseError < ActiveRecord::StatementInvalid
end

class ActiveRecord::NoEnvironmentInSchemaError < ActiveRecord::MigrationError
  private

  def initialize: () -> untyped
end

module ActiveRecord::NoTouching
  def self.applied_to?: (untyped klass) -> untyped

  def self.apply_to: (untyped klass) -> untyped

  public

  def no_touching?: () -> untyped

  def touch: (*untyped, **untyped) -> untyped

  def touch_later: (*untyped) -> untyped
end

module ActiveRecord::NoTouching::ClassMethods
  public

  def no_touching: () { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::NotNullViolation < ActiveRecord::StatementInvalid
end

module ActiveRecord::NullRelation
  public

  def any?: () -> untyped

  def calculate: (untyped operation, untyped _column_name) -> untyped

  def delete: (untyped _id_or_array) -> untyped

  def delete_all: () -> untyped

  def empty?: () -> untyped

  def exists?: (?untyped _conditions) -> untyped

  def many?: () -> untyped

  def none?: () -> untyped

  def one?: () -> untyped

  def or: (untyped other) -> untyped

  def pluck: (*untyped column_names) -> untyped

  def to_sql: () -> untyped

  def update_all: (untyped _updates) -> untyped

  private

  def exec_queries: () -> untyped
end

class ActiveRecord::PendingMigrationError < ActiveRecord::MigrationError
  include ActiveSupport::ActionableError

  def self._actions: () -> untyped

  def self._actions=: (untyped value) -> untyped

  def self._actions?: () -> untyped

  public

  def _actions: () -> untyped

  def _actions=: (untyped) -> untyped

  def _actions?: () -> untyped

  private

  def initialize: (?untyped message) -> untyped
end

module ActiveRecord::Persistence
  public

  def becomes: (untyped klass) -> untyped

  def becomes!: (untyped klass) -> untyped

  def decrement: (untyped attribute, ?untyped by) -> untyped

  def decrement!: (untyped attribute, ?untyped by, ?touch: untyped) -> untyped

  def delete: () -> untyped

  def destroy: () -> untyped

  def destroy!: () -> untyped

  def destroyed?: () -> untyped

  def increment: (untyped attribute, ?untyped by) -> untyped

  def increment!: (untyped attribute, ?untyped by, ?touch: untyped) -> untyped

  def new_record?: () -> untyped

  def persisted?: () -> untyped

  def previously_new_record?: () -> untyped

  def reload: (?untyped options) -> untyped

  def save: (**untyped) { (*untyped) -> untyped } -> untyped

  def save!: (**untyped) { (*untyped) -> untyped } -> untyped

  def toggle: (untyped attribute) -> untyped

  def toggle!: (untyped attribute) -> untyped

  def touch: (*untyped names, ?time: untyped) -> untyped

  def update: (untyped attributes) -> untyped

  def update!: (untyped attributes) -> untyped

  def update_attribute: (untyped name, untyped value) -> untyped

  def update_attributes: (*untyped args) { (*untyped) -> untyped } -> untyped

  def update_attributes!: (*untyped args) { (*untyped) -> untyped } -> untyped

  def update_column: (untyped name, untyped value) -> untyped

  def update_columns: (untyped attributes) -> untyped

  private

  def _create_record: (?untyped attribute_names) -> untyped

  def _delete_row: () -> untyped

  def _raise_readonly_record_error: () -> untyped

  def _raise_record_not_destroyed: () -> untyped

  def _raise_record_not_touched_error: () -> untyped

  def _touch_row: (untyped attribute_names, untyped time) -> untyped

  def _update_record: (?untyped attribute_names) -> untyped

  def _update_row: (untyped attribute_names, ?untyped attempted_action) -> untyped

  def belongs_to_touch_method: () -> untyped

  def create_or_update: (**untyped) { (*untyped) -> untyped } -> untyped

  def destroy_associations: () -> untyped

  def destroy_row: () -> untyped

  def verify_readonly_attribute: (untyped name) -> untyped
end

module ActiveRecord::Persistence::ClassMethods
  public

  def _delete_record: (untyped constraints) -> untyped

  def _insert_record: (untyped values) -> untyped

  def _update_record: (untyped values, untyped constraints) -> untyped

  def create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def delete: (untyped id_or_array) -> untyped

  def destroy: (untyped id) -> untyped

  def insert: (untyped attributes, ?returning: untyped, ?unique_by: untyped) -> untyped

  def insert!: (untyped attributes, ?returning: untyped) -> untyped

  def insert_all: (untyped attributes, ?returning: untyped, ?unique_by: untyped) -> untyped

  def insert_all!: (untyped attributes, ?returning: untyped) -> untyped

  def instantiate: (untyped attributes, ?untyped column_types) { (*untyped) -> untyped } -> untyped

  def update: (?untyped id, untyped attributes) -> untyped

  def upsert: (untyped attributes, ?returning: untyped, ?unique_by: untyped) -> untyped

  def upsert_all: (untyped attributes, ?returning: untyped, ?unique_by: untyped) -> untyped

  private

  def _substitute_values: (untyped values) -> untyped

  def discriminate_class_for_record: (untyped record) -> untyped

  def instantiate_instance_of: (untyped klass, untyped attributes, ?untyped column_types) { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::PredicateBuilder
  def self.references: (untyped attributes) -> untyped

  public

  def build: (untyped attribute, untyped value) -> untyped

  def build_bind_attribute: (untyped column_name, untyped value) -> untyped

  def build_from_hash: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def register_handler: (untyped klass, untyped handler) -> untyped

  def resolve_arel_attribute: (untyped table_name, untyped column_name) { (*untyped) -> untyped } -> untyped

  private

  def convert_dot_notation_to_hash: (untyped attributes) -> untyped

  def grouping_queries: (untyped queries) -> untyped

  def handler_for: (untyped object) -> untyped

  def initialize: (untyped table) -> untyped

  def table: () -> untyped
end

class ActiveRecord::PredicateBuilder::ArrayHandler
  public

  def call: (untyped attribute, untyped value) -> untyped

  private

  def initialize: (untyped predicate_builder) -> untyped

  def predicate_builder: () -> untyped
end

module ActiveRecord::PredicateBuilder::ArrayHandler::NullPredicate
  def self.or: (untyped other) -> untyped
end

class ActiveRecord::PredicateBuilder::AssociationQueryValue
  public

  def queries: () -> untyped

  private

  def associated_table: () -> untyped

  def convert_to_id: (untyped value) -> untyped

  def ids: () -> untyped

  def initialize: (untyped associated_table, untyped value) -> untyped

  def primary_key: () -> untyped

  def value: () -> untyped
end

class ActiveRecord::PredicateBuilder::BasicObjectHandler
  public

  def call: (untyped attribute, untyped value) -> untyped

  private

  def initialize: (untyped predicate_builder) -> untyped

  def predicate_builder: () -> untyped
end

class ActiveRecord::PredicateBuilder::PolymorphicArrayValue
  public

  def queries: () -> untyped

  private

  def associated_table: () -> untyped

  def convert_to_id: (untyped value) -> untyped

  def initialize: (untyped associated_table, untyped values) -> untyped

  def klass: (untyped value) -> untyped

  def primary_key: (untyped value) -> untyped

  def type_to_ids_mapping: () -> untyped

  def values: () -> untyped
end

class ActiveRecord::PredicateBuilder::RangeHandler
  public

  def call: (untyped attribute, untyped value) -> untyped

  private

  def initialize: (untyped predicate_builder) -> untyped

  def predicate_builder: () -> untyped
end

class ActiveRecord::PredicateBuilder::RangeHandler::RangeWithBinds < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def begin: () -> untyped

  def begin=: (untyped _) -> untyped

  def `end`: () -> untyped

  def end=: (untyped _) -> untyped

  def exclude_end?: () -> untyped

  def exclude_end?=: (untyped _) -> untyped
end

class ActiveRecord::PredicateBuilder::RelationHandler
  public

  def call: (untyped attribute, untyped value) -> untyped
end

class ActiveRecord::PreparedStatementCacheExpired < ActiveRecord::StatementInvalid
end

class ActiveRecord::PreparedStatementInvalid < ActiveRecord::ActiveRecordError
end

class ActiveRecord::ProtectedEnvironmentError < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped env) -> untyped
end

class ActiveRecord::QueryCache
  def self.complete: (untyped pools) -> untyped

  def self.install_executor_hooks: (?untyped executor) -> untyped

  def self.run: () -> untyped
end

module ActiveRecord::QueryCache::ClassMethods
  public

  def cache: () { (*untyped) -> untyped } -> untyped

  def uncached: () { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::QueryCanceled < ActiveRecord::QueryAborted
end

module ActiveRecord::QueryMethods
  include ActiveModel::ForbiddenAttributesProtection

  public

  def _select!: (*untyped fields) -> untyped

  def and: (untyped other) -> untyped

  def and!: (untyped other) -> untyped

  def annotate: (*untyped args) -> untyped

  def annotate!: (*untyped args) -> untyped

  def annotate_values: () -> untyped

  def annotate_values=: (untyped value) -> untyped

  def arel: (?untyped aliases) -> untyped

  def construct_join_dependency: (untyped associations, untyped join_type) -> untyped

  def create_with: (untyped value) -> untyped

  def create_with!: (untyped value) -> untyped

  def create_with_value: () -> untyped

  def create_with_value=: (untyped value) -> untyped

  def distinct: (?untyped value) -> untyped

  def distinct!: (?untyped value) -> untyped

  def distinct_value: () -> untyped

  def distinct_value=: (untyped value) -> untyped

  def eager_load: (*untyped args) -> untyped

  def eager_load!: (*untyped args) -> untyped

  def eager_load_values: () -> untyped

  def eager_load_values=: (untyped value) -> untyped

  def extending: (*untyped modules) { (*untyped) -> untyped } -> untyped

  def extending!: (*untyped modules) { (*untyped) -> untyped } -> untyped

  def extending_values: () -> untyped

  def extending_values=: (untyped value) -> untyped

  alias extensions extending_values

  def extract_associated: (untyped association) -> untyped

  def from: (untyped value, ?untyped subquery_name) -> untyped

  def from!: (untyped value, ?untyped subquery_name) -> untyped

  def from_clause: () -> untyped

  def from_clause=: (untyped value) -> untyped

  def group: (*untyped args) -> untyped

  def group!: (*untyped args) -> untyped

  def group_values: () -> untyped

  def group_values=: (untyped value) -> untyped

  def having: (untyped opts, *untyped rest) -> untyped

  def having!: (untyped opts, *untyped rest) -> untyped

  def having_clause: () -> untyped

  def having_clause=: (untyped value) -> untyped

  def includes: (*untyped args) -> untyped

  def includes!: (*untyped args) -> untyped

  def includes_values: () -> untyped

  def includes_values=: (untyped value) -> untyped

  def joins: (*untyped args) -> untyped

  def joins!: (*untyped args) -> untyped

  def joins_values: () -> untyped

  def joins_values=: (untyped value) -> untyped

  alias left_joins left_outer_joins

  def left_outer_joins: (*untyped args) -> untyped

  def left_outer_joins!: (*untyped args) -> untyped

  def left_outer_joins_values: () -> untyped

  def left_outer_joins_values=: (untyped value) -> untyped

  def limit: (untyped value) -> untyped

  def limit!: (untyped value) -> untyped

  def limit_value: () -> untyped

  def limit_value=: (untyped value) -> untyped

  def lock: (?untyped locks) -> untyped

  def lock!: (?untyped locks) -> untyped

  def lock_value: () -> untyped

  def lock_value=: (untyped value) -> untyped

  def none: () -> untyped

  def none!: () -> untyped

  def offset: (untyped value) -> untyped

  def offset!: (untyped value) -> untyped

  def offset_value: () -> untyped

  def offset_value=: (untyped value) -> untyped

  def optimizer_hints: (*untyped args) -> untyped

  def optimizer_hints!: (*untyped args) -> untyped

  def optimizer_hints_values: () -> untyped

  def optimizer_hints_values=: (untyped value) -> untyped

  def or: (untyped other) -> untyped

  def or!: (untyped other) -> untyped

  def order: (*untyped args) -> untyped

  def order!: (*untyped args) -> untyped

  def order_values: () -> untyped

  def order_values=: (untyped value) -> untyped

  def preload: (*untyped args) -> untyped

  def preload!: (*untyped args) -> untyped

  def preload_values: () -> untyped

  def preload_values=: (untyped value) -> untyped

  def readonly: (?untyped value) -> untyped

  def readonly!: (?untyped value) -> untyped

  def readonly_value: () -> untyped

  def readonly_value=: (untyped value) -> untyped

  def references: (*untyped table_names) -> untyped

  def references!: (*untyped table_names) -> untyped

  def references_values: () -> untyped

  def references_values=: (untyped value) -> untyped

  def reorder: (*untyped args) -> untyped

  def reorder!: (*untyped args) -> untyped

  def reordering_value: () -> untyped

  def reordering_value=: (untyped value) -> untyped

  def reselect: (*untyped args) -> untyped

  def reselect!: (*untyped args) -> untyped

  def reverse_order: () -> untyped

  def reverse_order!: () -> untyped

  def reverse_order_value: () -> untyped

  def reverse_order_value=: (untyped value) -> untyped

  def rewhere: (untyped conditions) -> untyped

  def select: (*untyped fields) -> untyped

  def select_values: () -> untyped

  def select_values=: (untyped value) -> untyped

  def skip_preloading!: () -> untyped

  def skip_query_cache!: (?untyped value) -> untyped

  def skip_query_cache_value: () -> untyped

  def skip_query_cache_value=: (untyped value) -> untyped

  def strict_loading: (?untyped value) -> untyped

  def strict_loading!: (?untyped value) -> untyped

  def strict_loading_value: () -> untyped

  def strict_loading_value=: (untyped value) -> untyped

  def uniq!: (untyped name) -> untyped

  def unscope: (*untyped args) -> untyped

  def unscope!: (*untyped args) -> untyped

  def unscope_values: () -> untyped

  def unscope_values=: (untyped value) -> untyped

  def where: (?untyped opts, *untyped rest) -> untyped

  def where!: (untyped opts, *untyped rest) -> untyped

  def where_clause: () -> untyped

  def where_clause=: (untyped value) -> untyped

  private

  def arel_column: (untyped field) -> untyped

  def arel_columns: (untyped columns) -> untyped

  def assert_mutability!: () -> untyped

  def build_arel: (untyped aliases) -> untyped

  def build_cast_value: (untyped name, untyped value) -> untyped

  def build_from: () -> untyped

  def build_join_buckets: () -> untyped

  def build_join_dependencies: () -> untyped

  def build_joins: (untyped manager, untyped aliases) -> untyped

  def build_order: (untyped arel) -> untyped

  def build_select: (untyped arel) -> untyped

  def check_if_method_has_arguments!: (untyped method_name, untyped args, ?untyped message) -> untyped

  def column_references: (untyped order_args) -> untyped

  def does_not_support_reverse?: (untyped order) -> untyped

  def each_join_dependencies: (?untyped join_dependencies) -> untyped

  def lookup_reflection_from_join_dependencies: (untyped table_name) -> untyped

  def order_column: (untyped field) -> untyped

  def preprocess_order_args: (untyped order_args) -> untyped

  def resolve_arel_attributes: (untyped attrs) -> untyped

  def reverse_sql_order: (untyped order_query) -> untyped

  def sanitize_order_arguments: (untyped order_args) -> untyped

  def select_association_list: (untyped associations, ?untyped stashed_joins) -> untyped

  def structurally_incompatible_values_for_or: (untyped other) -> untyped

  def table_name_matches?: (untyped from) -> untyped

  def validate_order_args: (untyped args) -> untyped

  def where_clause_factory: () -> untyped
end

ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY: Array

ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH: Hash

ActiveRecord::QueryMethods::STRUCTURAL_OR_METHODS: Array

ActiveRecord::QueryMethods::VALID_DIRECTIONS: Set

ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES: Set

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

  public

  def missing: (*untyped args) -> untyped

  def not: (untyped opts, *untyped rest) -> untyped

  private

  def initialize: (untyped scope) -> untyped

  def not_behaves_as_nor?: (untyped opts) -> untyped
end

module ActiveRecord::Querying
  public

  def and: (*untyped *) { (*untyped) -> untyped } -> untyped

  def annotate: (*untyped *) { (*untyped) -> untyped } -> untyped

  def any?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def average: (*untyped *) { (*untyped) -> untyped } -> untyped

  def calculate: (*untyped *) { (*untyped) -> untyped } -> untyped

  def count: (*untyped *) { (*untyped) -> untyped } -> untyped

  def count_by_sql: (untyped sql) -> untyped

  def create_or_find_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create_or_find_by!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create_with: (*untyped *) { (*untyped) -> untyped } -> untyped

  def delete_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def delete_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def destroy_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def destroy_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def distinct: (*untyped *) { (*untyped) -> untyped } -> untyped

  def eager_load: (*untyped *) { (*untyped) -> untyped } -> untyped

  def except: (*untyped *) { (*untyped) -> untyped } -> untyped

  def exists?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extending: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extract_associated: (*untyped *) { (*untyped) -> untyped } -> untyped

  def fifth: (*untyped *) { (*untyped) -> untyped } -> untyped

  def fifth!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_by!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_by_sql: (untyped sql, ?untyped binds, ?preparable: untyped) { (*untyped) -> untyped } -> untyped

  def find_each: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_in_batches: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_or_create_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_or_create_by!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def find_or_initialize_by: (*untyped *) { (*untyped) -> untyped } -> untyped

  def first: (*untyped *) { (*untyped) -> untyped } -> untyped

  def first!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def first_or_create: (*untyped *) { (*untyped) -> untyped } -> untyped

  def first_or_create!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def first_or_initialize: (*untyped *) { (*untyped) -> untyped } -> untyped

  def forty_two: (*untyped *) { (*untyped) -> untyped } -> untyped

  def forty_two!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def fourth: (*untyped *) { (*untyped) -> untyped } -> untyped

  def fourth!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def from: (*untyped *) { (*untyped) -> untyped } -> untyped

  def group: (*untyped *) { (*untyped) -> untyped } -> untyped

  def having: (*untyped *) { (*untyped) -> untyped } -> untyped

  def ids: (*untyped *) { (*untyped) -> untyped } -> untyped

  def in_batches: (*untyped *) { (*untyped) -> untyped } -> untyped

  def includes: (*untyped *) { (*untyped) -> untyped } -> untyped

  def joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def last: (*untyped *) { (*untyped) -> untyped } -> untyped

  def last!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def left_outer_joins: (*untyped *) { (*untyped) -> untyped } -> untyped

  def limit: (*untyped *) { (*untyped) -> untyped } -> untyped

  def lock: (*untyped *) { (*untyped) -> untyped } -> untyped

  def many?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def maximum: (*untyped *) { (*untyped) -> untyped } -> untyped

  def merge: (*untyped *) { (*untyped) -> untyped } -> untyped

  def minimum: (*untyped *) { (*untyped) -> untyped } -> untyped

  def none: (*untyped *) { (*untyped) -> untyped } -> untyped

  def none?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def offset: (*untyped *) { (*untyped) -> untyped } -> untyped

  def one?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def only: (*untyped *) { (*untyped) -> untyped } -> untyped

  def optimizer_hints: (*untyped *) { (*untyped) -> untyped } -> untyped

  def or: (*untyped *) { (*untyped) -> untyped } -> untyped

  def order: (*untyped *) { (*untyped) -> untyped } -> untyped

  def pick: (*untyped *) { (*untyped) -> untyped } -> untyped

  def pluck: (*untyped *) { (*untyped) -> untyped } -> untyped

  def preload: (*untyped *) { (*untyped) -> untyped } -> untyped

  def readonly: (*untyped *) { (*untyped) -> untyped } -> untyped

  def references: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reorder: (*untyped *) { (*untyped) -> untyped } -> untyped

  def reselect: (*untyped *) { (*untyped) -> untyped } -> untyped

  def rewhere: (*untyped *) { (*untyped) -> untyped } -> untyped

  def second: (*untyped *) { (*untyped) -> untyped } -> untyped

  def second!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def second_to_last: (*untyped *) { (*untyped) -> untyped } -> untyped

  def second_to_last!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def select: (*untyped *) { (*untyped) -> untyped } -> untyped

  def strict_loading: (*untyped *) { (*untyped) -> untyped } -> untyped

  def sum: (*untyped *) { (*untyped) -> untyped } -> untyped

  def take: (*untyped *) { (*untyped) -> untyped } -> untyped

  def take!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def third: (*untyped *) { (*untyped) -> untyped } -> untyped

  def third!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def third_to_last: (*untyped *) { (*untyped) -> untyped } -> untyped

  def third_to_last!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def touch_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def unscope: (*untyped *) { (*untyped) -> untyped } -> untyped

  def update_all: (*untyped *) { (*untyped) -> untyped } -> untyped

  def where: (*untyped *) { (*untyped) -> untyped } -> untyped
end

ActiveRecord::Querying::QUERYING_METHODS: Array

class ActiveRecord::RangeError < ActiveRecord::StatementInvalid
end

class ActiveRecord::ReadOnlyError < ActiveRecord::ActiveRecordError
end

class ActiveRecord::ReadOnlyRecord < ActiveRecord::ActiveRecordError
end

module ActiveRecord::ReadonlyAttributes
end

module ActiveRecord::ReadonlyAttributes::ClassMethods
  public

  def attr_readonly: (*untyped attributes) -> untyped

  def readonly_attribute?: (untyped name) -> untyped

  def readonly_attributes: () -> untyped
end

class ActiveRecord::RecordInvalid < ActiveRecord::ActiveRecordError
  public

  def record: () -> untyped

  private

  def initialize: (?untyped record) -> untyped
end

class ActiveRecord::RecordNotDestroyed < ActiveRecord::ActiveRecordError
  public

  def record: () -> untyped

  private

  def initialize: (?untyped message, ?untyped record) -> untyped
end

class ActiveRecord::RecordNotFound < ActiveRecord::ActiveRecordError
  public

  def id: () -> untyped

  def model: () -> untyped

  def primary_key: () -> untyped

  private

  def initialize: (?untyped message, ?untyped model, ?untyped primary_key, ?untyped id) -> untyped
end

class ActiveRecord::RecordNotSaved < ActiveRecord::ActiveRecordError
  public

  def record: () -> untyped

  private

  def initialize: (?untyped message, ?untyped record) -> untyped
end

class ActiveRecord::RecordNotUnique < ActiveRecord::WrappedDatabaseException
end

module ActiveRecord::Reflection
  def self.add_aggregate_reflection: (untyped ar, untyped name, untyped reflection) -> untyped

  def self.add_reflection: (untyped ar, untyped name, untyped reflection) -> untyped

  def self.create: (untyped macro, untyped name, untyped scope, untyped options, untyped ar) -> untyped
end

class ActiveRecord::Reflection::AbstractReflection
  public

  def alias_candidate: (untyped name) -> untyped

  def build_association: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def build_scope: (untyped table, ?untyped predicate_builder, ?untyped klass) -> untyped

  def chain: () -> untyped

  def check_validity_of_inverse!: () -> untyped

  def class_name: () -> untyped

  def constraints: () -> untyped

  def counter_cache_column: () -> untyped

  def counter_must_be_updated_by_has_many?: () -> untyped

  def has_cached_counter?: () -> untyped

  def inverse_of: () -> untyped

  alias inverse_updates_counter_cache? inverse_which_updates_counter_cache

  def inverse_updates_counter_in_memory?: () -> untyped

  def inverse_which_updates_counter_cache: () -> untyped

  def join_foreign_key: () -> untyped

  def join_primary_key: (?untyped klass) -> untyped

  def join_scope: (untyped table, untyped foreign_table, untyped foreign_klass) -> untyped

  def join_scopes: (untyped table, untyped predicate_builder, ?untyped klass) -> untyped

  def klass_join_scope: (untyped table, untyped predicate_builder) -> untyped

  def scopes: () -> untyped

  def strict_loading?: () -> untyped

  def table_name: () -> untyped

  def through_reflection?: () -> untyped

  private

  def predicate_builder: (untyped table) -> untyped

  def primary_key: (untyped klass) -> untyped
end

class ActiveRecord::Reflection::AbstractReflection::JoinKeys < Struct
  def self.[]: (*untyped) -> untyped

  def self.inspect: () -> untyped

  def self.members: () -> untyped

  def self.new: (*untyped) -> untyped

  public

  def foreign_key: () -> untyped

  def foreign_key=: (untyped _) -> untyped

  def key: () -> untyped

  def key=: (untyped _) -> untyped
end

class ActiveRecord::Reflection::AggregateReflection < ActiveRecord::Reflection::MacroReflection
  public

  def mapping: () -> untyped
end

class ActiveRecord::Reflection::AssociationReflection < ActiveRecord::Reflection::MacroReflection
  public

  def active_record_primary_key: () -> untyped

  def add_as_polymorphic_through: (untyped reflection, untyped seed) -> untyped

  def add_as_source: (untyped seed) -> untyped

  def add_as_through: (untyped seed) -> untyped

  def association_class: () -> untyped

  def association_foreign_key: () -> untyped

  def association_primary_key: (?untyped klass) -> untyped

  def association_scope_cache: (untyped klass, untyped owner) { (*untyped) -> untyped } -> untyped

  def belongs_to?: () -> untyped

  alias check_eager_loadable! check_preloadable!

  def check_preloadable!: () -> untyped

  def check_validity!: () -> untyped

  def clear_association_scope_cache: () -> untyped

  def collect_join_chain: () -> untyped

  def collection?: () -> untyped

  def compute_class: (untyped name) -> untyped

  def constructable?: () -> untyped

  def extensions: () -> untyped

  def foreign_key: () -> untyped

  def foreign_type: () -> untyped

  def has_inverse?: () -> untyped

  def has_one?: () -> untyped

  def has_scope?: () -> untyped

  def join_id_for: (untyped owner) -> untyped

  def join_table: () -> untyped

  def macro: () -> untyped

  def nested?: () -> untyped

  def parent_reflection: () -> untyped

  def parent_reflection=: (untyped) -> untyped

  def polymorphic?: () -> untyped

  def polymorphic_inverse_of: (untyped associated_class) -> untyped

  def source_reflection: () -> untyped

  def through_reflection: () -> untyped

  def `type`: () -> untyped

  def validate?: () -> untyped

  private

  def automatic_inverse_of: () -> untyped

  def calculate_constructable: (untyped macro, untyped options) -> untyped

  def can_find_inverse_of_automatically?: (untyped reflection) -> untyped

  def derive_class_name: () -> untyped

  def derive_foreign_key: () -> untyped

  def derive_join_table: () -> untyped

  def initialize: (untyped name, untyped scope, untyped options, untyped active_record) -> untyped

  def inverse_name: () -> untyped

  def valid_inverse_reflection?: (untyped reflection) -> untyped
end

ActiveRecord::Reflection::AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS: Array

ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS: Array

class ActiveRecord::Reflection::BelongsToReflection < ActiveRecord::Reflection::AssociationReflection
  public

  def association_class: () -> untyped

  def belongs_to?: () -> untyped

  def join_foreign_key: () -> untyped

  def join_primary_key: (?untyped klass) -> untyped

  def macro: () -> untyped

  private

  def calculate_constructable: (untyped macro, untyped options) -> untyped

  def can_find_inverse_of_automatically?: (untyped _) -> untyped
end

module ActiveRecord::Reflection::ClassMethods
  public

  def _reflect_on_association: (untyped association) -> untyped

  def clear_reflections_cache: () -> untyped

  def reflect_on_aggregation: (untyped aggregation) -> untyped

  def reflect_on_all_aggregations: () -> untyped

  def reflect_on_all_associations: (?untyped macro) -> untyped

  def reflect_on_all_autosave_associations: () -> untyped

  def reflect_on_association: (untyped association) -> untyped

  def reflections: () -> untyped
end

class ActiveRecord::Reflection::HasAndBelongsToManyReflection < ActiveRecord::Reflection::AssociationReflection
  public

  def collection?: () -> untyped

  def macro: () -> untyped
end

class ActiveRecord::Reflection::HasManyReflection < ActiveRecord::Reflection::AssociationReflection
  public

  def association_class: () -> untyped

  def association_primary_key: (?untyped klass) -> untyped

  def collection?: () -> untyped

  def macro: () -> untyped
end

class ActiveRecord::Reflection::HasOneReflection < ActiveRecord::Reflection::AssociationReflection
  public

  def association_class: () -> untyped

  def has_one?: () -> untyped

  def macro: () -> untyped

  private

  def calculate_constructable: (untyped macro, untyped options) -> untyped
end

class ActiveRecord::Reflection::MacroReflection < ActiveRecord::Reflection::AbstractReflection
  public

  def ==: (untyped other_aggregation) -> untyped

  def active_record: () -> untyped

  def autosave=: (untyped autosave) -> untyped

  def compute_class: (untyped name) -> untyped

  def klass: () -> untyped

  def name: () -> untyped

  def options: () -> untyped

  def plural_name: () -> untyped

  def scope: () -> untyped

  def scope_for: (untyped relation, ?untyped owner) -> untyped

  private

  def derive_class_name: () -> untyped

  def initialize: (untyped name, untyped scope, untyped options, untyped active_record) -> untyped
end

class ActiveRecord::Reflection::PolymorphicReflection < ActiveRecord::Reflection::AbstractReflection
  public

  def constraints: () -> untyped

  def join_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_primary_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_scopes: (untyped table, untyped predicate_builder, ?untyped klass) -> untyped

  def klass: (*untyped *) { (*untyped) -> untyped } -> untyped

  def plural_name: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scope: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scope_for: (*untyped *) { (*untyped) -> untyped } -> untyped

  def `type`: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped reflection, untyped previous_reflection) -> untyped

  def source_type_scope: () -> untyped
end

class ActiveRecord::Reflection::RuntimeReflection < ActiveRecord::Reflection::AbstractReflection
  public

  def aliased_table: () -> untyped

  def all_includes: () -> untyped

  def constraints: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_primary_key: (?untyped klass) -> untyped

  def klass: () -> untyped

  def scope: (*untyped *) { (*untyped) -> untyped } -> untyped

  def `type`: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped reflection, untyped association) -> untyped
end

class ActiveRecord::Reflection::ThroughReflection < ActiveRecord::Reflection::AbstractReflection
  public

  def active_record: (*untyped *) { (*untyped) -> untyped } -> untyped

  def active_record_primary_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def add_as_polymorphic_through: (untyped reflection, untyped seed) -> untyped

  def add_as_source: (untyped seed) -> untyped

  def add_as_through: (untyped seed) -> untyped

  def association_class: (*untyped *) { (*untyped) -> untyped } -> untyped

  def association_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def association_primary_key: (?untyped klass) -> untyped

  def association_scope_cache: (*untyped *) { (*untyped) -> untyped } -> untyped

  def autosave=: (untyped arg) -> untyped

  def belongs_to?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def check_eager_loadable!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def check_preloadable!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def check_validity!: () -> untyped

  def clear_association_scope_cache: () -> untyped

  def collect_join_chain: () -> untyped

  def collection?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def compute_class: (*untyped *) { (*untyped) -> untyped } -> untyped

  def constraints: () -> untyped

  def constructable?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def extensions: (*untyped *) { (*untyped) -> untyped } -> untyped

  def foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def foreign_type: (*untyped *) { (*untyped) -> untyped } -> untyped

  def has_inverse?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def has_one?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def has_scope?: () -> untyped

  def join_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_id_for: (*untyped *) { (*untyped) -> untyped } -> untyped

  def join_primary_key: (?untyped klass) -> untyped

  def join_scopes: (untyped table, untyped predicate_builder, ?untyped klass) -> untyped

  def join_table: (*untyped *) { (*untyped) -> untyped } -> untyped

  def klass: () -> untyped

  def macro: (*untyped *) { (*untyped) -> untyped } -> untyped

  def name: (*untyped *) { (*untyped) -> untyped } -> untyped

  def nested?: () -> untyped

  def options: (*untyped *) { (*untyped) -> untyped } -> untyped

  def parent_reflection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def parent_reflection=: (untyped arg) -> untyped

  def plural_name: (*untyped *) { (*untyped) -> untyped } -> untyped

  def polymorphic?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def polymorphic_inverse_of: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scope: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scope_for: (*untyped *) { (*untyped) -> untyped } -> untyped

  def scopes: () -> untyped

  def source_options: () -> untyped

  def source_reflection: () -> untyped

  def source_reflection_name: () -> untyped

  def source_reflection_names: () -> untyped

  def through_options: () -> untyped

  def through_reflection: () -> untyped

  def through_reflection?: () -> untyped

  def `type`: (*untyped *) { (*untyped) -> untyped } -> untyped

  def validate?: (*untyped *) { (*untyped) -> untyped } -> untyped

  private

  def collect_join_reflections: (untyped seed) -> untyped

  def delegate_reflection: () -> untyped

  def derive_class_name: () -> untyped

  def initialize: (untyped delegate_reflection) -> untyped

  def inverse_name: () -> untyped
end

class ActiveRecord::Relation < ActiveRecord::Relation
  include ActiveRecord::InternalMetadata::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::Relation < ActiveRecord::Relation
  include ActiveRecord::SchemaMigration::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::Relation
  include FinderMethods

  include Calculations

  include SpawnMethods

  include QueryMethods

  include Batches

  include Explain

  include Delegation

  include Enumerable

  public

  def ==: (untyped other) -> untyped

  def _deprecated_scope_source: () -> untyped

  def _exec_scope: (untyped name, *untyped args) { (*untyped) -> untyped } -> untyped

  def alias_tracker: (?untyped joins, ?untyped aliases) -> untyped

  def any?: () -> untyped

  def arel_attribute: (untyped name) -> untyped

  def bind_attribute: (untyped name, untyped value) -> untyped

  def blank?: () -> untyped

  alias build new

  def cache_key: (?untyped timestamp_column) -> untyped

  def cache_key_with_version: () -> untyped

  def cache_version: (?untyped timestamp_column) -> untyped

  def create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def create_or_find_by: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def create_or_find_by!: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def delete_all: () -> untyped

  def delete_by: (*untyped args) -> untyped

  def destroy_all: () -> untyped

  def destroy_by: (*untyped args) -> untyped

  def eager_loading?: () -> untyped

  def empty?: () -> untyped

  def empty_scope?: () -> untyped

  def encode_with: (untyped coder) -> untyped

  def explain: () -> untyped

  def find_or_create_by: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def find_or_create_by!: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def find_or_initialize_by: (untyped attributes) { (*untyped) -> untyped } -> untyped

  def first_or_create: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def first_or_create!: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def first_or_initialize: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def has_limit_or_offset?: () -> untyped

  def inspect: () -> untyped

  def joined_includes_values: () -> untyped

  def klass: () -> untyped

  def load: () { (*untyped) -> untyped } -> untyped

  def loaded: () -> untyped

  alias loaded? loaded

  alias locked? lock_value

  def many?: () -> untyped

  alias model klass

  def new: (?untyped attributes) { (*untyped) -> untyped } -> untyped

  def none?: () -> untyped

  def one?: () -> untyped

  def predicate_builder: () -> untyped

  def preload_associations: (untyped records) -> untyped

  def pretty_print: (untyped q) -> untyped

  def records: () -> untyped

  def reload: () -> untyped

  def reset: () -> untyped

  def scope_for_create: () -> untyped

  def scoping: () -> untyped

  def size: () -> untyped

  def skip_preloading_value: () -> untyped

  def skip_preloading_value=: (untyped) -> untyped

  def table: () -> untyped

  alias to_a to_ary

  def to_ary: () -> untyped

  def to_sql: () -> untyped

  def touch_all: (*untyped names, ?time: untyped) -> untyped

  def update: (?untyped id, untyped attributes) -> untyped

  def update_all: (untyped updates) -> untyped

  def update_counters: (untyped counters) -> untyped

  def values: () -> untyped

  def where_values_hash: (?untyped relation_table_name) -> untyped

  private

  def _deprecated_scope_block: (untyped name) { (*untyped) -> untyped } -> untyped

  def _deprecated_spawn: (untyped name) -> untyped

  def _increment_attribute: (untyped attribute, ?untyped value) -> untyped

  def _scoping: (untyped scope) -> untyped

  def _substitute_values: (untyped values) -> untyped

  def already_in_scope?: () -> untyped

  def build_preloader: () -> untyped

  def compute_cache_key: (?untyped timestamp_column) -> untyped

  def compute_cache_version: (untyped timestamp_column) -> untyped

  def exec_queries: () { (*untyped) -> untyped } -> untyped

  def initialize: (untyped klass, ?table: untyped, ?predicate_builder: untyped, ?values: untyped) -> untyped

  def initialize_copy: (untyped other) -> untyped

  def references_eager_loaded_tables?: () -> untyped

  def skip_query_cache_if_necessary: () -> untyped

  def tables_in_string: (untyped string) -> untyped
end

ActiveRecord::Relation::CLAUSE_METHODS: Array

ActiveRecord::Relation::INVALID_METHODS_FOR_DELETE_ALL: Array

ActiveRecord::Relation::MULTI_VALUE_METHODS: Array

ActiveRecord::Relation::SINGLE_VALUE_METHODS: Array

ActiveRecord::Relation::VALUE_METHODS: Array

class ActiveRecord::Relation < ActiveRecord::Relation
  include ActiveRecord::AdvisoryLockBase::GeneratedRelationMethods

  include ActiveRecord::Delegation::ClassSpecificRelation
end

class ActiveRecord::Relation::FromClause
  def self.empty: () -> untyped

  public

  def ==: (untyped other) -> untyped

  def empty?: () -> untyped

  def merge: (untyped other) -> untyped

  def name: () -> untyped

  def value: () -> untyped

  private

  def initialize: (untyped value, untyped name) -> untyped
end

class ActiveRecord::Relation::HashMerger
  public

  def hash: () -> untyped

  def merge: () -> untyped

  def other: () -> untyped

  def relation: () -> untyped

  private

  def initialize: (untyped relation, untyped hash, ?untyped rewhere) -> untyped
end

class ActiveRecord::Relation::Merger
  public

  def merge: () -> untyped

  def normal_values: () -> untyped

  def other: () -> untyped

  def relation: () -> untyped

  def values: () -> untyped

  private

  def initialize: (untyped relation, untyped other, ?untyped rewhere) -> untyped

  def merge_clauses: () -> untyped

  def merge_joins: () -> untyped

  def merge_multi_values: () -> untyped

  def merge_outer_joins: () -> untyped

  def merge_preloads: () -> untyped

  def merge_single_values: () -> untyped

  def replace_from_clause?: () -> untyped
end

ActiveRecord::Relation::Merger::NORMAL_VALUES: Array

class ActiveRecord::Relation::QueryAttribute < ActiveModel::Attribute
  public

  def infinite?: () -> untyped

  def nil?: () -> untyped

  def type_cast: (untyped value) -> untyped

  def unboundable?: () -> untyped

  def value_for_database: () -> untyped

  def with_cast_value: (untyped value) -> untyped

  private

  def infinity?: (untyped value) -> untyped
end

class ActiveRecord::Relation::WhereClause
  def self.empty: () -> untyped

  public

  def +: (untyped other) -> untyped

  def -: (untyped other) -> untyped

  def ==: (untyped other) -> untyped

  def any?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def ast: () -> untyped

  def contradiction?: () -> untyped

  def empty?: (*untyped *) { (*untyped) -> untyped } -> untyped

  def except: (*untyped columns) -> untyped

  def extract_attributes: () -> untyped

  def invert: (?untyped as) -> untyped

  def merge: (untyped other, ?untyped rewhere) -> untyped

  def or: (untyped other) -> untyped

  def to_h: (?untyped table_name) -> untyped

  def |: (untyped other) -> untyped

  private

  def equalities: (untyped predicates) -> untyped

  def equality_node?: (untyped node) -> untyped

  def except_predicates: (untyped columns) -> untyped

  def extract_attribute: (untyped node) -> untyped

  def extract_node_value: (untyped node) -> untyped

  def initialize: (untyped predicates) -> untyped

  def invert_predicate: (untyped node) -> untyped

  def non_empty_predicates: () -> untyped

  def predicates_unreferenced_by: (untyped other) -> untyped

  def predicates_with_wrapped_sql_literals: () -> untyped

  def wrap_sql_literal: (untyped node) -> untyped
end

ActiveRecord::Relation::WhereClause::ARRAY_WITH_EMPTY_STRING: Array

class ActiveRecord::Relation::WhereClauseFactory
  public

  def build: (untyped opts, untyped other) { (*untyped) -> untyped } -> untyped

  private

  def initialize: (untyped klass, untyped predicate_builder) -> untyped

  def klass: () -> untyped

  def predicate_builder: () -> untyped
end

class ActiveRecord::Result
  include Enumerable

  public

  def []: (untyped idx) -> untyped

  def cast_values: (?untyped type_overrides) -> untyped

  alias collect! map

  def column_types: () -> untyped

  def columns: () -> untyped

  def each: () -> untyped

  def empty?: () -> untyped

  def includes_column?: (untyped name) -> untyped

  def last: (?untyped n) -> untyped

  def length: () -> untyped

  alias map! map

  def rows: () -> untyped

  alias to_a to_ary

  def to_ary: () -> untyped

  def to_hash: () -> untyped

  private

  def column_type: (untyped name, ?untyped type_overrides) -> untyped

  def hash_rows: () -> untyped

  def initialize: (untyped columns, untyped rows, ?untyped column_types) -> untyped

  def initialize_copy: (untyped other) -> untyped
end

class ActiveRecord::Rollback < ActiveRecord::ActiveRecordError
end

class ActiveRecord::RuntimeRegistry
  def self.connection_handler: () -> untyped

  def self.connection_handler=: (untyped x) -> untyped

  def self.sql_runtime: () -> untyped

  def self.sql_runtime=: (untyped x) -> untyped

  public

  def connection_handler: () -> untyped

  def connection_handler=: (untyped) -> untyped

  def sql_runtime: () -> untyped

  def sql_runtime=: (untyped) -> untyped
end

module ActiveRecord::Sanitization
end

module ActiveRecord::Sanitization::ClassMethods
  public

  def disallow_raw_sql!: (untyped args, ?permit: untyped) -> untyped

  alias sanitize_sql sanitize_sql_for_conditions

  def sanitize_sql_array: (untyped ary) -> untyped

  def sanitize_sql_for_assignment: (untyped assignments, ?untyped default_table_name) -> untyped

  def sanitize_sql_for_conditions: (untyped condition) -> untyped

  def sanitize_sql_for_order: (untyped condition) -> untyped

  def sanitize_sql_hash_for_assignment: (untyped attrs, untyped table) -> untyped

  def sanitize_sql_like: (untyped string, ?untyped escape_character) -> untyped

  private

  def quote_bound_value: (untyped value, ?untyped c) -> untyped

  def raise_if_bind_arity_mismatch: (untyped statement, untyped expected, untyped provided) -> untyped

  def replace_bind_variable: (untyped value, ?untyped c) -> untyped

  def replace_bind_variables: (untyped statement, untyped values) -> untyped

  def replace_named_bind_variables: (untyped statement, untyped bind_vars) -> untyped
end

class ActiveRecord::Schema < ActiveRecord::Migration::Current
  def self.define: (?untyped info) { (*untyped) -> untyped } -> untyped

  public

  def define: (untyped info) { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::SchemaDumper
  def self.chk_ignore_pattern: () -> untyped

  def self.chk_ignore_pattern=: (untyped val) -> untyped

  def self.dump: (?untyped connection, ?untyped stream, ?untyped config) -> untyped

  def self.fk_ignore_pattern: () -> untyped

  def self.fk_ignore_pattern=: (untyped val) -> untyped

  def self.ignore_tables: () -> untyped

  def self.ignore_tables=: (untyped val) -> untyped

  public

  def chk_ignore_pattern: () -> untyped

  def chk_ignore_pattern=: (untyped val) -> untyped

  def dump: (untyped stream) -> untyped

  def fk_ignore_pattern: () -> untyped

  def fk_ignore_pattern=: (untyped val) -> untyped

  def ignore_tables: () -> untyped

  def ignore_tables=: (untyped val) -> untyped

  private

  def check_constraints_in_create: (untyped table, untyped stream) -> untyped

  def define_params: () -> untyped

  def extensions: (untyped stream) -> untyped

  def foreign_keys: (untyped table, untyped stream) -> untyped

  def format_colspec: (untyped colspec) -> untyped

  def format_index_parts: (untyped options) -> untyped

  def format_options: (untyped options) -> untyped

  def formatted_version: () -> untyped

  def header: (untyped stream) -> untyped

  def ignored?: (untyped table_name) -> untyped

  def index_parts: (untyped index) -> untyped

  def indexes: (untyped table, untyped stream) -> untyped

  def indexes_in_create: (untyped table, untyped stream) -> untyped

  def initialize: (untyped connection, ?untyped options) -> untyped

  def remove_prefix_and_suffix: (untyped table) -> untyped

  def table: (untyped table, untyped stream) -> untyped

  def table_name: () -> untyped

  def table_name=: (untyped) -> untyped

  def tables: (untyped stream) -> untyped

  def trailer: (untyped stream) -> untyped
end

class ActiveRecord::SchemaMigration < ActiveRecord::Base
  include ActiveRecord::SchemaMigration::GeneratedAssociationMethods

  include ActiveRecord::SchemaMigration::GeneratedAttributeMethods

  def self._internal?: () -> untyped

  def self._validators: () -> untyped

  def self.all_versions: () -> untyped

  def self.attribute_type_decorations: () -> untyped

  def self.create_table: () -> untyped

  def self.defined_enums: () -> untyped

  def self.drop_table: () -> untyped

  def self.normalize_migration_number: (untyped number) -> untyped

  def self.normalized_versions: () -> untyped

  def self.primary_key: () -> untyped

  def self.table_name: () -> untyped

  public

  def version: () -> untyped
end

module ActiveRecord::SchemaMigration::GeneratedAssociationMethods
end

module ActiveRecord::SchemaMigration::GeneratedAttributeMethods
end

module ActiveRecord::SchemaMigration::GeneratedRelationMethods
end

module ActiveRecord::Scoping
  public

  def initialize_internals_callback: () -> untyped

  def populate_with_current_scope_attributes: () -> untyped
end

module ActiveRecord::Scoping::ClassMethods
  public

  def current_scope: (?untyped skip_inherited_scope) -> untyped

  def current_scope=: (untyped scope) -> untyped

  def scope_attributes: () -> untyped

  def scope_attributes?: () -> untyped
end

module ActiveRecord::Scoping::Default
end

module ActiveRecord::Scoping::Default::ClassMethods
  public

  def before_remove_const: () -> untyped

  def scope_attributes?: () -> untyped

  def unscoped: () -> untyped

  private

  def build_default_scope: (?untyped relation) -> untyped

  def default_scope: (?untyped scope) { (*untyped) -> untyped } -> untyped

  def evaluate_default_scope: () -> untyped

  def ignore_default_scope=: (untyped ignore) -> untyped

  def ignore_default_scope?: () -> untyped
end

module ActiveRecord::Scoping::Named
end

module ActiveRecord::Scoping::Named::ClassMethods
  public

  def all: () -> untyped

  def default_extensions: () -> untyped

  def default_scoped: (?untyped scope) -> untyped

  def scope: (untyped name, untyped body) { (*untyped) -> untyped } -> untyped

  def scope_for_association: (?untyped scope) -> untyped

  private

  def singleton_method_added: (untyped name) -> untyped

  def valid_scope_name?: (untyped name) -> untyped
end

class ActiveRecord::Scoping::ScopeRegistry
  public

  def set_value_for: (untyped scope_type, untyped model, untyped value) -> untyped

  def value_for: (untyped scope_type, untyped model, ?untyped skip_inherited_scope) -> untyped

  private

  def initialize: () -> untyped

  def raise_invalid_scope_type!: (untyped scope_type) -> untyped
end

ActiveRecord::Scoping::ScopeRegistry::VALID_SCOPE_TYPES: Array

module ActiveRecord::SecureToken
end

ActiveRecord::SecureToken::MINIMUM_TOKEN_LENGTH: Integer

module ActiveRecord::SecureToken::ClassMethods
  public

  def generate_unique_secure_token: (?length: untyped) -> untyped

  def has_secure_token: (?untyped attribute, ?length: untyped) -> untyped
end

module ActiveRecord::Serialization
  public

  def serializable_hash: (?untyped options) -> untyped
end

class ActiveRecord::SerializationFailure < ActiveRecord::TransactionRollbackError
end

class ActiveRecord::SerializationTypeMismatch < ActiveRecord::ActiveRecordError
end

module ActiveRecord::SpawnMethods
  public

  def except: (*untyped skips) -> untyped

  def merge: (untyped other, *untyped rest) -> untyped

  def merge!: (untyped other, *untyped rest) -> untyped

  def only: (*untyped onlies) -> untyped

  def spawn: () -> untyped

  private

  def relation_with: (untyped values) -> untyped
end

class ActiveRecord::StaleObjectError < ActiveRecord::ActiveRecordError
  public

  def attempted_action: () -> untyped

  def record: () -> untyped

  private

  def initialize: (?untyped record, ?untyped attempted_action) -> untyped
end

class ActiveRecord::StatementCache
  def self.create: (untyped connection, ?untyped callable) { (*untyped) -> untyped } -> untyped

  def self.partial_query: (untyped values) -> untyped

  def self.partial_query_collector: () -> untyped

  def self.query: (untyped sql) -> untyped

  def self.unsupported_value?: (untyped value) -> untyped

  public

  def execute: (untyped params, untyped connection) { (*untyped) -> untyped } -> untyped

  private

  def bind_map: () -> untyped

  def initialize: (untyped query_builder, untyped bind_map, untyped klass) -> untyped

  def klass: () -> untyped

  def query_builder: () -> untyped
end

class ActiveRecord::StatementCache::BindMap
  public

  def bind: (untyped values) -> untyped

  private

  def initialize: (untyped bound_attributes) -> untyped
end

class ActiveRecord::StatementCache::Params
  public

  def bind: () -> untyped
end

class ActiveRecord::StatementCache::PartialQuery < ActiveRecord::StatementCache::Query
  public

  def sql_for: (untyped binds, untyped connection) -> untyped

  private

  def initialize: (untyped values) -> untyped
end

class ActiveRecord::StatementCache::PartialQueryCollector
  public

  def <<: (untyped str) -> untyped

  def add_bind: (untyped obj) -> untyped

  def add_binds: (untyped binds) -> untyped

  def preparable: () -> untyped

  def preparable=: (untyped) -> untyped

  def value: () -> untyped

  private

  def initialize: () -> untyped
end

class ActiveRecord::StatementCache::Query
  public

  def sql_for: (untyped binds, untyped connection) -> untyped

  private

  def initialize: (untyped sql) -> untyped
end

class ActiveRecord::StatementCache::Substitute
end

class ActiveRecord::StatementInvalid < ActiveRecord::ActiveRecordError
  public

  def binds: () -> untyped

  def sql: () -> untyped

  private

  def initialize: (?untyped message, ?sql: untyped, ?binds: untyped) -> untyped
end

class ActiveRecord::StatementTimeout < ActiveRecord::QueryAborted
end

module ActiveRecord::Store
  private

  def read_store_attribute: (untyped store_attribute, untyped key) -> untyped

  def store_accessor_for: (untyped store_attribute) -> untyped

  def write_store_attribute: (untyped store_attribute, untyped key, untyped value) -> untyped
end

module ActiveRecord::Store::ClassMethods
  public

  def _store_accessors_module: () -> untyped

  def store: (untyped store_attribute, ?untyped options) -> untyped

  def store_accessor: (untyped store_attribute, *untyped keys, ?prefix: untyped, ?suffix: untyped) -> untyped

  def stored_attributes: () -> untyped
end

class ActiveRecord::Store::HashAccessor
  def self.prepare: (untyped object, untyped attribute) -> untyped

  def self.read: (untyped object, untyped attribute, untyped key) -> untyped

  def self.write: (untyped object, untyped attribute, untyped key, untyped value) -> untyped
end

class ActiveRecord::Store::IndifferentCoder
  def self.as_indifferent_hash: (untyped obj) -> untyped

  public

  def dump: (untyped obj) -> untyped

  def load: (untyped yaml) -> untyped

  private

  def initialize: (untyped attr_name, untyped coder_or_class_name) -> untyped
end

class ActiveRecord::Store::IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
  def self.prepare: (untyped object, untyped store_attribute) -> untyped
end

class ActiveRecord::Store::StringKeyedHashAccessor < ActiveRecord::Store::HashAccessor
  def self.read: (untyped object, untyped attribute, untyped key) -> untyped

  def self.write: (untyped object, untyped attribute, untyped key, untyped value) -> untyped
end

class ActiveRecord::SubclassNotFound < ActiveRecord::ActiveRecordError
end

module ActiveRecord::Suppressor
  public

  def save: (**untyped) -> untyped

  def save!: (**untyped) -> untyped
end

module ActiveRecord::Suppressor::ClassMethods
  public

  def suppress: () { (*untyped) -> untyped } -> untyped
end

class ActiveRecord::SuppressorRegistry
  public

  def suppressed: () -> untyped

  private

  def initialize: () -> untyped
end

class ActiveRecord::TableMetadata
  public

  alias aggregated_with? reflect_on_aggregation

  def arel_attribute: (untyped column_name) -> untyped

  def associated_table: (untyped table_name) -> untyped

  def associated_with?: (untyped table_name) -> untyped

  def association_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def association_foreign_type: (*untyped *) { (*untyped) -> untyped } -> untyped

  def association_join_foreign_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def association_join_primary_key: (*untyped *) { (*untyped) -> untyped } -> untyped

  def has_column?: (untyped column_name) -> untyped

  def polymorphic_association?: () -> untyped

  def predicate_builder: () -> untyped

  def reflect_on_aggregation: (untyped aggregation_name) -> untyped

  def through_association?: () -> untyped

  def `type`: (untyped column_name) -> untyped

  private

  def arel_table: () -> untyped

  def initialize: (untyped klass, untyped arel_table, ?untyped reflection) -> untyped

  def klass: () -> untyped

  def reflection: () -> untyped
end

module ActiveRecord::Tasks
end

class ActiveRecord::Tasks::DatabaseNotSupported < StandardError
end

class ActiveRecord::Tasks::MySQLDatabaseTasks
  def self.using_database_configurations?: () -> untyped

  public

  def charset: () -> untyped

  def collation: () -> untyped

  def connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create: () -> untyped

  def drop: () -> untyped

  def establish_connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def purge: () -> untyped

  def structure_dump: (untyped filename, untyped extra_flags) -> untyped

  def structure_load: (untyped filename, untyped extra_flags) -> untyped

  private

  def configuration_hash: () -> untyped

  def configuration_hash_without_database: () -> untyped

  def creation_options: () -> untyped

  def db_config: () -> untyped

  def initialize: (untyped db_config) -> untyped

  def prepare_command_options: () -> untyped

  def run_cmd: (untyped cmd, untyped args, untyped action) -> untyped

  def run_cmd_error: (untyped cmd, untyped args, untyped action) -> untyped
end

ActiveRecord::Tasks::MySQLDatabaseTasks::ER_DB_CREATE_EXISTS: Integer

class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
  def self.using_database_configurations?: () -> untyped

  public

  def charset: () -> untyped

  def clear_active_connections!: (*untyped *) { (*untyped) -> untyped } -> untyped

  def collation: () -> untyped

  def connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create: (?untyped master_established) -> untyped

  def drop: () -> untyped

  def establish_connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def purge: () -> untyped

  def structure_dump: (untyped filename, untyped extra_flags) -> untyped

  def structure_load: (untyped filename, untyped extra_flags) -> untyped

  private

  def configuration_hash: () -> untyped

  def db_config: () -> untyped

  def encoding: () -> untyped

  def establish_master_connection: () -> untyped

  def initialize: (untyped db_config) -> untyped

  def remove_sql_header_comments: (untyped filename) -> untyped

  def run_cmd: (untyped cmd, untyped args, untyped action) -> untyped

  def run_cmd_error: (untyped cmd, untyped args, untyped action) -> untyped

  def set_psql_env: () -> untyped
end

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::DEFAULT_ENCODING: String

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::ON_ERROR_STOP_1: String

ActiveRecord::Tasks::PostgreSQLDatabaseTasks::SQL_COMMENT_BEGIN: String

class ActiveRecord::Tasks::SQLiteDatabaseTasks
  def self.using_database_configurations?: () -> untyped

  public

  def charset: () -> untyped

  def connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def create: () -> untyped

  def drop: () -> untyped

  def establish_connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def purge: () -> untyped

  def structure_dump: (untyped filename, untyped extra_flags) -> untyped

  def structure_load: (untyped filename, untyped extra_flags) -> untyped

  private

  def db_config: () -> untyped

  def initialize: (untyped db_config, ?untyped root) -> untyped

  def root: () -> untyped

  def run_cmd: (untyped cmd, untyped args, untyped `out`) -> untyped

  def run_cmd_error: (untyped cmd, untyped args) -> untyped
end

module ActiveRecord::TestDatabases
  def self.create_and_load_schema: (untyped i, env_name: untyped) -> untyped
end

module ActiveRecord::TestFixtures
  public

  def after_teardown: () -> untyped

  def before_setup: () -> untyped

  def enlist_fixture_connections: () -> untyped

  def run_in_transaction?: () -> untyped

  def setup_fixtures: (?untyped config) -> untyped

  def teardown_fixtures: () -> untyped

  private

  def instantiate_fixtures: () -> untyped

  def load_fixtures: (untyped config) -> untyped

  def load_instances?: () -> untyped

  def setup_shared_connection_pool: () -> untyped
end

module ActiveRecord::TestFixtures::ClassMethods
  public

  def fixtures: (*untyped fixture_set_names) -> untyped

  def set_fixture_class: (?untyped class_names) -> untyped

  def setup_fixture_accessors: (?untyped fixture_set_names) -> untyped

  def uses_transaction: (*untyped methods) -> untyped

  def uses_transaction?: (untyped method) -> untyped
end

class ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner, ?untyped reflection) -> untyped
end

class ActiveRecord::ThroughNestedAssociationsAreReadonly < ActiveRecord::ActiveRecordError
  private

  def initialize: (?untyped owner, ?untyped reflection) -> untyped
end

module ActiveRecord::Timestamp
  private

  def _create_record: () -> untyped

  def _update_record: () -> untyped

  def all_timestamp_attributes_in_model: () -> untyped

  def clear_timestamp_attributes: () -> untyped

  def create_or_update: (?touch: untyped, **untyped) -> untyped

  def current_time_from_proper_timezone: () -> untyped

  def initialize_dup: (untyped other) -> untyped

  def max_updated_column_timestamp: () -> untyped

  def should_record_timestamps?: () -> untyped

  def timestamp_attributes_for_create_in_model: () -> untyped

  def timestamp_attributes_for_update_in_model: () -> untyped
end

module ActiveRecord::Timestamp::ClassMethods
  public

  def all_timestamp_attributes_in_model: () -> untyped

  def current_time_from_proper_timezone: () -> untyped

  def timestamp_attributes_for_create_in_model: () -> untyped

  def timestamp_attributes_for_update_in_model: () -> untyped

  def touch_attributes_with_time: (*untyped names, ?time: untyped) -> untyped

  private

  def reload_schema_from_cache: () -> untyped

  def timestamp_attributes_for_create: () -> untyped

  def timestamp_attributes_for_update: () -> untyped
end

module ActiveRecord::TouchLater
  public

  def before_committed!: () -> untyped

  def touch: (*untyped names, ?time: untyped) -> untyped

  def touch_later: (*untyped names) -> untyped

  private

  def belongs_to_touch_method: () -> untyped

  def has_defer_touch_attrs?: () -> untyped

  def surreptitiously_touch: (untyped attr_names) -> untyped

  def touch_deferred_attributes: () -> untyped
end

class ActiveRecord::TransactionIsolationError < ActiveRecord::ActiveRecordError
end

class ActiveRecord::TransactionRollbackError < ActiveRecord::StatementInvalid
end

module ActiveRecord::Transactions
  public

  def before_committed!: () -> untyped

  def committed!: (?should_run_callbacks: untyped) -> untyped

  def destroy: () -> untyped

  def rolledback!: (?force_restore_state: untyped, ?should_run_callbacks: untyped) -> untyped

  def save: (**untyped) -> untyped

  def save!: (**untyped) -> untyped

  def touch: (*untyped, **untyped) -> untyped

  def transaction: (**untyped) { (*untyped) -> untyped } -> untyped

  def trigger_transactional_callbacks?: () -> untyped

  def with_transaction_returning_status: () -> untyped

  private

  def _committed_already_called: () -> untyped

  def _trigger_destroy_callback: () -> untyped

  def _trigger_update_callback: () -> untyped

  def add_to_transaction: (?untyped ensure_finalize) -> untyped

  def clear_transaction_record_state: () -> untyped

  def force_clear_transaction_record_state: () -> untyped

  def has_transactional_callbacks?: () -> untyped

  def remember_transaction_record_state: () -> untyped

  def restore_transaction_record_state: (?untyped force_restore_state) -> untyped

  def transaction_include_any_action?: (untyped actions) -> untyped
end

ActiveRecord::Transactions::ACTIONS: Array

module ActiveRecord::Transactions::ClassMethods
  public

  def after_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def after_create_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def after_destroy_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def after_rollback: (*untyped args) { (*untyped) -> untyped } -> untyped

  def after_save_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def after_update_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def before_commit: (*untyped args) { (*untyped) -> untyped } -> untyped

  def transaction: (**untyped) { (*untyped) -> untyped } -> untyped

  private

  def assert_valid_transaction_action: (untyped actions) -> untyped

  def set_options_for_callbacks!: (untyped args, ?untyped enforced_options) -> untyped
end

module ActiveRecord::Translation
  include ActiveModel::Translation

  public

  def i18n_scope: () -> untyped

  def lookup_ancestors: () -> untyped
end

module ActiveRecord::Type
  def self.adapter_name_from: (untyped model) -> untyped

  def self.add_modifier: (*untyped *) { (*untyped) -> untyped } -> untyped

  def self.default_value: () -> untyped

  def self.lookup: (*untyped args, ?adapter: untyped, **untyped) -> untyped

  def self.register: (untyped type_name, ?untyped klass, **untyped) { (*untyped) -> untyped } -> untyped

  def self.registry: () -> untyped

  def self.registry=: (untyped) -> untyped
end

class ActiveRecord::Type::AdapterSpecificRegistry < ActiveModel::Type::Registry
  public

  def add_modifier: (untyped options, untyped klass, **untyped) -> untyped

  private

  def find_registration: (untyped symbol, *untyped args, **untyped) -> untyped

  def registration_klass: () -> untyped
end

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

class ActiveRecord::Type::DecimalWithoutScale < ActiveModel::Type::BigInteger
  public

  def `type`: () -> untyped

  def type_cast_for_schema: (untyped value) -> untyped
end

class ActiveRecord::Type::DecorationRegistration < ActiveRecord::Type::Registration
  public

  def call: (untyped registry, *untyped args, **untyped) -> untyped

  def matches?: (*untyped args, **untyped) -> untyped

  def priority: () -> untyped

  private

  def initialize: (untyped options, untyped klass, ?adapter: untyped) -> untyped

  def klass: () -> untyped

  def matches_options?: (**untyped) -> untyped

  def options: () -> untyped
end

class ActiveRecord::Type::HashLookupTypeMap < ActiveRecord::Type::TypeMap
  public

  def alias_type: (untyped `type`, untyped alias_type) -> untyped

  def key?: (untyped key) -> untyped

  def keys: () -> untyped

  private

  def perform_fetch: (untyped `type`, *untyped args) { (*untyped) -> untyped } -> untyped
end

module ActiveRecord::Type::Internal
end

module ActiveRecord::Type::Internal::Timezone
  public

  def default_timezone: () -> untyped

  def is_utc?: () -> untyped
end

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

  public

  def accessor: () -> untyped

  def changed_in_place?: (untyped raw_old_value, untyped new_value) -> untyped

  def deserialize: (untyped value) -> untyped

  def serialize: (untyped value) -> untyped

  def `type`: () -> untyped
end

class ActiveRecord::Type::Registration
  public

  def <=>: (untyped other) -> untyped

  def call: (untyped _registry, *untyped args, ?adapter: untyped, **untyped) -> untyped

  def matches?: (untyped type_name, *untyped args, **untyped) -> untyped

  private

  def conflicts_with?: (untyped other) -> untyped

  def has_adapter_conflict?: (untyped other) -> untyped

  def initialize: (untyped name, untyped block, ?adapter: untyped, ?override: untyped) -> untyped

  def matches_adapter?: (?adapter: untyped, **untyped) -> untyped

  def same_priority_except_adapter?: (untyped other) -> untyped
end

class ActiveRecord::Type::Text < ActiveModel::Type::String
  public

  def `type`: () -> untyped
end

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

  public

  def serialize: (untyped value) -> untyped
end

class ActiveRecord::Type::TypeMap
  public

  def alias_type: (untyped key, untyped target_key) -> untyped

  def clear: () -> untyped

  def fetch: (untyped lookup_key, *untyped args) { (*untyped) -> untyped } -> untyped

  def lookup: (untyped lookup_key, *untyped args) -> untyped

  def register_type: (untyped key, ?untyped value) { (*untyped) -> untyped } -> untyped

  private

  def initialize: () -> untyped

  def perform_fetch: (untyped lookup_key, *untyped args) -> untyped
end

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

  def max_value: () -> untyped

  def min_value: () -> untyped
end

module ActiveRecord::TypeCaster
end

class ActiveRecord::TypeCaster::Connection
  public

  def type_cast_for_database: (untyped attr_name, untyped value) -> untyped

  def type_for_attribute: (untyped attr_name) -> untyped

  private

  def connection: (*untyped *) { (*untyped) -> untyped } -> untyped

  def initialize: (untyped klass, untyped table_name) -> untyped

  def table_name: () -> untyped
end

class ActiveRecord::TypeCaster::Map
  public

  def type_cast_for_database: (untyped attr_name, untyped value) -> untyped

  def type_for_attribute: (untyped name) -> untyped

  private

  def initialize: (untyped klass) -> untyped

  def klass: () -> untyped
end

class ActiveRecord::TypeConflictError < StandardError
end

class ActiveRecord::UnknownAttributeReference < ActiveRecord::ActiveRecordError
end

class ActiveRecord::UnknownMigrationVersionError < ActiveRecord::MigrationError
  private

  def initialize: (?untyped version) -> untyped
end

class ActiveRecord::UnknownPrimaryKey < ActiveRecord::ActiveRecordError
  public

  def model: () -> untyped

  private

  def initialize: (?untyped model, ?untyped description) -> untyped
end

module ActiveRecord::VERSION
end

ActiveRecord::VERSION::MAJOR: Integer

ActiveRecord::VERSION::MINOR: Integer

ActiveRecord::VERSION::PRE: String

ActiveRecord::VERSION::STRING: String

ActiveRecord::VERSION::TINY: Integer

module ActiveRecord::Validations
  public

  def save: (**untyped) -> untyped

  def save!: (**untyped) -> untyped

  def valid?: (?untyped context) -> untyped

  alias validate valid?

  private

  def default_validation_context: () -> untyped

  def perform_validations: (?untyped options) -> untyped

  def raise_validation_error: () -> untyped
end

class ActiveRecord::Validations::AbsenceValidator < ActiveModel::Validations::AbsenceValidator
  public

  def validate_each: (untyped record, untyped attribute, untyped association_or_value) -> untyped
end

class ActiveRecord::Validations::AssociatedValidator < ActiveModel::EachValidator
  public

  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped

  private

  def valid_object?: (untyped record) -> untyped
end

module ActiveRecord::Validations::ClassMethods
  public

  def validates_absence_of: (*untyped attr_names) -> untyped

  def validates_associated: (*untyped attr_names) -> untyped

  def validates_length_of: (*untyped attr_names) -> untyped

  def validates_numericality_of: (*untyped attr_names) -> untyped

  def validates_presence_of: (*untyped attr_names) -> untyped

  alias validates_size_of validates_length_of

  def validates_uniqueness_of: (*untyped attr_names) -> untyped
end

class ActiveRecord::Validations::LengthValidator < ActiveModel::Validations::LengthValidator
  public

  def validate_each: (untyped record, untyped attribute, untyped association_or_value) -> untyped
end

class ActiveRecord::Validations::PresenceValidator < ActiveModel::Validations::PresenceValidator
  public

  def validate_each: (untyped record, untyped attribute, untyped association_or_value) -> untyped
end

class ActiveRecord::Validations::UniquenessValidator < ActiveModel::EachValidator
  public

  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped

  private

  def build_relation: (untyped klass, untyped attribute, untyped value) -> untyped

  def find_finder_class_for: (untyped record) -> untyped

  def initialize: (untyped options) -> untyped

  def map_enum_attribute: (untyped klass, untyped attribute, untyped value) -> untyped

  def scope_relation: (untyped record, untyped relation) -> untyped
end

class ActiveRecord::ValueTooLong < ActiveRecord::StatementInvalid
end

class ActiveRecord::WrappedDatabaseException < ActiveRecord::StatementInvalid
end

I generate the rbs with the following stuff.

# added-modules.rb
before = ObjectSpace.each_object(Module).to_a

require ARGV.first

$map = {}

def const_get_suppress_error(base, const_name)
  base.const_get(const_name)
rescue Exception => ex
  warn ex
  nil
end

def load_modules(mod)
  return if $map[mod]
  $map[mod] = true

  mod.constants(false)
    .map {|const_name| const_get_suppress_error(mod, const_name) }
    .select { |constant| Module === constant }
    .each { |mod| load_modules(mod) }
end

load_modules(Object)

r = ObjectSpace.each_object(Module).to_a - before
puts r.reject(&:singleton_class?).filter_map(&:name).join("\n")

diff --git a/lib/rbs/prototype/runtime.rb b/lib/rbs/prototype/runtime.rb
index a12524f..a6a9340 100644
--- a/lib/rbs/prototype/runtime.rb
+++ b/lib/rbs/prototype/runtime.rb
@@ -14,6 +14,14 @@ module RBS
         @owners_included = owners_included.map do |name|
           Object.const_get(name)
         end
+
+        ActiveRecord.eager_load!
+        @patterns.each do |pattern|
+          next if pattern.end_with?('*')
+
+          Object.const_get(pattern)
+        rescue Exception
+        end
       end
 
       def target?(const)
@@ -241,6 +249,7 @@ module RBS
           end
         end
 
+
         private_instance_methods = mod.private_instance_methods.select {|name| target_method?(mod, instance: name) }
         unless private_instance_methods.empty?
           members << AST::Members::Private.new(location: nil)
@@ -307,7 +316,7 @@ module RBS
         super_class = if mod.superclass == ::Object
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: [])
+                        AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: []) rescue return
                       end
 
         decl = AST::Declarations::Class.new(

First, apply the patch.
Then, execute the following command.

$ RUBYOPT='-Ipath/to/rails/rails/activerecord/lib/ -Ipath/to/rails/rails/activesupport/lib' exe/rbs prototype runtime --require active_record $(ruby added-modules.rb active_record | grep ActiveRecord)  > /tmp/active_record.rbs

Note that it needs Rails with the master branch. I used df50341fe8e03229308a0389bc14a654bbae666c.
Becuase it needs at least the following patches.

• rails/rails#39577
• rails/rails#39573

In other words, it may work with Rails 6.x with the patches. But I haven't tried yet.

The rescue return patch is necessary for an unnamed superclass.
It causes incorrect type definitions, but I guess it is better than nothing.

Actually ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter class has an unnamed superclsas.
I haven't investigated yet that other classes have an unnamed superclass.