sorbet-rails 0.5.1 → 0.5.2

data/spec/support/v4.2/sorbet/rbi/gems/activejob.rbi

@@ -1,19 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: strong
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activejob/all/activejob.rbi
-#
-# activejob-4.2.11
-module ActiveJob
-  def self.gem_version; end
-  def self.version; end
-  extend ActiveSupport::Autoload
-end
-module ActiveJob::VERSION
-end
-class ActiveJob::Railtie < Rails::Railtie
-end

data/spec/support/v4.2/sorbet/rbi/gems/activemodel.rbi

@@ -1,335 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
-#
-# activemodel-4.2.11
-module ActiveModel
-  def self.eager_load!; end
-  def self.gem_version; end
-  def self.version; end
-  extend ActiveSupport::Autoload
-end
-module ActiveModel::VERSION
-end
-module ActiveModel::Serializers
-  extend ActiveSupport::Autoload
-end
-class ActiveModel::Railtie < Rails::Railtie
-end
-class ActiveModel::MissingAttributeError < NoMethodError
-end
-module ActiveModel::AttributeMethods
-  def attribute_method?(attr_name); end
-  def attribute_missing(match, *args, &block); end
-  def match_attribute_method?(method_name); end
-  def method_missing(method, *args, &block); end
-  def missing_attribute(attr_name, stack); end
-  def respond_to?(method, include_private_methods = nil); end
-  def respond_to_without_attributes?(*arg0); end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::AttributeMethods::ClassMethods
-  def alias_attribute(new_name, old_name); end
-  def attribute_alias(name); end
-  def attribute_alias?(new_name); end
-  def attribute_method_affix(*affixes); end
-  def attribute_method_matchers_cache; end
-  def attribute_method_matchers_matching(method_name); end
-  def attribute_method_prefix(*prefixes); end
-  def attribute_method_suffix(*suffixes); end
-  def define_attribute_method(attr_name); end
-  def define_attribute_methods(*attr_names); end
-  def define_proxy_call(include_private, mod, name, send, *extra); end
-  def generated_attribute_methods; end
-  def instance_method_already_implemented?(method_name); end
-  def undefine_attribute_methods; end
-end
-class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
-  def initialize(options = nil); end
-  def match(method_name); end
-  def method_missing_target; end
-  def method_name(attr_name); end
-  def plain?; end
-  def prefix; end
-  def suffix; end
-end
-class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher::AttributeMethodMatch < Struct
-  def attr_name; end
-  def attr_name=(_); end
-  def method_name; end
-  def method_name=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def target; end
-  def target=(_); end
-end
-module ActiveModel::SecurePassword
-  def self.min_cost; end
-  def self.min_cost=(arg0); end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::SecurePassword::ClassMethods
-  def has_secure_password(options = nil); end
-end
-module ActiveModel::SecurePassword::InstanceMethodsOnActivation
-  def authenticate(unencrypted_password); end
-  def password; end
-  def password=(unencrypted_password); end
-  def password_confirmation=(unencrypted_password); end
-end
-class ActiveModel::Name
-  def !~(*args, &block); end
-  def <=>(*args, &block); end
-  def ==(arg); end
-  def ===(arg); end
-  def =~(*args, &block); end
-  def _singularize(string, replacement = nil); end
-  def as_json(*args, &block); end
-  def cache_key; end
-  def collection; end
-  def element; end
-  def eql?(*args, &block); end
-  def human(options = nil); end
-  def i18n_key; end
-  def initialize(klass, namespace = nil, name = nil); end
-  def name; end
-  def param_key; end
-  def plural; end
-  def route_key; end
-  def singular; end
-  def singular_route_key; end
-  def to_s(*args, &block); end
-  def to_str(*args, &block); end
-  include Comparable
-end
-module ActiveModel::Naming
-  def model_name; end
-  def self.extended(base); end
-  def self.model_name_from_record_or_class(record_or_class); end
-  def self.param_key(record_or_class); end
-  def self.plural(record_or_class); end
-  def self.route_key(record_or_class); end
-  def self.singular(record_or_class); end
-  def self.singular_route_key(record_or_class); end
-  def self.uncountable?(record_or_class); end
-end
-module ActiveModel::Translation
-  def human_attribute_name(attribute, options = nil); end
-  def i18n_scope; end
-  def lookup_ancestors; end
-  include ActiveModel::Naming
-end
-class ActiveModel::ForbiddenAttributesError < StandardError
-end
-module ActiveModel::ForbiddenAttributesProtection
-  def sanitize_for_mass_assignment(attributes); end
-  def sanitize_forbidden_attributes(attributes); end
-end
-module ActiveModel::Conversion
-  def to_key; end
-  def to_model; end
-  def to_param; end
-  def to_partial_path; end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::Conversion::ClassMethods
-  def _to_partial_path; end
-end
-module ActiveModel::Validations
-  def errors; end
-  def initialize_dup(other); end
-  def invalid?(context = nil); end
-  def read_attribute_for_validation(*arg0); end
-  def run_validations!; end
-  def valid?(context = nil); end
-  def validate(context = nil); end
-  def validates_with(*args, &block); end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::Validations::ClassMethods
-  def _parse_validates_options(options); end
-  def _validates_default_keys; end
-  def attribute_method?(attribute); end
-  def clear_validators!; end
-  def inherited(base); end
-  def validate(*args, &block); end
-  def validates!(*attributes); end
-  def validates(*attributes); end
-  def validates_each(*attr_names, &block); end
-  def validates_with(*args, &block); end
-  def validators; end
-  def validators_on(*attributes); end
-end
-module ActiveModel::Validations::Clusivity
-  def check_validity!; end
-  def delimiter; end
-  def include?(record, value); end
-  def inclusion_method(enumerable); end
-end
-class ActiveModel::Validator
-  def initialize(options = nil); end
-  def kind; end
-  def options; end
-  def self.kind; end
-  def validate(record); end
-end
-class ActiveModel::EachValidator < ActiveModel::Validator
-  def attributes; end
-  def check_validity!; end
-  def initialize(options); end
-  def validate(record); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::BlockValidator < ActiveModel::EachValidator
-  def initialize(options, &block); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
-  def validate_each(record, attribute, value); end
-  include ActiveModel::Validations::Clusivity
-end
-module ActiveModel::Validations::HelperMethods
-  def _merge_attributes(attr_names); end
-  def validates_absence_of(*attr_names); end
-  def validates_acceptance_of(*attr_names); end
-  def validates_confirmation_of(*attr_names); end
-  def validates_exclusion_of(*attr_names); end
-  def validates_format_of(*attr_names); end
-  def validates_inclusion_of(*attr_names); end
-  def validates_length_of(*attr_names); end
-  def validates_numericality_of(*attr_names); end
-  def validates_presence_of(*attr_names); end
-  def validates_size_of(*attr_names); end
-end
-class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
-  def validate_each(record, attr_name, value); end
-end
-class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
-  def allow_only_integer?(record); end
-  def check_validity!; end
-  def filtered_options(value); end
-  def parse_raw_value_as_a_number(raw_value); end
-  def parse_raw_value_as_an_integer(raw_value); end
-  def record_attribute_changed_in_place?(record, attr_name); end
-  def validate_each(record, attr_name, value); end
-end
-module ActiveModel::Validations::Callbacks
-  def run_validations!; end
-  extend ActiveSupport::Concern
-end
-module ActiveModel::Validations::Callbacks::ClassMethods
-  def after_validation(*args, &block); end
-  def before_validation(*args, &block); end
-end
-class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
-  def validate_each(record, attribute, value); end
-  include ActiveModel::Validations::Clusivity
-end
-class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
-  def initialize(options); end
-  def setup!(klass); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
-  def check_options_validity(name); end
-  def check_validity!; end
-  def option_call(record, name); end
-  def record_error(record, attribute, name, value); end
-  def regexp_using_multiline_anchors?(regexp); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
-  def validate_each(record, attr_name, value); end
-end
-class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
-  def check_validity!; end
-  def initialize(options); end
-  def skip_nil_check?(key); end
-  def tokenize(value); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
-  def initialize(options); end
-  def setup!(klass); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
-  def validate_each(record, attr, val); end
-end
-module ActiveModel::Callbacks
-  def _define_after_model_callback(klass, callback); end
-  def _define_around_model_callback(klass, callback); end
-  def _define_before_model_callback(klass, callback); end
-  def define_model_callbacks(*callbacks); end
-  def self.extended(base); end
-end
-module ActiveModel::Dirty
-  def attribute_change(attr); end
-  def attribute_changed?(attr, options = nil); end
-  def attribute_changed_by_setter?(attr_name); end
-  def attribute_was(attr); end
-  def attribute_will_change!(attr); end
-  def attributes_changed_by_setter; end
-  def changed; end
-  def changed?; end
-  def changed_attributes; end
-  def changes; end
-  def changes_applied; end
-  def changes_include?(attr_name); end
-  def clear_attribute_changes(attributes); end
-  def clear_changes_information; end
-  def previous_changes; end
-  def reset_attribute!(attr); end
-  def reset_changes; end
-  def restore_attribute!(attr); end
-  def restore_attributes(attributes = nil); end
-  def set_attribute_was(attr, old_value); end
-  extend ActiveSupport::Concern
-  include ActiveModel::AttributeMethods
-end
-module ActiveModel::Serialization
-  def read_attribute_for_serialization(*arg0); end
-  def serializable_add_includes(options = nil); end
-  def serializable_hash(options = nil); end
-end
-module ActiveModel::Serializers::JSON
-  def as_json(options = nil); end
-  def from_json(json, include_root = nil); end
-  extend ActiveSupport::Concern
-  include ActiveModel::Serialization
-end
-module ActiveModel::Serializers::Xml
-  def from_xml(xml); end
-  def to_xml(options = nil, &block); end
-  extend ActiveSupport::Concern
-  include ActiveModel::Serialization
-end
-class ActiveModel::Serializers::Xml::Serializer
-  def add_associations(association, records, opts); end
-  def add_attributes_and_methods; end
-  def add_extra_behavior; end
-  def add_includes; end
-  def add_procs; end
-  def initialize(serializable, options = nil); end
-  def options; end
-  def serializable_collection; end
-  def serializable_hash; end
-  def serialize; end
-end
-class ActiveModel::Serializers::Xml::Serializer::Attribute
-  def compute_type; end
-  def decorations; end
-  def initialize(name, serializable, value); end
-  def name; end
-  def type; end
-  def value; end
-end
-class ActiveModel::Serializers::Xml::Serializer::MethodAttribute < ActiveModel::Serializers::Xml::Serializer::Attribute
-end

data/spec/support/v4.2/sorbet/rbi/gems/activerecord.rbi

@@ -1,3385 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
-
-# typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activerecord/all/activerecord.rbi
-#
-# activerecord-4.2.11
-module ActiveRecord
-  def self.eager_load!; end
-  def self.gem_version; end
-  def self.version; end
-  extend ActiveSupport::Autoload
-end
-module ActiveRecord::VERSION
-end
-class ActiveRecord::Attribute
-  def ==(other); end
-  def came_from_user?; end
-  def changed_from?(old_value); end
-  def changed_in_place_from?(old_value); end
-  def has_been_read?; end
-  def initialize(name, value_before_type_cast, type); end
-  def initialize_dup(other); end
-  def initialized?; end
-  def name; end
-  def original_value; end
-  def self.from_database(name, value, type); end
-  def self.from_user(name, value, type); end
-  def self.null(name); end
-  def self.uninitialized(name, type); end
-  def self.with_cast_value(name, value, type); end
-  def type; end
-  def type_cast(*arg0); end
-  def value; end
-  def value_before_type_cast; end
-  def value_for_database; end
-  def with_cast_value(value); end
-  def with_value_from_database(value); end
-  def with_value_from_user(value); end
-end
-class ActiveRecord::Attribute::FromDatabase < ActiveRecord::Attribute
-  def type_cast(value); end
-end
-class ActiveRecord::Attribute::FromUser < ActiveRecord::Attribute
-  def came_from_user?; end
-  def type_cast(value); end
-end
-class ActiveRecord::Attribute::WithCastValue < ActiveRecord::Attribute
-  def changed_in_place_from?(old_value); end
-  def type_cast(value); end
-end
-class ActiveRecord::Attribute::Null < ActiveRecord::Attribute
-  def initialize(name); end
-  def value; end
-  def with_value_from_database(value); end
-  def with_value_from_user(value); end
-end
-class ActiveRecord::Attribute::Uninitialized < ActiveRecord::Attribute
-  def initialize(name, type); end
-  def initialized?; end
-  def value; end
-  def value_for_database; end
-end
-class ActiveRecord::AttributeSet
-  def ==(other); end
-  def [](name); end
-  def attributes; end
-  def fetch_value(name); end
-  def freeze; end
-  def initialize(attributes); end
-  def initialize_clone(_); end
-  def initialize_dup(_); end
-  def initialized_attributes; end
-  def key?(name); end
-  def keys; end
-  def reset(key); end
-  def to_h; end
-  def to_hash; end
-  def values_before_type_cast; end
-  def write_cast_value(name, value); end
-  def write_from_database(name, value); end
-  def write_from_user(name, value); end
-end
-class ActiveRecord::AttributeSet::Builder
-  def always_initialized; end
-  def build_from_database(values = nil, additional_types = nil); end
-  def initialize(types, always_initialized = nil); end
-  def types; end
-end
-class ActiveRecord::LazyAttributeHash
-  def ==(other); end
-  def [](key); end
-  def []=(key, value); end
-  def additional_types; end
-  def assign_default_value(name); end
-  def delegate_hash; end
-  def initialize(types, values, additional_types); end
-  def initialize_dup(_); end
-  def initialized_keys; end
-  def key?(key); end
-  def materialize; end
-  def select; end
-  def transform_values(*args, &block); end
-  def types; end
-  def values; end
-end
-module ActiveRecord::AttributeMethods
-  def [](attr_name); end
-  def []=(attr_name, value); end
-  def arel_attributes_with_values(attribute_names); end
-  def arel_attributes_with_values_for_create(attribute_names); end
-  def arel_attributes_with_values_for_update(attribute_names); end
-  def attribute_for_inspect(attr_name); end
-  def attribute_method?(attr_name); end
-  def attribute_names; end
-  def attribute_present?(attribute); end
-  def attributes; end
-  def attributes_for_create(attribute_names); end
-  def attributes_for_update(attribute_names); end
-  def clone_attribute_value(reader_method, attribute_name); end
-  def has_attribute?(attr_name); end
-  def pk_attribute?(name); end
-  def readonly_attribute?(name); end
-  def respond_to?(name, include_private = nil); end
-  def typecasted_attribute_value(name); end
-  extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
-  include ActiveModel::AttributeMethods
-end
-module ActiveRecord::AttributeMethods::AttrNames
-  def self.set_name_cache(name, value); end
-end
-class ActiveRecord::AttributeMethods::AttributeMethodCache
-  def [](name); end
-  def initialize; end
-  def method_body(method_name, const_name); end
-end
-class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < Module
-end
-module ActiveRecord::AttributeMethods::ClassMethods
-  def attribute_method?(attribute); end
-  def attribute_names; end
-  def class_method_defined_within?(name, klass, superklass = nil); end
-  def column_for_attribute(name); end
-  def dangerous_attribute_method?(name); end
-  def dangerous_class_method?(method_name); end
-  def define_attribute_methods; end
-  def inherited(child_class); end
-  def initialize_generated_modules; end
-  def instance_method_already_implemented?(method_name); end
-  def method_defined_within?(name, klass, superklass = nil); end
-  def undefine_attribute_methods; end
-end
-module ActiveRecord::Type
-end
-module ActiveRecord::Type::Decorator
-  def encode_with(coder); end
-  def init_with(coder); end
-end
-module ActiveRecord::Type::Mutable
-  def changed_in_place?(raw_old_value, new_value); end
-  def type_cast_from_user(value); end
-end
-module ActiveRecord::Type::Numeric
-  def changed?(old_value, _new_value, new_value_before_type_cast); end
-  def non_numeric_string?(value); end
-  def number?; end
-  def number_to_non_number?(old_value, new_value_before_type_cast); end
-  def type_cast(value); end
-end
-module ActiveRecord::Type::TimeValue
-  def fast_string_to_time(string); end
-  def klass; end
-  def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil); end
-  def type_cast_for_schema(value); end
-end
-class ActiveRecord::Type::Value
-  def ==(other); end
-  def binary?; end
-  def cast_value(value); end
-  def changed?(old_value, new_value, _new_value_before_type_cast); end
-  def changed_in_place?(*arg0); end
-  def eql?(other); end
-  def hash; end
-  def initialize(options = nil); end
-  def klass; end
-  def limit; end
-  def number?; end
-  def precision; end
-  def scale; end
-  def text?; end
-  def type; end
-  def type_cast(value); end
-  def type_cast_for_database(value); end
-  def type_cast_for_schema(value); end
-  def type_cast_from_database(value); end
-  def type_cast_from_user(value); end
-end
-class ActiveRecord::Type::Integer < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def ensure_in_range(value); end
-  def initialize(*arg0); end
-  def max_value; end
-  def min_value; end
-  def range; end
-  def type; end
-  def type_cast_for_database(value); end
-  def type_cast_from_database(value); end
-  include ActiveRecord::Type::Numeric
-end
-class ActiveRecord::Type::BigInteger < ActiveRecord::Type::Integer
-  def max_value; end
-end
-class ActiveRecord::Type::Binary < ActiveRecord::Type::Value
-  def binary?; end
-  def changed_in_place?(raw_old_value, value); end
-  def type; end
-  def type_cast(value); end
-  def type_cast_for_database(value); end
-end
-class ActiveRecord::Type::Binary::Data
-  def ==(other); end
-  def hex; end
-  def initialize(value); end
-  def to_s; end
-  def to_str; end
-end
-class ActiveRecord::Type::Boolean < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def type; end
-end
-class ActiveRecord::Type::Date < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def fallback_string_to_date(string); end
-  def fast_string_to_date(string); end
-  def klass; end
-  def new_date(year, mon, mday); end
-  def type; end
-  def type_cast_for_database(value); end
-  def type_cast_for_schema(value); end
-end
-class ActiveRecord::Type::DateTime < ActiveRecord::Type::Value
-  def cast_value(string); end
-  def fallback_string_to_time(string); end
-  def has_precision?; end
-  def microseconds(time); end
-  def type; end
-  def type_cast_for_database(value); end
-  include ActiveRecord::Type::TimeValue
-end
-class ActiveRecord::Type::Decimal < ActiveRecord::Type::Value
-  def apply_scale(value); end
-  def cast_value(value); end
-  def convert_float_to_big_decimal(value); end
-  def float_precision; end
-  def type; end
-  def type_cast_for_schema(value); end
-  include ActiveRecord::Type::Numeric
-end
-class ActiveRecord::Type::DecimalWithoutScale < ActiveRecord::Type::BigInteger
-  def type; end
-end
-class ActiveRecord::Type::Float < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def type; end
-  def type_cast_for_database(value); end
-  include ActiveRecord::Type::Numeric
-end
-class ActiveRecord::Type::Serialized < Anonymous_Delegator_11
-  def accessor; end
-  def changed_in_place?(raw_old_value, value); end
-  def coder; end
-  def default_value?(value); end
-  def encode_with(coder); end
-  def init_with(coder); end
-  def initialize(subtype, coder); end
-  def inspect; end
-  def subtype; end
-  def type_cast_for_database(value); end
-  def type_cast_from_database(value); end
-  include ActiveRecord::Type::Decorator
-  include ActiveRecord::Type::Mutable
-end
-class ActiveRecord::Type::String < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def changed_in_place?(raw_old_value, new_value); end
-  def text?; end
-  def type; end
-  def type_cast_for_database(value); end
-end
-class ActiveRecord::Type::Text < ActiveRecord::Type::String
-  def type; end
-end
-class ActiveRecord::Type::Time < ActiveRecord::Type::Value
-  def cast_value(value); end
-  def type; end
-  include ActiveRecord::Type::TimeValue
-end
-class ActiveRecord::Type::UnsignedInteger < ActiveRecord::Type::Integer
-  def max_value; end
-  def min_value; end
-end
-class ActiveRecord::Type::TypeMap
-  def alias_type(key, target_key); end
-  def clear; end
-  def default_value; end
-  def fetch(lookup_key, *args, &block); end
-  def initialize; end
-  def lookup(lookup_key, *args); end
-  def perform_fetch(lookup_key, *args); end
-  def register_type(key, value = nil, &block); end
-end
-class ActiveRecord::Type::HashLookupTypeMap < ActiveRecord::Type::TypeMap
-  def alias_type(type, alias_type); end
-  def key?(key); end
-  def keys; end
-  def perform_fetch(type, *args, &block); end
-end
-module ActiveRecord::ConnectionAdapters
-  extend ActiveSupport::Autoload
-  extend ActiveSupport::Autoload
-end
-class ActiveRecord::ConnectionAdapters::SchemaCache
-  def add(table_name); end
-  def clear!; end
-  def clear_table_cache!(table_name); end
-  def columns(table_name); end
-  def columns_hash(table_name); end
-  def connection; end
-  def connection=(arg0); end
-  def initialize(conn); end
-  def marshal_dump; end
-  def marshal_load(array); end
-  def prepare_tables; end
-  def primary_keys(table_name); end
-  def size; end
-  def table_exists?(name); end
-  def tables(name); end
-  def version; end
-end
-module ActiveRecord::ConnectionAdapters::ColumnDumper
-  def column_spec(column, types); end
-  def migration_keys; end
-  def prepare_column_options(column, types); end
-  def schema_default(column); end
-end
-class ActiveRecord::ConnectionAdapters::AbstractAdapter
-  def _checkin_callbacks; end
-  def _checkin_callbacks?; end
-  def _checkout_callbacks; end
-  def _checkout_callbacks?; end
-  def _run_checkin_callbacks(&block); end
-  def _run_checkout_callbacks(&block); end
-  def active?; end
-  def adapter_name; end
-  def case_insensitive_comparison(table, attribute, column, value); end
-  def case_sensitive_comparison(table, attribute, column, value); end
-  def case_sensitive_modifier(node, table_attribute); end
-  def clear_cache!; end
-  def close; end
-  def collector; end
-  def column_for(table_name, column_name); end
-  def column_name_for_operation(operation, node); end
-  def create_savepoint(name = nil); end
-  def current_savepoint_name; end
-  def delete(*arg0); end
-  def disable_extension(name); end
-  def disable_referential_integrity; end
-  def disconnect!; end
-  def enable_extension(name); end
-  def expire; end
-  def extensions; end
-  def extract_limit(sql_type); end
-  def extract_precision(sql_type); end
-  def extract_scale(sql_type); end
-  def in_use?; end
-  def index_algorithms; end
-  def initialize(connection, logger = nil, pool = nil); end
-  def initialize_type_map(m); end
-  def insert(*arg0); end
-  def lease; end
-  def log(sql, name = nil, binds = nil, statement_name = nil); end
-  def logger; end
-  def lookup_cast_type(sql_type); end
-  def new_column(name, default, cast_type, sql_type = nil, null = nil); end
-  def owner; end
-  def pool; end
-  def pool=(arg0); end
-  def prefetch_primary_key?(table_name = nil); end
-  def prepared_statements; end
-  def raw_connection; end
-  def reconnect!; end
-  def register_class_with_limit(mapping, key, klass); end
-  def release_savepoint(name = nil); end
-  def reload_type_map; end
-  def requires_reloading?; end
-  def reset!; end
-  def rollback_db_transaction(*arg0); end
-  def rollback_to_savepoint(*arg0); end
-  def schema_cache; end
-  def schema_cache=(cache); end
-  def schema_creation; end
-  def self._checkin_callbacks; end
-  def self._checkin_callbacks=(val); end
-  def self._checkin_callbacks?; end
-  def self._checkout_callbacks; end
-  def self._checkout_callbacks=(val); end
-  def self._checkout_callbacks?; end
-  def self.type_cast_config_to_boolean(config); end
-  def self.type_cast_config_to_integer(config); end
-  def substitute_at(column, _unused = nil); end
-  def supports_bulk_alter?; end
-  def supports_ddl_transactions?; end
-  def supports_explain?; end
-  def supports_extensions?; end
-  def supports_foreign_keys?; end
-  def supports_index_sort_order?; end
-  def supports_indexes_in_create?; end
-  def supports_migrations?; end
-  def supports_partial_index?; end
-  def supports_primary_key?; end
-  def supports_savepoints?; end
-  def supports_transaction_isolation?; end
-  def supports_views?; end
-  def translate_exception(exception, message); end
-  def translate_exception_class(e, sql); end
-  def type_map; end
-  def unprepared_statement; end
-  def update(*arg0); end
-  def valid_type?(type); end
-  def verify!(*ignored); end
-  def visitor; end
-  def visitor=(arg0); end
-  def without_prepared_statement?(binds); end
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  include ActiveRecord::ConnectionAdapters::ColumnDumper
-  include ActiveRecord::ConnectionAdapters::DatabaseLimits
-  include ActiveRecord::ConnectionAdapters::QueryCache
-  include ActiveRecord::ConnectionAdapters::Quoting
-  include ActiveSupport::Callbacks
-  include MonitorMixin
-end
-class ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
-  def accept(o); end
-  def action_sql(action, dependency); end
-  def add_column_options!(sql, options); end
-  def column_options(o); end
-  def initialize(conn); end
-  def options_include_default?(options); end
-  def quote_column_name(name); end
-  def quote_table_name(name); end
-  def quote_value(value, column); end
-  def type_for_column(column); end
-  def type_to_sql(type, limit, precision, scale); end
-  def visit_AddColumn(o); end
-  def visit_AddForeignKey(o); end
-  def visit_AlterTable(o); end
-  def visit_ColumnDefinition(o); end
-  def visit_DropForeignKey(name); end
-  def visit_TableDefinition(o); end
-end
-module ActiveRecord::ConnectionAdapters::Quoting
-  def _quote(value); end
-  def _type_cast(value); end
-  def quote(value, column = nil); end
-  def quote_column_name(column_name); end
-  def quote_string(s); end
-  def quote_table_name(table_name); end
-  def quote_table_name_for_assignment(table, attr); end
-  def quoted_date(value); end
-  def quoted_false; end
-  def quoted_true; end
-  def type_cast(value, column); end
-  def types_which_need_no_typecasting; end
-  def unquoted_false; end
-  def unquoted_true; end
-end
-module ActiveRecord::ConnectionAdapters::DatabaseStatements
-  def add_transaction_record(record); end
-  def begin_db_transaction; end
-  def begin_isolated_db_transaction(isolation); end
-  def begin_transaction(*args, &block); end
-  def binds_from_relation(relation, binds); end
-  def cacheable_query(arel); end
-  def commit_db_transaction; end
-  def commit_transaction(*args, &block); end
-  def current_transaction(*args, &block); end
-  def default_sequence_name(table, column); end
-  def delete(arel, name = nil, binds = nil); end
-  def delete_sql(sql, name = nil); end
-  def empty_insert_statement_value; end
-  def exec_delete(sql, name, binds); end
-  def exec_insert(sql, name, binds, pk = nil, sequence_name = nil); end
-  def exec_query(sql, name = nil, binds = nil); end
-  def exec_rollback_db_transaction; end
-  def exec_rollback_to_savepoint(name = nil); end
-  def exec_update(sql, name, binds); end
-  def initialize; end
-  def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = nil); end
-  def insert_fixture(fixture, table_name); end
-  def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil); end
-  def join_to_delete(delete, select, key); end
-  def join_to_update(update, select); end
-  def last_inserted_id(result); end
-  def open_transactions(*args, &block); end
-  def reset_sequence!(table, column, sequence = nil); end
-  def reset_transaction; end
-  def rollback_db_transaction; end
-  def rollback_to_savepoint(name = nil); end
-  def rollback_transaction(*args, &block); end
-  def sanitize_limit(limit); end
-  def select(sql, name = nil, binds = nil); end
-  def select_all(arel, name = nil, binds = nil); end
-  def select_one(arel, name = nil, binds = nil); end
-  def select_value(arel, name = nil, binds = nil); end
-  def select_values(arel, name = nil); end
-  def sql_for_insert(sql, pk, id_value, sequence_name, binds); end
-  def subquery_for(key, select); end
-  def supports_statement_cache?; end
-  def to_sql(arel, binds = nil); end
-  def transaction(options = nil); end
-  def transaction_isolation_levels; end
-  def transaction_manager; end
-  def transaction_open?; end
-  def transaction_state; end
-  def truncate(table_name, name = nil); end
-  def update(arel, name = nil, binds = nil); end
-  def update_sql(sql, name = nil); end
-  def within_new_transaction(*args, &block); end
-end
-class ActiveRecord::ActiveRecordError < StandardError
-end
-class ActiveRecord::SubclassNotFound < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::AssociationTypeMismatch < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::SerializationTypeMismatch < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::AdapterNotSpecified < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::AdapterNotFound < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::ConnectionNotEstablished < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::RecordNotFound < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::RecordNotSaved < ActiveRecord::ActiveRecordError
-  def initialize(message, record = nil); end
-  def record; end
-end
-class ActiveRecord::RecordNotDestroyed < ActiveRecord::ActiveRecordError
-  def initialize(message, record = nil); end
-  def record; end
-end
-class ActiveRecord::StatementInvalid < ActiveRecord::ActiveRecordError
-  def initialize(message, original_exception = nil); end
-  def original_exception; end
-end
-class ActiveRecord::WrappedDatabaseException < ActiveRecord::StatementInvalid
-end
-class ActiveRecord::RecordNotUnique < ActiveRecord::WrappedDatabaseException
-end
-class ActiveRecord::InvalidForeignKey < ActiveRecord::WrappedDatabaseException
-end
-class ActiveRecord::PreparedStatementInvalid < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::NoDatabaseError < ActiveRecord::StatementInvalid
-end
-class ActiveRecord::StaleObjectError < ActiveRecord::ActiveRecordError
-  def attempted_action; end
-  def initialize(record, attempted_action); end
-  def record; end
-end
-class ActiveRecord::ConfigurationError < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::ReadOnlyRecord < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::Rollback < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::DangerousAttributeError < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::UnknownAttributeError < NoMethodError
-  def attribute; end
-  def initialize(record, attribute); end
-  def record; end
-end
-class ActiveRecord::AttributeAssignmentError < ActiveRecord::ActiveRecordError
-  def attribute; end
-  def exception; end
-  def initialize(message, exception, attribute); end
-end
-class ActiveRecord::MultiparameterAssignmentErrors < ActiveRecord::ActiveRecordError
-  def errors; end
-  def initialize(errors); end
-end
-class ActiveRecord::UnknownPrimaryKey < ActiveRecord::ActiveRecordError
-  def initialize(model, description = nil); end
-  def model; end
-end
-class ActiveRecord::ImmutableRelation < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::TransactionIsolationError < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::MigrationError < ActiveRecord::ActiveRecordError
-  def initialize(message = nil); end
-end
-class ActiveRecord::IrreversibleMigration < ActiveRecord::MigrationError
-end
-class ActiveRecord::DuplicateMigrationVersionError < ActiveRecord::MigrationError
-  def initialize(version); end
-end
-class ActiveRecord::DuplicateMigrationNameError < ActiveRecord::MigrationError
-  def initialize(name); end
-end
-class ActiveRecord::UnknownMigrationVersionError < ActiveRecord::MigrationError
-  def initialize(version); end
-end
-class ActiveRecord::IllegalMigrationNameError < ActiveRecord::MigrationError
-  def initialize(name); end
-end
-class ActiveRecord::PendingMigrationError < ActiveRecord::MigrationError
-  def initialize; end
-end
-class ActiveRecord::Migration
-  def announce(message); end
-  def connection; end
-  def copy(destination, sources, options = nil); end
-  def disable_ddl_transaction; end
-  def down; end
-  def exec_migration(conn, direction); end
-  def execute_block; end
-  def initialize(name = nil, version = nil); end
-  def method_missing(method, *arguments, &block); end
-  def migrate(direction); end
-  def name; end
-  def name=(arg0); end
-  def next_migration_number(number); end
-  def proper_table_name(name, options = nil); end
-  def reversible; end
-  def revert(*migration_classes); end
-  def reverting?; end
-  def run(*migration_classes); end
-  def say(message, subitem = nil); end
-  def say_with_time(message); end
-  def self.check_pending!(connection = nil); end
-  def self.delegate; end
-  def self.delegate=(arg0); end
-  def self.disable_ddl_transaction!; end
-  def self.disable_ddl_transaction; end
-  def self.disable_ddl_transaction=(arg0); end
-  def self.load_schema_if_pending!; end
-  def self.maintain_test_schema!; end
-  def self.method_missing(name, *args, &block); end
-  def self.migrate(direction); end
-  def self.verbose; end
-  def self.verbose=(obj); end
-  def suppress_messages; end
-  def table_name_options(config = nil); end
-  def up; end
-  def verbose; end
-  def verbose=(obj); end
-  def version; end
-  def version=(arg0); end
-  def write(text = nil); end
-end
-class ActiveRecord::Migration::CheckPending
-  def call(env); end
-  def connection; end
-  def initialize(app); end
-end
-class Anonymous_Struct_12 < Struct
-  def reverting; end
-  def reverting=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-end
-class ActiveRecord::Migration::ReversibleBlockHelper < Anonymous_Struct_12
-  def down; end
-  def up; end
-end
-class Anonymous_Struct_13 < Struct
-  def filename; end
-  def filename=(_); end
-  def name; end
-  def name=(_); end
-  def scope; end
-  def scope=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def version; end
-  def version=(_); end
-end
-class ActiveRecord::MigrationProxy < Anonymous_Struct_13
-  def announce(*args, &block); end
-  def basename; end
-  def disable_ddl_transaction(*args, &block); end
-  def initialize(name, version, filename, scope); end
-  def load_migration; end
-  def migrate(*args, &block); end
-  def migration; end
-  def mtime; end
-  def write(*args, &block); end
-end
-class ActiveRecord::NullMigration < ActiveRecord::MigrationProxy
-  def initialize; end
-  def mtime; end
-end
-class ActiveRecord::Migrator
-  def current; end
-  def current_migration; end
-  def current_version; end
-  def ddl_transaction(migration); end
-  def down?; end
-  def execute_migration_in_transaction(migration, direction); end
-  def finish; end
-  def initialize(direction, migrations, target_version = nil); end
-  def migrate; end
-  def migrated; end
-  def migrations; end
-  def pending_migrations; end
-  def ran?(migration); end
-  def record_version_state_after_migrating(version); end
-  def run; end
-  def runnable; end
-  def self.any_migrations?; end
-  def self.current_version(connection = nil); end
-  def self.down(migrations_paths, target_version = nil, &block); end
-  def self.forward(migrations_paths, steps = nil); end
-  def self.get_all_versions(connection = nil); end
-  def self.last_migration; end
-  def self.last_version; end
-  def self.migrate(migrations_paths, target_version = nil, &block); end
-  def self.migration_files(paths); end
-  def self.migrations(paths); end
-  def self.migrations_path; end
-  def self.migrations_path=(arg0); end
-  def self.migrations_paths; end
-  def self.migrations_paths=(arg0); end
-  def self.migrations_status(paths); end
-  def self.move(direction, migrations_paths, steps); end
-  def self.needs_migration?(connection = nil); end
-  def self.open(migrations_paths); end
-  def self.parse_migration_filename(filename); end
-  def self.rollback(migrations_paths, steps = nil); end
-  def self.run(direction, migrations_paths, target_version); end
-  def self.schema_migrations_table_name; end
-  def self.up(migrations_paths, target_version = nil); end
-  def start; end
-  def target; end
-  def up?; end
-  def use_transaction?(migration); end
-  def validate(migrations); end
-end
-module ActiveRecord::Migration::JoinTable
-  def find_join_table_name(table_1, table_2, options = nil); end
-  def join_table_name(table_1, table_2); end
-end
-class Anonymous_Struct_14 < Struct
-  def columns; end
-  def columns=(_); end
-  def lengths; end
-  def lengths=(_); end
-  def name; end
-  def name=(_); end
-  def orders; end
-  def orders=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def table; end
-  def table=(_); end
-  def type; end
-  def type=(_); end
-  def unique; end
-  def unique=(_); end
-  def using; end
-  def using=(_); end
-  def where; end
-  def where=(_); end
-end
-class ActiveRecord::ConnectionAdapters::IndexDefinition < Anonymous_Struct_14
-end
-class Anonymous_Struct_15 < Struct
-  def after; end
-  def after=(_); end
-  def cast_type; end
-  def cast_type=(_); end
-  def default; end
-  def default=(_); end
-  def first; end
-  def first=(_); end
-  def limit; end
-  def limit=(_); end
-  def name; end
-  def name=(_); end
-  def null; end
-  def null=(_); end
-  def precision; end
-  def precision=(_); end
-  def primary_key; end
-  def primary_key=(_); end
-  def scale; end
-  def scale=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def sql_type; end
-  def sql_type=(_); end
-  def type; end
-  def type=(_); end
-end
-class ActiveRecord::ConnectionAdapters::ColumnDefinition < Anonymous_Struct_15
-  def primary_key?; end
-end
-class Anonymous_Struct_16 < Struct
-  def column; end
-  def column=(_); end
-  def options; end
-  def options=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def type; end
-  def type=(_); end
-end
-class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < Anonymous_Struct_16
-end
-class Anonymous_Struct_17 < Struct
-  def from_table; end
-  def from_table=(_); end
-  def options; end
-  def options=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def to_table; end
-  def to_table=(_); end
-end
-class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < Anonymous_Struct_17
-  def column; end
-  def custom_primary_key?; end
-  def default_primary_key; end
-  def name; end
-  def on_delete; end
-  def on_update; end
-  def primary_key; end
-end
-module ActiveRecord::ConnectionAdapters::TimestampDefaultDeprecation
-  def emit_warning_if_null_unspecified(sym, options); end
-end
-class ActiveRecord::ConnectionAdapters::TableDefinition
-  def [](name); end
-  def aliased_types(name, fallback); end
-  def as; end
-  def belongs_to(*args); end
-  def bigint(*args); end
-  def binary(*args); end
-  def boolean(*args); end
-  def column(name, type, options = nil); end
-  def columns; end
-  def create_column_definition(name, type); end
-  def date(*args); end
-  def datetime(*args); end
-  def decimal(*args); end
-  def float(*args); end
-  def foreign_key(table_name, options = nil); end
-  def foreign_keys; end
-  def index(column_name, options = nil); end
-  def indexes; end
-  def indexes=(arg0); end
-  def initialize(types, name, temporary, options, as = nil); end
-  def integer(*args); end
-  def name; end
-  def native; end
-  def new_column_definition(name, type, options); end
-  def options; end
-  def primary_key(name, type = nil, options = nil); end
-  def references(*args); end
-  def remove_column(name); end
-  def string(*args); end
-  def temporary; end
-  def text(*args); end
-  def time(*args); end
-  def timestamp(*args); end
-  def timestamps(*args); end
-  include ActiveRecord::ConnectionAdapters::TimestampDefaultDeprecation
-end
-class ActiveRecord::ConnectionAdapters::AlterTable
-  def add_column(name, type, options); end
-  def add_foreign_key(to_table, options); end
-  def adds; end
-  def drop_foreign_key(name); end
-  def foreign_key_adds; end
-  def foreign_key_drops; end
-  def initialize(td); end
-  def name; end
-end
-class ActiveRecord::ConnectionAdapters::Table
-  def belongs_to(*args); end
-  def binary(*args); end
-  def boolean(*args); end
-  def change(column_name, type, options = nil); end
-  def change_default(column_name, default); end
-  def column(column_name, type, options = nil); end
-  def column_exists?(column_name, type = nil, options = nil); end
-  def date(*args); end
-  def datetime(*args); end
-  def decimal(*args); end
-  def float(*args); end
-  def index(column_name, options = nil); end
-  def index_exists?(column_name, options = nil); end
-  def initialize(table_name, base); end
-  def integer(*args); end
-  def name; end
-  def native; end
-  def references(*args); end
-  def remove(*column_names); end
-  def remove_belongs_to(*args); end
-  def remove_index(options = nil); end
-  def remove_references(*args); end
-  def remove_timestamps(options = nil); end
-  def rename(column_name, new_column_name); end
-  def rename_index(index_name, new_index_name); end
-  def string(*args); end
-  def text(*args); end
-  def time(*args); end
-  def timestamp(*args); end
-  def timestamps(options = nil); end
-end
-module ActiveRecord::ConnectionAdapters::SchemaStatements
-  def add_belongs_to(table_name, ref_name, options = nil); end
-  def add_column(table_name, column_name, type, options = nil); end
-  def add_foreign_key(from_table, to_table, options = nil); end
-  def add_index(table_name, column_name, options = nil); end
-  def add_index_options(table_name, column_name, options = nil); end
-  def add_index_sort_order(option_strings, column_names, options = nil); end
-  def add_reference(table_name, ref_name, options = nil); end
-  def add_timestamps(table_name, options = nil); end
-  def assume_migrated_upto_version(version, migrations_paths = nil); end
-  def change_column(table_name, column_name, type, options = nil); end
-  def change_column_default(table_name, column_name, default); end
-  def change_column_null(table_name, column_name, null, default = nil); end
-  def change_table(table_name, options = nil); end
-  def column_exists?(table_name, column_name, type = nil, options = nil); end
-  def columns(table_name); end
-  def columns_for_distinct(columns, orders); end
-  def create_alter_table(name); end
-  def create_join_table(table_1, table_2, options = nil); end
-  def create_table(table_name, options = nil); end
-  def create_table_definition(name, temporary, options, as = nil); end
-  def data_source_exists?(name); end
-  def data_sources; end
-  def drop_join_table(table_1, table_2, options = nil); end
-  def drop_table(table_name, options = nil); end
-  def dump_schema_information; end
-  def foreign_key_column_for(table_name); end
-  def foreign_key_name(table_name, options); end
-  def foreign_keys(table_name); end
-  def index_exists?(table_name, column_name, options = nil); end
-  def index_name(table_name, options); end
-  def index_name_exists?(table_name, index_name, default); end
-  def index_name_for_remove(table_name, options = nil); end
-  def initialize_schema_migrations_table; end
-  def native_database_types; end
-  def options_include_default?(options); end
-  def quoted_columns_for_index(column_names, options = nil); end
-  def remove_belongs_to(table_name, ref_name, options = nil); end
-  def remove_column(table_name, column_name, type = nil, options = nil); end
-  def remove_columns(table_name, *column_names); end
-  def remove_foreign_key(from_table, options_or_to_table = nil); end
-  def remove_index!(table_name, index_name); end
-  def remove_index(table_name, options = nil); end
-  def remove_reference(table_name, ref_name, options = nil); end
-  def remove_timestamps(table_name, options = nil); end
-  def rename_column(table_name, column_name, new_column_name); end
-  def rename_column_indexes(table_name, column_name, new_column_name); end
-  def rename_index(table_name, old_name, new_name); end
-  def rename_table(table_name, new_name); end
-  def rename_table_indexes(table_name, new_name); end
-  def table_alias_for(table_name); end
-  def table_exists?(table_name); end
-  def type_to_sql(type, limit = nil, precision = nil, scale = nil); end
-  def update_table_definition(table_name, base); end
-  def validate_index_length!(table_name, new_name); end
-  include ActiveRecord::ConnectionAdapters::TimestampDefaultDeprecation
-  include ActiveRecord::Migration::JoinTable
-end
-module ActiveRecord::ConnectionAdapters::DatabaseLimits
-  def allowed_index_name_length; end
-  def column_name_length; end
-  def columns_per_multicolumn_index; end
-  def columns_per_table; end
-  def in_clause_length; end
-  def index_name_length; end
-  def indexes_per_table; end
-  def joins_per_query; end
-  def sql_query_length; end
-  def table_alias_length; end
-  def table_name_length; end
-end
-module ActiveRecord::ConnectionAdapters::QueryCache
-  def cache; end
-  def cache_sql(sql, binds); end
-  def clear_query_cache; end
-  def disable_query_cache!; end
-  def enable_query_cache!; end
-  def initialize(*arg0); end
-  def locked?(arel); end
-  def query_cache; end
-  def query_cache_enabled; end
-  def select_all(arel, name = nil, binds = nil); end
-  def self.dirties_query_cache(base, *method_names); end
-  def self.included(base); end
-  def uncached; end
-end
-class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
-  def <=>(version_string); end
-  def initialize(version_string); end
-  include Comparable
-end
-class ActiveRecord::ConnectionAdapters::AbstractAdapter::BindCollector < Arel::Collectors::Bind
-  def compile(bvs, conn); end
-end
-class ActiveRecord::ConnectionAdapters::AbstractAdapter::SQLString < Arel::Collectors::SQLString
-  def compile(bvs, conn); end
-end
-module ActiveRecord::Scoping
-  def initialize_internals_callback; end
-  def populate_with_current_scope_attributes; end
-  extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Scoping::ClassMethods
-  def current_scope; end
-  def current_scope=(scope); end
-end
-class ActiveRecord::Scoping::ScopeRegistry
-  def initialize; end
-  def raise_invalid_scope_type!(scope_type); end
-  def self.set_value_for(*args, &block); end
-  def self.value_for(*args, &block); end
-  def set_value_for(scope_type, variable_name, value); end
-  def value_for(scope_type, variable_name); end
-  extend ActiveSupport::PerThreadRegistry
-end
-module ActiveRecord::Coders
-end
-module ActiveRecord::Locking
-  extend ActiveSupport::Autoload
-end
-module ActiveRecord::Tasks
-  extend ActiveSupport::Autoload
-end
-class ActiveRecord::Railtie < Rails::Railtie
-end
-class ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
-  def self.reset_runtime; end
-  def self.runtime; end
-  def self.runtime=(value); end
-end
-module ActiveRecord::Railties
-end
-module ActiveRecord::Railties::ControllerRuntime
-  def append_info_to_payload(payload); end
-  def cleanup_view_runtime; end
-  def db_runtime; end
-  def db_runtime=(arg0); end
-  def process_action(action, *args); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Railties::ControllerRuntime::ClassMethods
-  def log_process_action(payload); end
-end
-class ActiveRecord::QueryCache
-  def call(env); end
-  def initialize(app); end
-  def restore_query_cache_settings(connection_id, enabled); end
-end
-module ActiveRecord::QueryCache::ClassMethods
-  def cache(&block); end
-  def uncached(&block); end
-end
-class ActiveRecord::ConnectionTimeoutError < ActiveRecord::ConnectionNotEstablished
-end
-class ActiveRecord::ConnectionAdapters::ConnectionPool
-  def acquire_connection; end
-  def active_connection?; end
-  def automatic_reconnect; end
-  def automatic_reconnect=(arg0); end
-  def checkin(conn); end
-  def checkout; end
-  def checkout_and_verify(c); end
-  def checkout_new_connection; end
-  def checkout_timeout; end
-  def checkout_timeout=(arg0); end
-  def clear_reloadable_connections!; end
-  def connected?; end
-  def connection; end
-  def connections; end
-  def current_connection_id; end
-  def disconnect!; end
-  def initialize(spec); end
-  def new_connection; end
-  def reap; end
-  def reaper; end
-  def release(conn, owner); end
-  def release_connection(with_id = nil); end
-  def remove(conn); end
-  def size; end
-  def spec; end
-  def with_connection; end
-  include MonitorMixin
-end
-class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
-  def add(element); end
-  def any?; end
-  def any_waiting?; end
-  def can_remove_no_wait?; end
-  def clear; end
-  def delete(element); end
-  def initialize(lock = nil); end
-  def no_wait_poll; end
-  def num_waiting; end
-  def poll(timeout = nil); end
-  def remove; end
-  def synchronize(&block); end
-  def wait_poll(timeout); end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
-  def frequency; end
-  def initialize(pool, frequency); end
-  def pool; end
-  def run; end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionHandler
-  def active_connections?; end
-  def class_to_pool; end
-  def clear_active_connections!; end
-  def clear_all_connections!; end
-  def clear_reloadable_connections!; end
-  def connected?(klass); end
-  def connection_pool_list; end
-  def connection_pools; end
-  def establish_connection(owner, spec); end
-  def initialize; end
-  def owner_to_pool; end
-  def pool_for(owner); end
-  def pool_from_any_process_for(owner); end
-  def remove_connection(owner); end
-  def retrieve_connection(klass); end
-  def retrieve_connection_pool(klass); end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionManagement
-  def call(env); end
-  def initialize(app); end
-end
-module ActiveRecord::AttributeDecorators
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeDecorators::ClassMethods
-  def add_user_provided_columns(*arg0); end
-  def decorate_attribute_type(column_name, decorator_name, &block); end
-  def decorate_matching_attribute_types(matcher, decorator_name, &block); end
-end
-class ActiveRecord::AttributeDecorators::TypeDecorator
-  def apply(name, type); end
-  def clear(*args, &block); end
-  def decorators_for(name, type); end
-  def initialize(decorations = nil); end
-  def matching(name, type); end
-  def merge(*args); end
-end
-class ActiveRecord::ExplainRegistry
-  def collect; end
-  def collect=(arg0); end
-  def collect?; end
-  def initialize; end
-  def queries; end
-  def queries=(arg0); end
-  def reset; end
-  def self.collect?(*args, &block); end
-  extend ActiveSupport::PerThreadRegistry
-end
-class ActiveRecord::ExplainSubscriber
-  def finish(name, id, payload); end
-  def ignore_payload?(payload); end
-  def start(name, id, payload); end
-end
-module ActiveRecord::Delegation
-  def all?(*args, &block); end
-  def array_delegable?(method); end
-  def collect(*args, &block); end
-  def columns_hash(*args, &block); end
-  def connection(*args, &block); end
-  def each(*args, &block); end
-  def include?(*args, &block); end
-  def join(*args, &block); end
-  def length(*args, &block); end
-  def map(*args, &block); end
-  def method_missing(method, *args, &block); end
-  def primary_key(*args, &block); end
-  def quoted_primary_key(*args, &block); end
-  def quoted_table_name(*args, &block); end
-  def respond_to?(method, include_private = nil); end
-  def table_name(*args, &block); end
-  def to_ary(*args, &block); end
-  def to_xml(*args, &block); end
-  def to_yaml(*args, &block); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Delegation::DelegateCache
-  def inherited(child_class); end
-  def initialize_relation_delegate_cache; end
-  def relation_delegate_class(klass); end
-end
-module ActiveRecord::Delegation::ClassSpecificRelation
-  def method_missing(method, *args, &block); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
-  def delegate(method, opts = nil); end
-  def delegate_to_scoped_klass(method); end
-  def name; end
-end
-module ActiveRecord::Delegation::ClassMethods
-  def create(klass, *args); end
-  def relation_class_for(klass); end
-end
-module ActiveRecord::Attributes
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Attributes::ClassMethods
-  def add_user_provided_columns(schema_columns); end
-  def attribute(name, cast_type, options = nil); end
-  def clear_caches_calculated_from_columns; end
-  def columns; end
-  def columns_hash; end
-  def persistable_attribute_names; end
-  def raw_default_values; end
-  def reset_column_information; end
-end
-module ActiveRecord::ConnectionHandling
-  def clear_active_connections!(*args, &block); end
-  def clear_all_connections!(*args, &block); end
-  def clear_cache!; end
-  def clear_reloadable_connections!(*args, &block); end
-  def connected?; end
-  def connection; end
-  def connection_config; end
-  def connection_id; end
-  def connection_id=(connection_id); end
-  def connection_pool; end
-  def establish_connection(spec = nil); end
-  def remove_connection(klass = nil); end
-  def retrieve_connection; end
-  def sqlite3_connection(config); end
-end
-class ActiveRecord::ConnectionHandling::MergeAndResolveDefaultUrlConfig
-  def config; end
-  def initialize(raw_configurations); end
-  def resolve; end
-end
-module ActiveRecord::Querying
-  def any?(*args, &block); end
-  def average(*args, &block); end
-  def calculate(*args, &block); end
-  def count(*args, &block); end
-  def count_by_sql(sql); end
-  def create_with(*args, &block); end
-  def delete(*args, &block); end
-  def delete_all(*args, &block); end
-  def destroy(*args, &block); end
-  def destroy_all(*args, &block); end
-  def distinct(*args, &block); end
-  def eager_load(*args, &block); end
-  def except(*args, &block); end
-  def exists?(*args, &block); end
-  def fifth!(*args, &block); end
-  def fifth(*args, &block); end
-  def find(*args, &block); end
-  def find_by!(*args, &block); end
-  def find_by(*args, &block); end
-  def find_by_sql(sql, binds = nil); end
-  def find_each(*args, &block); end
-  def find_in_batches(*args, &block); end
-  def find_or_create_by!(*args, &block); end
-  def find_or_create_by(*args, &block); end
-  def find_or_initialize_by(*args, &block); end
-  def first!(*args, &block); end
-  def first(*args, &block); end
-  def first_or_create!(*args, &block); end
-  def first_or_create(*args, &block); end
-  def first_or_initialize(*args, &block); end
-  def forty_two!(*args, &block); end
-  def forty_two(*args, &block); end
-  def fourth!(*args, &block); end
-  def fourth(*args, &block); end
-  def from(*args, &block); end
-  def group(*args, &block); end
-  def having(*args, &block); end
-  def ids(*args, &block); end
-  def includes(*args, &block); end
-  def joins(*args, &block); end
-  def last!(*args, &block); end
-  def last(*args, &block); end
-  def limit(*args, &block); end
-  def lock(*args, &block); end
-  def many?(*args, &block); end
-  def maximum(*args, &block); end
-  def minimum(*args, &block); end
-  def none(*args, &block); end
-  def offset(*args, &block); end
-  def order(*args, &block); end
-  def pluck(*args, &block); end
-  def preload(*args, &block); end
-  def readonly(*args, &block); end
-  def references(*args, &block); end
-  def reorder(*args, &block); end
-  def rewhere(*args, &block); end
-  def second!(*args, &block); end
-  def second(*args, &block); end
-  def select(*args, &block); end
-  def sum(*args, &block); end
-  def take!(*args, &block); end
-  def take(*args, &block); end
-  def third!(*args, &block); end
-  def third(*args, &block); end
-  def uniq(*args, &block); end
-  def unscope(*args, &block); end
-  def update(*args, &block); end
-  def update_all(*args, &block); end
-  def where(*args, &block); end
-end
-module ActiveRecord::Translation
-  def i18n_scope; end
-  def lookup_ancestors; end
-  include ActiveModel::Translation
-end
-module ActiveRecord::DynamicMatchers
-  def method_missing(name, *arguments, &block); end
-  def respond_to?(name, include_private = nil); end
-end
-class ActiveRecord::DynamicMatchers::Method
-  def attribute_names; end
-  def body; end
-  def define; end
-  def initialize(model, name); end
-  def model; end
-  def name; end
-  def self.match(model, name); end
-  def self.matchers; end
-  def self.pattern; end
-  def self.prefix; end
-  def self.suffix; end
-  def valid?; end
-end
-module ActiveRecord::DynamicMatchers::Finder
-  def attributes_hash; end
-  def body; end
-  def finder; end
-  def result; end
-  def signature; end
-end
-class ActiveRecord::DynamicMatchers::FindBy < ActiveRecord::DynamicMatchers::Method
-  def finder; end
-  def self.prefix; end
-  include ActiveRecord::DynamicMatchers::Finder
-end
-class ActiveRecord::DynamicMatchers::FindByBang < ActiveRecord::DynamicMatchers::Method
-  def finder; end
-  def self.prefix; end
-  def self.suffix; end
-  include ActiveRecord::DynamicMatchers::Finder
-end
-module ActiveRecord::Explain
-  def collecting_queries_for_explain; end
-  def exec_explain(queries); end
-end
-module ActiveRecord::Enum
-  def _enum_methods_module; end
-  def detect_enum_conflict!(enum_name, method_name, klass_method = nil); end
-  def enum(definitions); end
-  def inherited(base); end
-  def self.extended(base); end
-end
-module ActiveRecord::Core
-  def <=>(other_object); end
-  def ==(comparison_object); end
-  def connection_handler; end
-  def custom_inspect_method_defined?; end
-  def encode_with(coder); end
-  def eql?(comparison_object); end
-  def freeze; end
-  def frozen?; end
-  def has_transactional_callbacks?; end
-  def hash; end
-  def init_attributes(attributes, options); end
-  def init_internals; end
-  def init_with(coder); end
-  def initialize(attributes = nil, options = nil); end
-  def initialize_dup(other); end
-  def initialize_internals_callback; end
-  def inspect; end
-  def pretty_print(pp); end
-  def readonly!; end
-  def readonly?; end
-  def set_transaction_state(state); end
-  def slice(*methods); end
-  def sync_with_transaction_state; end
-  def thaw; end
-  def to_ary; end
-  def update_attributes_from_transaction_state(transaction_state, depth); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Core::ClassMethods
-  def ===(object); end
-  def allocate; end
-  def arel_engine; end
-  def arel_table; end
-  def find(*ids); end
-  def find_by!(*args); end
-  def find_by(*args); end
-  def generated_association_methods; end
-  def inherited(child_class); end
-  def initialize_find_by_cache; end
-  def initialize_generated_modules; end
-  def inspect; end
-  def relation; end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionSpecification
-  def adapter_method; end
-  def config; end
-  def initialize(config, adapter_method); end
-  def initialize_dup(original); end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver
-  def database_from_path; end
-  def initialize(url); end
-  def query_hash; end
-  def raw_config; end
-  def to_hash; end
-  def uri; end
-  def uri_parser; end
-end
-class ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
-  def configurations; end
-  def initialize(configurations); end
-  def resolve(config); end
-  def resolve_all; end
-  def resolve_connection(spec); end
-  def resolve_hash_connection(spec); end
-  def resolve_string_connection(spec); end
-  def resolve_symbol_connection(spec); end
-  def resolve_url_connection(url); end
-  def spec(config); end
-end
-module ActiveRecord::Persistence
-  def _create_record(attribute_names = nil); end
-  def _update_record(attribute_names = nil); end
-  def becomes!(klass); end
-  def becomes(klass); end
-  def create_or_update; end
-  def decrement!(attribute, by = nil); end
-  def decrement(attribute, by = nil); end
-  def delete; end
-  def destroy!; end
-  def destroy; end
-  def destroy_associations; end
-  def destroy_row; end
-  def destroyed?; end
-  def increment!(attribute, by = nil); end
-  def increment(attribute, by = nil); end
-  def new_record?; end
-  def persisted?; end
-  def relation_for_destroy; end
-  def reload(options = nil); end
-  def save!(*arg0); end
-  def save(*arg0); end
-  def toggle!(attribute); end
-  def toggle(attribute); end
-  def touch(*names); end
-  def update!(attributes); end
-  def update(attributes); end
-  def update_attribute(name, value); end
-  def update_attributes!(attributes); end
-  def update_attributes(attributes); end
-  def update_column(name, value); end
-  def update_columns(attributes); end
-  def verify_readonly_attribute(name); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Persistence::ClassMethods
-  def create!(attributes = nil, &block); end
-  def create(attributes = nil, &block); end
-  def discriminate_class_for_record(record); end
-  def instantiate(attributes, column_types = nil); end
-end
-module ActiveRecord::ReadonlyAttributes
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::ReadonlyAttributes::ClassMethods
-  def attr_readonly(*attributes); end
-  def readonly_attributes; end
-end
-module ActiveRecord::ModelSchema
-  def self.derive_join_table_name(first_table, second_table); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::ModelSchema::ClassMethods
-  def _default_attributes; end
-  def attributes_builder; end
-  def column_defaults; end
-  def column_names; end
-  def column_types; end
-  def compute_table_name; end
-  def content_columns; end
-  def full_table_name_prefix; end
-  def full_table_name_suffix; end
-  def inheritance_column; end
-  def inheritance_column=(value); end
-  def quoted_table_name; end
-  def raw_default_values; end
-  def reset_column_information; end
-  def reset_sequence_name; end
-  def reset_table_name; end
-  def sequence_name; end
-  def sequence_name=(value); end
-  def table_exists?; end
-  def table_name; end
-  def table_name=(value); end
-  def type_for_attribute(attr_name); end
-  def undecorated_table_name(class_name = nil); end
-end
-module ActiveRecord::Inheritance
-  def ensure_proper_type; end
-  def initialize_dup(other); end
-  def initialize_internals_callback; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Inheritance::ClassMethods
-  def abstract_class; end
-  def abstract_class=(arg0); end
-  def abstract_class?; end
-  def base_class; end
-  def compute_type(type_name); end
-  def descends_from_active_record?; end
-  def discriminate_class_for_record(record); end
-  def find_sti_class(type_name); end
-  def finder_needs_type_condition?; end
-  def new(*args, &block); end
-  def sti_name; end
-  def subclass_from_attributes(attrs); end
-  def subclass_from_attributes?(attrs); end
-  def symbolized_base_class; end
-  def symbolized_sti_name; end
-  def type_condition(table = nil); end
-  def using_single_table_inheritance?(record); end
-end
-module ActiveRecord::Scoping::Default
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Scoping::Default::ClassMethods
-  def before_remove_const; end
-  def build_default_scope(base_rel = nil); end
-  def default_scope(scope = nil); end
-  def evaluate_default_scope; end
-  def ignore_default_scope=(ignore); end
-  def ignore_default_scope?; end
-  def unscoped; end
-end
-module ActiveRecord::Scoping::Named
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Scoping::Named::ClassMethods
-  def all; end
-  def default_scoped; end
-  def scope(name, body, &block); end
-  def scope_attributes; end
-  def scope_attributes?; end
-end
-module ActiveRecord::Sanitization
-  def quoted_id; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Sanitization::ClassMethods
-  def expand_hash_conditions_for_aggregates(attrs); end
-  def quote_bound_value(value, c = nil, column = nil); end
-  def quote_value(value, column); end
-  def raise_if_bind_arity_mismatch(statement, expected, provided); end
-  def replace_bind_variable(value, c = nil); end
-  def replace_bind_variables(statement, values); end
-  def replace_named_bind_variables(statement, bind_vars); end
-  def sanitize(object); end
-  def sanitize_conditions(condition, table_name = nil); end
-  def sanitize_sql(condition, table_name = nil); end
-  def sanitize_sql_array(ary); end
-  def sanitize_sql_for_assignment(assignments, default_table_name = nil); end
-  def sanitize_sql_for_conditions(condition, table_name = nil); end
-  def sanitize_sql_hash(attrs, default_table_name = nil); end
-  def sanitize_sql_hash_for_assignment(attrs, table); end
-  def sanitize_sql_hash_for_conditions(attrs, default_table_name = nil); end
-  def sanitize_sql_like(string, escape_character = nil); end
-end
-module ActiveRecord::AttributeAssignment
-  def _assign_attribute(k, v); end
-  def assign_attributes(new_attributes); end
-  def assign_multiparameter_attributes(pairs); end
-  def assign_nested_parameter_attributes(pairs); end
-  def attributes=(new_attributes); end
-  def execute_callstack_for_multiparameter_attributes(callstack); end
-  def extract_callstack_for_multiparameter_attributes(pairs); end
-  def find_parameter_position(multiparameter_name); end
-  def type_cast_attribute_value(multiparameter_name, value); end
-  extend ActiveSupport::Concern
-  include ActiveModel::ForbiddenAttributesProtection
-end
-class ActiveRecord::AttributeAssignment::MultiparameterAttribute
-  def blank_date_parameter?; end
-  def cast_type; end
-  def extract_max_param(upper_cap = nil); end
-  def initialize(object, name, values); end
-  def instantiate_time_object(set_values); end
-  def name; end
-  def object; end
-  def read_date; end
-  def read_other; end
-  def read_time; end
-  def read_value; end
-  def validate_required_parameters!(positions); end
-  def values; end
-end
-module ActiveRecord::Integration
-  def cache_key(*timestamp_names); end
-  def to_param; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Integration::ClassMethods
-  def to_param(method_name = nil); end
-end
-module ActiveRecord::Validations
-  def perform_validations(options = nil); end
-  def raise_record_invalid; end
-  def save!(options = nil); end
-  def save(options = nil); end
-  def valid?(context = nil); end
-  def validate!(context = nil); end
-  def validate(context = nil); end
-  extend ActiveSupport::Concern
-  include ActiveModel::Validations
-end
-class ActiveRecord::Validations::AssociatedValidator < ActiveModel::EachValidator
-  def validate_each(record, attribute, value); end
-end
-module ActiveRecord::Validations::ClassMethods
-  def validates_associated(*attr_names); end
-  def validates_presence_of(*attr_names); end
-  def validates_uniqueness_of(*attr_names); end
-end
-class ActiveRecord::Validations::UniquenessValidator < ActiveModel::EachValidator
-  def build_relation(klass, table, attribute, value); end
-  def find_finder_class_for(record); end
-  def initialize(options); end
-  def map_enum_attribute(klass, attribute, value); end
-  def scope_relation(record, table, relation); end
-  def validate_each(record, attribute, value); end
-end
-class ActiveRecord::Validations::PresenceValidator < ActiveModel::Validations::PresenceValidator
-  def validate(record); end
-end
-class ActiveRecord::RecordInvalid < ActiveRecord::ActiveRecordError
-  def initialize(record); end
-  def record; end
-end
-module ActiveRecord::CounterCache
-  def _create_record(*arg0); end
-  def actually_destroyed?; end
-  def clear_destroy_state; end
-  def destroy_row; end
-  def each_counter_cached_associations; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::CounterCache::ClassMethods
-  def decrement_counter(counter_name, id); end
-  def increment_counter(counter_name, id); end
-  def reset_counters(id, *counters); end
-  def update_counters(id, counters); end
-end
-module ActiveRecord::Locking::Optimistic
-  def _create_record(attribute_names = nil, *arg1); end
-  def _update_record(attribute_names = nil); end
-  def destroy_row; end
-  def increment_lock; end
-  def locking_enabled?; end
-  def relation_for_destroy; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Locking::Optimistic::ClassMethods
-  def inherited(subclass); end
-  def locking_column; end
-  def locking_column=(value); end
-  def locking_enabled?; end
-  def reset_locking_column; end
-  def update_counters(id, counters); end
-end
-class ActiveRecord::Locking::LockingType < SimpleDelegator
-  def encode_with(coder); end
-  def init_with(coder); end
-  def type_cast_from_database(value); end
-end
-module ActiveRecord::Locking::Pessimistic
-  def lock!(lock = nil); end
-  def with_lock(lock = nil); end
-end
-module ActiveRecord::AttributeMethods::Read
-  def _read_attribute(attr_name); end
-  def attribute(attribute_name); end
-  def read_attribute(attr_name, &block); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::Read::ClassMethods
-  def cache_attribute?(*arg0); end
-  def cache_attributes(*arg0); end
-  def cached_attributes(*arg0); end
-  def cached_attributes_deprecation_warning(method_name); end
-  def define_method_attribute(name); end
-end
-module ActiveRecord::AttributeMethods::Write
-  def attribute=(attribute_name, value); end
-  def raw_write_attribute(attr_name, value); end
-  def write_attribute(attr_name, value); end
-  def write_attribute_with_type_cast(attr_name, value, should_type_cast); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::Write::ClassMethods
-  def define_method_attribute=(name); end
-end
-module ActiveRecord::AttributeMethods::BeforeTypeCast
-  def attribute_before_type_cast(attribute_name); end
-  def attribute_came_from_user?(attribute_name); end
-  def attributes_before_type_cast; end
-  def read_attribute_before_type_cast(attr_name); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::Query
-  def attribute?(attribute_name); end
-  def query_attribute(attr_name); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::PrimaryKey
-  def attribute_method?(attr_name); end
-  def id; end
-  def id=(value); end
-  def id?; end
-  def id_before_type_cast; end
-  def id_was; end
-  def to_key; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
-  def dangerous_attribute_method?(method_name); end
-  def define_method_attribute(attr_name); end
-  def get_primary_key(base_name); end
-  def primary_key; end
-  def primary_key=(value); end
-  def quoted_primary_key; end
-  def reset_primary_key; end
-end
-module ActiveRecord::AttributeMethods::TimeZoneConversion
-  extend ActiveSupport::Concern
-end
-class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter < Anonymous_Delegator_18
-  def convert_time_to_time_zone(value); end
-  def type_cast_from_database(value); end
-  def type_cast_from_user(value); end
-  include ActiveRecord::Type::Decorator
-end
-module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
-  def create_time_zone_conversion_attribute?(name, cast_type); end
-  def inherited(subclass); end
-end
-module ActiveRecord::AttributeMethods::Dirty
-  def _create_record(*arg0); end
-  def _field_changed?(attr, old_value); end
-  def _update_record(*arg0); end
-  def attribute_changed_in_place?(attr_name); end
-  def attributes_changed_in_place; end
-  def cache_changed_attributes; end
-  def calculate_changes_from_defaults; end
-  def changed_attributes; end
-  def changed_in_place; end
-  def changes; end
-  def changes_applied; end
-  def changes_include?(attr_name); end
-  def clear_changed_attributes_cache; end
-  def clear_changes_information; end
-  def initialize_dup(other); end
-  def keys_for_partial_write; end
-  def old_attribute_value(attr); end
-  def original_raw_attribute(attr_name); end
-  def original_raw_attributes; end
-  def raw_write_attribute(attr, value); end
-  def reload(*arg0); end
-  def save!(*arg0); end
-  def save(*arg0); end
-  def save_changed_attribute(attr, old_value); end
-  def store_original_raw_attribute(attr_name); end
-  def store_original_raw_attributes; end
-  def write_attribute(attr, value); end
-  extend ActiveSupport::Concern
-  include ActiveModel::Dirty
-end
-module ActiveRecord::Timestamp
-  def _create_record; end
-  def _update_record(*args); end
-  def all_timestamp_attributes; end
-  def all_timestamp_attributes_in_model; end
-  def clear_timestamp_attributes; end
-  def current_time_from_proper_timezone; end
-  def initialize_dup(other); end
-  def max_updated_column_timestamp(timestamp_names = nil); end
-  def should_record_timestamps?; end
-  def timestamp_attributes_for_create; end
-  def timestamp_attributes_for_create_in_model; end
-  def timestamp_attributes_for_update; end
-  def timestamp_attributes_for_update_in_model; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::Serialization
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AttributeMethods::Serialization::ClassMethods
-  def serialize(attr_name, class_name_or_coder = nil); end
-  def serialized_attributes; end
-end
-module ActiveRecord::Callbacks
-  def _create_record; end
-  def _update_record(*arg0); end
-  def create_or_update; end
-  def destroy; end
-  def touch(*arg0); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Callbacks::ClassMethods
-  include ActiveModel::Callbacks
-end
-class ActiveRecord::AssociationNotFoundError < ActiveRecord::ConfigurationError
-  def initialize(record, association_name); end
-end
-class ActiveRecord::InverseOfAssociationNotFoundError < ActiveRecord::ActiveRecordError
-  def initialize(reflection, associated_class = nil); end
-end
-class ActiveRecord::HasManyThroughAssociationNotFoundError < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection); end
-end
-class ActiveRecord::HasManyThroughAssociationPolymorphicSourceError < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection, source_reflection); end
-end
-class ActiveRecord::HasManyThroughAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection); end
-end
-class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection, source_reflection); end
-end
-class ActiveRecord::HasOneThroughCantAssociateThroughCollection < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection, through_reflection); end
-end
-class ActiveRecord::HasOneAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name, reflection); end
-end
-class ActiveRecord::HasManyThroughSourceAssociationNotFoundError < ActiveRecord::ActiveRecordError
-  def initialize(reflection); end
-end
-class ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ActiveRecordError
-  def initialize(owner, reflection); end
-end
-class ActiveRecord::HasManyThroughCantAssociateNewRecords < ActiveRecord::ActiveRecordError
-  def initialize(owner, reflection); end
-end
-class ActiveRecord::HasManyThroughCantDissociateNewRecords < ActiveRecord::ActiveRecordError
-  def initialize(owner, reflection); end
-end
-class ActiveRecord::HasManyThroughNestedAssociationsAreReadonly < ActiveRecord::ActiveRecordError
-  def initialize(owner, reflection); end
-end
-class ActiveRecord::EagerLoadPolymorphicError < ActiveRecord::ActiveRecordError
-  def initialize(reflection); end
-end
-class ActiveRecord::ReadOnlyAssociation < ActiveRecord::ActiveRecordError
-  def initialize(reflection); end
-end
-class ActiveRecord::DeleteRestrictionError < ActiveRecord::ActiveRecordError
-  def initialize(name); end
-end
-module ActiveRecord::Associations
-  def association(name); end
-  def association_cache; end
-  def association_instance_get(name); end
-  def association_instance_set(name, association); end
-  def clear_association_cache; end
-  extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Associations::Builder
-end
-module ActiveRecord::Associations::ClassMethods
-  def belongs_to(name, scope = nil, options = nil); end
-  def has_and_belongs_to_many(name, scope = nil, options = nil, &extension); end
-  def has_many(name, scope = nil, options = nil, &extension); end
-  def has_one(name, scope = nil, options = nil); end
-end
-module ActiveRecord::AutosaveAssociation
-  def associated_records_to_validate_or_save(association, new_record, autosave); end
-  def association_valid?(reflection, record); end
-  def before_save_collection_association; end
-  def changed_for_autosave?; end
-  def destroyed_by_association; end
-  def destroyed_by_association=(reflection); end
-  def mark_for_destruction; end
-  def marked_for_destruction?; end
-  def nested_records_changed_for_autosave?; end
-  def record_changed?(reflection, record, key); end
-  def reload(options = nil); end
-  def save_belongs_to_association(reflection); end
-  def save_collection_association(reflection); end
-  def save_has_one_association(reflection); end
-  def validate_collection_association(reflection); end
-  def validate_single_association(reflection); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::AutosaveAssociation::AssociationBuilderExtension
-  def self.build(model, reflection); end
-  def self.valid_options; end
-end
-module ActiveRecord::AutosaveAssociation::ClassMethods
-  def add_autosave_association_callbacks(reflection); end
-  def define_autosave_validation_callbacks(reflection); end
-  def define_non_cyclic_method(name, &block); end
-end
-class ActiveRecord::Associations::Builder::Association
-  def build(model); end
-  def define_extensions(model); end
-  def initialize(model, name, scope, options); end
-  def macro; end
-  def name; end
-  def options; end
-  def scope; end
-  def self.add_destroy_callbacks(model, reflection); end
-  def self.build(model, name, scope, options, &block); end
-  def self.check_dependent_options(dependent); end
-  def self.create_builder(model, name, scope, options, &block); end
-  def self.define_accessors(model, reflection); end
-  def self.define_callbacks(model, reflection); end
-  def self.define_readers(mixin, name); end
-  def self.define_validations(model, reflection); end
-  def self.define_writers(mixin, name); end
-  def self.extensions; end
-  def self.extensions=(arg0); end
-  def self.valid_dependent_options; end
-  def self.valid_options; end
-  def self.valid_options=(arg0); end
-  def valid_options; end
-  def validate_options; end
-end
-module ActiveRecord::NestedAttributes
-  def _destroy; end
-  def allow_destroy?(association_name); end
-  def assign_nested_attributes_for_collection_association(association_name, attributes_collection); end
-  def assign_nested_attributes_for_one_to_one_association(association_name, attributes); end
-  def assign_to_or_mark_for_destruction(record, attributes, allow_destroy); end
-  def call_reject_if(association_name, attributes); end
-  def check_record_limit!(limit, attributes_collection); end
-  def has_destroy_flag?(hash); end
-  def raise_nested_attributes_record_not_found!(association_name, record_id); end
-  def reject_new_record?(association_name, attributes); end
-  def will_be_destroyed?(association_name, attributes); end
-  extend ActiveSupport::Concern
-end
-class ActiveRecord::NestedAttributes::TooManyRecords < ActiveRecord::ActiveRecordError
-end
-module ActiveRecord::NestedAttributes::ClassMethods
-  def accepts_nested_attributes_for(*attr_names); end
-  def generate_association_writer(association_name, type); end
-end
-module ActiveRecord::Aggregations
-  def clear_aggregation_cache; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Aggregations::ClassMethods
-  def composed_of(part_id, options = nil); end
-  def reader_method(name, class_name, mapping, allow_nil, constructor); end
-  def writer_method(name, class_name, mapping, allow_nil, converter); end
-end
-module ActiveRecord::Transactions
-  def add_to_transaction; end
-  def clear_transaction_record_state; end
-  def committed!(should_run_callbacks = nil); end
-  def destroy; end
-  def force_clear_transaction_record_state; end
-  def remember_transaction_record_state; end
-  def restore_transaction_record_state(force = nil); end
-  def rollback_active_record_state!; end
-  def rolledback!(force_restore_state = nil, should_run_callbacks = nil); end
-  def save!(*arg0); end
-  def save(*arg0); end
-  def touch(*arg0); end
-  def transaction(options = nil, &block); end
-  def transaction_include_any_action?(actions); end
-  def transaction_record_state(state); end
-  def with_transaction_returning_status; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Transactions::ClassMethods
-  def after_commit(*args, &block); end
-  def after_rollback(*args, &block); end
-  def assert_valid_transaction_action(actions); end
-  def set_options_for_callbacks!(args); end
-  def transaction(options = nil, &block); end
-end
-module ActiveRecord::NoTouching
-  def no_touching?; end
-  def self.applied_to?(klass); end
-  def self.apply_to(klass); end
-  def self.klasses; end
-  def touch(*arg0); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::NoTouching::ClassMethods
-  def no_touching(&block); end
-end
-module ActiveRecord::Reflection
-  def self.add_aggregate_reflection(ar, name, reflection); end
-  def self.add_reflection(ar, name, reflection); end
-  def self.create(macro, name, scope, options, ar); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Reflection::ClassMethods
-  def _reflect_on_association(association); end
-  def clear_reflections_cache; end
-  def reflect_on_aggregation(aggregation); end
-  def reflect_on_all_aggregations; end
-  def reflect_on_all_associations(macro = nil); end
-  def reflect_on_all_autosave_associations; end
-  def reflect_on_association(association); end
-  def reflections; end
-end
-class ActiveRecord::Reflection::AbstractReflection
-  def build_association(attributes, &block); end
-  def check_validity_of_inverse!; end
-  def class_name; end
-  def inverse_of; end
-  def join_keys(assoc_klass); end
-  def primary_key_type; end
-  def quoted_table_name; end
-  def source_macro; end
-  def table_name; end
-end
-class ActiveRecord::Reflection::AbstractReflection::JoinKeys < Struct
-  def foreign_key; end
-  def foreign_key=(_); end
-  def key; end
-  def key=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-end
-class ActiveRecord::Reflection::MacroReflection < ActiveRecord::Reflection::AbstractReflection
-  def ==(other_aggregation); end
-  def active_record; end
-  def autosave=(autosave); end
-  def compute_class(name); end
-  def derive_class_name; end
-  def initialize(name, scope, options, active_record); end
-  def klass; end
-  def name; end
-  def options; end
-  def plural_name; end
-  def scope; end
-end
-class ActiveRecord::Reflection::AggregateReflection < ActiveRecord::Reflection::MacroReflection
-  def mapping; end
-end
-class ActiveRecord::Reflection::AssociationReflection < ActiveRecord::Reflection::MacroReflection
-  def active_record_primary_key; end
-  def actual_source_reflection; end
-  def association_class; end
-  def association_foreign_key; end
-  def association_primary_key(klass = nil); end
-  def association_scope_cache(conn, owner); end
-  def automatic_inverse_of; end
-  def belongs_to?; end
-  def calculate_constructable(macro, options); end
-  def can_find_inverse_of_automatically?(reflection); end
-  def chain; end
-  def check_eager_loadable!; end
-  def check_preloadable!; end
-  def check_validity!; end
-  def collection?; end
-  def compute_class(name); end
-  def constructable?; end
-  def counter_cache_column; end
-  def derive_class_name; end
-  def derive_foreign_key; end
-  def derive_join_table; end
-  def foreign_key; end
-  def foreign_type; end
-  def has_inverse?; end
-  def has_one?; end
-  def initialize(name, scope, options, active_record); end
-  def inverse_name; end
-  def join_id_for(owner); end
-  def join_table; end
-  def klass; end
-  def macro; end
-  def nested?; end
-  def parent_reflection; end
-  def parent_reflection=(arg0); end
-  def polymorphic?; end
-  def polymorphic_inverse_of(associated_class); end
-  def primary_key(klass); end
-  def scope_chain; end
-  def source_reflection; end
-  def through_reflection; end
-  def type; end
-  def valid_inverse_reflection?(reflection); end
-  def validate?; end
-end
-class ActiveRecord::Reflection::HasManyReflection < ActiveRecord::Reflection::AssociationReflection
-  def collection?; end
-  def initialize(name, scope, options, active_record); end
-  def macro; end
-end
-class ActiveRecord::Reflection::HasOneReflection < ActiveRecord::Reflection::AssociationReflection
-  def has_one?; end
-  def initialize(name, scope, options, active_record); end
-  def macro; end
-end
-class ActiveRecord::Reflection::BelongsToReflection < ActiveRecord::Reflection::AssociationReflection
-  def belongs_to?; end
-  def initialize(name, scope, options, active_record); end
-  def join_id_for(owner); end
-  def join_keys(assoc_klass); end
-  def macro; end
-end
-class ActiveRecord::Reflection::HasAndBelongsToManyReflection < ActiveRecord::Reflection::AssociationReflection
-  def collection?; end
-  def initialize(name, scope, options, active_record); end
-  def macro; end
-end
-class ActiveRecord::Reflection::ThroughReflection < ActiveRecord::Reflection::AbstractReflection
-  def active_record(*args, &block); end
-  def active_record_primary_key(*args, &block); end
-  def actual_source_reflection; end
-  def association_class(*args, &block); end
-  def association_foreign_key(*args, &block); end
-  def association_primary_key(klass = nil); end
-  def association_scope_cache(*args, &block); end
-  def autosave=(arg); end
-  def belongs_to?(*args, &block); end
-  def chain; end
-  def check_eager_loadable!(*args, &block); end
-  def check_preloadable!(*args, &block); end
-  def check_validity!; end
-  def collection?(*args, &block); end
-  def compute_class(*args, &block); end
-  def constructable?(*args, &block); end
-  def counter_cache_column(*args, &block); end
-  def delegate_reflection; end
-  def derive_class_name; end
-  def foreign_key(*args, &block); end
-  def foreign_type(*args, &block); end
-  def has_inverse?(*args, &block); end
-  def has_one?(*args, &block); end
-  def initialize(delegate_reflection); end
-  def inverse_name; end
-  def join_id_for(owner); end
-  def join_keys(assoc_klass); end
-  def join_table(*args, &block); end
-  def klass; end
-  def macro(*args, &block); end
-  def name(*args, &block); end
-  def nested?; end
-  def options(*args, &block); end
-  def parent_reflection(*args, &block); end
-  def parent_reflection=(arg); end
-  def plural_name(*args, &block); end
-  def polymorphic?(*args, &block); end
-  def polymorphic_inverse_of(*args, &block); end
-  def primary_key(klass); end
-  def scope(*args, &block); end
-  def scope_chain; end
-  def source_macro; end
-  def source_options; end
-  def source_reflection; end
-  def source_reflection_name; end
-  def source_reflection_names; end
-  def through_options; end
-  def through_reflection; end
-  def type(*args, &block); end
-  def validate?(*args, &block); end
-end
-module ActiveRecord::Serialization
-  def serializable_hash(options = nil); end
-  def to_xml(options = nil, &block); end
-  extend ActiveSupport::Concern
-  include ActiveModel::Serializers::JSON
-  include ActiveModel::Serializers::Xml
-end
-class ActiveRecord::XmlSerializer < ActiveModel::Serializers::Xml::Serializer
-end
-class ActiveRecord::XmlSerializer::Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute
-  def compute_type; end
-end
-module ActiveRecord::Store
-  def read_store_attribute(store_attribute, key); end
-  def store_accessor_for(store_attribute); end
-  def write_store_attribute(store_attribute, key, value); end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::Store::ClassMethods
-  def _store_accessors_module; end
-  def store(store_attribute, options = nil); end
-  def store_accessor(store_attribute, *keys); end
-  def stored_attributes; end
-end
-class ActiveRecord::Store::HashAccessor
-  def self.prepare(object, attribute); end
-  def self.read(object, attribute, key); end
-  def self.write(object, attribute, key, value); end
-end
-class ActiveRecord::Store::StringKeyedHashAccessor < ActiveRecord::Store::HashAccessor
-  def self.read(object, attribute, key); end
-  def self.write(object, attribute, key, value); end
-end
-class ActiveRecord::Store::IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
-  def self.prepare(object, store_attribute); end
-end
-class ActiveRecord::Store::IndifferentCoder
-  def dump(obj); end
-  def initialize(coder_or_class_name); end
-  def load(yaml); end
-  def self.as_indifferent_hash(obj); end
-end
-class ActiveRecord::ConnectionAdapters::StatementPool
-  def [](key); end
-  def []=(sql, key); end
-  def clear; end
-  def delete(key); end
-  def each; end
-  def initialize(connection, max = nil); end
-  def key?(key); end
-  def length; end
-  include Enumerable
-end
-module ActiveRecord::ConnectionAdapters::Savepoints
-  def create_savepoint(name = nil); end
-  def exec_rollback_to_savepoint(name = nil); end
-  def release_savepoint(name = nil); end
-  def supports_savepoints?; end
-end
-class ActiveRecord::ConnectionAdapters::SQLite3Binary < ActiveRecord::Type::Binary
-  def cast_value(value); end
-end
-class ActiveRecord::ConnectionAdapters::SQLite3Adapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
-  def _quote(value); end
-  def _type_cast(value); end
-  def active?; end
-  def add_column(table_name, column_name, type, options = nil); end
-  def allowed_index_name_length; end
-  def alter_table(table_name, options = nil); end
-  def begin_db_transaction; end
-  def change_column(table_name, column_name, type, options = nil); end
-  def change_column_default(table_name, column_name, default); end
-  def change_column_null(table_name, column_name, null, default = nil); end
-  def clear_cache!; end
-  def columns(table_name); end
-  def commit_db_transaction; end
-  def copy_table(from, to, options = nil); end
-  def copy_table_contents(from, to, columns, rename = nil); end
-  def copy_table_indexes(from, to, rename = nil); end
-  def create(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil); end
-  def data_source_exists?(table_name); end
-  def data_sources(name = nil, table_name = nil); end
-  def delete_sql(sql, name = nil); end
-  def disconnect!; end
-  def encoding; end
-  def exec_delete(sql, name = nil, binds = nil); end
-  def exec_query(sql, name = nil, binds = nil); end
-  def exec_rollback_db_transaction; end
-  def exec_update(sql, name = nil, binds = nil); end
-  def execute(sql, name = nil); end
-  def explain(arel, binds = nil); end
-  def indexes(table_name, name = nil); end
-  def initialize(connection, logger, connection_options, config); end
-  def initialize_type_map(m); end
-  def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil); end
-  def last_inserted_id(result); end
-  def move_table(from, to, options = nil, &block); end
-  def native_database_types; end
-  def primary_key(table_name); end
-  def quote_column_name(name); end
-  def quote_string(s); end
-  def quote_table_name_for_assignment(table, attr); end
-  def quoted_date(value); end
-  def remove_column(table_name, column_name, type = nil, options = nil); end
-  def remove_index!(table_name, index_name); end
-  def rename_column(table_name, column_name, new_column_name); end
-  def rename_table(table_name, new_name); end
-  def requires_reloading?; end
-  def select_rows(sql, name = nil, binds = nil); end
-  def sqlite_version; end
-  def supports_ddl_transactions?; end
-  def supports_explain?; end
-  def supports_index_sort_order?; end
-  def supports_migrations?; end
-  def supports_partial_index?; end
-  def supports_primary_key?; end
-  def supports_savepoints?; end
-  def supports_statement_cache?; end
-  def supports_views?; end
-  def table_exists?(table_name); end
-  def table_structure(table_name); end
-  def tables(name = nil, table_name = nil); end
-  def translate_exception(exception, message); end
-  def update_sql(sql, name = nil); end
-  def valid_alter_table_type?(type); end
-  include ActiveRecord::ConnectionAdapters::Savepoints
-end
-class ActiveRecord::ConnectionAdapters::SQLite3Adapter::StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
-  def [](key); end
-  def []=(sql, key); end
-  def cache; end
-  def clear; end
-  def dealloc(stmt); end
-  def each(&block); end
-  def initialize(connection, max); end
-  def key?(key); end
-  def length; end
-end
-class ActiveRecord::ConnectionAdapters::SQLite3Adapter::ExplainPrettyPrinter
-  def pp(result); end
-end
-class ActiveRecord::RuntimeRegistry
-  def connection_handler; end
-  def connection_handler=(arg0); end
-  def connection_id; end
-  def connection_id=(arg0); end
-  def self.connection_handler; end
-  def self.connection_handler=(x); end
-  def self.connection_id; end
-  def self.connection_id=(x); end
-  def self.sql_runtime; end
-  def self.sql_runtime=(x); end
-  def sql_runtime; end
-  def sql_runtime=(arg0); end
-  extend ActiveSupport::PerThreadRegistry
-end
-module ActiveRecord::FinderMethods
-  def apply_join_dependency(relation, join_dependency); end
-  def construct_join_dependency(joins = nil); end
-  def construct_relation_for_association_calculations; end
-  def exists?(conditions = nil); end
-  def fifth!; end
-  def fifth; end
-  def find(*args); end
-  def find_by!(*args); end
-  def find_by(*args); end
-  def find_last; end
-  def find_nth!(index); end
-  def find_nth(index, offset); end
-  def find_nth_with_limit(offset, limit); end
-  def find_one(id); end
-  def find_some(ids); end
-  def find_take; end
-  def find_with_associations; end
-  def find_with_ids(*ids); end
-  def first!; end
-  def first(limit = nil); end
-  def forty_two!; end
-  def forty_two; end
-  def fourth!; end
-  def fourth; end
-  def last!; end
-  def last(limit = nil); end
-  def limited_ids_for(relation); end
-  def offset_index; end
-  def raise_record_not_found_exception!(ids, result_size, expected_size); end
-  def second!; end
-  def second; end
-  def take!; end
-  def take(limit = nil); end
-  def third!; end
-  def third; end
-  def using_limitable_reflections?(reflections); end
-end
-module ActiveRecord::Calculations
-  def aggregate_column(column_name); end
-  def average(column_name, options = nil); end
-  def build_count_subquery(relation, column_name, distinct); end
-  def calculate(operation, column_name, options = nil); end
-  def column_alias_for(keys); end
-  def count(column_name = nil, options = nil); end
-  def execute_grouped_calculation(operation, column_name, distinct); end
-  def execute_simple_calculation(operation, column_name, distinct); end
-  def has_include?(column_name); end
-  def ids; end
-  def maximum(column_name, options = nil); end
-  def minimum(column_name, options = nil); end
-  def operation_over_aggregate_column(column, operation, distinct); end
-  def perform_calculation(operation, column_name, options = nil); end
-  def pluck(*column_names); end
-  def select_for_count; end
-  def sum(*args); end
-  def type_cast_calculated_value(value, type, operation = nil); end
-  def type_for(field); end
-end
-class ActiveRecord::Relation
-  def ==(other); end
-  def _update_record(values, id, id_was); end
-  def any?; end
-  def as_json(options = nil); end
-  def blank?; end
-  def build(*args, &block); end
-  def build_preloader; end
-  def create!(*args, &block); end
-  def create(*args, &block); end
-  def delete(id_or_array); end
-  def delete_all(conditions = nil); end
-  def destroy(id); end
-  def destroy_all(conditions = nil); end
-  def eager_loading?; end
-  def empty?; end
-  def encode_with(coder); end
-  def exec_queries; end
-  def explain; end
-  def find_or_create_by!(attributes, &block); end
-  def find_or_create_by(attributes, &block); end
-  def find_or_initialize_by(attributes, &block); end
-  def first_or_create!(attributes = nil, &block); end
-  def first_or_create(attributes = nil, &block); end
-  def first_or_initialize(attributes = nil, &block); end
-  def initialize(klass, table, values = nil); end
-  def initialize_copy(other); end
-  def insert(values); end
-  def inspect; end
-  def joined_includes_values; end
-  def klass; end
-  def load; end
-  def loaded; end
-  def loaded?; end
-  def many?; end
-  def model; end
-  def new(*args, &block); end
-  def pretty_print(q); end
-  def references_eager_loaded_tables?; end
-  def reload; end
-  def reset; end
-  def scope_for_create; end
-  def scoping; end
-  def size; end
-  def substitute_values(values); end
-  def table; end
-  def tables_in_string(string); end
-  def to_a; end
-  def to_sql; end
-  def uniq_value; end
-  def update(id, attributes); end
-  def update_all(updates); end
-  def values; end
-  def where_values_hash(relation_table_name = nil); end
-  extend ActiveRecord::Delegation::ClassMethods
-  include ActiveRecord::FinderMethods
-  include SorbetRails::CustomFinderMethods
-end
-class ActiveRecord::Relation::HashMerger
-  def hash; end
-  def initialize(relation, hash); end
-  def merge; end
-  def other; end
-  def relation; end
-end
-class ActiveRecord::Relation::Merger
-  def filter_binds(lhs_binds, removed_wheres); end
-  def initialize(relation, other); end
-  def merge; end
-  def merge_joins; end
-  def merge_multi_values; end
-  def merge_preloads; end
-  def merge_single_values; end
-  def normal_values; end
-  def other; end
-  def partition_overwrites(lhs_wheres, rhs_wheres); end
-  def relation; end
-  def values; end
-end
-module ActiveRecord::SpawnMethods
-  def except(*skips); end
-  def merge!(other); end
-  def merge(other); end
-  def only(*onlies); end
-  def relation_with(values); end
-  def spawn; end
-end
-module ActiveRecord::QueryMethods
-  def _select!(*fields); end
-  def add_relations_to_bind_values(attributes); end
-  def arel; end
-  def arel_columns(columns); end
-  def array_of_strings?(o); end
-  def association_for_table(table_name); end
-  def bind!(value); end
-  def bind(value); end
-  def bind_values; end
-  def bind_values=(values); end
-  def build_arel; end
-  def build_from; end
-  def build_joins(manager, joins); end
-  def build_order(arel); end
-  def build_select(arel); end
-  def build_where(opts, other = nil); end
-  def check_cached_relation; end
-  def check_if_method_has_arguments!(method_name, args); end
-  def collapse_wheres(arel, wheres); end
-  def create_binds(opts); end
-  def create_with!(value); end
-  def create_with(value); end
-  def create_with_value; end
-  def create_with_value=(value); end
-  def custom_join_ast(table, joins); end
-  def distinct!(value = nil); end
-  def distinct(value = nil); end
-  def distinct_value; end
-  def distinct_value=(value); end
-  def eager_load!(*args); end
-  def eager_load(*args); end
-  def eager_load_values; end
-  def eager_load_values=(values); end
-  def extending!(*modules, &block); end
-  def extending(*modules, &block); end
-  def extending_values; end
-  def extending_values=(values); end
-  def extensions; end
-  def from!(value, subquery_name = nil); end
-  def from(value, subquery_name = nil); end
-  def from_value; end
-  def from_value=(value); end
-  def group!(*args); end
-  def group(*args); end
-  def group_values; end
-  def group_values=(values); end
-  def having!(opts, *rest); end
-  def having(opts, *rest); end
-  def having_values; end
-  def having_values=(values); end
-  def includes!(*args); end
-  def includes(*args); end
-  def includes_values; end
-  def includes_values=(values); end
-  def joins!(*args); end
-  def joins(*args); end
-  def joins_values; end
-  def joins_values=(values); end
-  def limit!(value); end
-  def limit(value); end
-  def limit_value; end
-  def limit_value=(value); end
-  def lock!(locks = nil); end
-  def lock(locks = nil); end
-  def lock_value; end
-  def lock_value=(value); end
-  def none!; end
-  def none; end
-  def offset!(value); end
-  def offset(value); end
-  def offset_value; end
-  def offset_value=(value); end
-  def order!(*args); end
-  def order(*args); end
-  def order_values; end
-  def order_values=(values); end
-  def preload!(*args); end
-  def preload(*args); end
-  def preload_values; end
-  def preload_values=(values); end
-  def preprocess_order_args(order_args); end
-  def readonly!(value = nil); end
-  def readonly(value = nil); end
-  def readonly_value; end
-  def readonly_value=(value); end
-  def references!(*table_names); end
-  def references(*table_names); end
-  def references_values; end
-  def references_values=(values); end
-  def reorder!(*args); end
-  def reorder(*args); end
-  def reordering_value; end
-  def reordering_value=(value); end
-  def reverse_order!; end
-  def reverse_order; end
-  def reverse_order_value; end
-  def reverse_order_value=(value); end
-  def reverse_sql_order(order_query); end
-  def rewhere(conditions); end
-  def select(*fields); end
-  def select_values; end
-  def select_values=(values); end
-  def symbol_unscoping(scope); end
-  def uniq!(value = nil); end
-  def uniq(value = nil); end
-  def uniq_value; end
-  def uniq_value=(value); end
-  def unscope!(*args); end
-  def unscope(*args); end
-  def unscope_values; end
-  def unscope_values=(values); end
-  def validate_order_args(args); end
-  def where!(opts, *rest); end
-  def where(opts = nil, *rest); end
-  def where_unscoping(target_value); end
-  def where_values; end
-  def where_values=(values); end
-  extend ActiveSupport::Concern
-  include ActiveModel::ForbiddenAttributesProtection
-end
-class ActiveRecord::QueryMethods::WhereChain
-  def initialize(scope); end
-  def not(opts, *rest); end
-end
-module ActiveRecord::Batches
-  def batch_order; end
-  def find_each(options = nil); end
-  def find_in_batches(options = nil); end
-end
-class ActiveRecord::Base
-  def _commit_callbacks; end
-  def _commit_callbacks?; end
-  def _create_callbacks; end
-  def _create_callbacks?; end
-  def _destroy_callbacks; end
-  def _destroy_callbacks?; end
-  def _find_callbacks; end
-  def _find_callbacks?; end
-  def _initialize_callbacks; end
-  def _initialize_callbacks?; end
-  def _reflections; end
-  def _reflections?; end
-  def _rollback_callbacks; end
-  def _rollback_callbacks?; end
-  def _run_commit_callbacks(&block); end
-  def _run_create_callbacks(&block); end
-  def _run_destroy_callbacks(&block); end
-  def _run_find_callbacks(&block); end
-  def _run_initialize_callbacks(&block); end
-  def _run_rollback_callbacks(&block); end
-  def _run_save_callbacks(&block); end
-  def _run_touch_callbacks(&block); end
-  def _run_update_callbacks(&block); end
-  def _run_validate_callbacks(&block); end
-  def _run_validation_callbacks(&block); end
-  def _save_callbacks; end
-  def _save_callbacks?; end
-  def _touch_callbacks; end
-  def _touch_callbacks?; end
-  def _update_callbacks; end
-  def _update_callbacks?; end
-  def _validate_callbacks; end
-  def _validate_callbacks?; end
-  def _validation_callbacks; end
-  def _validation_callbacks?; end
-  def _validators; end
-  def _validators?; end
-  def aggregate_reflections; end
-  def aggregate_reflections?; end
-  def attribute_aliases; end
-  def attribute_aliases?; end
-  def attribute_method_matchers; end
-  def attribute_method_matchers?; end
-  def cache_timestamp_format; end
-  def cache_timestamp_format?; end
-  def column_for_attribute(*args, &block); end
-  def default_connection_handler; end
-  def default_connection_handler?; end
-  def default_scopes; end
-  def default_timezone; end
-  def defined_enums; end
-  def defined_enums?; end
-  def dump_schema_after_migration; end
-  def find_by_statement_cache; end
-  def find_by_statement_cache=(arg0); end
-  def find_by_statement_cache?; end
-  def include_root_in_json; end
-  def include_root_in_json?; end
-  def lock_optimistically; end
-  def lock_optimistically?; end
-  def logger; end
-  def model_name(*args, &block); end
-  def nested_attributes_options; end
-  def nested_attributes_options?; end
-  def partial_writes; end
-  def partial_writes?; end
-  def persistable_attribute_names(*args, &block); end
-  def pluralize_table_names; end
-  def pluralize_table_names?; end
-  def primary_key_prefix_type; end
-  def raise_in_transactional_callbacks; end
-  def record_timestamps; end
-  def record_timestamps=(arg0); end
-  def record_timestamps?; end
-  def schema_format; end
-  def self._attr_readonly; end
-  def self._attr_readonly=(val); end
-  def self._attr_readonly?; end
-  def self._commit_callbacks; end
-  def self._commit_callbacks=(val); end
-  def self._commit_callbacks?; end
-  def self._create_callbacks; end
-  def self._create_callbacks=(val); end
-  def self._create_callbacks?; end
-  def self._destroy_callbacks; end
-  def self._destroy_callbacks=(val); end
-  def self._destroy_callbacks?; end
-  def self._find_callbacks; end
-  def self._find_callbacks=(val); end
-  def self._find_callbacks?; end
-  def self._initialize_callbacks; end
-  def self._initialize_callbacks=(val); end
-  def self._initialize_callbacks?; end
-  def self._reflections; end
-  def self._reflections=(val); end
-  def self._reflections?; end
-  def self._rollback_callbacks; end
-  def self._rollback_callbacks=(val); end
-  def self._rollback_callbacks?; end
-  def self._save_callbacks; end
-  def self._save_callbacks=(val); end
-  def self._save_callbacks?; end
-  def self._touch_callbacks; end
-  def self._touch_callbacks=(val); end
-  def self._touch_callbacks?; end
-  def self._update_callbacks; end
-  def self._update_callbacks=(val); end
-  def self._update_callbacks?; end
-  def self._validate_callbacks; end
-  def self._validate_callbacks=(val); end
-  def self._validate_callbacks?; end
-  def self._validation_callbacks; end
-  def self._validation_callbacks=(val); end
-  def self._validation_callbacks?; end
-  def self._validators; end
-  def self._validators=(val); end
-  def self._validators?; end
-  def self.after_create(*args, &block); end
-  def self.after_destroy(*args, &block); end
-  def self.after_find(*args, &block); end
-  def self.after_initialize(*args, &block); end
-  def self.after_save(*args, &block); end
-  def self.after_touch(*args, &block); end
-  def self.after_update(*args, &block); end
-  def self.aggregate_reflections; end
-  def self.aggregate_reflections=(val); end
-  def self.aggregate_reflections?; end
-  def self.around_create(*args, &block); end
-  def self.around_destroy(*args, &block); end
-  def self.around_save(*args, &block); end
-  def self.around_update(*args, &block); end
-  def self.attribute_aliases; end
-  def self.attribute_aliases=(val); end
-  def self.attribute_aliases?; end
-  def self.attribute_method_matchers; end
-  def self.attribute_method_matchers=(val); end
-  def self.attribute_method_matchers?; end
-  def self.attribute_type_decorations; end
-  def self.attribute_type_decorations=(val); end
-  def self.attribute_type_decorations?; end
-  def self.before_create(*args, &block); end
-  def self.before_destroy(*args, &block); end
-  def self.before_save(*args, &block); end
-  def self.before_update(*args, &block); end
-  def self.cache_timestamp_format; end
-  def self.cache_timestamp_format=(val); end
-  def self.cache_timestamp_format?; end
-  def self.configurations; end
-  def self.configurations=(config); end
-  def self.connection_handler; end
-  def self.connection_handler=(handler); end
-  def self.default_connection_handler; end
-  def self.default_connection_handler=(val); end
-  def self.default_connection_handler?; end
-  def self.default_scopes; end
-  def self.default_scopes=(val); end
-  def self.default_timezone; end
-  def self.default_timezone=(obj); end
-  def self.defined_enums; end
-  def self.defined_enums=(val); end
-  def self.defined_enums?; end
-  def self.disable_implicit_join_references=(value); end
-  def self.dump_schema_after_migration; end
-  def self.dump_schema_after_migration=(obj); end
-  def self.find_by_statement_cache; end
-  def self.find_by_statement_cache=(val); end
-  def self.find_by_statement_cache?; end
-  def self.include_root_in_json; end
-  def self.include_root_in_json=(val); end
-  def self.include_root_in_json?; end
-  def self.local_stored_attributes; end
-  def self.local_stored_attributes=(arg0); end
-  def self.lock_optimistically; end
-  def self.lock_optimistically=(val); end
-  def self.lock_optimistically?; end
-  def self.logger; end
-  def self.logger=(obj); end
-  def self.maintain_test_schema; end
-  def self.maintain_test_schema=(obj); end
-  def self.nested_attributes_options; end
-  def self.nested_attributes_options=(val); end
-  def self.nested_attributes_options?; end
-  def self.partial_writes; end
-  def self.partial_writes=(val); end
-  def self.partial_writes?; end
-  def self.pluralize_table_names; end
-  def self.pluralize_table_names=(val); end
-  def self.pluralize_table_names?; end
-  def self.primary_key_prefix_type; end
-  def self.primary_key_prefix_type=(obj); end
-  def self.raise_in_transactional_callbacks; end
-  def self.raise_in_transactional_callbacks=(obj); end
-  def self.record_timestamps; end
-  def self.record_timestamps=(val); end
-  def self.record_timestamps?; end
-  def self.schema_format; end
-  def self.schema_format=(obj); end
-  def self.schema_migrations_table_name; end
-  def self.schema_migrations_table_name=(val); end
-  def self.schema_migrations_table_name?; end
-  def self.skip_time_zone_conversion_for_attributes; end
-  def self.skip_time_zone_conversion_for_attributes=(val); end
-  def self.skip_time_zone_conversion_for_attributes?; end
-  def self.store_full_sti_class; end
-  def self.store_full_sti_class=(val); end
-  def self.store_full_sti_class?; end
-  def self.table_name_prefix; end
-  def self.table_name_prefix=(val); end
-  def self.table_name_prefix?; end
-  def self.table_name_suffix; end
-  def self.table_name_suffix=(val); end
-  def self.table_name_suffix?; end
-  def self.time_zone_aware_attributes; end
-  def self.time_zone_aware_attributes=(obj); end
-  def self.timestamped_migrations; end
-  def self.timestamped_migrations=(obj); end
-  def self.user_provided_columns; end
-  def self.user_provided_columns=(val); end
-  def self.user_provided_columns?; end
-  def self.user_provided_defaults; end
-  def self.user_provided_defaults=(val); end
-  def self.user_provided_defaults?; end
-  def skip_time_zone_conversion_for_attributes; end
-  def skip_time_zone_conversion_for_attributes?; end
-  def store_full_sti_class; end
-  def store_full_sti_class?; end
-  def table_name_prefix; end
-  def table_name_prefix?; end
-  def table_name_suffix; end
-  def table_name_suffix?; end
-  def time_zone_aware_attributes; end
-  def timestamped_migrations; end
-  def type_for_attribute(*args, &block); end
-  def validation_context; end
-  def validation_context=(arg0); end
-  extend ActiveModel::AttributeMethods::ClassMethods
-  extend ActiveModel::Callbacks
-  extend ActiveModel::Conversion::ClassMethods
-  extend ActiveModel::Naming
-  extend ActiveModel::Naming
-  extend ActiveModel::Naming
-  extend ActiveModel::Naming
-  extend ActiveModel::SecurePassword::ClassMethods
-  extend ActiveModel::Translation
-  extend ActiveModel::Validations::Callbacks::ClassMethods
-  extend ActiveModel::Validations::ClassMethods
-  extend ActiveModel::Validations::HelperMethods
-  extend ActiveRecord::Aggregations::ClassMethods
-  extend ActiveRecord::Associations::ClassMethods
-  extend ActiveRecord::AttributeDecorators::ClassMethods
-  extend ActiveRecord::AttributeMethods::ClassMethods
-  extend ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
-  extend ActiveRecord::AttributeMethods::Read::ClassMethods
-  extend ActiveRecord::AttributeMethods::Serialization::ClassMethods
-  extend ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
-  extend ActiveRecord::AttributeMethods::Write::ClassMethods
-  extend ActiveRecord::Attributes::ClassMethods
-  extend ActiveRecord::AutosaveAssociation::ClassMethods
-  extend ActiveRecord::Callbacks::ClassMethods
-  extend ActiveRecord::ConnectionHandling
-  extend ActiveRecord::Core::ClassMethods
-  extend ActiveRecord::CounterCache::ClassMethods
-  extend ActiveRecord::Delegation::DelegateCache
-  extend ActiveRecord::DynamicMatchers
-  extend ActiveRecord::Enum
-  extend ActiveRecord::Explain
-  extend ActiveRecord::Inheritance::ClassMethods
-  extend ActiveRecord::Integration::ClassMethods
-  extend ActiveRecord::Locking::Optimistic::ClassMethods
-  extend ActiveRecord::ModelSchema::ClassMethods
-  extend ActiveRecord::NestedAttributes::ClassMethods
-  extend ActiveRecord::NoTouching::ClassMethods
-  extend ActiveRecord::Persistence::ClassMethods
-  extend ActiveRecord::QueryCache::ClassMethods
-  extend ActiveRecord::Querying
-  extend ActiveRecord::ReadonlyAttributes::ClassMethods
-  extend ActiveRecord::Reflection::ClassMethods
-  extend ActiveRecord::Sanitization::ClassMethods
-  extend ActiveRecord::Scoping::ClassMethods
-  extend ActiveRecord::Scoping::Default::ClassMethods
-  extend ActiveRecord::Scoping::Named::ClassMethods
-  extend ActiveRecord::Store::ClassMethods
-  extend ActiveRecord::Transactions::ClassMethods
-  extend ActiveRecord::Translation
-  extend ActiveRecord::Validations::ClassMethods
-  extend ActiveSupport::Benchmarkable
-  extend ActiveSupport::Callbacks::ClassMethods
-  extend ActiveSupport::DescendantsTracker
-  extend ActiveSupport::DescendantsTracker
-  extend SorbetRails::CustomFinderMethods
-  include ActiveModel::AttributeMethods
-  include ActiveModel::AttributeMethods
-  include ActiveModel::Conversion
-  include ActiveModel::Dirty
-  include ActiveModel::SecurePassword
-  include ActiveModel::Serializers::JSON
-  include ActiveModel::Serializers::Xml
-  include ActiveModel::Validations
-  include ActiveModel::Validations::Callbacks
-  include ActiveModel::Validations::HelperMethods
-  include ActiveRecord::Aggregations
-  include ActiveRecord::Associations
-  include ActiveRecord::AttributeAssignment
-  include ActiveRecord::AttributeDecorators
-  include ActiveRecord::AttributeMethods
-  include ActiveRecord::AttributeMethods::BeforeTypeCast
-  include ActiveRecord::AttributeMethods::Dirty
-  include ActiveRecord::AttributeMethods::PrimaryKey
-  include ActiveRecord::AttributeMethods::Query
-  include ActiveRecord::AttributeMethods::Read
-  include ActiveRecord::AttributeMethods::Serialization
-  include ActiveRecord::AttributeMethods::TimeZoneConversion
-  include ActiveRecord::AttributeMethods::Write
-  include ActiveRecord::Attributes
-  include ActiveRecord::AutosaveAssociation
-  include ActiveRecord::Base::GeneratedAssociationMethods
-  include ActiveRecord::Callbacks
-  include ActiveRecord::Core
-  include ActiveRecord::CounterCache
-  include ActiveRecord::Inheritance
-  include ActiveRecord::Integration
-  include ActiveRecord::Locking::Optimistic
-  include ActiveRecord::Locking::Pessimistic
-  include ActiveRecord::ModelSchema
-  include ActiveRecord::NestedAttributes
-  include ActiveRecord::NoTouching
-  include ActiveRecord::Persistence
-  include ActiveRecord::ReadonlyAttributes
-  include ActiveRecord::Reflection
-  include ActiveRecord::Sanitization
-  include ActiveRecord::Scoping
-  include ActiveRecord::Scoping::Default
-  include ActiveRecord::Scoping::Named
-  include ActiveRecord::Serialization
-  include ActiveRecord::Store
-  include ActiveRecord::Timestamp
-  include ActiveRecord::Transactions
-  include ActiveRecord::Validations
-  include ActiveSupport::Callbacks
-  include ActiveSupport::Callbacks
-  include Anonymous_ActiveRecord_AttributeMethods_GeneratedAttributeMethods_19
-  include GlobalID::Identification
-end
-module Anonymous_ActiveRecord_AttributeMethods_GeneratedAttributeMethods_19
-  def self.lock; end
-  def self.locked?; end
-  def self.synchronize(&block); end
-  def self.try_lock; end
-  def self.unlock; end
-  extend Mutex_m
-end
-module ActiveRecord::Base::GeneratedAssociationMethods
-end
-class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
-  def <<(*records); end
-  def ==(other); end
-  def any?(&block); end
-  def append(*records); end
-  def arel; end
-  def average(*args, &block); end
-  def build(attributes = nil, &block); end
-  def calculate(*args, &block); end
-  def clear; end
-  def concat(*records); end
-  def count(column_name = nil, options = nil); end
-  def create!(attributes = nil, &block); end
-  def create(attributes = nil, &block); end
-  def delete(*records); end
-  def delete_all(dependent = nil); end
-  def destroy(*records); end
-  def destroy_all; end
-  def distinct; end
-  def empty?; end
-  def fifth(*args); end
-  def find(*args, &block); end
-  def find_nth(*args, &block); end
-  def first(*args); end
-  def forty_two(*args); end
-  def fourth(*args); end
-  def ids(*args, &block); end
-  def include?(record); end
-  def initialize(klass, association); end
-  def last(*args); end
-  def length; end
-  def load_target; end
-  def loaded?; end
-  def many?(&block); end
-  def maximum(*args, &block); end
-  def minimum(*args, &block); end
-  def new(attributes = nil, &block); end
-  def pluck(*args, &block); end
-  def prepend(*args); end
-  def proxy_association; end
-  def push(*records); end
-  def reload; end
-  def replace(other_array); end
-  def reset; end
-  def scope; end
-  def scoping; end
-  def second(*args); end
-  def select(*fields, &block); end
-  def size; end
-  def spawn; end
-  def sum(*args, &block); end
-  def take(n = nil); end
-  def target; end
-  def third(*args); end
-  def to_a; end
-  def to_ary; end
-  def uniq; end
-end
-class ActiveRecord::AssociationRelation < ActiveRecord::Relation
-  def ==(other); end
-  def build(*args, &block); end
-  def create!(*args, &block); end
-  def create(*args, &block); end
-  def exec_queries; end
-  def initialize(klass, table, association); end
-  def new(*args, &block); end
-  def proxy_association; end
-end
-class ActiveRecord::Associations::Builder::SingularAssociation < ActiveRecord::Associations::Builder::Association
-  def self.define_accessors(model, reflection); end
-  def self.define_constructors(mixin, name); end
-  def self.define_validations(model, reflection); end
-  def valid_options; end
-end
-class ActiveRecord::Associations::Builder::BelongsTo < ActiveRecord::Associations::Builder::SingularAssociation
-  def macro; end
-  def self.add_counter_cache_callbacks(model, reflection); end
-  def self.add_counter_cache_methods(mixin); end
-  def self.add_destroy_callbacks(model, reflection); end
-  def self.add_touch_callbacks(model, reflection); end
-  def self.define_accessors(mixin, reflection); end
-  def self.define_callbacks(model, reflection); end
-  def self.touch_record(o, foreign_key, name, touch); end
-  def self.valid_dependent_options; end
-  def valid_options; end
-end
-class ActiveRecord::Associations::Builder::HasOne < ActiveRecord::Associations::Builder::SingularAssociation
-  def macro; end
-  def self.add_destroy_callbacks(model, reflection); end
-  def self.valid_dependent_options; end
-  def valid_options; end
-end
-class ActiveRecord::Associations::Builder::CollectionAssociation < ActiveRecord::Associations::Builder::Association
-  def block_extension; end
-  def define_extensions(model); end
-  def initialize(model, name, scope, options); end
-  def self.define_callback(model, callback_name, name, options); end
-  def self.define_callbacks(model, reflection); end
-  def self.define_readers(mixin, name); end
-  def self.define_writers(mixin, name); end
-  def valid_options; end
-  def wrap_scope(scope, mod); end
-end
-class ActiveRecord::Associations::Builder::HasMany < ActiveRecord::Associations::Builder::CollectionAssociation
-  def macro; end
-  def self.valid_dependent_options; end
-  def valid_options; end
-end
-class ActiveRecord::ConnectionAdapters::TransactionState
-  def committed?; end
-  def completed?; end
-  def finalized?; end
-  def initialize(state = nil); end
-  def parent; end
-  def rolledback?; end
-  def set_state(state); end
-end
-class ActiveRecord::ConnectionAdapters::NullTransaction
-  def add_record(record); end
-  def closed?; end
-  def initialize; end
-  def joinable?; end
-  def open?; end
-end
-class ActiveRecord::ConnectionAdapters::Transaction
-  def add_record(record); end
-  def closed?; end
-  def commit; end
-  def commit_records; end
-  def connection; end
-  def full_rollback?; end
-  def initialize(connection, options); end
-  def joinable=(arg0); end
-  def joinable?; end
-  def open?; end
-  def records; end
-  def rollback; end
-  def rollback_records; end
-  def savepoint_name; end
-  def state; end
-end
-class ActiveRecord::ConnectionAdapters::SavepointTransaction < ActiveRecord::ConnectionAdapters::Transaction
-  def commit; end
-  def full_rollback?; end
-  def initialize(connection, savepoint_name, options); end
-  def rollback; end
-end
-class ActiveRecord::ConnectionAdapters::RealTransaction < ActiveRecord::ConnectionAdapters::Transaction
-  def commit; end
-  def initialize(connection, options); end
-  def rollback; end
-end
-class ActiveRecord::ConnectionAdapters::TransactionManager
-  def begin_transaction(options = nil); end
-  def commit_transaction; end
-  def current_transaction; end
-  def initialize(connection); end
-  def open_transactions; end
-  def rollback_transaction; end
-  def within_new_transaction(options = nil); end
-end
-class ActiveRecord::Result
-  def [](idx); end
-  def cast_values(type_overrides = nil); end
-  def collect!; end
-  def column_type(name, type_overrides = nil); end
-  def column_types; end
-  def columns; end
-  def each; end
-  def empty?; end
-  def hash_rows; end
-  def initialize(columns, rows, column_types = nil); end
-  def initialize_copy(other); end
-  def last; end
-  def length; end
-  def map!; end
-  def rows; end
-  def to_ary; end
-  def to_hash; end
-  include Enumerable
-end
-class ActiveRecord::ConnectionAdapters::Column
-  def ==(other); end
-  def accessor(*args, &block); end
-  def attributes_for_hash; end
-  def binary?(*args, &block); end
-  def cast_type; end
-  def changed?(*args, &block); end
-  def default; end
-  def default_function; end
-  def eql?(other); end
-  def has_default?; end
-  def hash; end
-  def human_name; end
-  def initialize(name, default, cast_type, sql_type = nil, null = nil); end
-  def klass(*args, &block); end
-  def limit(*args, &block); end
-  def name; end
-  def null; end
-  def number?(*args, &block); end
-  def precision(*args, &block); end
-  def scale(*args, &block); end
-  def sql_type; end
-  def text?(*args, &block); end
-  def type(*args, &block); end
-  def type_cast_for_database(*args, &block); end
-  def type_cast_for_schema(*args, &block); end
-  def type_cast_from_database(*args, &block); end
-  def type_cast_from_user(*args, &block); end
-  def with_type(type); end
-end
-module ActiveRecord::ConnectionAdapters::Column::Format
-end
-class ActiveRecord::Associations::Preloader
-  def grouped_records(association, records); end
-  def preload(records, associations, preload_scope = nil); end
-  def preloader_for(reflection, owners, rhs_klass); end
-  def preloaders_for_hash(association, records, scope); end
-  def preloaders_for_one(association, records, scope); end
-  def preloaders_on(association, records, scope); end
-  extend ActiveSupport::Autoload
-end
-class ActiveRecord::Associations::Preloader::AlreadyLoaded
-  def initialize(klass, owners, reflection, preload_scope); end
-  def owners; end
-  def preloaded_records; end
-  def reflection; end
-  def run(preloader); end
-end
-class ActiveRecord::Associations::Preloader::NullPreloader
-  def self.new(klass, owners, reflection, preload_scope); end
-  def self.preloaded_records; end
-  def self.run(preloader); end
-end
-class Wizard::ActiveRecord_Relation < ActiveRecord::Relation
-  def arel_table(*args, &block); end
-end
-class ActiveRecord::SchemaMigration < ActiveRecord::Base
-  def self._validators; end
-  def self.attribute_type_decorations; end
-  def self.create_table(limit = nil); end
-  def self.defined_enums; end
-  def self.drop_table; end
-  def self.find_by_statement_cache; end
-  def self.index_name; end
-  def self.normalize_migration_number(number); end
-  def self.normalized_versions; end
-  def self.primary_key; end
-  def self.table_exists?; end
-  def self.table_name; end
-  def version; end
-  include ActiveRecord::SchemaMigration::GeneratedAssociationMethods
-  include Anonymous_ActiveRecord_AttributeMethods_GeneratedAttributeMethods_3
-end
-module Anonymous_ActiveRecord_AttributeMethods_GeneratedAttributeMethods_3
-  def self.lock; end
-  def self.locked?; end
-  def self.synchronize(&block); end
-  def self.try_lock; end
-  def self.unlock; end
-  extend Mutex_m
-end
-module ActiveRecord::SchemaMigration::GeneratedAssociationMethods
-end
-class ActiveRecord::SchemaMigration::ActiveRecord_Relation < ActiveRecord::Relation
-  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
-  include ActiveRecord::Delegation::ClassSpecificRelation
-end
-class ActiveRecord::SchemaMigration::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
-  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
-  include ActiveRecord::Delegation::ClassSpecificRelation
-end
-class ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation
-  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
-  include ActiveRecord::Delegation::ClassSpecificRelation
-end
-module ActiveRecord::LegacyYamlAdapter
-  def self.convert(klass, coder); end
-end
-module ActiveRecord::LegacyYamlAdapter::Rails41
-  def self.convert(klass, coder); end
-end
-class ActiveRecord::FixtureSet
-  def [](x); end
-  def []=(k, v); end
-  def add_join_records(rows, row, association); end
-  def all_loaded_fixtures; end
-  def all_loaded_fixtures=(obj); end
-  def column_names; end
-  def config; end
-  def each(&block); end
-  def fixtures; end
-  def has_primary_key_column?; end
-  def inheritance_column_name; end
-  def initialize(connection, name, class_name, path, config = nil); end
-  def model_class; end
-  def name; end
-  def primary_key_name; end
-  def primary_key_type; end
-  def read_fixture_files(path, model_class); end
-  def self.all_loaded_fixtures; end
-  def self.all_loaded_fixtures=(obj); end
-  def self.cache_fixtures(connection, fixtures_map); end
-  def self.cache_for_connection(connection); end
-  def self.cached_fixtures(connection, keys_to_fetch = nil); end
-  def self.context_class; end
-  def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = nil, config = nil); end
-  def self.default_fixture_model_name(fixture_set_name, config = nil); end
-  def self.default_fixture_table_name(fixture_set_name, config = nil); end
-  def self.fixture_is_cached?(connection, table_name); end
-  def self.identify(label, column_type = nil); end
-  def self.instantiate_all_loaded_fixtures(object, load_instances = nil); end
-  def self.instantiate_fixtures(object, fixture_set, load_instances = nil); end
-  def self.reset_cache; end
-  def self.update_all_loaded_fixtures(fixtures_map); end
-  def size; end
-  def table_name; end
-  def table_rows; end
-  def timestamp_column_names; end
-  def yaml_file_path(path); end
-end
-class ActiveRecord::FixtureSet::File
-  def each(&block); end
-  def initialize(file); end
-  def render(content); end
-  def rows; end
-  def self.open(file); end
-  def validate(data); end
-  include Enumerable
-end
-class ActiveRecord::FixtureClassNotFound < ActiveRecord::ActiveRecordError
-end
-class ActiveRecord::FixtureSet::ClassCache
-  def [](fs_name); end
-  def default_fixture_model(fs_name, config); end
-  def initialize(class_names, config); end
-  def insert_class(class_names, name, klass); end
-end
-class ActiveRecord::FixtureSet::ReflectionProxy
-  def initialize(association); end
-  def join_table; end
-  def name; end
-  def primary_key_type; end
-end
-class ActiveRecord::FixtureSet::HasManyThroughProxy < ActiveRecord::FixtureSet::ReflectionProxy
-  def join_table; end
-  def lhs_key; end
-  def rhs_key; end
-end
-class ActiveRecord::Fixture
-  def [](key); end
-  def class_name; end
-  def each; end
-  def find; end
-  def fixture; end
-  def initialize(fixture, model_class); end
-  def model_class; end
-  def to_hash; end
-  include Enumerable
-end
-class ActiveRecord::Fixture::FixtureError < StandardError
-end
-class ActiveRecord::Fixture::FormatError < ActiveRecord::Fixture::FixtureError
-end
-module ActiveRecord::TestFixtures
-  def after_teardown; end
-  def before_setup; end
-  def enlist_fixture_connections; end
-  def instantiate_fixtures; end
-  def load_fixtures(config); end
-  def load_instances?; end
-  def run_in_transaction?; end
-  def setup_fixtures(config = nil); end
-  def teardown_fixtures; end
-  extend ActiveSupport::Concern
-end
-module ActiveRecord::TestFixtures::ClassMethods
-  def fixtures(*fixture_set_names); end
-  def set_fixture_class(class_names = nil); end
-  def setup_fixture_accessors(fixture_set_names = nil); end
-  def uses_transaction(*methods); end
-  def uses_transaction?(method); end
-end
-class ActiveRecord::FixtureSet::RenderContext
-  def self.create_subclass; end
-end