redux-scraper/sorbet/rbi/dsl/domain/post/fa_post.rbi

# typed: true

# DO NOT EDIT MANUALLY
# This is an autogenerated file for dynamic methods in `Domain::Post::FaPost`.
# Please instead update this file by running `bin/tapioca dsl Domain::Post::FaPost`.


class Domain::Post::FaPost
  include GeneratedAssociationMethods
  include GeneratedAttributeMethods
  include EnumMethodsModule
  extend CommonRelationMethods
  extend GeneratedRelationMethods

  sig { returns(ColorLogger) }
  def logger; end

  private

  sig { returns(NilClass) }
  def to_ary; end

  class << self
    sig do
      params(
        name: Symbol,
        type: T.any(Symbol, ActiveModel::Type::Value),
        options: T.nilable(T::Hash[Symbol, T.untyped])
      ).void
    end
    def attr_json(name, type, options = nil); end

    sig do
      params(
        default_container_attribute: T.nilable(Symbol),
        bad_cast: T.nilable(Symbol),
        unknown_key: T.nilable(Symbol)
      ).void
    end
    def attr_json_config(default_container_attribute: nil, bad_cast: nil, unknown_key: nil); end

    sig { returns(T::Array[Symbol]) }
    def attr_json_registry; end

    sig { returns(ColorLogger) }
    def logger; end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def new(attributes = nil, &block); end

    sig { returns(T::Hash[T.any(String, Symbol), String]) }
    def states; end
  end

  module CommonRelationMethods
    sig do
      params(
        block: T.nilable(T.proc.params(record: ::Domain::Post::FaPost).returns(T.untyped))
      ).returns(T::Boolean)
    end
    def any?(&block); end

    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
    def average(column_name); end

    sig do
      params(
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def build(attributes = nil, &block); end

    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
    def calculate(operation, column_name); end

    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
    sig { params(column_name: NilClass, block: T.proc.params(object: ::Domain::Post::FaPost).void).returns(Integer) }
    def count(column_name = nil, &block); end

    sig do
      params(
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def create(attributes = nil, &block); end

    sig do
      params(
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def create!(attributes = nil, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def create_or_find_by(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def create_or_find_by!(attributes, &block); end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def destroy_all; end

    sig { params(conditions: T.untyped).returns(T::Boolean) }
    def exists?(conditions = :none); end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def fifth; end

    sig { returns(::Domain::Post::FaPost) }
    def fifth!; end

    sig do
      params(
        args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])
      ).returns(::Domain::Post::FaPost)
    end
    sig do
      params(
        args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]
      ).returns(T::Enumerable[::Domain::Post::FaPost])
    end
    sig do
      params(
        args: NilClass,
        block: T.proc.params(object: ::Domain::Post::FaPost).void
      ).returns(T.nilable(::Domain::Post::FaPost))
    end
    def find(args = nil, &block); end

    sig { params(args: T.untyped).returns(T.nilable(::Domain::Post::FaPost)) }
    def find_by(*args); end

    sig { params(args: T.untyped).returns(::Domain::Post::FaPost) }
    def find_by!(*args); end

    sig do
      params(
        start: T.untyped,
        finish: T.untyped,
        batch_size: Integer,
        error_on_ignore: T.untyped,
        order: Symbol,
        block: T.proc.params(object: ::Domain::Post::FaPost).void
      ).void
    end
    sig do
      params(
        start: T.untyped,
        finish: T.untyped,
        batch_size: Integer,
        error_on_ignore: T.untyped,
        order: Symbol
      ).returns(T::Enumerator[::Domain::Post::FaPost])
    end
    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end

    sig do
      params(
        start: T.untyped,
        finish: T.untyped,
        batch_size: Integer,
        error_on_ignore: T.untyped,
        order: Symbol,
        block: T.proc.params(object: T::Array[::Domain::Post::FaPost]).void
      ).void
    end
    sig do
      params(
        start: T.untyped,
        finish: T.untyped,
        batch_size: Integer,
        error_on_ignore: T.untyped,
        order: Symbol
      ).returns(T::Enumerator[T::Enumerator[::Domain::Post::FaPost]])
    end
    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def find_or_create_by(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def find_or_create_by!(attributes, &block); end

    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def find_or_initialize_by(attributes, &block); end

    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::Domain::Post::FaPost)) }
    def find_signed(signed_id, purpose: nil); end

    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::Domain::Post::FaPost) }
    def find_signed!(signed_id, purpose: nil); end

    sig { params(arg: T.untyped, args: T.untyped).returns(::Domain::Post::FaPost) }
    def find_sole_by(arg, *args); end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    sig { params(limit: Integer).returns(T::Array[::Domain::Post::FaPost]) }
    def first(limit = nil); end

    sig { returns(::Domain::Post::FaPost) }
    def first!; end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def forty_two; end

    sig { returns(::Domain::Post::FaPost) }
    def forty_two!; end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def fourth; end

    sig { returns(::Domain::Post::FaPost) }
    def fourth!; end

    sig { returns(Array) }
    def ids; end

    sig do
      params(
        of: Integer,
        start: T.untyped,
        finish: T.untyped,
        load: T.untyped,
        error_on_ignore: T.untyped,
        order: Symbol,
        use_ranges: T.untyped,
        block: T.proc.params(object: PrivateRelation).void
      ).void
    end
    sig do
      params(
        of: Integer,
        start: T.untyped,
        finish: T.untyped,
        load: T.untyped,
        error_on_ignore: T.untyped,
        order: Symbol,
        use_ranges: T.untyped
      ).returns(::ActiveRecord::Batches::BatchEnumerator)
    end
    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end

    sig { params(record: T.untyped).returns(T::Boolean) }
    def include?(record); end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    sig { params(limit: Integer).returns(T::Array[::Domain::Post::FaPost]) }
    def last(limit = nil); end

    sig { returns(::Domain::Post::FaPost) }
    def last!; end

    sig do
      params(
        block: T.nilable(T.proc.params(record: ::Domain::Post::FaPost).returns(T.untyped))
      ).returns(T::Boolean)
    end
    def many?(&block); end

    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
    def maximum(column_name); end

    sig { params(record: T.untyped).returns(T::Boolean) }
    def member?(record); end

    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
    def minimum(column_name); end

    sig do
      params(
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    sig do
      params(
        attributes: T::Array[T.untyped],
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Domain::Post::FaPost).void)
      ).returns(::Domain::Post::FaPost)
    end
    def new(attributes = nil, &block); end

    sig do
      params(
        block: T.nilable(T.proc.params(record: ::Domain::Post::FaPost).returns(T.untyped))
      ).returns(T::Boolean)
    end
    def none?(&block); end

    sig do
      params(
        block: T.nilable(T.proc.params(record: ::Domain::Post::FaPost).returns(T.untyped))
      ).returns(T::Boolean)
    end
    def one?(&block); end

    sig { params(column_names: T.untyped).returns(T.untyped) }
    def pick(*column_names); end

    sig { params(column_names: T.untyped).returns(T.untyped) }
    def pluck(*column_names); end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def second; end

    sig { returns(::Domain::Post::FaPost) }
    def second!; end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def second_to_last; end

    sig { returns(::Domain::Post::FaPost) }
    def second_to_last!; end

    sig { returns(::Domain::Post::FaPost) }
    def sole; end

    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
    sig do
      type_parameters(:U)
        .params(
          initial_value_or_column: T.nilable(T.type_parameter(:U)),
          block: T.proc.params(object: ::Domain::Post::FaPost).returns(T.type_parameter(:U))
        ).returns(T.type_parameter(:U))
    end
    def sum(initial_value_or_column = nil, &block); end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    sig { params(limit: Integer).returns(T::Array[::Domain::Post::FaPost]) }
    def take(limit = nil); end

    sig { returns(::Domain::Post::FaPost) }
    def take!; end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def third; end

    sig { returns(::Domain::Post::FaPost) }
    def third!; end

    sig { returns(T.nilable(::Domain::Post::FaPost)) }
    def third_to_last; end

    sig { returns(::Domain::Post::FaPost) }
    def third_to_last!; end
  end

  module EnumMethodsModule
    sig { void }
    def state_file_error!; end

    sig { returns(T::Boolean) }
    def state_file_error?; end

    sig { void }
    def state_ok!; end

    sig { returns(T::Boolean) }
    def state_ok?; end

    sig { void }
    def state_removed!; end

    sig { returns(T::Boolean) }
    def state_removed?; end

    sig { void }
    def state_scan_error!; end

    sig { returns(T::Boolean) }
    def state_scan_error?; end
  end

  module GeneratedAssociationMethods
    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::User::FaUser) }
    def build_creator(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) }
    def build_file(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_first_browse_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_first_gallery_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_first_seen_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_fuzzysearch_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_last_submission_log_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def build_last_user_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostCreation) }
    def build_primary_user_post_creation(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostFav) }
    def build_user_post_fav(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::User::FaUser) }
    def create_creator(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::User::FaUser) }
    def create_creator!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) }
    def create_file(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) }
    def create_file!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_browse_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_browse_page!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_gallery_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_gallery_page!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_seen_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_first_seen_entry!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_fuzzysearch_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_fuzzysearch_entry!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_last_submission_log_entry(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_last_submission_log_entry!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_last_user_page(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::HttpLogEntry) }
    def create_last_user_page!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostCreation) }
    def create_primary_user_post_creation(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostCreation) }
    def create_primary_user_post_creation!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostFav) }
    def create_user_post_fav(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::UserPostFav) }
    def create_user_post_fav!(*args, &blk); end

    sig { returns(T.nilable(::Domain::User::FaUser)) }
    def creator; end

    sig { params(value: T.nilable(::Domain::User::FaUser)).void }
    def creator=(value); end

    sig { returns(T::Array[T.untyped]) }
    def faving_user_ids; end

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def faving_user_ids=(ids); end

    # This method is created by ActiveRecord on the `Domain::Post::FaPost` class because it declared `has_many :faving_users, through: :user_post_favs`.
    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
    sig { returns(::Domain::User::FaUser::PrivateCollectionProxy) }
    def faving_users; end

    sig { params(value: T::Enumerable[::Domain::User::FaUser]).void }
    def faving_users=(value); end

    sig { returns(T.nilable(::Domain::PostFile)) }
    def file; end

    sig { params(value: T.nilable(::Domain::PostFile)).void }
    def file=(value); end

    sig { returns(T::Array[T.untyped]) }
    def file_ids; end

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def file_ids=(ids); end

    # This method is created by ActiveRecord on the `Domain::Post` class because it declared `has_many :files`.
    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
    sig { returns(::Domain::PostFile::PrivateCollectionProxy) }
    def files; end

    sig { params(value: T::Enumerable[::Domain::PostFile]).void }
    def files=(value); end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def first_browse_page; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def first_browse_page=(value); end

    sig { returns(T::Boolean) }
    def first_browse_page_changed?; end

    sig { returns(T::Boolean) }
    def first_browse_page_previously_changed?; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def first_gallery_page; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def first_gallery_page=(value); end

    sig { returns(T::Boolean) }
    def first_gallery_page_changed?; end

    sig { returns(T::Boolean) }
    def first_gallery_page_previously_changed?; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def first_seen_entry; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def first_seen_entry=(value); end

    sig { returns(T::Boolean) }
    def first_seen_entry_changed?; end

    sig { returns(T::Boolean) }
    def first_seen_entry_previously_changed?; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def fuzzysearch_entry; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def fuzzysearch_entry=(value); end

    sig { returns(T::Boolean) }
    def fuzzysearch_entry_changed?; end

    sig { returns(T::Boolean) }
    def fuzzysearch_entry_previously_changed?; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def last_submission_log_entry; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def last_submission_log_entry=(value); end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def last_user_page; end

    sig { params(value: T.nilable(::HttpLogEntry)).void }
    def last_user_page=(value); end

    sig { returns(T::Boolean) }
    def last_user_page_changed?; end

    sig { returns(T::Boolean) }
    def last_user_page_previously_changed?; end

    sig { returns(T.nilable(::Domain::UserPostCreation)) }
    def primary_user_post_creation; end

    sig { params(value: T.nilable(::Domain::UserPostCreation)).void }
    def primary_user_post_creation=(value); end

    sig { returns(T.nilable(::Domain::User::FaUser)) }
    def reload_creator; end

    sig { returns(T.nilable(::Domain::PostFile)) }
    def reload_file; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_first_browse_page; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_first_gallery_page; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_first_seen_entry; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_fuzzysearch_entry; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_last_submission_log_entry; end

    sig { returns(T.nilable(::HttpLogEntry)) }
    def reload_last_user_page; end

    sig { returns(T.nilable(::Domain::UserPostCreation)) }
    def reload_primary_user_post_creation; end

    sig { returns(T.nilable(::Domain::UserPostFav)) }
    def reload_user_post_fav; end

    sig { void }
    def reset_creator; end

    sig { void }
    def reset_file; end

    sig { void }
    def reset_first_browse_page; end

    sig { void }
    def reset_first_gallery_page; end

    sig { void }
    def reset_first_seen_entry; end

    sig { void }
    def reset_fuzzysearch_entry; end

    sig { void }
    def reset_last_submission_log_entry; end

    sig { void }
    def reset_last_user_page; end

    sig { void }
    def reset_primary_user_post_creation; end

    sig { void }
    def reset_user_post_fav; end

    sig { returns(T::Array[T.untyped]) }
    def user_post_creation_ids; end

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def user_post_creation_ids=(ids); end

    # This method is created by ActiveRecord on the `Domain::Post` class because it declared `has_many :user_post_creations`.
    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
    sig { returns(::Domain::UserPostCreation::PrivateCollectionProxy) }
    def user_post_creations; end

    sig { params(value: T::Enumerable[::Domain::UserPostCreation]).void }
    def user_post_creations=(value); end

    sig { returns(T.nilable(::Domain::UserPostFav)) }
    def user_post_fav; end

    sig { params(value: T.nilable(::Domain::UserPostFav)).void }
    def user_post_fav=(value); end

    sig { returns(T::Array[T.untyped]) }
    def user_post_fav_ids; end

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def user_post_fav_ids=(ids); end

    # This method is created by ActiveRecord on the `Domain::Post` class because it declared `has_many :user_post_favs`.
    # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
    sig { returns(::Domain::UserPostFav::PrivateCollectionProxy) }
    def user_post_favs; end

    sig { params(value: T::Enumerable[::Domain::UserPostFav]).void }
    def user_post_favs=(value); end
  end

  module GeneratedAssociationRelationMethods
    sig { returns(PrivateAssociationRelation) }
    def all; end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def and(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def annotate(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def arel_columns(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def create_with(*args, &blk); end

    sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
    def distinct(value = true); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def eager_load(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def except(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def excluding(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def extending(*args, &blk); end

    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
    def extract_associated(association); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def from(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
    def group(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def having(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def in_order_of(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def includes(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def invert_where(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def left_joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def left_outer_joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def limit(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def lock(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def merge(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def none(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def not_state_file_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def not_state_ok(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def not_state_removed(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def not_state_scan_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def null_relation?(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def offset(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def only(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def optimizer_hints(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def or(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def order(*args, &blk); end

    sig do
      params(
        num: T.any(Integer, String)
      ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
    end
    def page(num = nil); end

    sig do
      params(
        num: Integer
      ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
    end
    def per(num); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def preload(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def readonly(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def references(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def regroup(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def reorder(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def reselect(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def reverse_order(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def rewhere(*args, &blk); end

    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
    sig do
      params(
        blk: T.proc.params(record: ::Domain::Post::FaPost).returns(T::Boolean)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    def select(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def state_file_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def state_ok(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def state_removed(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def state_scan_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def strict_loading(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def structurally_compatible?(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def uniq!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def unscope(*args, &blk); end

    sig { returns(PrivateAssociationRelationWhereChain) }
    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
    def where(*args); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def with(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def with_recursive(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def with_user_post_fav(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def without(*args, &blk); end

    sig do
      returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
    end
    def without_count; end
  end

  module GeneratedAttributeMethods
    sig { returns(T.nilable(::String)) }
    def category; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def category=(value); end

    sig { returns(T::Boolean) }
    def category?; end

    sig { returns(T.nilable(::String)) }
    def category_before_last_save; end

    sig { returns(T.untyped) }
    def category_before_type_cast; end

    sig { returns(T::Boolean) }
    def category_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def category_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def category_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def category_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def category_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def category_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def category_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def category_previously_was; end

    sig { returns(T.nilable(::String)) }
    def category_was; end

    sig { void }
    def category_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at=(value); end

    sig { returns(T::Boolean) }
    def created_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at_before_last_save; end

    sig { returns(T.untyped) }
    def created_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def created_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def created_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def created_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def created_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def created_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def created_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def created_at_was; end

    sig { void }
    def created_at_will_change!; end

    sig { returns(T.nilable(::String)) }
    def description; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def description=(value); end

    sig { returns(T::Boolean) }
    def description?; end

    sig { returns(T.nilable(::String)) }
    def description_before_last_save; end

    sig { returns(T.untyped) }
    def description_before_type_cast; end

    sig { returns(T::Boolean) }
    def description_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def description_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def description_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def description_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def description_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def description_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def description_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def description_previously_was; end

    sig { returns(T.nilable(::String)) }
    def description_was; end

    sig { void }
    def description_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def fa_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def fa_id=(value); end

    sig { returns(T::Boolean) }
    def fa_id?; end

    sig { returns(T.nilable(::Integer)) }
    def fa_id_before_last_save; end

    sig { returns(T.untyped) }
    def fa_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def fa_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fa_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fa_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def fa_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def fa_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fa_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def fa_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def fa_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def fa_id_was; end

    sig { void }
    def fa_id_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def first_browse_page_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def first_browse_page_id=(value); end

    sig { returns(T::Boolean) }
    def first_browse_page_id?; end

    sig { returns(T.nilable(::Integer)) }
    def first_browse_page_id_before_last_save; end

    sig { returns(T.untyped) }
    def first_browse_page_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def first_browse_page_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_browse_page_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_browse_page_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_browse_page_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_browse_page_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_browse_page_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_browse_page_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_browse_page_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def first_browse_page_id_was; end

    sig { void }
    def first_browse_page_id_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def first_gallery_page_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def first_gallery_page_id=(value); end

    sig { returns(T::Boolean) }
    def first_gallery_page_id?; end

    sig { returns(T.nilable(::Integer)) }
    def first_gallery_page_id_before_last_save; end

    sig { returns(T.untyped) }
    def first_gallery_page_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def first_gallery_page_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_gallery_page_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_gallery_page_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_gallery_page_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_gallery_page_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_gallery_page_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_gallery_page_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_gallery_page_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def first_gallery_page_id_was; end

    sig { void }
    def first_gallery_page_id_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def first_seen_entry_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def first_seen_entry_id=(value); end

    sig { returns(T::Boolean) }
    def first_seen_entry_id?; end

    sig { returns(T.nilable(::Integer)) }
    def first_seen_entry_id_before_last_save; end

    sig { returns(T.untyped) }
    def first_seen_entry_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def first_seen_entry_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_seen_entry_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_seen_entry_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_seen_entry_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_seen_entry_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def first_seen_entry_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def first_seen_entry_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def first_seen_entry_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def first_seen_entry_id_was; end

    sig { void }
    def first_seen_entry_id_will_change!; end

    sig { returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at; end

    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at=(value); end

    sig { returns(T::Boolean) }
    def fuzzysearch_checked_at?; end

    sig { returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at_before_last_save; end

    sig { returns(T.untyped) }
    def fuzzysearch_checked_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def fuzzysearch_checked_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def fuzzysearch_checked_at_change; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def fuzzysearch_checked_at_change_to_be_saved; end

    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
    def fuzzysearch_checked_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at_in_database; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def fuzzysearch_checked_at_previous_change; end

    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
    def fuzzysearch_checked_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at_previously_was; end

    sig { returns(T.nilable(::Time)) }
    def fuzzysearch_checked_at_was; end

    sig { void }
    def fuzzysearch_checked_at_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id=(value); end

    sig { returns(T::Boolean) }
    def fuzzysearch_entry_id?; end

    sig { returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id_before_last_save; end

    sig { returns(T.untyped) }
    def fuzzysearch_entry_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def fuzzysearch_entry_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fuzzysearch_entry_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fuzzysearch_entry_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def fuzzysearch_entry_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def fuzzysearch_entry_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def fuzzysearch_entry_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def fuzzysearch_entry_id_was; end

    sig { void }
    def fuzzysearch_entry_id_will_change!; end

    sig { returns(T.untyped) }
    def fuzzysearch_json; end

    sig { params(value: T.untyped).returns(T.untyped) }
    def fuzzysearch_json=(value); end

    sig { returns(T::Boolean) }
    def fuzzysearch_json?; end

    sig { returns(T.untyped) }
    def fuzzysearch_json_before_last_save; end

    sig { returns(T.untyped) }
    def fuzzysearch_json_before_type_cast; end

    sig { returns(T::Boolean) }
    def fuzzysearch_json_came_from_user?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def fuzzysearch_json_change; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def fuzzysearch_json_change_to_be_saved; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def fuzzysearch_json_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def fuzzysearch_json_in_database; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def fuzzysearch_json_previous_change; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def fuzzysearch_json_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def fuzzysearch_json_previously_was; end

    sig { returns(T.untyped) }
    def fuzzysearch_json_was; end

    sig { void }
    def fuzzysearch_json_will_change!; end

    sig { returns(T.nilable(::String)) }
    def gender; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def gender=(value); end

    sig { returns(T::Boolean) }
    def gender?; end

    sig { returns(T.nilable(::String)) }
    def gender_before_last_save; end

    sig { returns(T.untyped) }
    def gender_before_type_cast; end

    sig { returns(T::Boolean) }
    def gender_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def gender_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def gender_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def gender_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def gender_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def gender_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def gender_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def gender_previously_was; end

    sig { returns(T.nilable(::String)) }
    def gender_was; end

    sig { void }
    def gender_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def id=(value); end

    sig { returns(T::Boolean) }
    def id?; end

    sig { returns(T.nilable(::Integer)) }
    def id_before_last_save; end

    sig { returns(T.untyped) }
    def id_before_type_cast; end

    sig { returns(T::Boolean) }
    def id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def id_value; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def id_value=(value); end

    sig { returns(T::Boolean) }
    def id_value?; end

    sig { returns(T.nilable(::Integer)) }
    def id_value_before_last_save; end

    sig { returns(T.untyped) }
    def id_value_before_type_cast; end

    sig { returns(T::Boolean) }
    def id_value_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_value_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_value_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def id_value_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def id_value_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def id_value_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def id_value_was; end

    sig { void }
    def id_value_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def id_was; end

    sig { void }
    def id_will_change!; end

    sig { returns(T.untyped) }
    def json_attributes; end

    sig { params(value: T.untyped).returns(T.untyped) }
    def json_attributes=(value); end

    sig { returns(T::Boolean) }
    def json_attributes?; end

    sig { returns(T.untyped) }
    def json_attributes_before_last_save; end

    sig { returns(T.untyped) }
    def json_attributes_before_type_cast; end

    sig { returns(T::Boolean) }
    def json_attributes_came_from_user?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def json_attributes_change; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def json_attributes_change_to_be_saved; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def json_attributes_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def json_attributes_in_database; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def json_attributes_previous_change; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def json_attributes_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def json_attributes_previously_was; end

    sig { returns(T.untyped) }
    def json_attributes_was; end

    sig { void }
    def json_attributes_will_change!; end

    sig { returns(T.untyped) }
    def keywords; end

    sig { params(value: T.untyped).returns(T.untyped) }
    def keywords=(value); end

    sig { returns(T::Boolean) }
    def keywords?; end

    sig { returns(T.untyped) }
    def keywords_before_last_save; end

    sig { returns(T.untyped) }
    def keywords_before_type_cast; end

    sig { returns(T::Boolean) }
    def keywords_came_from_user?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def keywords_change; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def keywords_change_to_be_saved; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def keywords_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def keywords_in_database; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def keywords_previous_change; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def keywords_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def keywords_previously_was; end

    sig { returns(T.untyped) }
    def keywords_was; end

    sig { void }
    def keywords_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id=(value); end

    sig { returns(T::Boolean) }
    def last_submission_log_entry_id?; end

    sig { returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id_before_last_save; end

    sig { returns(T.untyped) }
    def last_submission_log_entry_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def last_submission_log_entry_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_submission_log_entry_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_submission_log_entry_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def last_submission_log_entry_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_submission_log_entry_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def last_submission_log_entry_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def last_submission_log_entry_id_was; end

    sig { void }
    def last_submission_log_entry_id_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def last_user_page_id; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def last_user_page_id=(value); end

    sig { returns(T::Boolean) }
    def last_user_page_id?; end

    sig { returns(T.nilable(::Integer)) }
    def last_user_page_id_before_last_save; end

    sig { returns(T.untyped) }
    def last_user_page_id_before_type_cast; end

    sig { returns(T::Boolean) }
    def last_user_page_id_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_user_page_id_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_user_page_id_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def last_user_page_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def last_user_page_id_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def last_user_page_id_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def last_user_page_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def last_user_page_id_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def last_user_page_id_was; end

    sig { void }
    def last_user_page_id_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def num_comments; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def num_comments=(value); end

    sig { returns(T::Boolean) }
    def num_comments?; end

    sig { returns(T.nilable(::Integer)) }
    def num_comments_before_last_save; end

    sig { returns(T.untyped) }
    def num_comments_before_type_cast; end

    sig { returns(T::Boolean) }
    def num_comments_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_comments_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_comments_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_comments_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_comments_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_comments_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_comments_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_comments_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def num_comments_was; end

    sig { void }
    def num_comments_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def num_favorites; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def num_favorites=(value); end

    sig { returns(T::Boolean) }
    def num_favorites?; end

    sig { returns(T.nilable(::Integer)) }
    def num_favorites_before_last_save; end

    sig { returns(T.untyped) }
    def num_favorites_before_type_cast; end

    sig { returns(T::Boolean) }
    def num_favorites_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_favorites_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_favorites_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_favorites_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_favorites_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_favorites_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_favorites_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_favorites_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def num_favorites_was; end

    sig { void }
    def num_favorites_will_change!; end

    sig { returns(T.nilable(::Integer)) }
    def num_views; end

    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
    def num_views=(value); end

    sig { returns(T::Boolean) }
    def num_views?; end

    sig { returns(T.nilable(::Integer)) }
    def num_views_before_last_save; end

    sig { returns(T.untyped) }
    def num_views_before_type_cast; end

    sig { returns(T::Boolean) }
    def num_views_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_views_change; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_views_change_to_be_saved; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_views_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_views_in_database; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def num_views_previous_change; end

    sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) }
    def num_views_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Integer)) }
    def num_views_previously_was; end

    sig { returns(T.nilable(::Integer)) }
    def num_views_was; end

    sig { void }
    def num_views_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at=(value); end

    sig { returns(T::Boolean) }
    def posted_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at_before_last_save; end

    sig { returns(T.untyped) }
    def posted_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def posted_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def posted_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def posted_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def posted_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def posted_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def posted_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def posted_at_was; end

    sig { void }
    def posted_at_will_change!; end

    sig { void }
    def restore_category!; end

    sig { void }
    def restore_created_at!; end

    sig { void }
    def restore_description!; end

    sig { void }
    def restore_fa_id!; end

    sig { void }
    def restore_first_browse_page_id!; end

    sig { void }
    def restore_first_gallery_page_id!; end

    sig { void }
    def restore_first_seen_entry_id!; end

    sig { void }
    def restore_fuzzysearch_checked_at!; end

    sig { void }
    def restore_fuzzysearch_entry_id!; end

    sig { void }
    def restore_fuzzysearch_json!; end

    sig { void }
    def restore_gender!; end

    sig { void }
    def restore_id!; end

    sig { void }
    def restore_id_value!; end

    sig { void }
    def restore_json_attributes!; end

    sig { void }
    def restore_keywords!; end

    sig { void }
    def restore_last_submission_log_entry_id!; end

    sig { void }
    def restore_last_user_page_id!; end

    sig { void }
    def restore_num_comments!; end

    sig { void }
    def restore_num_favorites!; end

    sig { void }
    def restore_num_views!; end

    sig { void }
    def restore_posted_at!; end

    sig { void }
    def restore_scan_file_error!; end

    sig { void }
    def restore_scanned_at!; end

    sig { void }
    def restore_species!; end

    sig { void }
    def restore_state!; end

    sig { void }
    def restore_theme!; end

    sig { void }
    def restore_title!; end

    sig { void }
    def restore_tried_from_fur_archiver!; end

    sig { void }
    def restore_tried_from_tor!; end

    sig { void }
    def restore_type!; end

    sig { void }
    def restore_updated_at!; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_category; end

    sig { returns(T::Boolean) }
    def saved_change_to_category?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_created_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_created_at?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_description; end

    sig { returns(T::Boolean) }
    def saved_change_to_description?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_fa_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_fa_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_first_browse_page_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_first_browse_page_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_first_gallery_page_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_first_gallery_page_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_first_seen_entry_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_first_seen_entry_id?; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def saved_change_to_fuzzysearch_checked_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_fuzzysearch_checked_at?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_fuzzysearch_entry_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_fuzzysearch_entry_id?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def saved_change_to_fuzzysearch_json; end

    sig { returns(T::Boolean) }
    def saved_change_to_fuzzysearch_json?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_gender; end

    sig { returns(T::Boolean) }
    def saved_change_to_gender?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_id_value; end

    sig { returns(T::Boolean) }
    def saved_change_to_id_value?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def saved_change_to_json_attributes; end

    sig { returns(T::Boolean) }
    def saved_change_to_json_attributes?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def saved_change_to_keywords; end

    sig { returns(T::Boolean) }
    def saved_change_to_keywords?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_last_submission_log_entry_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_last_submission_log_entry_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_last_user_page_id; end

    sig { returns(T::Boolean) }
    def saved_change_to_last_user_page_id?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_num_comments; end

    sig { returns(T::Boolean) }
    def saved_change_to_num_comments?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_num_favorites; end

    sig { returns(T::Boolean) }
    def saved_change_to_num_favorites?; end

    sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_num_views; end

    sig { returns(T::Boolean) }
    def saved_change_to_num_views?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_posted_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_posted_at?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_scan_file_error; end

    sig { returns(T::Boolean) }
    def saved_change_to_scan_file_error?; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def saved_change_to_scanned_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_scanned_at?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_species; end

    sig { returns(T::Boolean) }
    def saved_change_to_species?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_state; end

    sig { returns(T::Boolean) }
    def saved_change_to_state?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_theme; end

    sig { returns(T::Boolean) }
    def saved_change_to_theme?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def saved_change_to_title; end

    sig { returns(T::Boolean) }
    def saved_change_to_title?; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def saved_change_to_tried_from_fur_archiver; end

    sig { returns(T::Boolean) }
    def saved_change_to_tried_from_fur_archiver?; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def saved_change_to_tried_from_tor; end

    sig { returns(T::Boolean) }
    def saved_change_to_tried_from_tor?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def saved_change_to_type; end

    sig { returns(T::Boolean) }
    def saved_change_to_type?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_updated_at; end

    sig { returns(T::Boolean) }
    def saved_change_to_updated_at?; end

    sig { returns(T.nilable(::String)) }
    def scan_file_error; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def scan_file_error=(value); end

    sig { returns(T::Boolean) }
    def scan_file_error?; end

    sig { returns(T.nilable(::String)) }
    def scan_file_error_before_last_save; end

    sig { returns(T.untyped) }
    def scan_file_error_before_type_cast; end

    sig { returns(T::Boolean) }
    def scan_file_error_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def scan_file_error_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def scan_file_error_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def scan_file_error_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def scan_file_error_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def scan_file_error_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def scan_file_error_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def scan_file_error_previously_was; end

    sig { returns(T.nilable(::String)) }
    def scan_file_error_was; end

    sig { void }
    def scan_file_error_will_change!; end

    sig { returns(T.nilable(::Time)) }
    def scanned_at; end

    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
    def scanned_at=(value); end

    sig { returns(T::Boolean) }
    def scanned_at?; end

    sig { returns(T.nilable(::Time)) }
    def scanned_at_before_last_save; end

    sig { returns(T.untyped) }
    def scanned_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def scanned_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def scanned_at_change; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def scanned_at_change_to_be_saved; end

    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
    def scanned_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Time)) }
    def scanned_at_in_database; end

    sig { returns(T.nilable([T.nilable(::Time), T.nilable(::Time)])) }
    def scanned_at_previous_change; end

    sig { params(from: T.nilable(::Time), to: T.nilable(::Time)).returns(T::Boolean) }
    def scanned_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::Time)) }
    def scanned_at_previously_was; end

    sig { returns(T.nilable(::Time)) }
    def scanned_at_was; end

    sig { void }
    def scanned_at_will_change!; end

    sig { returns(T.nilable(::String)) }
    def species; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def species=(value); end

    sig { returns(T::Boolean) }
    def species?; end

    sig { returns(T.nilable(::String)) }
    def species_before_last_save; end

    sig { returns(T.untyped) }
    def species_before_type_cast; end

    sig { returns(T::Boolean) }
    def species_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def species_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def species_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def species_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def species_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def species_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def species_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def species_previously_was; end

    sig { returns(T.nilable(::String)) }
    def species_was; end

    sig { void }
    def species_will_change!; end

    sig { returns(T.nilable(::String)) }
    def state; end

    sig { params(value: T.nilable(T.any(::String, ::Symbol))).returns(T.nilable(T.any(::String, ::Symbol))) }
    def state=(value); end

    sig { returns(T::Boolean) }
    def state?; end

    sig { returns(T.nilable(::String)) }
    def state_before_last_save; end

    sig { returns(T.untyped) }
    def state_before_type_cast; end

    sig { returns(T::Boolean) }
    def state_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def state_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def state_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(T.any(::String, ::Symbol)),
        to: T.nilable(T.any(::String, ::Symbol))
      ).returns(T::Boolean)
    end
    def state_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def state_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def state_previous_change; end

    sig do
      params(
        from: T.nilable(T.any(::String, ::Symbol)),
        to: T.nilable(T.any(::String, ::Symbol))
      ).returns(T::Boolean)
    end
    def state_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def state_previously_was; end

    sig { returns(T.nilable(::String)) }
    def state_was; end

    sig { void }
    def state_will_change!; end

    sig { returns(T.nilable(::String)) }
    def theme; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def theme=(value); end

    sig { returns(T::Boolean) }
    def theme?; end

    sig { returns(T.nilable(::String)) }
    def theme_before_last_save; end

    sig { returns(T.untyped) }
    def theme_before_type_cast; end

    sig { returns(T::Boolean) }
    def theme_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def theme_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def theme_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def theme_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def theme_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def theme_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def theme_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def theme_previously_was; end

    sig { returns(T.nilable(::String)) }
    def theme_was; end

    sig { void }
    def theme_will_change!; end

    sig { returns(T.nilable(::String)) }
    def title; end

    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
    def title=(value); end

    sig { returns(T::Boolean) }
    def title?; end

    sig { returns(T.nilable(::String)) }
    def title_before_last_save; end

    sig { returns(T.untyped) }
    def title_before_type_cast; end

    sig { returns(T::Boolean) }
    def title_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def title_change; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def title_change_to_be_saved; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def title_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def title_in_database; end

    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
    def title_previous_change; end

    sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) }
    def title_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::String)) }
    def title_previously_was; end

    sig { returns(T.nilable(::String)) }
    def title_was; end

    sig { void }
    def title_will_change!; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver; end

    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver=(value); end

    sig { returns(T::Boolean) }
    def tried_from_fur_archiver?; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver_before_last_save; end

    sig { returns(T.untyped) }
    def tried_from_fur_archiver_before_type_cast; end

    sig { returns(T::Boolean) }
    def tried_from_fur_archiver_came_from_user?; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_fur_archiver_change; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_fur_archiver_change_to_be_saved; end

    sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) }
    def tried_from_fur_archiver_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver_in_database; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_fur_archiver_previous_change; end

    sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) }
    def tried_from_fur_archiver_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver_previously_was; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_fur_archiver_was; end

    sig { void }
    def tried_from_fur_archiver_will_change!; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_tor; end

    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
    def tried_from_tor=(value); end

    sig { returns(T::Boolean) }
    def tried_from_tor?; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_tor_before_last_save; end

    sig { returns(T.untyped) }
    def tried_from_tor_before_type_cast; end

    sig { returns(T::Boolean) }
    def tried_from_tor_came_from_user?; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_tor_change; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_tor_change_to_be_saved; end

    sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) }
    def tried_from_tor_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_tor_in_database; end

    sig { returns(T.nilable([T.nilable(T::Boolean), T.nilable(T::Boolean)])) }
    def tried_from_tor_previous_change; end

    sig { params(from: T.nilable(T::Boolean), to: T.nilable(T::Boolean)).returns(T::Boolean) }
    def tried_from_tor_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_tor_previously_was; end

    sig { returns(T.nilable(T::Boolean)) }
    def tried_from_tor_was; end

    sig { void }
    def tried_from_tor_will_change!; end

    sig { returns(T.untyped) }
    def type; end

    sig { params(value: T.untyped).returns(T.untyped) }
    def type=(value); end

    sig { returns(T::Boolean) }
    def type?; end

    sig { returns(T.untyped) }
    def type_before_last_save; end

    sig { returns(T.untyped) }
    def type_before_type_cast; end

    sig { returns(T::Boolean) }
    def type_came_from_user?; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def type_change; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def type_change_to_be_saved; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def type_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def type_in_database; end

    sig { returns(T.nilable([T.untyped, T.untyped])) }
    def type_previous_change; end

    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
    def type_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.untyped) }
    def type_previously_was; end

    sig { returns(T.untyped) }
    def type_was; end

    sig { void }
    def type_will_change!; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at; end

    sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at=(value); end

    sig { returns(T::Boolean) }
    def updated_at?; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_before_last_save; end

    sig { returns(T.untyped) }
    def updated_at_before_type_cast; end

    sig { returns(T::Boolean) }
    def updated_at_came_from_user?; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_change; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_change_to_be_saved; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def updated_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_in_database; end

    sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def updated_at_previous_change; end

    sig do
      params(
        from: T.nilable(::ActiveSupport::TimeWithZone),
        to: T.nilable(::ActiveSupport::TimeWithZone)
      ).returns(T::Boolean)
    end
    def updated_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_previously_was; end

    sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
    def updated_at_was; end

    sig { void }
    def updated_at_will_change!; end

    sig { returns(T::Boolean) }
    def will_save_change_to_category?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_created_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_description?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_fa_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_first_browse_page_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_first_gallery_page_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_first_seen_entry_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_fuzzysearch_checked_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_fuzzysearch_entry_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_fuzzysearch_json?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_gender?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_id_value?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_json_attributes?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_keywords?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_last_submission_log_entry_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_last_user_page_id?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_num_comments?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_num_favorites?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_num_views?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_posted_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_scan_file_error?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_scanned_at?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_species?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_state?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_theme?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_title?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_tried_from_fur_archiver?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_tried_from_tor?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_type?; end

    sig { returns(T::Boolean) }
    def will_save_change_to_updated_at?; end
  end

  module GeneratedRelationMethods
    sig { returns(PrivateRelation) }
    def all; end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def and(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def annotate(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def arel_columns(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def create_with(*args, &blk); end

    sig { params(value: T::Boolean).returns(PrivateRelation) }
    def distinct(value = true); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def eager_load(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def except(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def excluding(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def extending(*args, &blk); end

    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
    def extract_associated(association); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def from(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
    def group(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def having(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def in_order_of(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def includes(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def invert_where(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def left_joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def left_outer_joins(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def limit(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def lock(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def merge(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def none(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def not_state_file_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def not_state_ok(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def not_state_removed(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def not_state_scan_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def null_relation?(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def offset(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def only(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def optimizer_hints(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def or(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def order(*args, &blk); end

    sig do
      params(
        num: T.any(Integer, String)
      ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
    end
    def page(num = nil); end

    sig do
      params(
        num: Integer
      ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods))
    end
    def per(num); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def preload(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def readonly(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def references(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def regroup(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def reorder(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def reselect(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def reverse_order(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def rewhere(*args, &blk); end

    sig { params(args: T.untyped).returns(PrivateRelation) }
    sig do
      params(
        blk: T.proc.params(record: ::Domain::Post::FaPost).returns(T::Boolean)
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    def select(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def state_file_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def state_ok(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def state_removed(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def state_scan_error(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def strict_loading(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def structurally_compatible?(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def uniq!(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def unscope(*args, &blk); end

    sig { returns(PrivateRelationWhereChain) }
    sig { params(args: T.untyped).returns(PrivateRelation) }
    def where(*args); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def with(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def with_recursive(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def with_user_post_fav(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def without(*args, &blk); end

    sig { returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) }
    def without_count; end
  end

  class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation
    include CommonRelationMethods
    include GeneratedAssociationRelationMethods

    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_a; end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_ary; end
  end

  class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
    def average(column_name); end

    sig do
      params(
        operation: Symbol,
        column_name: T.any(String, Symbol)
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def calculate(operation, column_name); end

    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
    def count(column_name = nil); end

    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
    def having(*args, &blk); end

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
    def maximum(column_name); end

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
    def minimum(column_name); end

    sig do
      params(
        column_name: T.nilable(T.any(String, Symbol)),
        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def size(column_name = nil, &block); end

    sig do
      params(
        column_name: T.nilable(T.any(String, Symbol)),
        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def sum(column_name = nil, &block); end
  end

  class PrivateAssociationRelationWhereChain
    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
    def associated(*args); end

    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
    def missing(*args); end

    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
    def not(opts, *rest); end
  end

  class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
    include CommonRelationMethods
    include GeneratedAssociationRelationMethods

    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig do
      params(
        records: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(PrivateCollectionProxy)
    end
    def <<(*records); end

    sig do
      params(
        records: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(PrivateCollectionProxy)
    end
    def append(*records); end

    sig { returns(PrivateCollectionProxy) }
    def clear; end

    sig do
      params(
        records: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(PrivateCollectionProxy)
    end
    def concat(*records); end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def load_target; end

    sig do
      params(
        records: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(PrivateCollectionProxy)
    end
    def prepend(*records); end

    sig do
      params(
        records: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(PrivateCollectionProxy)
    end
    def push(*records); end

    sig do
      params(
        other_array: T.any(::Domain::Post::FaPost, T::Enumerable[T.any(::Domain::Post::FaPost, T::Enumerable[::Domain::Post::FaPost])])
      ).returns(T::Array[::Domain::Post::FaPost])
    end
    def replace(other_array); end

    sig { returns(PrivateAssociationRelation) }
    def scope; end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def target; end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_a; end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_ary; end
  end

  class PrivateRelation < ::ActiveRecord::Relation
    include CommonRelationMethods
    include GeneratedRelationMethods

    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_a; end

    sig { returns(T::Array[::Domain::Post::FaPost]) }
    def to_ary; end
  end

  class PrivateRelationGroupChain < PrivateRelation
    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
    def average(column_name); end

    sig do
      params(
        operation: Symbol,
        column_name: T.any(String, Symbol)
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def calculate(operation, column_name); end

    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
    def count(column_name = nil); end

    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
    def having(*args, &blk); end

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
    def maximum(column_name); end

    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
    def minimum(column_name); end

    sig do
      params(
        column_name: T.nilable(T.any(String, Symbol)),
        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def size(column_name = nil, &block); end

    sig do
      params(
        column_name: T.nilable(T.any(String, Symbol)),
        block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))
      ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)])
    end
    def sum(column_name = nil, &block); end
  end

  class PrivateRelationWhereChain
    Elem = type_member { { fixed: ::Domain::Post::FaPost } }

    sig { params(args: T.untyped).returns(PrivateRelation) }
    def associated(*args); end

    sig { params(args: T.untyped).returns(PrivateRelation) }
    def missing(*args); end

    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
    def not(opts, *rest); end
  end
end