claude/mattermost-community-enterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
mattermost-community-enterp.../vendor/github.com/redis/rueidis/internal/cmds/gen_connection.go
Claude ec1f89217a Merge: Complete Mattermost Server with Community Enterprise 
Full Mattermost server source with integrated Community Enterprise features.
Includes vendor directory for offline/air-gapped builds.

Structure:
- enterprise-impl/: Enterprise feature implementations
- enterprise-community/: Init files that register implementations
- enterprise/: Bridge imports (community_imports.go)
- vendor/: All dependencies for offline builds

Build (online):
  go build ./cmd/mattermost

Build (offline/air-gapped):
  go build -mod=vendor ./cmd/mattermost

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-17 23:59:07 +09:00

8017 lines
226 KiB
Go
Raw Permalink Blame History

// Code generated DO NOT EDIT
package cmds
import "strconv"
type Auth Incomplete
func (b Builder) Auth() (c Auth) {
c = Auth{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "AUTH")
return c
}
func (c Auth) Username(username string) AuthUsername {
c.cs.s = append(c.cs.s, username)
return (AuthUsername)(c)
}
func (c Auth) Password(password string) AuthPassword {
c.cs.s = append(c.cs.s, password)
return (AuthPassword)(c)
}
type AuthPassword Incomplete
func (c AuthPassword) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AuthUsername Incomplete
func (c AuthUsername) Password(password string) AuthPassword {
c.cs.s = append(c.cs.s, password)
return (AuthPassword)(c)
}
type ClientCaching Incomplete
func (b Builder) ClientCaching() (c ClientCaching) {
c = ClientCaching{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "CACHING")
return c
}
func (c ClientCaching) Yes() ClientCachingModeYes {
c.cs.s = append(c.cs.s, "YES")
return (ClientCachingModeYes)(c)
}
func (c ClientCaching) No() ClientCachingModeNo {
c.cs.s = append(c.cs.s, "NO")
return (ClientCachingModeNo)(c)
}
type ClientCachingModeNo Incomplete
func (c ClientCachingModeNo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientCachingModeYes Incomplete
func (c ClientCachingModeYes) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientCapa Incomplete
func (b Builder) ClientCapa() (c ClientCapa) {
c = ClientCapa{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "CAPA")
return c
}
func (c ClientCapa) Capability(capability ...string) ClientCapaCapability {
c.cs.s = append(c.cs.s, capability...)
return (ClientCapaCapability)(c)
}
type ClientCapaCapability Incomplete
func (c ClientCapaCapability) Capability(capability ...string) ClientCapaCapability {
c.cs.s = append(c.cs.s, capability...)
return c
}
func (c ClientCapaCapability) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientGetname Incomplete
func (b Builder) ClientGetname() (c ClientGetname) {
c = ClientGetname{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "GETNAME")
return c
}
func (c ClientGetname) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientGetredir Incomplete
func (b Builder) ClientGetredir() (c ClientGetredir) {
c = ClientGetredir{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "GETREDIR")
return c
}
func (c ClientGetredir) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientId Incomplete
func (b Builder) ClientId() (c ClientId) {
c = ClientId{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "ID")
return c
}
func (c ClientId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientInfo Incomplete
func (b Builder) ClientInfo() (c ClientInfo) {
c = ClientInfo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "INFO")
return c
}
func (c ClientInfo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKill Incomplete
func (b Builder) ClientKill() (c ClientKill) {
c = ClientKill{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "KILL")
return c
}
func (c ClientKill) IpPort(ipPort string) ClientKillIpPort {
c.cs.s = append(c.cs.s, ipPort)
return (ClientKillIpPort)(c)
}
func (c ClientKill) Id(clientId int64) ClientKillId {
c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
return (ClientKillId)(c)
}
func (c ClientKill) TypeNormal() ClientKillTypeNormal {
c.cs.s = append(c.cs.s, "TYPE", "NORMAL")
return (ClientKillTypeNormal)(c)
}
func (c ClientKill) TypeMaster() ClientKillTypeMaster {
c.cs.s = append(c.cs.s, "TYPE", "MASTER")
return (ClientKillTypeMaster)(c)
}
func (c ClientKill) TypePrimary() ClientKillTypePrimary {
c.cs.s = append(c.cs.s, "TYPE", "PRIMARY")
return (ClientKillTypePrimary)(c)
}
func (c ClientKill) TypeSlave() ClientKillTypeSlave {
c.cs.s = append(c.cs.s, "TYPE", "SLAVE")
return (ClientKillTypeSlave)(c)
}
func (c ClientKill) TypeReplica() ClientKillTypeReplica {
c.cs.s = append(c.cs.s, "TYPE", "REPLICA")
return (ClientKillTypeReplica)(c)
}
func (c ClientKill) TypePubsub() ClientKillTypePubsub {
c.cs.s = append(c.cs.s, "TYPE", "PUBSUB")
return (ClientKillTypePubsub)(c)
}
func (c ClientKill) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKill) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKill) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKill) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKill) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKill) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKill) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKill) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKill) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKill) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKill) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKill) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKill) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKill) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKill) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKill) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKill) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKill) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKill) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKill) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKill) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKill) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKill) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKill) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKill) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKill) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKill) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKill) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKill) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKill) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKill) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKill) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillAddr Incomplete
func (c ClientKillAddr) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillAddr) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillAddr) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillAddr) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillAddr) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillAddr) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillAddr) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillAddr) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillAddr) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillAddr) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillAddr) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillAddr) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillAddr) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillAddr) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillAddr) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillAddr) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillAddr) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillAddr) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillAddr) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillAddr) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillAddr) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillAddr) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillAddr) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillAddr) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillAddr) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillAddr) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillAddr) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillAddr) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillAddr) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillAddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillCapa Incomplete
func (c ClientKillCapa) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillCapa) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillCapa) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillCapa) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillCapa) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillCapa) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillCapa) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillCapa) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillCapa) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillCapa) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillCapa) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillCapa) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillCapa) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillCapa) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillCapa) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillCapa) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillCapa) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillCapa) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillCapa) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillDb Incomplete
func (c ClientKillDb) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillDb) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillDb) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillDb) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillDb) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillDb) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillDb) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillDb) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillDb) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillDb) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillDb) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillDb) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillDb) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillDb) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillDb) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillDb) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillDb) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillDb) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillDb) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillDb) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillFlags Incomplete
func (c ClientKillFlags) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillFlags) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillFlags) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillFlags) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillFlags) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillFlags) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillFlags) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillFlags) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillFlags) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillFlags) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillFlags) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillFlags) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillFlags) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillFlags) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillFlags) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillFlags) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillFlags) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillFlags) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillFlags) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillFlags) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillFlags) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillFlags) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillFlags) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillId Incomplete
func (c ClientKillId) TypeNormal() ClientKillTypeNormal {
c.cs.s = append(c.cs.s, "TYPE", "NORMAL")
return (ClientKillTypeNormal)(c)
}
func (c ClientKillId) TypeMaster() ClientKillTypeMaster {
c.cs.s = append(c.cs.s, "TYPE", "MASTER")
return (ClientKillTypeMaster)(c)
}
func (c ClientKillId) TypePrimary() ClientKillTypePrimary {
c.cs.s = append(c.cs.s, "TYPE", "PRIMARY")
return (ClientKillTypePrimary)(c)
}
func (c ClientKillId) TypeSlave() ClientKillTypeSlave {
c.cs.s = append(c.cs.s, "TYPE", "SLAVE")
return (ClientKillTypeSlave)(c)
}
func (c ClientKillId) TypeReplica() ClientKillTypeReplica {
c.cs.s = append(c.cs.s, "TYPE", "REPLICA")
return (ClientKillTypeReplica)(c)
}
func (c ClientKillId) TypePubsub() ClientKillTypePubsub {
c.cs.s = append(c.cs.s, "TYPE", "PUBSUB")
return (ClientKillTypePubsub)(c)
}
func (c ClientKillId) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillId) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillId) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillId) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillId) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillId) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillId) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillId) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillId) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillId) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillId) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillId) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillId) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillId) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillId) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillId) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillId) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillId) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillId) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillId) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillId) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillId) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillId) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillId) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillId) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillId) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillId) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillId) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillId) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillId) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillId) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillIdle Incomplete
func (c ClientKillIdle) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillIdle) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillIdle) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillIdle) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillIdle) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillIdle) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillIdle) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillIdle) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillIdle) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillIdle) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillIdle) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillIdle) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillIdle) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillIdle) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillIdle) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillIdle) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillIdle) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillIdle) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillIdle) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillIdle) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillIdle) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillIdle) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillIdle) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillIdle) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillIp Incomplete
func (c ClientKillIp) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillIp) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillIp) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillIp) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillIp) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillIp) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillIp) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillIp) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillIp) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillIp) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillIp) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillIp) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillIp) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillIp) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillIp) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillIp) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillIp) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillIp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillIpPort Incomplete
func (c ClientKillIpPort) Id(clientId int64) ClientKillId {
c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
return (ClientKillId)(c)
}
func (c ClientKillIpPort) TypeNormal() ClientKillTypeNormal {
c.cs.s = append(c.cs.s, "TYPE", "NORMAL")
return (ClientKillTypeNormal)(c)
}
func (c ClientKillIpPort) TypeMaster() ClientKillTypeMaster {
c.cs.s = append(c.cs.s, "TYPE", "MASTER")
return (ClientKillTypeMaster)(c)
}
func (c ClientKillIpPort) TypePrimary() ClientKillTypePrimary {
c.cs.s = append(c.cs.s, "TYPE", "PRIMARY")
return (ClientKillTypePrimary)(c)
}
func (c ClientKillIpPort) TypeSlave() ClientKillTypeSlave {
c.cs.s = append(c.cs.s, "TYPE", "SLAVE")
return (ClientKillTypeSlave)(c)
}
func (c ClientKillIpPort) TypeReplica() ClientKillTypeReplica {
c.cs.s = append(c.cs.s, "TYPE", "REPLICA")
return (ClientKillTypeReplica)(c)
}
func (c ClientKillIpPort) TypePubsub() ClientKillTypePubsub {
c.cs.s = append(c.cs.s, "TYPE", "PUBSUB")
return (ClientKillTypePubsub)(c)
}
func (c ClientKillIpPort) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillIpPort) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillIpPort) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillIpPort) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillIpPort) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillIpPort) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillIpPort) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillIpPort) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillIpPort) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillIpPort) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillIpPort) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillIpPort) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillIpPort) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillIpPort) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillIpPort) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillIpPort) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillIpPort) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillIpPort) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillIpPort) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillIpPort) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillIpPort) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillIpPort) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillIpPort) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillIpPort) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillIpPort) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillIpPort) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillIpPort) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillIpPort) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillIpPort) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillIpPort) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillIpPort) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillIpPort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillLaddr Incomplete
func (c ClientKillLaddr) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillLaddr) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillLaddr) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillLaddr) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillLaddr) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillLaddr) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillLaddr) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillLaddr) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillLaddr) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillLaddr) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillLaddr) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillLaddr) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillLaddr) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillLaddr) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillLaddr) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillLaddr) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillLaddr) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillLaddr) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillLaddr) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillLaddr) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillLaddr) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillLaddr) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillLaddr) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillLaddr) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillLaddr) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillLaddr) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillLaddr) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillLaddr) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillLaddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillLibName Incomplete
func (c ClientKillLibName) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillLibName) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillLibName) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillLibName) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillLibName) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillLibName) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillLibName) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillLibName) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillLibName) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillLibName) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillLibName) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillLibName) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillLibName) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillLibName) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillLibName) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillLibName) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillLibName) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillLibName) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillLibName) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillLibName) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillLibName) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillLibName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillLibVer Incomplete
func (c ClientKillLibVer) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillLibVer) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillLibVer) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillLibVer) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillLibVer) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillLibVer) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillLibVer) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillLibVer) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillLibVer) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillLibVer) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillLibVer) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillLibVer) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillLibVer) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillLibVer) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillLibVer) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillLibVer) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillLibVer) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillLibVer) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillLibVer) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillLibVer) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillLibVer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillMaxage Incomplete
func (c ClientKillMaxage) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillMaxage) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillMaxage) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillMaxage) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillMaxage) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillMaxage) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillMaxage) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillMaxage) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillMaxage) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillMaxage) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillMaxage) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillMaxage) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillMaxage) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillMaxage) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillMaxage) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillMaxage) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillMaxage) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillMaxage) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillMaxage) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillMaxage) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillMaxage) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillMaxage) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillMaxage) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillMaxage) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillMaxage) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillMaxage) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillName Incomplete
func (c ClientKillName) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillName) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillName) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillName) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillName) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillName) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillName) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillName) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillName) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillName) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillName) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillName) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillName) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillName) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillName) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillName) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillName) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillName) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillName) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillName) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillName) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillName) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillName) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillName) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotAddr Incomplete
func (c ClientKillNotAddr) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotAddr) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotAddr) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotAddr) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotAddr) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotAddr) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotAddr) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotAddr) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotAddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotCapa Incomplete
func (c ClientKillNotCapa) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotCapa) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotDb Incomplete
func (c ClientKillNotDb) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotDb) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotDb) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotFlags Incomplete
func (c ClientKillNotFlags) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotFlags) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotFlags) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotFlags) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotFlags) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotFlags) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotIdNotClientId Incomplete
func (c ClientKillNotIdNotClientId) NotClientId(notClientId ...int64) ClientKillNotIdNotClientId {
for _, n := range notClientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return c
}
func (c ClientKillNotIdNotClientId) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotIdNotClientId) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotIdNotClientId) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotIdNotClientId) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotIdNotClientId) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotIdNotClientId) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotIdNotClientId) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotIdNotClientId) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotIdNotClientId) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotIdNotClientId) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotIdNotClientId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotIdNotId Incomplete
func (c ClientKillNotIdNotId) NotClientId(notClientId ...int64) ClientKillNotIdNotClientId {
for _, n := range notClientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return (ClientKillNotIdNotClientId)(c)
}
type ClientKillNotIp Incomplete
func (c ClientKillNotIp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotLaddr Incomplete
func (c ClientKillNotLaddr) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotLaddr) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotLaddr) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotLaddr) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotLaddr) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotLaddr) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotLaddr) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotLaddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotLibName Incomplete
func (c ClientKillNotLibName) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotLibName) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotLibName) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotLibName) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotLibName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotLibVer Incomplete
func (c ClientKillNotLibVer) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotLibVer) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotLibVer) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotLibVer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotName Incomplete
func (c ClientKillNotName) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotName) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotName) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotName) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotName) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotName) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypeMaster Incomplete
func (c ClientKillNotTypeMaster) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypeMaster) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypeMaster) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypeMaster) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypeMaster) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypeMaster) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypeMaster) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypeMaster) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypeMaster) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypeMaster) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypeMaster) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypeMaster) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypeNormal Incomplete
func (c ClientKillNotTypeNormal) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypeNormal) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypeNormal) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypeNormal) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypeNormal) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypeNormal) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypeNormal) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypeNormal) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypeNormal) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypeNormal) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypeNormal) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypeNormal) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypePrimary Incomplete
func (c ClientKillNotTypePrimary) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypePrimary) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypePrimary) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypePrimary) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypePrimary) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypePrimary) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypePrimary) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypePrimary) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypePrimary) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypePrimary) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypePrimary) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypePrimary) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypePubsub Incomplete
func (c ClientKillNotTypePubsub) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypePubsub) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypePubsub) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypePubsub) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypePubsub) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypePubsub) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypePubsub) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypePubsub) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypePubsub) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypePubsub) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypePubsub) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypePubsub) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypeReplica Incomplete
func (c ClientKillNotTypeReplica) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypeReplica) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypeReplica) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypeReplica) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypeReplica) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypeReplica) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypeReplica) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypeReplica) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypeReplica) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypeReplica) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypeReplica) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypeReplica) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotTypeSlave Incomplete
func (c ClientKillNotTypeSlave) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillNotTypeSlave) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillNotTypeSlave) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotTypeSlave) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotTypeSlave) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotTypeSlave) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotTypeSlave) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotTypeSlave) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotTypeSlave) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotTypeSlave) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotTypeSlave) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotTypeSlave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillNotUser Incomplete
func (c ClientKillNotUser) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillNotUser) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillNotUser) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillNotUser) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillNotUser) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillNotUser) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillNotUser) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillNotUser) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillNotUser) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillNotUser) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillSkipmeNo Incomplete
func (c ClientKillSkipmeNo) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillSkipmeNo) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillSkipmeNo) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillSkipmeNo) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillSkipmeNo) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillSkipmeNo) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillSkipmeNo) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillSkipmeNo) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillSkipmeNo) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillSkipmeNo) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillSkipmeNo) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillSkipmeNo) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillSkipmeNo) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillSkipmeNo) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillSkipmeNo) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillSkipmeNo) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillSkipmeNo) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillSkipmeNo) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillSkipmeNo) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillSkipmeNo) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillSkipmeNo) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillSkipmeNo) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillSkipmeNo) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillSkipmeNo) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillSkipmeNo) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillSkipmeNo) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillSkipmeNo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillSkipmeYes Incomplete
func (c ClientKillSkipmeYes) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillSkipmeYes) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillSkipmeYes) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillSkipmeYes) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillSkipmeYes) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillSkipmeYes) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillSkipmeYes) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillSkipmeYes) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillSkipmeYes) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillSkipmeYes) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillSkipmeYes) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillSkipmeYes) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillSkipmeYes) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillSkipmeYes) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillSkipmeYes) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillSkipmeYes) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillSkipmeYes) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillSkipmeYes) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillSkipmeYes) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillSkipmeYes) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillSkipmeYes) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillSkipmeYes) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillSkipmeYes) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillSkipmeYes) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillSkipmeYes) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillSkipmeYes) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillSkipmeYes) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypeMaster Incomplete
func (c ClientKillTypeMaster) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypeMaster) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypeMaster) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypeMaster) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypeMaster) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypeMaster) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypeMaster) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypeMaster) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypeMaster) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypeMaster) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypeMaster) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypeMaster) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypeMaster) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypeMaster) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypeMaster) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypeMaster) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypeMaster) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypeMaster) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypeMaster) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypeMaster) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypeMaster) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypeMaster) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypeMaster) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypeMaster) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypeMaster) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypeMaster) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypeMaster) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypeMaster) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypeMaster) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypeMaster) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypeMaster) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypeMaster) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypeNormal Incomplete
func (c ClientKillTypeNormal) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypeNormal) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypeNormal) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypeNormal) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypeNormal) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypeNormal) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypeNormal) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypeNormal) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypeNormal) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypeNormal) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypeNormal) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypeNormal) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypeNormal) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypeNormal) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypeNormal) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypeNormal) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypeNormal) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypeNormal) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypeNormal) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypeNormal) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypeNormal) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypeNormal) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypeNormal) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypeNormal) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypeNormal) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypeNormal) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypeNormal) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypeNormal) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypeNormal) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypeNormal) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypeNormal) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypeNormal) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypePrimary Incomplete
func (c ClientKillTypePrimary) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypePrimary) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypePrimary) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypePrimary) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypePrimary) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypePrimary) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypePrimary) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypePrimary) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypePrimary) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypePrimary) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypePrimary) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypePrimary) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypePrimary) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypePrimary) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypePrimary) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypePrimary) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypePrimary) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypePrimary) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypePrimary) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypePrimary) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypePrimary) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypePrimary) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypePrimary) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypePrimary) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypePrimary) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypePrimary) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypePrimary) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypePrimary) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypePrimary) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypePrimary) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypePrimary) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypePrimary) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypePubsub Incomplete
func (c ClientKillTypePubsub) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypePubsub) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypePubsub) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypePubsub) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypePubsub) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypePubsub) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypePubsub) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypePubsub) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypePubsub) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypePubsub) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypePubsub) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypePubsub) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypePubsub) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypePubsub) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypePubsub) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypePubsub) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypePubsub) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypePubsub) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypePubsub) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypePubsub) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypePubsub) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypePubsub) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypePubsub) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypePubsub) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypePubsub) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypePubsub) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypePubsub) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypePubsub) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypePubsub) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypePubsub) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypePubsub) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypePubsub) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypeReplica Incomplete
func (c ClientKillTypeReplica) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypeReplica) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypeReplica) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypeReplica) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypeReplica) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypeReplica) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypeReplica) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypeReplica) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypeReplica) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypeReplica) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypeReplica) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypeReplica) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypeReplica) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypeReplica) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypeReplica) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypeReplica) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypeReplica) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypeReplica) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypeReplica) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypeReplica) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypeReplica) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypeReplica) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypeReplica) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypeReplica) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypeReplica) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypeReplica) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypeReplica) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypeReplica) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypeReplica) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypeReplica) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypeReplica) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypeReplica) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillTypeSlave Incomplete
func (c ClientKillTypeSlave) User(username string) ClientKillUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientKillUser)(c)
}
func (c ClientKillTypeSlave) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillTypeSlave) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillTypeSlave) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillTypeSlave) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillTypeSlave) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillTypeSlave) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillTypeSlave) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillTypeSlave) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillTypeSlave) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillTypeSlave) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillTypeSlave) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillTypeSlave) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillTypeSlave) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillTypeSlave) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillTypeSlave) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillTypeSlave) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillTypeSlave) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillTypeSlave) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillTypeSlave) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillTypeSlave) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillTypeSlave) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillTypeSlave) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillTypeSlave) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillTypeSlave) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillTypeSlave) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillTypeSlave) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillTypeSlave) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillTypeSlave) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillTypeSlave) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillTypeSlave) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillTypeSlave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientKillUser Incomplete
func (c ClientKillUser) Addr(ipPort string) ClientKillAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientKillAddr)(c)
}
func (c ClientKillUser) Laddr(ipPort string) ClientKillLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientKillLaddr)(c)
}
func (c ClientKillUser) SkipmeYes() ClientKillSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientKillSkipmeYes)(c)
}
func (c ClientKillUser) SkipmeNo() ClientKillSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientKillSkipmeNo)(c)
}
func (c ClientKillUser) Maxage(maxage int64) ClientKillMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientKillMaxage)(c)
}
func (c ClientKillUser) Name(name string) ClientKillName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientKillName)(c)
}
func (c ClientKillUser) Idle(idle int64) ClientKillIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientKillIdle)(c)
}
func (c ClientKillUser) Flags(flags string) ClientKillFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientKillFlags)(c)
}
func (c ClientKillUser) LibName(libName string) ClientKillLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientKillLibName)(c)
}
func (c ClientKillUser) LibVer(libVer string) ClientKillLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientKillLibVer)(c)
}
func (c ClientKillUser) Db(db int64) ClientKillDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientKillDb)(c)
}
func (c ClientKillUser) Capa(capa string) ClientKillCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientKillCapa)(c)
}
func (c ClientKillUser) Ip(ip string) ClientKillIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientKillIp)(c)
}
func (c ClientKillUser) NotTypeNormal() ClientKillNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientKillNotTypeNormal)(c)
}
func (c ClientKillUser) NotTypeMaster() ClientKillNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientKillNotTypeMaster)(c)
}
func (c ClientKillUser) NotTypePrimary() ClientKillNotTypePrimary {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PRIMARY")
return (ClientKillNotTypePrimary)(c)
}
func (c ClientKillUser) NotTypeSlave() ClientKillNotTypeSlave {
c.cs.s = append(c.cs.s, "NOT-TYPE", "SLAVE")
return (ClientKillNotTypeSlave)(c)
}
func (c ClientKillUser) NotTypeReplica() ClientKillNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientKillNotTypeReplica)(c)
}
func (c ClientKillUser) NotTypePubsub() ClientKillNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientKillNotTypePubsub)(c)
}
func (c ClientKillUser) NotId() ClientKillNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientKillNotIdNotId)(c)
}
func (c ClientKillUser) NotUser(notUsername string) ClientKillNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientKillNotUser)(c)
}
func (c ClientKillUser) NotAddr(notAddr string) ClientKillNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientKillNotAddr)(c)
}
func (c ClientKillUser) NotLaddr(notLaddr string) ClientKillNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientKillNotLaddr)(c)
}
func (c ClientKillUser) NotName(notName string) ClientKillNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientKillNotName)(c)
}
func (c ClientKillUser) NotFlags(notFlags string) ClientKillNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientKillNotFlags)(c)
}
func (c ClientKillUser) NotLibName(notLibName string) ClientKillNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientKillNotLibName)(c)
}
func (c ClientKillUser) NotLibVer(notLibVer string) ClientKillNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientKillNotLibVer)(c)
}
func (c ClientKillUser) NotDb(notDb int64) ClientKillNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientKillNotDb)(c)
}
func (c ClientKillUser) NotCapa(notCapa string) ClientKillNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientKillNotCapa)(c)
}
func (c ClientKillUser) NotIp(notIp string) ClientKillNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientKillNotIp)(c)
}
func (c ClientKillUser) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientList Incomplete
func (b Builder) ClientList() (c ClientList) {
c = ClientList{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "LIST")
return c
}
func (c ClientList) TypeNormal() ClientListTypeNormal {
c.cs.s = append(c.cs.s, "TYPE", "NORMAL")
return (ClientListTypeNormal)(c)
}
func (c ClientList) TypeMaster() ClientListTypeMaster {
c.cs.s = append(c.cs.s, "TYPE", "MASTER")
return (ClientListTypeMaster)(c)
}
func (c ClientList) TypeReplica() ClientListTypeReplica {
c.cs.s = append(c.cs.s, "TYPE", "REPLICA")
return (ClientListTypeReplica)(c)
}
func (c ClientList) TypePubsub() ClientListTypePubsub {
c.cs.s = append(c.cs.s, "TYPE", "PUBSUB")
return (ClientListTypePubsub)(c)
}
func (c ClientList) Id() ClientListIdId {
c.cs.s = append(c.cs.s, "ID")
return (ClientListIdId)(c)
}
func (c ClientList) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientList) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientList) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientList) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientList) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientList) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientList) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientList) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientList) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientList) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientList) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientList) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientList) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientList) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientList) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientList) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientList) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientList) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientList) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientList) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientList) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientList) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientList) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientList) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientList) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientList) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientList) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientList) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientList) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientList) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListAddr Incomplete
func (c ClientListAddr) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListAddr) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListAddr) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListAddr) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListAddr) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListAddr) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListAddr) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListAddr) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListAddr) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListAddr) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListAddr) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListAddr) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListAddr) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListAddr) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListAddr) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListAddr) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListAddr) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListAddr) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListAddr) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListAddr) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListAddr) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListAddr) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListAddr) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListAddr) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListAddr) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListAddr) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListAddr) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListAddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListCapa Incomplete
func (c ClientListCapa) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListCapa) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListCapa) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListCapa) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListCapa) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListCapa) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListCapa) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListCapa) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListCapa) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListCapa) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListCapa) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListCapa) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListCapa) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListCapa) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListCapa) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListCapa) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListCapa) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListDb Incomplete
func (c ClientListDb) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListDb) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListDb) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListDb) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListDb) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListDb) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListDb) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListDb) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListDb) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListDb) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListDb) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListDb) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListDb) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListDb) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListDb) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListDb) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListDb) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListDb) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListFlags Incomplete
func (c ClientListFlags) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListFlags) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListFlags) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListFlags) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListFlags) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListFlags) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListFlags) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListFlags) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListFlags) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListFlags) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListFlags) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListFlags) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListFlags) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListFlags) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListFlags) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListFlags) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListFlags) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListFlags) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListFlags) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListFlags) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListFlags) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListIdClientId Incomplete
func (c ClientListIdClientId) ClientId(clientId ...int64) ClientListIdClientId {
for _, n := range clientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return c
}
func (c ClientListIdClientId) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientListIdClientId) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListIdClientId) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListIdClientId) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListIdClientId) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListIdClientId) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListIdClientId) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListIdClientId) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListIdClientId) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListIdClientId) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListIdClientId) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListIdClientId) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListIdClientId) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListIdClientId) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListIdClientId) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListIdClientId) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListIdClientId) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListIdClientId) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListIdClientId) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListIdClientId) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListIdClientId) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListIdClientId) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListIdClientId) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListIdClientId) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListIdClientId) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListIdClientId) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListIdClientId) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListIdClientId) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListIdClientId) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListIdClientId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListIdId Incomplete
func (c ClientListIdId) ClientId(clientId ...int64) ClientListIdClientId {
for _, n := range clientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return (ClientListIdClientId)(c)
}
type ClientListIdle Incomplete
func (c ClientListIdle) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListIdle) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListIdle) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListIdle) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListIdle) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListIdle) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListIdle) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListIdle) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListIdle) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListIdle) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListIdle) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListIdle) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListIdle) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListIdle) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListIdle) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListIdle) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListIdle) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListIdle) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListIdle) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListIdle) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListIdle) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListIdle) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListIp Incomplete
func (c ClientListIp) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListIp) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListIp) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListIp) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListIp) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListIp) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListIp) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListIp) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListIp) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListIp) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListIp) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListIp) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListIp) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListIp) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListIp) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListIp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListLaddr Incomplete
func (c ClientListLaddr) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListLaddr) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListLaddr) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListLaddr) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListLaddr) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListLaddr) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListLaddr) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListLaddr) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListLaddr) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListLaddr) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListLaddr) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListLaddr) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListLaddr) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListLaddr) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListLaddr) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListLaddr) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListLaddr) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListLaddr) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListLaddr) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListLaddr) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListLaddr) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListLaddr) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListLaddr) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListLaddr) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListLaddr) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListLaddr) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListLaddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListLibName Incomplete
func (c ClientListLibName) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListLibName) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListLibName) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListLibName) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListLibName) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListLibName) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListLibName) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListLibName) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListLibName) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListLibName) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListLibName) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListLibName) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListLibName) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListLibName) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListLibName) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListLibName) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListLibName) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListLibName) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListLibName) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListLibName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListLibVer Incomplete
func (c ClientListLibVer) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListLibVer) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListLibVer) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListLibVer) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListLibVer) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListLibVer) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListLibVer) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListLibVer) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListLibVer) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListLibVer) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListLibVer) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListLibVer) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListLibVer) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListLibVer) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListLibVer) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListLibVer) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListLibVer) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListLibVer) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListLibVer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListMaxage Incomplete
func (c ClientListMaxage) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListMaxage) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListMaxage) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListMaxage) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListMaxage) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListMaxage) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListMaxage) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListMaxage) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListMaxage) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListMaxage) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListMaxage) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListMaxage) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListMaxage) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListMaxage) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListMaxage) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListMaxage) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListMaxage) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListMaxage) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListMaxage) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListMaxage) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListMaxage) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListMaxage) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListMaxage) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListMaxage) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListName Incomplete
func (c ClientListName) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListName) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListName) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListName) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListName) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListName) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListName) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListName) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListName) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListName) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListName) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListName) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListName) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListName) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListName) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListName) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListName) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListName) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListName) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListName) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListName) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListName) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotAddr Incomplete
func (c ClientListNotAddr) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotAddr) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotAddr) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotAddr) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotAddr) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotAddr) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotAddr) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotAddr) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotAddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotCapa Incomplete
func (c ClientListNotCapa) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotCapa) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotDb Incomplete
func (c ClientListNotDb) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotDb) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotDb) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotFlags Incomplete
func (c ClientListNotFlags) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotFlags) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotFlags) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotFlags) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotFlags) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotFlags) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotIdNotClientId Incomplete
func (c ClientListNotIdNotClientId) NotClientId(notClientId ...int64) ClientListNotIdNotClientId {
for _, n := range notClientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return c
}
func (c ClientListNotIdNotClientId) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListNotIdNotClientId) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotIdNotClientId) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotIdNotClientId) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotIdNotClientId) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotIdNotClientId) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotIdNotClientId) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotIdNotClientId) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotIdNotClientId) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotIdNotClientId) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotIdNotClientId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotIdNotId Incomplete
func (c ClientListNotIdNotId) NotClientId(notClientId ...int64) ClientListNotIdNotClientId {
for _, n := range notClientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
}
return (ClientListNotIdNotClientId)(c)
}
type ClientListNotIp Incomplete
func (c ClientListNotIp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotLaddr Incomplete
func (c ClientListNotLaddr) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotLaddr) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotLaddr) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotLaddr) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotLaddr) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotLaddr) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotLaddr) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotLaddr) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotLibName Incomplete
func (c ClientListNotLibName) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotLibName) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotLibName) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotLibName) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotLibName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotLibVer Incomplete
func (c ClientListNotLibVer) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotLibVer) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotLibVer) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotLibVer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotName Incomplete
func (c ClientListNotName) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotName) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotName) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotName) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotName) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotName) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotTypeMaster Incomplete
func (c ClientListNotTypeMaster) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListNotTypeMaster) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListNotTypeMaster) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotTypeMaster) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotTypeMaster) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotTypeMaster) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotTypeMaster) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotTypeMaster) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotTypeMaster) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotTypeMaster) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotTypeMaster) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotTypeMaster) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotTypeNormal Incomplete
func (c ClientListNotTypeNormal) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListNotTypeNormal) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListNotTypeNormal) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotTypeNormal) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotTypeNormal) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotTypeNormal) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotTypeNormal) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotTypeNormal) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotTypeNormal) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotTypeNormal) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotTypeNormal) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotTypeNormal) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotTypePubsub Incomplete
func (c ClientListNotTypePubsub) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListNotTypePubsub) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListNotTypePubsub) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotTypePubsub) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotTypePubsub) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotTypePubsub) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotTypePubsub) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotTypePubsub) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotTypePubsub) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotTypePubsub) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotTypePubsub) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotTypePubsub) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotTypeReplica Incomplete
func (c ClientListNotTypeReplica) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListNotTypeReplica) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListNotTypeReplica) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotTypeReplica) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotTypeReplica) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotTypeReplica) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotTypeReplica) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotTypeReplica) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotTypeReplica) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotTypeReplica) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotTypeReplica) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotTypeReplica) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListNotUser Incomplete
func (c ClientListNotUser) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListNotUser) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListNotUser) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListNotUser) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListNotUser) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListNotUser) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListNotUser) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListNotUser) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListNotUser) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListNotUser) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListSkipmeNo Incomplete
func (c ClientListSkipmeNo) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListSkipmeNo) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListSkipmeNo) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListSkipmeNo) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListSkipmeNo) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListSkipmeNo) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListSkipmeNo) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListSkipmeNo) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListSkipmeNo) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListSkipmeNo) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListSkipmeNo) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListSkipmeNo) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListSkipmeNo) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListSkipmeNo) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListSkipmeNo) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListSkipmeNo) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListSkipmeNo) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListSkipmeNo) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListSkipmeNo) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListSkipmeNo) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListSkipmeNo) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListSkipmeNo) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListSkipmeNo) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListSkipmeNo) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListSkipmeNo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListSkipmeYes Incomplete
func (c ClientListSkipmeYes) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListSkipmeYes) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListSkipmeYes) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListSkipmeYes) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListSkipmeYes) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListSkipmeYes) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListSkipmeYes) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListSkipmeYes) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListSkipmeYes) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListSkipmeYes) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListSkipmeYes) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListSkipmeYes) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListSkipmeYes) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListSkipmeYes) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListSkipmeYes) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListSkipmeYes) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListSkipmeYes) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListSkipmeYes) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListSkipmeYes) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListSkipmeYes) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListSkipmeYes) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListSkipmeYes) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListSkipmeYes) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListSkipmeYes) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListSkipmeYes) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListTypeMaster Incomplete
func (c ClientListTypeMaster) Id() ClientListIdId {
c.cs.s = append(c.cs.s, "ID")
return (ClientListIdId)(c)
}
func (c ClientListTypeMaster) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientListTypeMaster) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListTypeMaster) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListTypeMaster) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListTypeMaster) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListTypeMaster) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListTypeMaster) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListTypeMaster) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListTypeMaster) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListTypeMaster) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListTypeMaster) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListTypeMaster) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListTypeMaster) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListTypeMaster) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListTypeMaster) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListTypeMaster) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListTypeMaster) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListTypeMaster) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListTypeMaster) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListTypeMaster) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListTypeMaster) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListTypeMaster) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListTypeMaster) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListTypeMaster) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListTypeMaster) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListTypeMaster) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListTypeMaster) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListTypeMaster) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListTypeMaster) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListTypeMaster) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListTypeNormal Incomplete
func (c ClientListTypeNormal) Id() ClientListIdId {
c.cs.s = append(c.cs.s, "ID")
return (ClientListIdId)(c)
}
func (c ClientListTypeNormal) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientListTypeNormal) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListTypeNormal) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListTypeNormal) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListTypeNormal) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListTypeNormal) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListTypeNormal) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListTypeNormal) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListTypeNormal) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListTypeNormal) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListTypeNormal) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListTypeNormal) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListTypeNormal) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListTypeNormal) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListTypeNormal) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListTypeNormal) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListTypeNormal) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListTypeNormal) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListTypeNormal) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListTypeNormal) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListTypeNormal) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListTypeNormal) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListTypeNormal) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListTypeNormal) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListTypeNormal) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListTypeNormal) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListTypeNormal) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListTypeNormal) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListTypeNormal) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListTypeNormal) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListTypePubsub Incomplete
func (c ClientListTypePubsub) Id() ClientListIdId {
c.cs.s = append(c.cs.s, "ID")
return (ClientListIdId)(c)
}
func (c ClientListTypePubsub) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientListTypePubsub) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListTypePubsub) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListTypePubsub) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListTypePubsub) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListTypePubsub) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListTypePubsub) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListTypePubsub) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListTypePubsub) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListTypePubsub) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListTypePubsub) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListTypePubsub) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListTypePubsub) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListTypePubsub) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListTypePubsub) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListTypePubsub) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListTypePubsub) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListTypePubsub) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListTypePubsub) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListTypePubsub) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListTypePubsub) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListTypePubsub) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListTypePubsub) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListTypePubsub) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListTypePubsub) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListTypePubsub) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListTypePubsub) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListTypePubsub) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListTypePubsub) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListTypePubsub) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListTypeReplica Incomplete
func (c ClientListTypeReplica) Id() ClientListIdId {
c.cs.s = append(c.cs.s, "ID")
return (ClientListIdId)(c)
}
func (c ClientListTypeReplica) User(username string) ClientListUser {
c.cs.s = append(c.cs.s, "USER", username)
return (ClientListUser)(c)
}
func (c ClientListTypeReplica) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListTypeReplica) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListTypeReplica) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListTypeReplica) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListTypeReplica) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListTypeReplica) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListTypeReplica) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListTypeReplica) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListTypeReplica) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListTypeReplica) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListTypeReplica) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListTypeReplica) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListTypeReplica) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListTypeReplica) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListTypeReplica) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListTypeReplica) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListTypeReplica) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListTypeReplica) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListTypeReplica) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListTypeReplica) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListTypeReplica) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListTypeReplica) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListTypeReplica) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListTypeReplica) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListTypeReplica) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListTypeReplica) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListTypeReplica) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListTypeReplica) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListTypeReplica) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientListUser Incomplete
func (c ClientListUser) Addr(ipPort string) ClientListAddr {
c.cs.s = append(c.cs.s, "ADDR", ipPort)
return (ClientListAddr)(c)
}
func (c ClientListUser) Laddr(ipPort string) ClientListLaddr {
c.cs.s = append(c.cs.s, "LADDR", ipPort)
return (ClientListLaddr)(c)
}
func (c ClientListUser) SkipmeYes() ClientListSkipmeYes {
c.cs.s = append(c.cs.s, "SKIPME", "YES")
return (ClientListSkipmeYes)(c)
}
func (c ClientListUser) SkipmeNo() ClientListSkipmeNo {
c.cs.s = append(c.cs.s, "SKIPME", "NO")
return (ClientListSkipmeNo)(c)
}
func (c ClientListUser) Maxage(maxage int64) ClientListMaxage {
c.cs.s = append(c.cs.s, "MAXAGE", strconv.FormatInt(maxage, 10))
return (ClientListMaxage)(c)
}
func (c ClientListUser) Name(name string) ClientListName {
c.cs.s = append(c.cs.s, "NAME", name)
return (ClientListName)(c)
}
func (c ClientListUser) Idle(idle int64) ClientListIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(idle, 10))
return (ClientListIdle)(c)
}
func (c ClientListUser) Flags(flags string) ClientListFlags {
c.cs.s = append(c.cs.s, "FLAGS", flags)
return (ClientListFlags)(c)
}
func (c ClientListUser) LibName(libName string) ClientListLibName {
c.cs.s = append(c.cs.s, "LIB-NAME", libName)
return (ClientListLibName)(c)
}
func (c ClientListUser) LibVer(libVer string) ClientListLibVer {
c.cs.s = append(c.cs.s, "LIB-VER", libVer)
return (ClientListLibVer)(c)
}
func (c ClientListUser) Db(db int64) ClientListDb {
c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(db, 10))
return (ClientListDb)(c)
}
func (c ClientListUser) Capa(capa string) ClientListCapa {
c.cs.s = append(c.cs.s, "CAPA", capa)
return (ClientListCapa)(c)
}
func (c ClientListUser) Ip(ip string) ClientListIp {
c.cs.s = append(c.cs.s, "IP", ip)
return (ClientListIp)(c)
}
func (c ClientListUser) NotTypeNormal() ClientListNotTypeNormal {
c.cs.s = append(c.cs.s, "NOT-TYPE", "NORMAL")
return (ClientListNotTypeNormal)(c)
}
func (c ClientListUser) NotTypeMaster() ClientListNotTypeMaster {
c.cs.s = append(c.cs.s, "NOT-TYPE", "MASTER")
return (ClientListNotTypeMaster)(c)
}
func (c ClientListUser) NotTypeReplica() ClientListNotTypeReplica {
c.cs.s = append(c.cs.s, "NOT-TYPE", "REPLICA")
return (ClientListNotTypeReplica)(c)
}
func (c ClientListUser) NotTypePubsub() ClientListNotTypePubsub {
c.cs.s = append(c.cs.s, "NOT-TYPE", "PUBSUB")
return (ClientListNotTypePubsub)(c)
}
func (c ClientListUser) NotId() ClientListNotIdNotId {
c.cs.s = append(c.cs.s, "NOT-ID")
return (ClientListNotIdNotId)(c)
}
func (c ClientListUser) NotUser(notUsername string) ClientListNotUser {
c.cs.s = append(c.cs.s, "NOT-USER", notUsername)
return (ClientListNotUser)(c)
}
func (c ClientListUser) NotAddr(notAddr string) ClientListNotAddr {
c.cs.s = append(c.cs.s, "NOT-ADDR", notAddr)
return (ClientListNotAddr)(c)
}
func (c ClientListUser) NotLaddr(notLaddr string) ClientListNotLaddr {
c.cs.s = append(c.cs.s, "NOT-LADDR", notLaddr)
return (ClientListNotLaddr)(c)
}
func (c ClientListUser) NotName(notName string) ClientListNotName {
c.cs.s = append(c.cs.s, "NOT-NAME", notName)
return (ClientListNotName)(c)
}
func (c ClientListUser) NotFlags(notFlags string) ClientListNotFlags {
c.cs.s = append(c.cs.s, "NOT-FLAGS", notFlags)
return (ClientListNotFlags)(c)
}
func (c ClientListUser) NotLibName(notLibName string) ClientListNotLibName {
c.cs.s = append(c.cs.s, "NOT-LIB-NAME", notLibName)
return (ClientListNotLibName)(c)
}
func (c ClientListUser) NotLibVer(notLibVer string) ClientListNotLibVer {
c.cs.s = append(c.cs.s, "NOT-LIB-VER", notLibVer)
return (ClientListNotLibVer)(c)
}
func (c ClientListUser) NotDb(notDb int64) ClientListNotDb {
c.cs.s = append(c.cs.s, "NOT-DB", strconv.FormatInt(notDb, 10))
return (ClientListNotDb)(c)
}
func (c ClientListUser) NotCapa(notCapa string) ClientListNotCapa {
c.cs.s = append(c.cs.s, "NOT-CAPA", notCapa)
return (ClientListNotCapa)(c)
}
func (c ClientListUser) NotIp(notIp string) ClientListNotIp {
c.cs.s = append(c.cs.s, "NOT-IP", notIp)
return (ClientListNotIp)(c)
}
func (c ClientListUser) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientNoEvict Incomplete
func (b Builder) ClientNoEvict() (c ClientNoEvict) {
c = ClientNoEvict{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "NO-EVICT")
return c
}
func (c ClientNoEvict) On() ClientNoEvictEnabledOn {
c.cs.s = append(c.cs.s, "ON")
return (ClientNoEvictEnabledOn)(c)
}
func (c ClientNoEvict) Off() ClientNoEvictEnabledOff {
c.cs.s = append(c.cs.s, "OFF")
return (ClientNoEvictEnabledOff)(c)
}
type ClientNoEvictEnabledOff Incomplete
func (c ClientNoEvictEnabledOff) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientNoEvictEnabledOn Incomplete
func (c ClientNoEvictEnabledOn) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientNoTouch Incomplete
func (b Builder) ClientNoTouch() (c ClientNoTouch) {
c = ClientNoTouch{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "NO-TOUCH")
return c
}
func (c ClientNoTouch) On() ClientNoTouchEnabledOn {
c.cs.s = append(c.cs.s, "ON")
return (ClientNoTouchEnabledOn)(c)
}
func (c ClientNoTouch) Off() ClientNoTouchEnabledOff {
c.cs.s = append(c.cs.s, "OFF")
return (ClientNoTouchEnabledOff)(c)
}
type ClientNoTouchEnabledOff Incomplete
func (c ClientNoTouchEnabledOff) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientNoTouchEnabledOn Incomplete
func (c ClientNoTouchEnabledOn) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientPause Incomplete
func (b Builder) ClientPause() (c ClientPause) {
c = ClientPause{cs: get(), ks: b.ks, cf: int16(blockTag)}
c.cs.s = append(c.cs.s, "CLIENT", "PAUSE")
return c
}
func (c ClientPause) Timeout(timeout int64) ClientPauseTimeout {
c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
return (ClientPauseTimeout)(c)
}
type ClientPauseModeAll Incomplete
func (c ClientPauseModeAll) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientPauseModeWrite Incomplete
func (c ClientPauseModeWrite) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientPauseTimeout Incomplete
func (c ClientPauseTimeout) Write() ClientPauseModeWrite {
c.cs.s = append(c.cs.s, "WRITE")
return (ClientPauseModeWrite)(c)
}
func (c ClientPauseTimeout) All() ClientPauseModeAll {
c.cs.s = append(c.cs.s, "ALL")
return (ClientPauseModeAll)(c)
}
func (c ClientPauseTimeout) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientReply Incomplete
func (b Builder) ClientReply() (c ClientReply) {
c = ClientReply{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "REPLY")
return c
}
func (c ClientReply) On() ClientReplyReplyModeOn {
c.cs.s = append(c.cs.s, "ON")
return (ClientReplyReplyModeOn)(c)
}
func (c ClientReply) Off() ClientReplyReplyModeOff {
c.cs.s = append(c.cs.s, "OFF")
return (ClientReplyReplyModeOff)(c)
}
func (c ClientReply) Skip() ClientReplyReplyModeSkip {
c.cs.s = append(c.cs.s, "SKIP")
return (ClientReplyReplyModeSkip)(c)
}
type ClientReplyReplyModeOff Incomplete
func (c ClientReplyReplyModeOff) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientReplyReplyModeOn Incomplete
func (c ClientReplyReplyModeOn) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientReplyReplyModeSkip Incomplete
func (c ClientReplyReplyModeSkip) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientSetinfo Incomplete
func (b Builder) ClientSetinfo() (c ClientSetinfo) {
c = ClientSetinfo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "SETINFO")
return c
}
func (c ClientSetinfo) Libname(libname string) ClientSetinfoAttrLibname {
c.cs.s = append(c.cs.s, "LIB-NAME", libname)
return (ClientSetinfoAttrLibname)(c)
}
func (c ClientSetinfo) Libver(libver string) ClientSetinfoAttrLibver {
c.cs.s = append(c.cs.s, "LIB-VER", libver)
return (ClientSetinfoAttrLibver)(c)
}
type ClientSetinfoAttrLibname Incomplete
func (c ClientSetinfoAttrLibname) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientSetinfoAttrLibver Incomplete
func (c ClientSetinfoAttrLibver) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientSetname Incomplete
func (b Builder) ClientSetname() (c ClientSetname) {
c = ClientSetname{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "SETNAME")
return c
}
func (c ClientSetname) ConnectionName(connectionName string) ClientSetnameConnectionName {
c.cs.s = append(c.cs.s, connectionName)
return (ClientSetnameConnectionName)(c)
}
type ClientSetnameConnectionName Incomplete
func (c ClientSetnameConnectionName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTracking Incomplete
func (b Builder) ClientTracking() (c ClientTracking) {
c = ClientTracking{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "TRACKING")
return c
}
func (c ClientTracking) On() ClientTrackingStatusOn {
c.cs.s = append(c.cs.s, "ON")
return (ClientTrackingStatusOn)(c)
}
func (c ClientTracking) Off() ClientTrackingStatusOff {
c.cs.s = append(c.cs.s, "OFF")
return (ClientTrackingStatusOff)(c)
}
type ClientTrackingBcast Incomplete
func (c ClientTrackingBcast) Optin() ClientTrackingOptin {
c.cs.s = append(c.cs.s, "OPTIN")
return (ClientTrackingOptin)(c)
}
func (c ClientTrackingBcast) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingBcast) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingBcast) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingNoloop Incomplete
func (c ClientTrackingNoloop) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingOptin Incomplete
func (c ClientTrackingOptin) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingOptin) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingOptin) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingOptout Incomplete
func (c ClientTrackingOptout) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingOptout) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingPrefix Incomplete
func (c ClientTrackingPrefix) Prefix(prefix string) ClientTrackingPrefix {
c.cs.s = append(c.cs.s, "PREFIX", prefix)
return c
}
func (c ClientTrackingPrefix) Bcast() ClientTrackingBcast {
c.cs.s = append(c.cs.s, "BCAST")
return (ClientTrackingBcast)(c)
}
func (c ClientTrackingPrefix) Optin() ClientTrackingOptin {
c.cs.s = append(c.cs.s, "OPTIN")
return (ClientTrackingOptin)(c)
}
func (c ClientTrackingPrefix) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingPrefix) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingPrefix) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingRedirect Incomplete
func (c ClientTrackingRedirect) Prefix() ClientTrackingPrefix {
return (ClientTrackingPrefix)(c)
}
func (c ClientTrackingRedirect) Bcast() ClientTrackingBcast {
c.cs.s = append(c.cs.s, "BCAST")
return (ClientTrackingBcast)(c)
}
func (c ClientTrackingRedirect) Optin() ClientTrackingOptin {
c.cs.s = append(c.cs.s, "OPTIN")
return (ClientTrackingOptin)(c)
}
func (c ClientTrackingRedirect) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingRedirect) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingRedirect) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingStatusOff Incomplete
func (c ClientTrackingStatusOff) Redirect(clientId int64) ClientTrackingRedirect {
c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
return (ClientTrackingRedirect)(c)
}
func (c ClientTrackingStatusOff) Prefix() ClientTrackingPrefix {
return (ClientTrackingPrefix)(c)
}
func (c ClientTrackingStatusOff) Bcast() ClientTrackingBcast {
c.cs.s = append(c.cs.s, "BCAST")
return (ClientTrackingBcast)(c)
}
func (c ClientTrackingStatusOff) Optin() ClientTrackingOptin {
c.cs.s = append(c.cs.s, "OPTIN")
return (ClientTrackingOptin)(c)
}
func (c ClientTrackingStatusOff) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingStatusOff) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingStatusOff) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackingStatusOn Incomplete
func (c ClientTrackingStatusOn) Redirect(clientId int64) ClientTrackingRedirect {
c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
return (ClientTrackingRedirect)(c)
}
func (c ClientTrackingStatusOn) Prefix() ClientTrackingPrefix {
return (ClientTrackingPrefix)(c)
}
func (c ClientTrackingStatusOn) Bcast() ClientTrackingBcast {
c.cs.s = append(c.cs.s, "BCAST")
return (ClientTrackingBcast)(c)
}
func (c ClientTrackingStatusOn) Optin() ClientTrackingOptin {
c.cs.s = append(c.cs.s, "OPTIN")
return (ClientTrackingOptin)(c)
}
func (c ClientTrackingStatusOn) Optout() ClientTrackingOptout {
c.cs.s = append(c.cs.s, "OPTOUT")
return (ClientTrackingOptout)(c)
}
func (c ClientTrackingStatusOn) Noloop() ClientTrackingNoloop {
c.cs.s = append(c.cs.s, "NOLOOP")
return (ClientTrackingNoloop)(c)
}
func (c ClientTrackingStatusOn) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientTrackinginfo Incomplete
func (b Builder) ClientTrackinginfo() (c ClientTrackinginfo) {
c = ClientTrackinginfo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "TRACKINGINFO")
return c
}
func (c ClientTrackinginfo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientUnblock Incomplete
func (b Builder) ClientUnblock() (c ClientUnblock) {
c = ClientUnblock{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "UNBLOCK")
return c
}
func (c ClientUnblock) ClientId(clientId int64) ClientUnblockClientId {
c.cs.s = append(c.cs.s, strconv.FormatInt(clientId, 10))
return (ClientUnblockClientId)(c)
}
type ClientUnblockClientId Incomplete
func (c ClientUnblockClientId) Timeout() ClientUnblockUnblockTypeTimeout {
c.cs.s = append(c.cs.s, "TIMEOUT")
return (ClientUnblockUnblockTypeTimeout)(c)
}
func (c ClientUnblockClientId) Error() ClientUnblockUnblockTypeError {
c.cs.s = append(c.cs.s, "ERROR")
return (ClientUnblockUnblockTypeError)(c)
}
func (c ClientUnblockClientId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientUnblockUnblockTypeError Incomplete
func (c ClientUnblockUnblockTypeError) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientUnblockUnblockTypeTimeout Incomplete
func (c ClientUnblockUnblockTypeTimeout) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ClientUnpause Incomplete
func (b Builder) ClientUnpause() (c ClientUnpause) {
c = ClientUnpause{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CLIENT", "UNPAUSE")
return c
}
func (c ClientUnpause) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Echo Incomplete
func (b Builder) Echo() (c Echo) {
c = Echo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ECHO")
return c
}
func (c Echo) Message(message string) EchoMessage {
c.cs.s = append(c.cs.s, message)
return (EchoMessage)(c)
}
type EchoMessage Incomplete
func (c EchoMessage) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Hello Incomplete
func (b Builder) Hello() (c Hello) {
c = Hello{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "HELLO")
return c
}
func (c Hello) Protover(protover int64) HelloArgumentsProtover {
c.cs.s = append(c.cs.s, strconv.FormatInt(protover, 10))
return (HelloArgumentsProtover)(c)
}
func (c Hello) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HelloArgumentsAuth Incomplete
func (c HelloArgumentsAuth) Setname(clientname string) HelloArgumentsSetname {
c.cs.s = append(c.cs.s, "SETNAME", clientname)
return (HelloArgumentsSetname)(c)
}
func (c HelloArgumentsAuth) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HelloArgumentsProtover Incomplete
func (c HelloArgumentsProtover) Auth(username string, password string) HelloArgumentsAuth {
c.cs.s = append(c.cs.s, "AUTH", username, password)
return (HelloArgumentsAuth)(c)
}
func (c HelloArgumentsProtover) Setname(clientname string) HelloArgumentsSetname {
c.cs.s = append(c.cs.s, "SETNAME", clientname)
return (HelloArgumentsSetname)(c)
}
func (c HelloArgumentsProtover) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type HelloArgumentsSetname Incomplete
func (c HelloArgumentsSetname) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Ping Incomplete
func (b Builder) Ping() (c Ping) {
c = Ping{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "PING")
return c
}
func (c Ping) Message(message string) PingMessage {
c.cs.s = append(c.cs.s, message)
return (PingMessage)(c)
}
func (c Ping) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type PingMessage Incomplete
func (c PingMessage) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Quit Incomplete
func (b Builder) Quit() (c Quit) {
c = Quit{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "QUIT")
return c
}
func (c Quit) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Reset Incomplete
func (b Builder) Reset() (c Reset) {
c = Reset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "RESET")
return c
}
func (c Reset) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Select Incomplete
func (b Builder) Select() (c Select) {
c = Select{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SELECT")
return c
}
func (c Select) Index(index int64) SelectIndex {
c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
return (SelectIndex)(c)
}
type SelectIndex Incomplete
func (c SelectIndex) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
Reference in New Issue View Git Blame Copy Permalink