Arie/serveme

# typed: true

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

class User
  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: ::User).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 { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::User).void)).returns(::User) }
    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 { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::User).void)).returns(::User) }
    def create(attributes = nil, &block); end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { returns(::User) }
    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(::User) }
    def last!; end

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

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

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

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

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

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

    sig { returns(::User) }
    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(::User) }
    def take!; end

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

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

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

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

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

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

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

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

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

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

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

    sig { params(value: T::Enumerable[::Group]).void }
    def groups=(value); 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 `User` class because it declared `has_many :log_uploads, through: :reservations`.
    # 🔗 [Rails guide for `has_many_through` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association)
    sig { returns(::LogUpload::PrivateCollectionProxy) }
    def log_uploads; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
    def reservation_ids=(ids); 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 `User` 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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { params(value: T::Enumerable[::Voucher]).void }
    def vouchers=(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 geocoded(*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 near(*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_geocoded(*args, &blk); end

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
    def not_reverse_geocoded(*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 within_bounding_box(*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(::String)) }
    def api_key; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def api_key_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(::ActiveSupport::TimeWithZone)) }
    def current_sign_in_at; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def current_sign_in_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def current_sign_in_ip_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def demos_tf_api_key_will_change!; end

    sig { returns(::String) }
    def email; end

    sig { params(value: ::String).returns(::String) }
    def email=(value); end

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def email_will_change!; end

    sig { returns(::String) }
    def encrypted_password; end

    sig { params(value: ::String).returns(::String) }
    def encrypted_password=(value); end

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def encrypted_password_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def expired_reservations_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(::ActiveSupport::TimeWithZone)) }
    def last_sign_in_at; end

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def last_sign_in_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def last_sign_in_ip_will_change!; end

    sig { returns(T.nilable(::Float)) }
    def latitude; end

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

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

    sig { returns(T.nilable(::Float)) }
    def latitude_before_last_save; end

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

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

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

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

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

    sig { returns(T.nilable(::Float)) }
    def latitude_in_database; end

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

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

    sig { returns(T.nilable(::Float)) }
    def latitude_previously_was; end

    sig { returns(T.nilable(::Float)) }
    def latitude_was; end

    sig { void }
    def latitude_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def logs_tf_api_key_will_change!; end

    sig { returns(T.nilable(::Float)) }
    def longitude; end

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

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

    sig { returns(T.nilable(::Float)) }
    def longitude_before_last_save; end

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

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

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

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

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

    sig { returns(T.nilable(::Float)) }
    def longitude_in_database; end

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

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

    sig { returns(T.nilable(::Float)) }
    def longitude_previously_was; end

    sig { returns(T.nilable(::Float)) }
    def longitude_was; end

    sig { void }
    def longitude_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def name_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def nickname_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def provider_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def remember_created_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def remember_token_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def reset_password_sent_at_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def reset_password_token_will_change!; end

    sig { void }
    def restore_api_key!; end

    sig { void }
    def restore_created_at!; end

    sig { void }
    def restore_current_sign_in_at!; end

    sig { void }
    def restore_current_sign_in_ip!; end

    sig { void }
    def restore_demos_tf_api_key!; end

    sig { void }
    def restore_email!; end

    sig { void }
    def restore_encrypted_password!; end

    sig { void }
    def restore_expired_reservations!; end

    sig { void }
    def restore_id!; end

    sig { void }
    def restore_last_sign_in_at!; end

    sig { void }
    def restore_last_sign_in_ip!; end

    sig { void }
    def restore_latitude!; end

    sig { void }
    def restore_logs_tf_api_key!; end

    sig { void }
    def restore_longitude!; end

    sig { void }
    def restore_name!; end

    sig { void }
    def restore_nickname!; end

    sig { void }
    def restore_provider!; end

    sig { void }
    def restore_remember_created_at!; end

    sig { void }
    def restore_remember_token!; end

    sig { void }
    def restore_reset_password_sent_at!; end

    sig { void }
    def restore_reset_password_token!; end

    sig { void }
    def restore_sign_in_count!; end

    sig { void }
    def restore_time_zone!; end

    sig { void }
    def restore_uid!; end

    sig { void }
    def restore_updated_at!; end

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

    sig { returns(T::Boolean) }
    def saved_change_to_api_key?; 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(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_current_sign_in_at; end

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

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

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

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

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

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

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

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

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

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

    sig { returns(T::Boolean) }
    def saved_change_to_expired_reservations?; 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(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) }
    def saved_change_to_last_sign_in_at; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def sign_in_count_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def time_zone_will_change!; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { void }
    def uid_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::Boolean) }
    def will_save_change_to_api_key?; end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
    def not_reverse_geocoded(*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 within_bounding_box(*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: ::User } }

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

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

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

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

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

    sig { returns(PrivateCollectionProxy) }
    def clear; end

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

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

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

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

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

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

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

    sig { returns(PrivateAssociationRelation) }
    def scope; end

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

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

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

    Elem = type_member { { fixed: ::User } }

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

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

    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