// Code generated by entc, DO NOT EDIT.

package player

import (
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"git.harting.dev/csgowtf/csgowtfd/ent/predicate"
)

// ID filters vertices based on their ID field.
func ID(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(ids) == 0 {
			s.Where(sql.False())
			return
		}
		v := make([]interface{}, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id uint64) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
func Name(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldName), v))
	})
}

// Avatar applies equality check predicate on the "avatar" field. It's identical to AvatarEQ.
func Avatar(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAvatar), v))
	})
}

// VanityURL applies equality check predicate on the "vanity_url" field. It's identical to VanityURLEQ.
func VanityURL(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVanityURL), v))
	})
}

// VanityURLReal applies equality check predicate on the "vanity_url_real" field. It's identical to VanityURLRealEQ.
func VanityURLReal(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVanityURLReal), v))
	})
}

// VacDate applies equality check predicate on the "vac_date" field. It's identical to VacDateEQ.
func VacDate(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVacDate), v))
	})
}

// VacCount applies equality check predicate on the "vac_count" field. It's identical to VacCountEQ.
func VacCount(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVacCount), v))
	})
}

// GameBanDate applies equality check predicate on the "game_ban_date" field. It's identical to GameBanDateEQ.
func GameBanDate(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGameBanDate), v))
	})
}

// GameBanCount applies equality check predicate on the "game_ban_count" field. It's identical to GameBanCountEQ.
func GameBanCount(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGameBanCount), v))
	})
}

// SteamUpdated applies equality check predicate on the "steam_updated" field. It's identical to SteamUpdatedEQ.
func SteamUpdated(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSteamUpdated), v))
	})
}

// SharecodeUpdated applies equality check predicate on the "sharecode_updated" field. It's identical to SharecodeUpdatedEQ.
func SharecodeUpdated(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSharecodeUpdated), v))
	})
}

// AuthCode applies equality check predicate on the "auth_code" field. It's identical to AuthCodeEQ.
func AuthCode(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAuthCode), v))
	})
}

// ProfileCreated applies equality check predicate on the "profile_created" field. It's identical to ProfileCreatedEQ.
func ProfileCreated(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldProfileCreated), v))
	})
}

// OldestSharecodeSeen applies equality check predicate on the "oldest_sharecode_seen" field. It's identical to OldestSharecodeSeenEQ.
func OldestSharecodeSeen(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOldestSharecodeSeen), v))
	})
}

// Wins applies equality check predicate on the "wins" field. It's identical to WinsEQ.
func Wins(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWins), v))
	})
}

// Looses applies equality check predicate on the "looses" field. It's identical to LoosesEQ.
func Looses(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLooses), v))
	})
}

// Ties applies equality check predicate on the "ties" field. It's identical to TiesEQ.
func Ties(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTies), v))
	})
}

// NameEQ applies the EQ predicate on the "name" field.
func NameEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldName), v))
	})
}

// NameNEQ applies the NEQ predicate on the "name" field.
func NameNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldName), v))
	})
}

// NameIn applies the In predicate on the "name" field.
func NameIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldName), v...))
	})
}

// NameNotIn applies the NotIn predicate on the "name" field.
func NameNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldName), v...))
	})
}

// NameGT applies the GT predicate on the "name" field.
func NameGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldName), v))
	})
}

// NameGTE applies the GTE predicate on the "name" field.
func NameGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldName), v))
	})
}

// NameLT applies the LT predicate on the "name" field.
func NameLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldName), v))
	})
}

// NameLTE applies the LTE predicate on the "name" field.
func NameLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldName), v))
	})
}

// NameContains applies the Contains predicate on the "name" field.
func NameContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldName), v))
	})
}

// NameHasPrefix applies the HasPrefix predicate on the "name" field.
func NameHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldName), v))
	})
}

// NameHasSuffix applies the HasSuffix predicate on the "name" field.
func NameHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldName), v))
	})
}

// NameIsNil applies the IsNil predicate on the "name" field.
func NameIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldName)))
	})
}

// NameNotNil applies the NotNil predicate on the "name" field.
func NameNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldName)))
	})
}

// NameEqualFold applies the EqualFold predicate on the "name" field.
func NameEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldName), v))
	})
}

// NameContainsFold applies the ContainsFold predicate on the "name" field.
func NameContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldName), v))
	})
}

// AvatarEQ applies the EQ predicate on the "avatar" field.
func AvatarEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAvatar), v))
	})
}

// AvatarNEQ applies the NEQ predicate on the "avatar" field.
func AvatarNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAvatar), v))
	})
}

// AvatarIn applies the In predicate on the "avatar" field.
func AvatarIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldAvatar), v...))
	})
}

// AvatarNotIn applies the NotIn predicate on the "avatar" field.
func AvatarNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldAvatar), v...))
	})
}

// AvatarGT applies the GT predicate on the "avatar" field.
func AvatarGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAvatar), v))
	})
}

// AvatarGTE applies the GTE predicate on the "avatar" field.
func AvatarGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAvatar), v))
	})
}

// AvatarLT applies the LT predicate on the "avatar" field.
func AvatarLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAvatar), v))
	})
}

// AvatarLTE applies the LTE predicate on the "avatar" field.
func AvatarLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAvatar), v))
	})
}

// AvatarContains applies the Contains predicate on the "avatar" field.
func AvatarContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldAvatar), v))
	})
}

// AvatarHasPrefix applies the HasPrefix predicate on the "avatar" field.
func AvatarHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldAvatar), v))
	})
}

// AvatarHasSuffix applies the HasSuffix predicate on the "avatar" field.
func AvatarHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldAvatar), v))
	})
}

// AvatarIsNil applies the IsNil predicate on the "avatar" field.
func AvatarIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldAvatar)))
	})
}

// AvatarNotNil applies the NotNil predicate on the "avatar" field.
func AvatarNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldAvatar)))
	})
}

// AvatarEqualFold applies the EqualFold predicate on the "avatar" field.
func AvatarEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldAvatar), v))
	})
}

// AvatarContainsFold applies the ContainsFold predicate on the "avatar" field.
func AvatarContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldAvatar), v))
	})
}

// VanityURLEQ applies the EQ predicate on the "vanity_url" field.
func VanityURLEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVanityURL), v))
	})
}

// VanityURLNEQ applies the NEQ predicate on the "vanity_url" field.
func VanityURLNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldVanityURL), v))
	})
}

// VanityURLIn applies the In predicate on the "vanity_url" field.
func VanityURLIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldVanityURL), v...))
	})
}

// VanityURLNotIn applies the NotIn predicate on the "vanity_url" field.
func VanityURLNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldVanityURL), v...))
	})
}

// VanityURLGT applies the GT predicate on the "vanity_url" field.
func VanityURLGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldVanityURL), v))
	})
}

// VanityURLGTE applies the GTE predicate on the "vanity_url" field.
func VanityURLGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldVanityURL), v))
	})
}

// VanityURLLT applies the LT predicate on the "vanity_url" field.
func VanityURLLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldVanityURL), v))
	})
}

// VanityURLLTE applies the LTE predicate on the "vanity_url" field.
func VanityURLLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldVanityURL), v))
	})
}

// VanityURLContains applies the Contains predicate on the "vanity_url" field.
func VanityURLContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldVanityURL), v))
	})
}

// VanityURLHasPrefix applies the HasPrefix predicate on the "vanity_url" field.
func VanityURLHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldVanityURL), v))
	})
}

// VanityURLHasSuffix applies the HasSuffix predicate on the "vanity_url" field.
func VanityURLHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldVanityURL), v))
	})
}

// VanityURLIsNil applies the IsNil predicate on the "vanity_url" field.
func VanityURLIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldVanityURL)))
	})
}

// VanityURLNotNil applies the NotNil predicate on the "vanity_url" field.
func VanityURLNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldVanityURL)))
	})
}

// VanityURLEqualFold applies the EqualFold predicate on the "vanity_url" field.
func VanityURLEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldVanityURL), v))
	})
}

// VanityURLContainsFold applies the ContainsFold predicate on the "vanity_url" field.
func VanityURLContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldVanityURL), v))
	})
}

// VanityURLRealEQ applies the EQ predicate on the "vanity_url_real" field.
func VanityURLRealEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealNEQ applies the NEQ predicate on the "vanity_url_real" field.
func VanityURLRealNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealIn applies the In predicate on the "vanity_url_real" field.
func VanityURLRealIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldVanityURLReal), v...))
	})
}

// VanityURLRealNotIn applies the NotIn predicate on the "vanity_url_real" field.
func VanityURLRealNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldVanityURLReal), v...))
	})
}

// VanityURLRealGT applies the GT predicate on the "vanity_url_real" field.
func VanityURLRealGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealGTE applies the GTE predicate on the "vanity_url_real" field.
func VanityURLRealGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealLT applies the LT predicate on the "vanity_url_real" field.
func VanityURLRealLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealLTE applies the LTE predicate on the "vanity_url_real" field.
func VanityURLRealLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealContains applies the Contains predicate on the "vanity_url_real" field.
func VanityURLRealContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealHasPrefix applies the HasPrefix predicate on the "vanity_url_real" field.
func VanityURLRealHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealHasSuffix applies the HasSuffix predicate on the "vanity_url_real" field.
func VanityURLRealHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealIsNil applies the IsNil predicate on the "vanity_url_real" field.
func VanityURLRealIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldVanityURLReal)))
	})
}

// VanityURLRealNotNil applies the NotNil predicate on the "vanity_url_real" field.
func VanityURLRealNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldVanityURLReal)))
	})
}

// VanityURLRealEqualFold applies the EqualFold predicate on the "vanity_url_real" field.
func VanityURLRealEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldVanityURLReal), v))
	})
}

// VanityURLRealContainsFold applies the ContainsFold predicate on the "vanity_url_real" field.
func VanityURLRealContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldVanityURLReal), v))
	})
}

// VacDateEQ applies the EQ predicate on the "vac_date" field.
func VacDateEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVacDate), v))
	})
}

// VacDateNEQ applies the NEQ predicate on the "vac_date" field.
func VacDateNEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldVacDate), v))
	})
}

// VacDateIn applies the In predicate on the "vac_date" field.
func VacDateIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldVacDate), v...))
	})
}

// VacDateNotIn applies the NotIn predicate on the "vac_date" field.
func VacDateNotIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldVacDate), v...))
	})
}

// VacDateGT applies the GT predicate on the "vac_date" field.
func VacDateGT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldVacDate), v))
	})
}

// VacDateGTE applies the GTE predicate on the "vac_date" field.
func VacDateGTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldVacDate), v))
	})
}

// VacDateLT applies the LT predicate on the "vac_date" field.
func VacDateLT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldVacDate), v))
	})
}

// VacDateLTE applies the LTE predicate on the "vac_date" field.
func VacDateLTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldVacDate), v))
	})
}

// VacDateIsNil applies the IsNil predicate on the "vac_date" field.
func VacDateIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldVacDate)))
	})
}

// VacDateNotNil applies the NotNil predicate on the "vac_date" field.
func VacDateNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldVacDate)))
	})
}

// VacCountEQ applies the EQ predicate on the "vac_count" field.
func VacCountEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldVacCount), v))
	})
}

// VacCountNEQ applies the NEQ predicate on the "vac_count" field.
func VacCountNEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldVacCount), v))
	})
}

// VacCountIn applies the In predicate on the "vac_count" field.
func VacCountIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldVacCount), v...))
	})
}

// VacCountNotIn applies the NotIn predicate on the "vac_count" field.
func VacCountNotIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldVacCount), v...))
	})
}

// VacCountGT applies the GT predicate on the "vac_count" field.
func VacCountGT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldVacCount), v))
	})
}

// VacCountGTE applies the GTE predicate on the "vac_count" field.
func VacCountGTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldVacCount), v))
	})
}

// VacCountLT applies the LT predicate on the "vac_count" field.
func VacCountLT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldVacCount), v))
	})
}

// VacCountLTE applies the LTE predicate on the "vac_count" field.
func VacCountLTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldVacCount), v))
	})
}

// VacCountIsNil applies the IsNil predicate on the "vac_count" field.
func VacCountIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldVacCount)))
	})
}

// VacCountNotNil applies the NotNil predicate on the "vac_count" field.
func VacCountNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldVacCount)))
	})
}

// GameBanDateEQ applies the EQ predicate on the "game_ban_date" field.
func GameBanDateEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateNEQ applies the NEQ predicate on the "game_ban_date" field.
func GameBanDateNEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateIn applies the In predicate on the "game_ban_date" field.
func GameBanDateIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldGameBanDate), v...))
	})
}

// GameBanDateNotIn applies the NotIn predicate on the "game_ban_date" field.
func GameBanDateNotIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldGameBanDate), v...))
	})
}

// GameBanDateGT applies the GT predicate on the "game_ban_date" field.
func GameBanDateGT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateGTE applies the GTE predicate on the "game_ban_date" field.
func GameBanDateGTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateLT applies the LT predicate on the "game_ban_date" field.
func GameBanDateLT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateLTE applies the LTE predicate on the "game_ban_date" field.
func GameBanDateLTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldGameBanDate), v))
	})
}

// GameBanDateIsNil applies the IsNil predicate on the "game_ban_date" field.
func GameBanDateIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldGameBanDate)))
	})
}

// GameBanDateNotNil applies the NotNil predicate on the "game_ban_date" field.
func GameBanDateNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldGameBanDate)))
	})
}

// GameBanCountEQ applies the EQ predicate on the "game_ban_count" field.
func GameBanCountEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountNEQ applies the NEQ predicate on the "game_ban_count" field.
func GameBanCountNEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountIn applies the In predicate on the "game_ban_count" field.
func GameBanCountIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldGameBanCount), v...))
	})
}

// GameBanCountNotIn applies the NotIn predicate on the "game_ban_count" field.
func GameBanCountNotIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldGameBanCount), v...))
	})
}

// GameBanCountGT applies the GT predicate on the "game_ban_count" field.
func GameBanCountGT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountGTE applies the GTE predicate on the "game_ban_count" field.
func GameBanCountGTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountLT applies the LT predicate on the "game_ban_count" field.
func GameBanCountLT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountLTE applies the LTE predicate on the "game_ban_count" field.
func GameBanCountLTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldGameBanCount), v))
	})
}

// GameBanCountIsNil applies the IsNil predicate on the "game_ban_count" field.
func GameBanCountIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldGameBanCount)))
	})
}

// GameBanCountNotNil applies the NotNil predicate on the "game_ban_count" field.
func GameBanCountNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldGameBanCount)))
	})
}

// SteamUpdatedEQ applies the EQ predicate on the "steam_updated" field.
func SteamUpdatedEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSteamUpdated), v))
	})
}

// SteamUpdatedNEQ applies the NEQ predicate on the "steam_updated" field.
func SteamUpdatedNEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSteamUpdated), v))
	})
}

// SteamUpdatedIn applies the In predicate on the "steam_updated" field.
func SteamUpdatedIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldSteamUpdated), v...))
	})
}

// SteamUpdatedNotIn applies the NotIn predicate on the "steam_updated" field.
func SteamUpdatedNotIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldSteamUpdated), v...))
	})
}

// SteamUpdatedGT applies the GT predicate on the "steam_updated" field.
func SteamUpdatedGT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSteamUpdated), v))
	})
}

// SteamUpdatedGTE applies the GTE predicate on the "steam_updated" field.
func SteamUpdatedGTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSteamUpdated), v))
	})
}

// SteamUpdatedLT applies the LT predicate on the "steam_updated" field.
func SteamUpdatedLT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSteamUpdated), v))
	})
}

// SteamUpdatedLTE applies the LTE predicate on the "steam_updated" field.
func SteamUpdatedLTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSteamUpdated), v))
	})
}

// SharecodeUpdatedEQ applies the EQ predicate on the "sharecode_updated" field.
func SharecodeUpdatedEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedNEQ applies the NEQ predicate on the "sharecode_updated" field.
func SharecodeUpdatedNEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedIn applies the In predicate on the "sharecode_updated" field.
func SharecodeUpdatedIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldSharecodeUpdated), v...))
	})
}

// SharecodeUpdatedNotIn applies the NotIn predicate on the "sharecode_updated" field.
func SharecodeUpdatedNotIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldSharecodeUpdated), v...))
	})
}

// SharecodeUpdatedGT applies the GT predicate on the "sharecode_updated" field.
func SharecodeUpdatedGT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedGTE applies the GTE predicate on the "sharecode_updated" field.
func SharecodeUpdatedGTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedLT applies the LT predicate on the "sharecode_updated" field.
func SharecodeUpdatedLT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedLTE applies the LTE predicate on the "sharecode_updated" field.
func SharecodeUpdatedLTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSharecodeUpdated), v))
	})
}

// SharecodeUpdatedIsNil applies the IsNil predicate on the "sharecode_updated" field.
func SharecodeUpdatedIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldSharecodeUpdated)))
	})
}

// SharecodeUpdatedNotNil applies the NotNil predicate on the "sharecode_updated" field.
func SharecodeUpdatedNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldSharecodeUpdated)))
	})
}

// AuthCodeEQ applies the EQ predicate on the "auth_code" field.
func AuthCodeEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAuthCode), v))
	})
}

// AuthCodeNEQ applies the NEQ predicate on the "auth_code" field.
func AuthCodeNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAuthCode), v))
	})
}

// AuthCodeIn applies the In predicate on the "auth_code" field.
func AuthCodeIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldAuthCode), v...))
	})
}

// AuthCodeNotIn applies the NotIn predicate on the "auth_code" field.
func AuthCodeNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldAuthCode), v...))
	})
}

// AuthCodeGT applies the GT predicate on the "auth_code" field.
func AuthCodeGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAuthCode), v))
	})
}

// AuthCodeGTE applies the GTE predicate on the "auth_code" field.
func AuthCodeGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAuthCode), v))
	})
}

// AuthCodeLT applies the LT predicate on the "auth_code" field.
func AuthCodeLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAuthCode), v))
	})
}

// AuthCodeLTE applies the LTE predicate on the "auth_code" field.
func AuthCodeLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAuthCode), v))
	})
}

// AuthCodeContains applies the Contains predicate on the "auth_code" field.
func AuthCodeContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldAuthCode), v))
	})
}

// AuthCodeHasPrefix applies the HasPrefix predicate on the "auth_code" field.
func AuthCodeHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldAuthCode), v))
	})
}

// AuthCodeHasSuffix applies the HasSuffix predicate on the "auth_code" field.
func AuthCodeHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldAuthCode), v))
	})
}

// AuthCodeIsNil applies the IsNil predicate on the "auth_code" field.
func AuthCodeIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldAuthCode)))
	})
}

// AuthCodeNotNil applies the NotNil predicate on the "auth_code" field.
func AuthCodeNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldAuthCode)))
	})
}

// AuthCodeEqualFold applies the EqualFold predicate on the "auth_code" field.
func AuthCodeEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldAuthCode), v))
	})
}

// AuthCodeContainsFold applies the ContainsFold predicate on the "auth_code" field.
func AuthCodeContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldAuthCode), v))
	})
}

// ProfileCreatedEQ applies the EQ predicate on the "profile_created" field.
func ProfileCreatedEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedNEQ applies the NEQ predicate on the "profile_created" field.
func ProfileCreatedNEQ(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedIn applies the In predicate on the "profile_created" field.
func ProfileCreatedIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldProfileCreated), v...))
	})
}

// ProfileCreatedNotIn applies the NotIn predicate on the "profile_created" field.
func ProfileCreatedNotIn(vs ...time.Time) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldProfileCreated), v...))
	})
}

// ProfileCreatedGT applies the GT predicate on the "profile_created" field.
func ProfileCreatedGT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedGTE applies the GTE predicate on the "profile_created" field.
func ProfileCreatedGTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedLT applies the LT predicate on the "profile_created" field.
func ProfileCreatedLT(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedLTE applies the LTE predicate on the "profile_created" field.
func ProfileCreatedLTE(v time.Time) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldProfileCreated), v))
	})
}

// ProfileCreatedIsNil applies the IsNil predicate on the "profile_created" field.
func ProfileCreatedIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldProfileCreated)))
	})
}

// ProfileCreatedNotNil applies the NotNil predicate on the "profile_created" field.
func ProfileCreatedNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldProfileCreated)))
	})
}

// OldestSharecodeSeenEQ applies the EQ predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenNEQ applies the NEQ predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenNEQ(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenIn applies the In predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldOldestSharecodeSeen), v...))
	})
}

// OldestSharecodeSeenNotIn applies the NotIn predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenNotIn(vs ...string) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldOldestSharecodeSeen), v...))
	})
}

// OldestSharecodeSeenGT applies the GT predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenGT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenGTE applies the GTE predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenGTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenLT applies the LT predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenLT(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenLTE applies the LTE predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenLTE(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenContains applies the Contains predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenContains(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenHasPrefix applies the HasPrefix predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenHasPrefix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenHasSuffix applies the HasSuffix predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenHasSuffix(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenIsNil applies the IsNil predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldOldestSharecodeSeen)))
	})
}

// OldestSharecodeSeenNotNil applies the NotNil predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldOldestSharecodeSeen)))
	})
}

// OldestSharecodeSeenEqualFold applies the EqualFold predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenEqualFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldOldestSharecodeSeen), v))
	})
}

// OldestSharecodeSeenContainsFold applies the ContainsFold predicate on the "oldest_sharecode_seen" field.
func OldestSharecodeSeenContainsFold(v string) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldOldestSharecodeSeen), v))
	})
}

// WinsEQ applies the EQ predicate on the "wins" field.
func WinsEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWins), v))
	})
}

// WinsNEQ applies the NEQ predicate on the "wins" field.
func WinsNEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldWins), v))
	})
}

// WinsIn applies the In predicate on the "wins" field.
func WinsIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldWins), v...))
	})
}

// WinsNotIn applies the NotIn predicate on the "wins" field.
func WinsNotIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldWins), v...))
	})
}

// WinsGT applies the GT predicate on the "wins" field.
func WinsGT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldWins), v))
	})
}

// WinsGTE applies the GTE predicate on the "wins" field.
func WinsGTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldWins), v))
	})
}

// WinsLT applies the LT predicate on the "wins" field.
func WinsLT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldWins), v))
	})
}

// WinsLTE applies the LTE predicate on the "wins" field.
func WinsLTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldWins), v))
	})
}

// WinsIsNil applies the IsNil predicate on the "wins" field.
func WinsIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldWins)))
	})
}

// WinsNotNil applies the NotNil predicate on the "wins" field.
func WinsNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldWins)))
	})
}

// LoosesEQ applies the EQ predicate on the "looses" field.
func LoosesEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLooses), v))
	})
}

// LoosesNEQ applies the NEQ predicate on the "looses" field.
func LoosesNEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldLooses), v))
	})
}

// LoosesIn applies the In predicate on the "looses" field.
func LoosesIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldLooses), v...))
	})
}

// LoosesNotIn applies the NotIn predicate on the "looses" field.
func LoosesNotIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldLooses), v...))
	})
}

// LoosesGT applies the GT predicate on the "looses" field.
func LoosesGT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldLooses), v))
	})
}

// LoosesGTE applies the GTE predicate on the "looses" field.
func LoosesGTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldLooses), v))
	})
}

// LoosesLT applies the LT predicate on the "looses" field.
func LoosesLT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldLooses), v))
	})
}

// LoosesLTE applies the LTE predicate on the "looses" field.
func LoosesLTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldLooses), v))
	})
}

// LoosesIsNil applies the IsNil predicate on the "looses" field.
func LoosesIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldLooses)))
	})
}

// LoosesNotNil applies the NotNil predicate on the "looses" field.
func LoosesNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldLooses)))
	})
}

// TiesEQ applies the EQ predicate on the "ties" field.
func TiesEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTies), v))
	})
}

// TiesNEQ applies the NEQ predicate on the "ties" field.
func TiesNEQ(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTies), v))
	})
}

// TiesIn applies the In predicate on the "ties" field.
func TiesIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.In(s.C(FieldTies), v...))
	})
}

// TiesNotIn applies the NotIn predicate on the "ties" field.
func TiesNotIn(vs ...int) predicate.Player {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Player(func(s *sql.Selector) {
		// if not arguments were provided, append the FALSE constants,
		// since we can't apply "IN ()". This will make this predicate falsy.
		if len(v) == 0 {
			s.Where(sql.False())
			return
		}
		s.Where(sql.NotIn(s.C(FieldTies), v...))
	})
}

// TiesGT applies the GT predicate on the "ties" field.
func TiesGT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldTies), v))
	})
}

// TiesGTE applies the GTE predicate on the "ties" field.
func TiesGTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldTies), v))
	})
}

// TiesLT applies the LT predicate on the "ties" field.
func TiesLT(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldTies), v))
	})
}

// TiesLTE applies the LTE predicate on the "ties" field.
func TiesLTE(v int) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldTies), v))
	})
}

// TiesIsNil applies the IsNil predicate on the "ties" field.
func TiesIsNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.IsNull(s.C(FieldTies)))
	})
}

// TiesNotNil applies the NotNil predicate on the "ties" field.
func TiesNotNil() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s.Where(sql.NotNull(s.C(FieldTies)))
	})
}

// HasStats applies the HasEdge predicate on the "stats" edge.
func HasStats() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(StatsTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, StatsTable, StatsColumn),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasStatsWith applies the HasEdge predicate on the "stats" edge with a given conditions (other predicates).
func HasStatsWith(preds ...predicate.MatchPlayer) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(StatsInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.O2M, false, StatsTable, StatsColumn),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// HasMatches applies the HasEdge predicate on the "matches" edge.
func HasMatches() predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MatchesTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, MatchesTable, MatchesPrimaryKey...),
		)
		sqlgraph.HasNeighbors(s, step)
	})
}

// HasMatchesWith applies the HasEdge predicate on the "matches" edge with a given conditions (other predicates).
func HasMatchesWith(preds ...predicate.Match) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		step := sqlgraph.NewStep(
			sqlgraph.From(Table, FieldID),
			sqlgraph.To(MatchesInverseTable, FieldID),
			sqlgraph.Edge(sqlgraph.M2M, false, MatchesTable, MatchesPrimaryKey...),
		)
		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
			for _, p := range preds {
				p(s)
			}
		})
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Player) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Player) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Not applies the not operator on the given predicate.
func Not(p predicate.Player) predicate.Player {
	return predicate.Player(func(s *sql.Selector) {
		p(s.Not())
	})
}