// Code generated by ent, DO NOT EDIT.

package settings

import (
	"entgo.io/ent/dialect/sql"
	"github.com/FrankenBotDev/FrankenAPI/ent/predicate"
)

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

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

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

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		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 ...int) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		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 int) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

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

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

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

// Serverid applies equality check predicate on the "serverid" field. It's identical to ServeridEQ.
func Serverid(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldServerid), v))
	})
}

// Servername applies equality check predicate on the "servername" field. It's identical to ServernameEQ.
func Servername(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldServername), v))
	})
}

// Ownerid applies equality check predicate on the "ownerid" field. It's identical to OwneridEQ.
func Ownerid(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOwnerid), v))
	})
}

// Permtoken applies equality check predicate on the "permtoken" field. It's identical to PermtokenEQ.
func Permtoken(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPermtoken), v))
	})
}

// Apitoken applies equality check predicate on the "apitoken" field. It's identical to ApitokenEQ.
func Apitoken(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldApitoken), v))
	})
}

// Statspagemode applies equality check predicate on the "statspagemode" field. It's identical to StatspagemodeEQ.
func Statspagemode(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatspagemode), v))
	})
}

// Loggerchannel applies equality check predicate on the "loggerchannel" field. It's identical to LoggerchannelEQ.
func Loggerchannel(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLoggerchannel), v))
	})
}

// Spamchannel applies equality check predicate on the "spamchannel" field. It's identical to SpamchannelEQ.
func Spamchannel(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSpamchannel), v))
	})
}

// Greeterchannel applies equality check predicate on the "greeterchannel" field. It's identical to GreeterchannelEQ.
func Greeterchannel(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreeterchannel), v))
	})
}

// Greetermode applies equality check predicate on the "greetermode" field. It's identical to GreetermodeEQ.
func Greetermode(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreetermode), v))
	})
}

// Announcechannel applies equality check predicate on the "announcechannel" field. It's identical to AnnouncechannelEQ.
func Announcechannel(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAnnouncechannel), v))
	})
}

// Logger applies equality check predicate on the "logger" field. It's identical to LoggerEQ.
func Logger(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLogger), v))
	})
}

// Spamprotection applies equality check predicate on the "spamprotection" field. It's identical to SpamprotectionEQ.
func Spamprotection(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSpamprotection), v))
	})
}

// Linkprotection applies equality check predicate on the "linkprotection" field. It's identical to LinkprotectionEQ.
func Linkprotection(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLinkprotection), v))
	})
}

// Wordfilter applies equality check predicate on the "wordfilter" field. It's identical to WordfilterEQ.
func Wordfilter(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWordfilter), v))
	})
}

// Greetings applies equality check predicate on the "greetings" field. It's identical to GreetingsEQ.
func Greetings(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreetings), v))
	})
}

// Apitoggle applies equality check predicate on the "apitoggle" field. It's identical to ApitoggleEQ.
func Apitoggle(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldApitoggle), v))
	})
}

// Moderation applies equality check predicate on the "moderation" field. It's identical to ModerationEQ.
func Moderation(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldModeration), v))
	})
}

// Automatedmoderation applies equality check predicate on the "automatedmoderation" field. It's identical to AutomatedmoderationEQ.
func Automatedmoderation(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAutomatedmoderation), v))
	})
}

// Twitchannounce applies equality check predicate on the "twitchannounce" field. It's identical to TwitchannounceEQ.
func Twitchannounce(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTwitchannounce), v))
	})
}

// Twitterannounce applies equality check predicate on the "twitterannounce" field. It's identical to TwitterannounceEQ.
func Twitterannounce(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTwitterannounce), v))
	})
}

// Music applies equality check predicate on the "music" field. It's identical to MusicEQ.
func Music(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMusic), v))
	})
}

// Statspage applies equality check predicate on the "statspage" field. It's identical to StatspageEQ.
func Statspage(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatspage), v))
	})
}

// Statsprivate applies equality check predicate on the "statsprivate" field. It's identical to StatsprivateEQ.
func Statsprivate(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatsprivate), v))
	})
}

// Stats applies equality check predicate on the "stats" field. It's identical to StatsEQ.
func Stats(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStats), v))
	})
}

// ServeridEQ applies the EQ predicate on the "serverid" field.
func ServeridEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldServerid), v))
	})
}

// ServeridNEQ applies the NEQ predicate on the "serverid" field.
func ServeridNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldServerid), v))
	})
}

// ServeridIn applies the In predicate on the "serverid" field.
func ServeridIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldServerid), v...))
	})
}

// ServeridNotIn applies the NotIn predicate on the "serverid" field.
func ServeridNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldServerid), v...))
	})
}

// ServeridGT applies the GT predicate on the "serverid" field.
func ServeridGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldServerid), v))
	})
}

// ServeridGTE applies the GTE predicate on the "serverid" field.
func ServeridGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldServerid), v))
	})
}

// ServeridLT applies the LT predicate on the "serverid" field.
func ServeridLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldServerid), v))
	})
}

// ServeridLTE applies the LTE predicate on the "serverid" field.
func ServeridLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldServerid), v))
	})
}

// ServeridContains applies the Contains predicate on the "serverid" field.
func ServeridContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldServerid), v))
	})
}

// ServeridHasPrefix applies the HasPrefix predicate on the "serverid" field.
func ServeridHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldServerid), v))
	})
}

// ServeridHasSuffix applies the HasSuffix predicate on the "serverid" field.
func ServeridHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldServerid), v))
	})
}

// ServeridEqualFold applies the EqualFold predicate on the "serverid" field.
func ServeridEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldServerid), v))
	})
}

// ServeridContainsFold applies the ContainsFold predicate on the "serverid" field.
func ServeridContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldServerid), v))
	})
}

// ServernameEQ applies the EQ predicate on the "servername" field.
func ServernameEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldServername), v))
	})
}

// ServernameNEQ applies the NEQ predicate on the "servername" field.
func ServernameNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldServername), v))
	})
}

// ServernameIn applies the In predicate on the "servername" field.
func ServernameIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldServername), v...))
	})
}

// ServernameNotIn applies the NotIn predicate on the "servername" field.
func ServernameNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldServername), v...))
	})
}

// ServernameGT applies the GT predicate on the "servername" field.
func ServernameGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldServername), v))
	})
}

// ServernameGTE applies the GTE predicate on the "servername" field.
func ServernameGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldServername), v))
	})
}

// ServernameLT applies the LT predicate on the "servername" field.
func ServernameLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldServername), v))
	})
}

// ServernameLTE applies the LTE predicate on the "servername" field.
func ServernameLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldServername), v))
	})
}

// ServernameContains applies the Contains predicate on the "servername" field.
func ServernameContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldServername), v))
	})
}

// ServernameHasPrefix applies the HasPrefix predicate on the "servername" field.
func ServernameHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldServername), v))
	})
}

// ServernameHasSuffix applies the HasSuffix predicate on the "servername" field.
func ServernameHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldServername), v))
	})
}

// ServernameEqualFold applies the EqualFold predicate on the "servername" field.
func ServernameEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldServername), v))
	})
}

// ServernameContainsFold applies the ContainsFold predicate on the "servername" field.
func ServernameContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldServername), v))
	})
}

// OwneridEQ applies the EQ predicate on the "ownerid" field.
func OwneridEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOwnerid), v))
	})
}

// OwneridNEQ applies the NEQ predicate on the "ownerid" field.
func OwneridNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldOwnerid), v))
	})
}

// OwneridIn applies the In predicate on the "ownerid" field.
func OwneridIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldOwnerid), v...))
	})
}

// OwneridNotIn applies the NotIn predicate on the "ownerid" field.
func OwneridNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldOwnerid), v...))
	})
}

// OwneridGT applies the GT predicate on the "ownerid" field.
func OwneridGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldOwnerid), v))
	})
}

// OwneridGTE applies the GTE predicate on the "ownerid" field.
func OwneridGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldOwnerid), v))
	})
}

// OwneridLT applies the LT predicate on the "ownerid" field.
func OwneridLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldOwnerid), v))
	})
}

// OwneridLTE applies the LTE predicate on the "ownerid" field.
func OwneridLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldOwnerid), v))
	})
}

// OwneridContains applies the Contains predicate on the "ownerid" field.
func OwneridContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldOwnerid), v))
	})
}

// OwneridHasPrefix applies the HasPrefix predicate on the "ownerid" field.
func OwneridHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldOwnerid), v))
	})
}

// OwneridHasSuffix applies the HasSuffix predicate on the "ownerid" field.
func OwneridHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldOwnerid), v))
	})
}

// OwneridEqualFold applies the EqualFold predicate on the "ownerid" field.
func OwneridEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldOwnerid), v))
	})
}

// OwneridContainsFold applies the ContainsFold predicate on the "ownerid" field.
func OwneridContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldOwnerid), v))
	})
}

// PermtokenEQ applies the EQ predicate on the "permtoken" field.
func PermtokenEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPermtoken), v))
	})
}

// PermtokenNEQ applies the NEQ predicate on the "permtoken" field.
func PermtokenNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPermtoken), v))
	})
}

// PermtokenIn applies the In predicate on the "permtoken" field.
func PermtokenIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldPermtoken), v...))
	})
}

// PermtokenNotIn applies the NotIn predicate on the "permtoken" field.
func PermtokenNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldPermtoken), v...))
	})
}

// PermtokenGT applies the GT predicate on the "permtoken" field.
func PermtokenGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldPermtoken), v))
	})
}

// PermtokenGTE applies the GTE predicate on the "permtoken" field.
func PermtokenGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldPermtoken), v))
	})
}

// PermtokenLT applies the LT predicate on the "permtoken" field.
func PermtokenLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldPermtoken), v))
	})
}

// PermtokenLTE applies the LTE predicate on the "permtoken" field.
func PermtokenLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldPermtoken), v))
	})
}

// PermtokenContains applies the Contains predicate on the "permtoken" field.
func PermtokenContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldPermtoken), v))
	})
}

// PermtokenHasPrefix applies the HasPrefix predicate on the "permtoken" field.
func PermtokenHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldPermtoken), v))
	})
}

// PermtokenHasSuffix applies the HasSuffix predicate on the "permtoken" field.
func PermtokenHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldPermtoken), v))
	})
}

// PermtokenEqualFold applies the EqualFold predicate on the "permtoken" field.
func PermtokenEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldPermtoken), v))
	})
}

// PermtokenContainsFold applies the ContainsFold predicate on the "permtoken" field.
func PermtokenContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldPermtoken), v))
	})
}

// ApitokenEQ applies the EQ predicate on the "apitoken" field.
func ApitokenEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldApitoken), v))
	})
}

// ApitokenNEQ applies the NEQ predicate on the "apitoken" field.
func ApitokenNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldApitoken), v))
	})
}

// ApitokenIn applies the In predicate on the "apitoken" field.
func ApitokenIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldApitoken), v...))
	})
}

// ApitokenNotIn applies the NotIn predicate on the "apitoken" field.
func ApitokenNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldApitoken), v...))
	})
}

// ApitokenGT applies the GT predicate on the "apitoken" field.
func ApitokenGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldApitoken), v))
	})
}

// ApitokenGTE applies the GTE predicate on the "apitoken" field.
func ApitokenGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldApitoken), v))
	})
}

// ApitokenLT applies the LT predicate on the "apitoken" field.
func ApitokenLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldApitoken), v))
	})
}

// ApitokenLTE applies the LTE predicate on the "apitoken" field.
func ApitokenLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldApitoken), v))
	})
}

// ApitokenContains applies the Contains predicate on the "apitoken" field.
func ApitokenContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldApitoken), v))
	})
}

// ApitokenHasPrefix applies the HasPrefix predicate on the "apitoken" field.
func ApitokenHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldApitoken), v))
	})
}

// ApitokenHasSuffix applies the HasSuffix predicate on the "apitoken" field.
func ApitokenHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldApitoken), v))
	})
}

// ApitokenEqualFold applies the EqualFold predicate on the "apitoken" field.
func ApitokenEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldApitoken), v))
	})
}

// ApitokenContainsFold applies the ContainsFold predicate on the "apitoken" field.
func ApitokenContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldApitoken), v))
	})
}

// StatspagemodeEQ applies the EQ predicate on the "statspagemode" field.
func StatspagemodeEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeNEQ applies the NEQ predicate on the "statspagemode" field.
func StatspagemodeNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeIn applies the In predicate on the "statspagemode" field.
func StatspagemodeIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldStatspagemode), v...))
	})
}

// StatspagemodeNotIn applies the NotIn predicate on the "statspagemode" field.
func StatspagemodeNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldStatspagemode), v...))
	})
}

// StatspagemodeGT applies the GT predicate on the "statspagemode" field.
func StatspagemodeGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeGTE applies the GTE predicate on the "statspagemode" field.
func StatspagemodeGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeLT applies the LT predicate on the "statspagemode" field.
func StatspagemodeLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeLTE applies the LTE predicate on the "statspagemode" field.
func StatspagemodeLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeContains applies the Contains predicate on the "statspagemode" field.
func StatspagemodeContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeHasPrefix applies the HasPrefix predicate on the "statspagemode" field.
func StatspagemodeHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeHasSuffix applies the HasSuffix predicate on the "statspagemode" field.
func StatspagemodeHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeEqualFold applies the EqualFold predicate on the "statspagemode" field.
func StatspagemodeEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldStatspagemode), v))
	})
}

// StatspagemodeContainsFold applies the ContainsFold predicate on the "statspagemode" field.
func StatspagemodeContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldStatspagemode), v))
	})
}

// LoggerchannelEQ applies the EQ predicate on the "loggerchannel" field.
func LoggerchannelEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelNEQ applies the NEQ predicate on the "loggerchannel" field.
func LoggerchannelNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelIn applies the In predicate on the "loggerchannel" field.
func LoggerchannelIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldLoggerchannel), v...))
	})
}

// LoggerchannelNotIn applies the NotIn predicate on the "loggerchannel" field.
func LoggerchannelNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldLoggerchannel), v...))
	})
}

// LoggerchannelGT applies the GT predicate on the "loggerchannel" field.
func LoggerchannelGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelGTE applies the GTE predicate on the "loggerchannel" field.
func LoggerchannelGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelLT applies the LT predicate on the "loggerchannel" field.
func LoggerchannelLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelLTE applies the LTE predicate on the "loggerchannel" field.
func LoggerchannelLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelContains applies the Contains predicate on the "loggerchannel" field.
func LoggerchannelContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelHasPrefix applies the HasPrefix predicate on the "loggerchannel" field.
func LoggerchannelHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelHasSuffix applies the HasSuffix predicate on the "loggerchannel" field.
func LoggerchannelHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelEqualFold applies the EqualFold predicate on the "loggerchannel" field.
func LoggerchannelEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldLoggerchannel), v))
	})
}

// LoggerchannelContainsFold applies the ContainsFold predicate on the "loggerchannel" field.
func LoggerchannelContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldLoggerchannel), v))
	})
}

// SpamchannelEQ applies the EQ predicate on the "spamchannel" field.
func SpamchannelEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelNEQ applies the NEQ predicate on the "spamchannel" field.
func SpamchannelNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelIn applies the In predicate on the "spamchannel" field.
func SpamchannelIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldSpamchannel), v...))
	})
}

// SpamchannelNotIn applies the NotIn predicate on the "spamchannel" field.
func SpamchannelNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldSpamchannel), v...))
	})
}

// SpamchannelGT applies the GT predicate on the "spamchannel" field.
func SpamchannelGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelGTE applies the GTE predicate on the "spamchannel" field.
func SpamchannelGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelLT applies the LT predicate on the "spamchannel" field.
func SpamchannelLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelLTE applies the LTE predicate on the "spamchannel" field.
func SpamchannelLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelContains applies the Contains predicate on the "spamchannel" field.
func SpamchannelContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelHasPrefix applies the HasPrefix predicate on the "spamchannel" field.
func SpamchannelHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelHasSuffix applies the HasSuffix predicate on the "spamchannel" field.
func SpamchannelHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelEqualFold applies the EqualFold predicate on the "spamchannel" field.
func SpamchannelEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldSpamchannel), v))
	})
}

// SpamchannelContainsFold applies the ContainsFold predicate on the "spamchannel" field.
func SpamchannelContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldSpamchannel), v))
	})
}

// GreeterchannelEQ applies the EQ predicate on the "greeterchannel" field.
func GreeterchannelEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelNEQ applies the NEQ predicate on the "greeterchannel" field.
func GreeterchannelNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelIn applies the In predicate on the "greeterchannel" field.
func GreeterchannelIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldGreeterchannel), v...))
	})
}

// GreeterchannelNotIn applies the NotIn predicate on the "greeterchannel" field.
func GreeterchannelNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldGreeterchannel), v...))
	})
}

// GreeterchannelGT applies the GT predicate on the "greeterchannel" field.
func GreeterchannelGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelGTE applies the GTE predicate on the "greeterchannel" field.
func GreeterchannelGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelLT applies the LT predicate on the "greeterchannel" field.
func GreeterchannelLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelLTE applies the LTE predicate on the "greeterchannel" field.
func GreeterchannelLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelContains applies the Contains predicate on the "greeterchannel" field.
func GreeterchannelContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelHasPrefix applies the HasPrefix predicate on the "greeterchannel" field.
func GreeterchannelHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelHasSuffix applies the HasSuffix predicate on the "greeterchannel" field.
func GreeterchannelHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelEqualFold applies the EqualFold predicate on the "greeterchannel" field.
func GreeterchannelEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldGreeterchannel), v))
	})
}

// GreeterchannelContainsFold applies the ContainsFold predicate on the "greeterchannel" field.
func GreeterchannelContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldGreeterchannel), v))
	})
}

// GreetermodeEQ applies the EQ predicate on the "greetermode" field.
func GreetermodeEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreetermode), v))
	})
}

// GreetermodeNEQ applies the NEQ predicate on the "greetermode" field.
func GreetermodeNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldGreetermode), v))
	})
}

// GreetermodeIn applies the In predicate on the "greetermode" field.
func GreetermodeIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldGreetermode), v...))
	})
}

// GreetermodeNotIn applies the NotIn predicate on the "greetermode" field.
func GreetermodeNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldGreetermode), v...))
	})
}

// GreetermodeGT applies the GT predicate on the "greetermode" field.
func GreetermodeGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldGreetermode), v))
	})
}

// GreetermodeGTE applies the GTE predicate on the "greetermode" field.
func GreetermodeGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldGreetermode), v))
	})
}

// GreetermodeLT applies the LT predicate on the "greetermode" field.
func GreetermodeLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldGreetermode), v))
	})
}

// GreetermodeLTE applies the LTE predicate on the "greetermode" field.
func GreetermodeLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldGreetermode), v))
	})
}

// GreetermodeContains applies the Contains predicate on the "greetermode" field.
func GreetermodeContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldGreetermode), v))
	})
}

// GreetermodeHasPrefix applies the HasPrefix predicate on the "greetermode" field.
func GreetermodeHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldGreetermode), v))
	})
}

// GreetermodeHasSuffix applies the HasSuffix predicate on the "greetermode" field.
func GreetermodeHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldGreetermode), v))
	})
}

// GreetermodeEqualFold applies the EqualFold predicate on the "greetermode" field.
func GreetermodeEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldGreetermode), v))
	})
}

// GreetermodeContainsFold applies the ContainsFold predicate on the "greetermode" field.
func GreetermodeContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldGreetermode), v))
	})
}

// AnnouncechannelEQ applies the EQ predicate on the "announcechannel" field.
func AnnouncechannelEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelNEQ applies the NEQ predicate on the "announcechannel" field.
func AnnouncechannelNEQ(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelIn applies the In predicate on the "announcechannel" field.
func AnnouncechannelIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldAnnouncechannel), v...))
	})
}

// AnnouncechannelNotIn applies the NotIn predicate on the "announcechannel" field.
func AnnouncechannelNotIn(vs ...string) predicate.Settings {
	v := make([]interface{}, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Settings(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(FieldAnnouncechannel), v...))
	})
}

// AnnouncechannelGT applies the GT predicate on the "announcechannel" field.
func AnnouncechannelGT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelGTE applies the GTE predicate on the "announcechannel" field.
func AnnouncechannelGTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelLT applies the LT predicate on the "announcechannel" field.
func AnnouncechannelLT(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelLTE applies the LTE predicate on the "announcechannel" field.
func AnnouncechannelLTE(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelContains applies the Contains predicate on the "announcechannel" field.
func AnnouncechannelContains(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelHasPrefix applies the HasPrefix predicate on the "announcechannel" field.
func AnnouncechannelHasPrefix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelHasSuffix applies the HasSuffix predicate on the "announcechannel" field.
func AnnouncechannelHasSuffix(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelEqualFold applies the EqualFold predicate on the "announcechannel" field.
func AnnouncechannelEqualFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldAnnouncechannel), v))
	})
}

// AnnouncechannelContainsFold applies the ContainsFold predicate on the "announcechannel" field.
func AnnouncechannelContainsFold(v string) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldAnnouncechannel), v))
	})
}

// LoggerEQ applies the EQ predicate on the "logger" field.
func LoggerEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLogger), v))
	})
}

// LoggerNEQ applies the NEQ predicate on the "logger" field.
func LoggerNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldLogger), v))
	})
}

// SpamprotectionEQ applies the EQ predicate on the "spamprotection" field.
func SpamprotectionEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSpamprotection), v))
	})
}

// SpamprotectionNEQ applies the NEQ predicate on the "spamprotection" field.
func SpamprotectionNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSpamprotection), v))
	})
}

// LinkprotectionEQ applies the EQ predicate on the "linkprotection" field.
func LinkprotectionEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldLinkprotection), v))
	})
}

// LinkprotectionNEQ applies the NEQ predicate on the "linkprotection" field.
func LinkprotectionNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldLinkprotection), v))
	})
}

// WordfilterEQ applies the EQ predicate on the "wordfilter" field.
func WordfilterEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWordfilter), v))
	})
}

// WordfilterNEQ applies the NEQ predicate on the "wordfilter" field.
func WordfilterNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldWordfilter), v))
	})
}

// GreetingsEQ applies the EQ predicate on the "greetings" field.
func GreetingsEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldGreetings), v))
	})
}

// GreetingsNEQ applies the NEQ predicate on the "greetings" field.
func GreetingsNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldGreetings), v))
	})
}

// ApitoggleEQ applies the EQ predicate on the "apitoggle" field.
func ApitoggleEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldApitoggle), v))
	})
}

// ApitoggleNEQ applies the NEQ predicate on the "apitoggle" field.
func ApitoggleNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldApitoggle), v))
	})
}

// ModerationEQ applies the EQ predicate on the "moderation" field.
func ModerationEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldModeration), v))
	})
}

// ModerationNEQ applies the NEQ predicate on the "moderation" field.
func ModerationNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldModeration), v))
	})
}

// AutomatedmoderationEQ applies the EQ predicate on the "automatedmoderation" field.
func AutomatedmoderationEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAutomatedmoderation), v))
	})
}

// AutomatedmoderationNEQ applies the NEQ predicate on the "automatedmoderation" field.
func AutomatedmoderationNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAutomatedmoderation), v))
	})
}

// TwitchannounceEQ applies the EQ predicate on the "twitchannounce" field.
func TwitchannounceEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTwitchannounce), v))
	})
}

// TwitchannounceNEQ applies the NEQ predicate on the "twitchannounce" field.
func TwitchannounceNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTwitchannounce), v))
	})
}

// TwitterannounceEQ applies the EQ predicate on the "twitterannounce" field.
func TwitterannounceEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTwitterannounce), v))
	})
}

// TwitterannounceNEQ applies the NEQ predicate on the "twitterannounce" field.
func TwitterannounceNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTwitterannounce), v))
	})
}

// MusicEQ applies the EQ predicate on the "music" field.
func MusicEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMusic), v))
	})
}

// MusicNEQ applies the NEQ predicate on the "music" field.
func MusicNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMusic), v))
	})
}

// StatspageEQ applies the EQ predicate on the "statspage" field.
func StatspageEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatspage), v))
	})
}

// StatspageNEQ applies the NEQ predicate on the "statspage" field.
func StatspageNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldStatspage), v))
	})
}

// StatsprivateEQ applies the EQ predicate on the "statsprivate" field.
func StatsprivateEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStatsprivate), v))
	})
}

// StatsprivateNEQ applies the NEQ predicate on the "statsprivate" field.
func StatsprivateNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldStatsprivate), v))
	})
}

// StatsEQ applies the EQ predicate on the "stats" field.
func StatsEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldStats), v))
	})
}

// StatsNEQ applies the NEQ predicate on the "stats" field.
func StatsNEQ(v bool) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldStats), v))
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Settings) predicate.Settings {
	return predicate.Settings(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.Settings) predicate.Settings {
	return predicate.Settings(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.Settings) predicate.Settings {
	return predicate.Settings(func(s *sql.Selector) {
		p(s.Not())
	})
}