Arie/serveme

# typed: true

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

class Reservation
  include GeneratedAssociationMethods
  include GeneratedAttributeMethods
  extend CommonRelationMethods
  extend GeneratedRelationMethods

  private

  sig { returns(NilClass) }
  def to_ary; end

  module CommonRelationMethods
    sig { params(block: T.nilable(T.proc.params(record: ::Reservation).returns(T.untyped))).returns(T::Boolean) }
    def any?(&block); end

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

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def build(attributes = nil, &block); end

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

    sig { params(column_name: T.untyped).returns(T.untyped) }
    def count(column_name = nil); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def create(attributes = nil, &block); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def create!(attributes = nil, &block); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def create_or_find_by(attributes, &block); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def create_or_find_by!(attributes, &block); end

    sig { returns(T::Array[::Reservation]) }
    def destroy_all; end

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

    sig { returns(T.nilable(::Reservation)) }
    def fifth; end

    sig { returns(::Reservation) }
    def fifth!; end

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

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

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

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def find_or_create_by(attributes, &block); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def find_or_create_by!(attributes, &block); end

    sig do
      params(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def find_or_initialize_by(attributes, &block); end

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

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

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

    sig { params(limit: T.untyped).returns(T.untyped) }
    def first(limit = nil); end

    sig { returns(::Reservation) }
    def first!; end

    sig { returns(T.nilable(::Reservation)) }
    def forty_two; end

    sig { returns(::Reservation) }
    def forty_two!; end

    sig { returns(T.nilable(::Reservation)) }
    def fourth; end

    sig { returns(::Reservation) }
    def fourth!; end

    sig { returns(Array) }
    def ids; end

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

    sig { params(limit: T.untyped).returns(T.untyped) }
    def last(limit = nil); end

    sig { returns(::Reservation) }
    def last!; end

    sig { params(block: T.nilable(T.proc.params(record: ::Reservation).returns(T.untyped))).returns(T::Boolean) }
    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(
        attributes: T.untyped,
        block: T.nilable(T.proc.params(object: ::Reservation).void)
      ).returns(::Reservation)
    end
    def new(attributes = nil, &block); end

    sig { params(block: T.nilable(T.proc.params(record: ::Reservation).returns(T.untyped))).returns(T::Boolean) }
    def none?(&block); end

    sig { params(block: T.nilable(T.proc.params(record: ::Reservation).returns(T.untyped))).returns(T::Boolean) }
    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(::Reservation)) }
    def second; end

    sig { returns(::Reservation) }
    def second!; end

    sig { returns(T.nilable(::Reservation)) }
    def second_to_last; end

    sig { returns(::Reservation) }
    def second_to_last!; end

    sig { returns(::Reservation) }
    def sole; 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.untyped)
    end
    def sum(column_name = nil, &block); end

    sig { params(limit: T.untyped).returns(T.untyped) }
    def take(limit = nil); end

    sig { returns(::Reservation) }
    def take!; end

    sig { returns(T.nilable(::Reservation)) }
    def third; end

    sig { returns(::Reservation) }
    def third!; end

    sig { returns(T.nilable(::Reservation)) }
    def third_to_last; end

    sig { returns(::Reservation) }
    def third_to_last!; end
  end

  module GeneratedAssociationMethods
    sig { params(args: T.untyped, blk: T.untyped).returns(::Server) }
    def build_server(*args, &blk); end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { params(value: T::Enumerable[::LogUpload]).void }
    def log_uploads=(value); end

    sig { returns(T.nilable(::Server)) }
    def reload_server; end

    sig { returns(T.nilable(::ServerConfig)) }
    def reload_server_config; end

    sig { returns(T.nilable(::User)) }
    def reload_user; end

    sig { returns(T.nilable(::Whitelist)) }
    def reload_whitelist; end

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

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

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

    sig { params(value: T::Enumerable[::ReservationPlayer]).void }
    def reservation_players=(value); end

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

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

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

    sig { params(value: T::Enumerable[::ReservationStatus]).void }
    def reservation_statuses=(value); end

    sig { returns(T.nilable(::Server)) }
    def server; end

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

    sig { returns(T.nilable(::ServerConfig)) }
    def server_config; end

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

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

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

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

    sig { params(value: T::Enumerable[::ServerStatistic]).void }
    def server_statistics=(value); end

    sig { returns(T.nilable(::User)) }
    def user; end

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

    sig { returns(T.nilable(::Whitelist)) }
    def whitelist; end

    sig { params(value: T.nilable(::Whitelist)).void }
    def whitelist=(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 create_with(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def distinct(*args, &blk); 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(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def extract_associated(*args, &blk); 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(PrivateAssociationRelation) }
    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 do
      params(
        attributes: Hash,
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass)),
        unique_by: T.nilable(T.any(T::Array[Symbol], Symbol))
      ).returns(ActiveRecord::Result)
    end
    def insert(attributes, returning: nil, unique_by: nil); end

    sig do
      params(
        attributes: Hash,
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass))
      ).returns(ActiveRecord::Result)
    end
    def insert!(attributes, returning: nil); end

    sig do
      params(
        attributes: T::Array[Hash],
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass)),
        unique_by: T.nilable(T.any(T::Array[Symbol], Symbol))
      ).returns(ActiveRecord::Result)
    end
    def insert_all(attributes, returning: nil, unique_by: nil); end

    sig do
      params(
        attributes: T::Array[Hash],
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass))
      ).returns(ActiveRecord::Result)
    end
    def insert_all!(attributes, returning: nil); 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 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 { 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 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, blk: T.untyped).returns(PrivateAssociationRelation) }
    def select(*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 do
      params(
        attributes: Hash,
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass)),
        unique_by: T.nilable(T.any(T::Array[Symbol], Symbol))
      ).returns(ActiveRecord::Result)
    end
    def upsert(attributes, returning: nil, unique_by: nil); end

    sig do
      params(
        attributes: T::Array[Hash],
        returning: T.nilable(T.any(T::Array[Symbol], FalseClass)),
        unique_by: T.nilable(T.any(T::Array[Symbol], Symbol))
      ).returns(ActiveRecord::Result)
    end
    def upsert_all(attributes, returning: nil, unique_by: nil); end

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

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

  module GeneratedAttributeMethods
    sig { returns(T.nilable(T::Boolean)) }
    def auto_end; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def auto_end_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 { returns(T::Boolean) }
    def created_at_changed?; 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 { returns(T::Boolean) }
    def created_at_previously_changed?; 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 custom_whitelist_id; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def custom_whitelist_id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def duration_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def enable_arena_respawn_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def enable_demos_tf_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def enable_plugins_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def end_instantly_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def ended_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def ends_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def first_map_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def gameye_location_will_change!; end

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

    sig { params(value: ::Integer).returns(::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 { returns(T::Boolean) }
    def id_changed?; 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 { returns(T::Boolean) }
    def id_previously_changed?; end

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

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

    sig { void }
    def id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def inactive_minute_counter_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def last_number_of_players_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def logsecret_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def password_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def provisioned_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def rcon_will_change!; end

    sig { void }
    def restore_auto_end!; end

    sig { void }
    def restore_created_at!; end

    sig { void }
    def restore_custom_whitelist_id!; end

    sig { void }
    def restore_duration!; end

    sig { void }
    def restore_enable_arena_respawn!; end

    sig { void }
    def restore_enable_demos_tf!; end

    sig { void }
    def restore_enable_plugins!; end

    sig { void }
    def restore_end_instantly!; end

    sig { void }
    def restore_ended!; end

    sig { void }
    def restore_ends_at!; end

    sig { void }
    def restore_first_map!; end

    sig { void }
    def restore_gameye_location!; end

    sig { void }
    def restore_id!; end

    sig { void }
    def restore_inactive_minute_counter!; end

    sig { void }
    def restore_last_number_of_players!; end

    sig { void }
    def restore_logsecret!; end

    sig { void }
    def restore_password!; end

    sig { void }
    def restore_provisioned!; end

    sig { void }
    def restore_rcon!; end

    sig { void }
    def restore_sdr_ip!; end

    sig { void }
    def restore_sdr_port!; end

    sig { void }
    def restore_sdr_tv_port!; end

    sig { void }
    def restore_server_config_id!; end

    sig { void }
    def restore_server_id!; end

    sig { void }
    def restore_start_instantly!; end

    sig { void }
    def restore_starts_at!; end

    sig { void }
    def restore_tv_password!; end

    sig { void }
    def restore_tv_relaypassword!; end

    sig { void }
    def restore_updated_at!; end

    sig { void }
    def restore_user_id!; end

    sig { void }
    def restore_whitelist_id!; end

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

    sig { returns(T::Boolean) }
    def saved_change_to_auto_end?; 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_custom_whitelist_id; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { returns(T::Boolean) }
    def saved_change_to_gameye_location?; 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_inactive_minute_counter; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { returns(T::Boolean) }
    def saved_change_to_tv_relaypassword?; 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([T.nilable(::Integer), T.nilable(::Integer)])) }
    def saved_change_to_user_id; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def sdr_ip_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def sdr_port_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def sdr_tv_port_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def server_config_id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def server_id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def start_instantly_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def starts_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def tv_password_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def tv_relaypassword_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 { returns(T::Boolean) }
    def updated_at_changed?; 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 { returns(T::Boolean) }
    def updated_at_previously_changed?; 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.nilable(::Integer)) }
    def user_id; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def user_id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def whitelist_id_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { returns(T::Boolean) }
    def will_save_change_to_whitelist_id?; 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 create_with(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def distinct(*args, &blk); 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(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def extract_associated(*args, &blk); 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(PrivateRelation) }
    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 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 { 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 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, blk: T.untyped).returns(PrivateRelation) }
    def select(*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 { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationWhereChain) }
    def where(*args, &blk); end

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

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

    Elem = type_member { { fixed: ::Reservation } }

    sig { returns(T::Array[::Reservation]) }
    def to_ary; end
  end

  class PrivateAssociationRelationWhereChain < PrivateAssociationRelation
    Elem = type_member { { fixed: ::Reservation } }

    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: ::Reservation } }

    sig do
      params(
        records: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(PrivateCollectionProxy)
    end
    def <<(*records); end

    sig do
      params(
        records: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(PrivateCollectionProxy)
    end
    def append(*records); end

    sig { returns(PrivateCollectionProxy) }
    def clear; end

    sig do
      params(
        records: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(PrivateCollectionProxy)
    end
    def concat(*records); end

    sig do
      params(
        records: T.any(::Reservation, Integer, String, T::Enumerable[T.any(::Reservation, Integer, String, T::Enumerable[::Reservation])])
      ).returns(T::Array[::Reservation])
    end
    def delete(*records); end

    sig do
      params(
        records: T.any(::Reservation, Integer, String, T::Enumerable[T.any(::Reservation, Integer, String, T::Enumerable[::Reservation])])
      ).returns(T::Array[::Reservation])
    end
    def destroy(*records); end

    sig { returns(T::Array[::Reservation]) }
    def load_target; end

    sig do
      params(
        records: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(PrivateCollectionProxy)
    end
    def prepend(*records); end

    sig do
      params(
        records: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(PrivateCollectionProxy)
    end
    def push(*records); end

    sig do
      params(
        other_array: T.any(::Reservation, T::Enumerable[T.any(::Reservation, T::Enumerable[::Reservation])])
      ).returns(T::Array[::Reservation])
    end
    def replace(other_array); end

    sig { returns(PrivateAssociationRelation) }
    def scope; end

    sig { returns(T::Array[::Reservation]) }
    def target; end

    sig { returns(T::Array[::Reservation]) }
    def to_ary; end
  end

  class PrivateRelation < ::ActiveRecord::Relation
    include CommonRelationMethods
    include GeneratedRelationMethods

    Elem = type_member { { fixed: ::Reservation } }

    sig { returns(T::Array[::Reservation]) }
    def to_ary; end
  end

  class PrivateRelationWhereChain < PrivateRelation
    Elem = type_member { { fixed: ::Reservation } }

    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