// Code generated DO NOT EDIT

package cmds

import "strconv"

type Copy Incomplete

func (b Builder) Copy() (c Copy) {
	c = Copy{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "COPY")
	return c
}

func (c Copy) Source(source string) CopySource {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(source)
	} else {
		c.ks = check(c.ks, slot(source))
	}
	c.cs.s = append(c.cs.s, source)
	return (CopySource)(c)
}

type CopyDb Incomplete

func (c CopyDb) Replace() CopyReplace {
	c.cs.s = append(c.cs.s, "REPLACE")
	return (CopyReplace)(c)
}

func (c CopyDb) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type CopyDestination Incomplete

func (c CopyDestination) Db(destinationDb int64) CopyDb {
	c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(destinationDb, 10))
	return (CopyDb)(c)
}

func (c CopyDestination) Replace() CopyReplace {
	c.cs.s = append(c.cs.s, "REPLACE")
	return (CopyReplace)(c)
}

func (c CopyDestination) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type CopyReplace Incomplete

func (c CopyReplace) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type CopySource Incomplete

func (c CopySource) Destination(destination string) CopyDestination {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, destination)
	return (CopyDestination)(c)
}

type Del Incomplete

func (b Builder) Del() (c Del) {
	c = Del{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "DEL")
	return c
}

func (c Del) Key(key ...string) DelKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return (DelKey)(c)
}

type DelKey Incomplete

func (c DelKey) Key(key ...string) DelKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return c
}

func (c DelKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Dump Incomplete

func (b Builder) Dump() (c Dump) {
	c = Dump{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "DUMP")
	return c
}

func (c Dump) Key(key string) DumpKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (DumpKey)(c)
}

type DumpKey Incomplete

func (c DumpKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Exists Incomplete

func (b Builder) Exists() (c Exists) {
	c = Exists{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "EXISTS")
	return c
}

func (c Exists) Key(key ...string) ExistsKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return (ExistsKey)(c)
}

type ExistsKey Incomplete

func (c ExistsKey) Key(key ...string) ExistsKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return c
}

func (c ExistsKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Expire Incomplete

func (b Builder) Expire() (c Expire) {
	c = Expire{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "EXPIRE")
	return c
}

func (c Expire) Key(key string) ExpireKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ExpireKey)(c)
}

type ExpireConditionGt Incomplete

func (c ExpireConditionGt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireConditionLt Incomplete

func (c ExpireConditionLt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireConditionNx Incomplete

func (c ExpireConditionNx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireConditionXx Incomplete

func (c ExpireConditionXx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireKey Incomplete

func (c ExpireKey) Seconds(seconds int64) ExpireSeconds {
	c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
	return (ExpireSeconds)(c)
}

type ExpireSeconds Incomplete

func (c ExpireSeconds) Nx() ExpireConditionNx {
	c.cs.s = append(c.cs.s, "NX")
	return (ExpireConditionNx)(c)
}

func (c ExpireSeconds) Xx() ExpireConditionXx {
	c.cs.s = append(c.cs.s, "XX")
	return (ExpireConditionXx)(c)
}

func (c ExpireSeconds) Gt() ExpireConditionGt {
	c.cs.s = append(c.cs.s, "GT")
	return (ExpireConditionGt)(c)
}

func (c ExpireSeconds) Lt() ExpireConditionLt {
	c.cs.s = append(c.cs.s, "LT")
	return (ExpireConditionLt)(c)
}

func (c ExpireSeconds) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Expireat Incomplete

func (b Builder) Expireat() (c Expireat) {
	c = Expireat{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "EXPIREAT")
	return c
}

func (c Expireat) Key(key string) ExpireatKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ExpireatKey)(c)
}

type ExpireatConditionGt Incomplete

func (c ExpireatConditionGt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireatConditionLt Incomplete

func (c ExpireatConditionLt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireatConditionNx Incomplete

func (c ExpireatConditionNx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireatConditionXx Incomplete

func (c ExpireatConditionXx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ExpireatKey Incomplete

func (c ExpireatKey) Timestamp(timestamp int64) ExpireatTimestamp {
	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
	return (ExpireatTimestamp)(c)
}

type ExpireatTimestamp Incomplete

func (c ExpireatTimestamp) Nx() ExpireatConditionNx {
	c.cs.s = append(c.cs.s, "NX")
	return (ExpireatConditionNx)(c)
}

func (c ExpireatTimestamp) Xx() ExpireatConditionXx {
	c.cs.s = append(c.cs.s, "XX")
	return (ExpireatConditionXx)(c)
}

func (c ExpireatTimestamp) Gt() ExpireatConditionGt {
	c.cs.s = append(c.cs.s, "GT")
	return (ExpireatConditionGt)(c)
}

func (c ExpireatTimestamp) Lt() ExpireatConditionLt {
	c.cs.s = append(c.cs.s, "LT")
	return (ExpireatConditionLt)(c)
}

func (c ExpireatTimestamp) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Expiretime Incomplete

func (b Builder) Expiretime() (c Expiretime) {
	c = Expiretime{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "EXPIRETIME")
	return c
}

func (c Expiretime) Key(key string) ExpiretimeKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ExpiretimeKey)(c)
}

type ExpiretimeKey Incomplete

func (c ExpiretimeKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c ExpiretimeKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Keys Incomplete

func (b Builder) Keys() (c Keys) {
	c = Keys{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "KEYS")
	return c
}

func (c Keys) Pattern(pattern string) KeysPattern {
	c.cs.s = append(c.cs.s, pattern)
	return (KeysPattern)(c)
}

type KeysPattern Incomplete

func (c KeysPattern) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Migrate Incomplete

func (b Builder) Migrate() (c Migrate) {
	c = Migrate{cs: get(), ks: b.ks, cf: int16(blockTag)}
	c.cs.s = append(c.cs.s, "MIGRATE")
	return c
}

func (c Migrate) Host(host string) MigrateHost {
	c.cs.s = append(c.cs.s, host)
	return (MigrateHost)(c)
}

type MigrateAuthAuth Incomplete

func (c MigrateAuthAuth) Auth2(username string, password string) MigrateAuthAuth2 {
	c.cs.s = append(c.cs.s, "AUTH2", username, password)
	return (MigrateAuthAuth2)(c)
}

func (c MigrateAuthAuth) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return (MigrateKeys)(c)
}

func (c MigrateAuthAuth) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MigrateAuthAuth2 Incomplete

func (c MigrateAuthAuth2) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return (MigrateKeys)(c)
}

func (c MigrateAuthAuth2) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MigrateCopy Incomplete

func (c MigrateCopy) Replace() MigrateReplace {
	c.cs.s = append(c.cs.s, "REPLACE")
	return (MigrateReplace)(c)
}

func (c MigrateCopy) Auth(password string) MigrateAuthAuth {
	c.cs.s = append(c.cs.s, "AUTH", password)
	return (MigrateAuthAuth)(c)
}

func (c MigrateCopy) Auth2(username string, password string) MigrateAuthAuth2 {
	c.cs.s = append(c.cs.s, "AUTH2", username, password)
	return (MigrateAuthAuth2)(c)
}

func (c MigrateCopy) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return (MigrateKeys)(c)
}

func (c MigrateCopy) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MigrateDestinationDb Incomplete

func (c MigrateDestinationDb) Timeout(timeout int64) MigrateTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
	return (MigrateTimeout)(c)
}

type MigrateHost Incomplete

func (c MigrateHost) Port(port int64) MigratePort {
	c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
	return (MigratePort)(c)
}

type MigrateKey Incomplete

func (c MigrateKey) DestinationDb(destinationDb int64) MigrateDestinationDb {
	c.cs.s = append(c.cs.s, strconv.FormatInt(destinationDb, 10))
	return (MigrateDestinationDb)(c)
}

type MigrateKeys Incomplete

func (c MigrateKeys) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return c
}

func (c MigrateKeys) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MigratePort Incomplete

func (c MigratePort) Key(key string) MigrateKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (MigrateKey)(c)
}

type MigrateReplace Incomplete

func (c MigrateReplace) Auth(password string) MigrateAuthAuth {
	c.cs.s = append(c.cs.s, "AUTH", password)
	return (MigrateAuthAuth)(c)
}

func (c MigrateReplace) Auth2(username string, password string) MigrateAuthAuth2 {
	c.cs.s = append(c.cs.s, "AUTH2", username, password)
	return (MigrateAuthAuth2)(c)
}

func (c MigrateReplace) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return (MigrateKeys)(c)
}

func (c MigrateReplace) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MigrateTimeout Incomplete

func (c MigrateTimeout) Copy() MigrateCopy {
	c.cs.s = append(c.cs.s, "COPY")
	return (MigrateCopy)(c)
}

func (c MigrateTimeout) Replace() MigrateReplace {
	c.cs.s = append(c.cs.s, "REPLACE")
	return (MigrateReplace)(c)
}

func (c MigrateTimeout) Auth(password string) MigrateAuthAuth {
	c.cs.s = append(c.cs.s, "AUTH", password)
	return (MigrateAuthAuth)(c)
}

func (c MigrateTimeout) Auth2(username string, password string) MigrateAuthAuth2 {
	c.cs.s = append(c.cs.s, "AUTH2", username, password)
	return (MigrateAuthAuth2)(c)
}

func (c MigrateTimeout) Keys(key ...string) MigrateKeys {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, "KEYS")
	c.cs.s = append(c.cs.s, key...)
	return (MigrateKeys)(c)
}

func (c MigrateTimeout) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Move Incomplete

func (b Builder) Move() (c Move) {
	c = Move{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "MOVE")
	return c
}

func (c Move) Key(key string) MoveKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (MoveKey)(c)
}

type MoveDb Incomplete

func (c MoveDb) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type MoveKey Incomplete

func (c MoveKey) Db(db int64) MoveDb {
	c.cs.s = append(c.cs.s, strconv.FormatInt(db, 10))
	return (MoveDb)(c)
}

type ObjectEncoding Incomplete

func (b Builder) ObjectEncoding() (c ObjectEncoding) {
	c = ObjectEncoding{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "OBJECT", "ENCODING")
	return c
}

func (c ObjectEncoding) Key(key string) ObjectEncodingKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ObjectEncodingKey)(c)
}

type ObjectEncodingKey Incomplete

func (c ObjectEncodingKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ObjectFreq Incomplete

func (b Builder) ObjectFreq() (c ObjectFreq) {
	c = ObjectFreq{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "OBJECT", "FREQ")
	return c
}

func (c ObjectFreq) Key(key string) ObjectFreqKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ObjectFreqKey)(c)
}

type ObjectFreqKey Incomplete

func (c ObjectFreqKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ObjectHelp Incomplete

func (b Builder) ObjectHelp() (c ObjectHelp) {
	c = ObjectHelp{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "OBJECT", "HELP")
	return c
}

func (c ObjectHelp) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ObjectIdletime Incomplete

func (b Builder) ObjectIdletime() (c ObjectIdletime) {
	c = ObjectIdletime{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "OBJECT", "IDLETIME")
	return c
}

func (c ObjectIdletime) Key(key string) ObjectIdletimeKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ObjectIdletimeKey)(c)
}

type ObjectIdletimeKey Incomplete

func (c ObjectIdletimeKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ObjectRefcount Incomplete

func (b Builder) ObjectRefcount() (c ObjectRefcount) {
	c = ObjectRefcount{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "OBJECT", "REFCOUNT")
	return c
}

func (c ObjectRefcount) Key(key string) ObjectRefcountKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (ObjectRefcountKey)(c)
}

type ObjectRefcountKey Incomplete

func (c ObjectRefcountKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Persist Incomplete

func (b Builder) Persist() (c Persist) {
	c = Persist{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "PERSIST")
	return c
}

func (c Persist) Key(key string) PersistKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (PersistKey)(c)
}

type PersistKey Incomplete

func (c PersistKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Pexpire Incomplete

func (b Builder) Pexpire() (c Pexpire) {
	c = Pexpire{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "PEXPIRE")
	return c
}

func (c Pexpire) Key(key string) PexpireKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (PexpireKey)(c)
}

type PexpireConditionGt Incomplete

func (c PexpireConditionGt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireConditionLt Incomplete

func (c PexpireConditionLt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireConditionNx Incomplete

func (c PexpireConditionNx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireConditionXx Incomplete

func (c PexpireConditionXx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireKey Incomplete

func (c PexpireKey) Milliseconds(milliseconds int64) PexpireMilliseconds {
	c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
	return (PexpireMilliseconds)(c)
}

type PexpireMilliseconds Incomplete

func (c PexpireMilliseconds) Nx() PexpireConditionNx {
	c.cs.s = append(c.cs.s, "NX")
	return (PexpireConditionNx)(c)
}

func (c PexpireMilliseconds) Xx() PexpireConditionXx {
	c.cs.s = append(c.cs.s, "XX")
	return (PexpireConditionXx)(c)
}

func (c PexpireMilliseconds) Gt() PexpireConditionGt {
	c.cs.s = append(c.cs.s, "GT")
	return (PexpireConditionGt)(c)
}

func (c PexpireMilliseconds) Lt() PexpireConditionLt {
	c.cs.s = append(c.cs.s, "LT")
	return (PexpireConditionLt)(c)
}

func (c PexpireMilliseconds) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Pexpireat Incomplete

func (b Builder) Pexpireat() (c Pexpireat) {
	c = Pexpireat{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "PEXPIREAT")
	return c
}

func (c Pexpireat) Key(key string) PexpireatKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (PexpireatKey)(c)
}

type PexpireatConditionGt Incomplete

func (c PexpireatConditionGt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireatConditionLt Incomplete

func (c PexpireatConditionLt) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireatConditionNx Incomplete

func (c PexpireatConditionNx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireatConditionXx Incomplete

func (c PexpireatConditionXx) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type PexpireatKey Incomplete

func (c PexpireatKey) MillisecondsTimestamp(millisecondsTimestamp int64) PexpireatMillisecondsTimestamp {
	c.cs.s = append(c.cs.s, strconv.FormatInt(millisecondsTimestamp, 10))
	return (PexpireatMillisecondsTimestamp)(c)
}

type PexpireatMillisecondsTimestamp Incomplete

func (c PexpireatMillisecondsTimestamp) Nx() PexpireatConditionNx {
	c.cs.s = append(c.cs.s, "NX")
	return (PexpireatConditionNx)(c)
}

func (c PexpireatMillisecondsTimestamp) Xx() PexpireatConditionXx {
	c.cs.s = append(c.cs.s, "XX")
	return (PexpireatConditionXx)(c)
}

func (c PexpireatMillisecondsTimestamp) Gt() PexpireatConditionGt {
	c.cs.s = append(c.cs.s, "GT")
	return (PexpireatConditionGt)(c)
}

func (c PexpireatMillisecondsTimestamp) Lt() PexpireatConditionLt {
	c.cs.s = append(c.cs.s, "LT")
	return (PexpireatConditionLt)(c)
}

func (c PexpireatMillisecondsTimestamp) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Pexpiretime Incomplete

func (b Builder) Pexpiretime() (c Pexpiretime) {
	c = Pexpiretime{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "PEXPIRETIME")
	return c
}

func (c Pexpiretime) Key(key string) PexpiretimeKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (PexpiretimeKey)(c)
}

type PexpiretimeKey Incomplete

func (c PexpiretimeKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c PexpiretimeKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Pttl Incomplete

func (b Builder) Pttl() (c Pttl) {
	c = Pttl{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "PTTL")
	return c
}

func (c Pttl) Key(key string) PttlKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (PttlKey)(c)
}

type PttlKey Incomplete

func (c PttlKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c PttlKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Randomkey Incomplete

func (b Builder) Randomkey() (c Randomkey) {
	c = Randomkey{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "RANDOMKEY")
	return c
}

func (c Randomkey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Rename Incomplete

func (b Builder) Rename() (c Rename) {
	c = Rename{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "RENAME")
	return c
}

func (c Rename) Key(key string) RenameKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (RenameKey)(c)
}

type RenameKey Incomplete

func (c RenameKey) Newkey(newkey string) RenameNewkey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(newkey)
	} else {
		c.ks = check(c.ks, slot(newkey))
	}
	c.cs.s = append(c.cs.s, newkey)
	return (RenameNewkey)(c)
}

type RenameNewkey Incomplete

func (c RenameNewkey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Renamenx Incomplete

func (b Builder) Renamenx() (c Renamenx) {
	c = Renamenx{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "RENAMENX")
	return c
}

func (c Renamenx) Key(key string) RenamenxKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (RenamenxKey)(c)
}

type RenamenxKey Incomplete

func (c RenamenxKey) Newkey(newkey string) RenamenxNewkey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(newkey)
	} else {
		c.ks = check(c.ks, slot(newkey))
	}
	c.cs.s = append(c.cs.s, newkey)
	return (RenamenxNewkey)(c)
}

type RenamenxNewkey Incomplete

func (c RenamenxNewkey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Restore Incomplete

func (b Builder) Restore() (c Restore) {
	c = Restore{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "RESTORE")
	return c
}

func (c Restore) Key(key string) RestoreKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (RestoreKey)(c)
}

type RestoreAbsttl Incomplete

func (c RestoreAbsttl) Idletime(seconds int64) RestoreIdletime {
	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
	return (RestoreIdletime)(c)
}

func (c RestoreAbsttl) Freq(frequency int64) RestoreFreq {
	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
	return (RestoreFreq)(c)
}

func (c RestoreAbsttl) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type RestoreFreq Incomplete

func (c RestoreFreq) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type RestoreIdletime Incomplete

func (c RestoreIdletime) Freq(frequency int64) RestoreFreq {
	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
	return (RestoreFreq)(c)
}

func (c RestoreIdletime) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type RestoreKey Incomplete

func (c RestoreKey) Ttl(ttl int64) RestoreTtl {
	c.cs.s = append(c.cs.s, strconv.FormatInt(ttl, 10))
	return (RestoreTtl)(c)
}

type RestoreReplace Incomplete

func (c RestoreReplace) Absttl() RestoreAbsttl {
	c.cs.s = append(c.cs.s, "ABSTTL")
	return (RestoreAbsttl)(c)
}

func (c RestoreReplace) Idletime(seconds int64) RestoreIdletime {
	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
	return (RestoreIdletime)(c)
}

func (c RestoreReplace) Freq(frequency int64) RestoreFreq {
	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
	return (RestoreFreq)(c)
}

func (c RestoreReplace) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type RestoreSerializedValue Incomplete

func (c RestoreSerializedValue) Replace() RestoreReplace {
	c.cs.s = append(c.cs.s, "REPLACE")
	return (RestoreReplace)(c)
}

func (c RestoreSerializedValue) Absttl() RestoreAbsttl {
	c.cs.s = append(c.cs.s, "ABSTTL")
	return (RestoreAbsttl)(c)
}

func (c RestoreSerializedValue) Idletime(seconds int64) RestoreIdletime {
	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
	return (RestoreIdletime)(c)
}

func (c RestoreSerializedValue) Freq(frequency int64) RestoreFreq {
	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
	return (RestoreFreq)(c)
}

func (c RestoreSerializedValue) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type RestoreTtl Incomplete

func (c RestoreTtl) SerializedValue(serializedValue string) RestoreSerializedValue {
	c.cs.s = append(c.cs.s, serializedValue)
	return (RestoreSerializedValue)(c)
}

type Scan Incomplete

func (b Builder) Scan() (c Scan) {
	c = Scan{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "SCAN")
	return c
}

func (c Scan) Cursor(cursor uint64) ScanCursor {
	c.cs.s = append(c.cs.s, strconv.FormatUint(cursor, 10))
	return (ScanCursor)(c)
}

type ScanCount Incomplete

func (c ScanCount) Type(typ string) ScanType {
	c.cs.s = append(c.cs.s, "TYPE", typ)
	return (ScanType)(c)
}

func (c ScanCount) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ScanCursor Incomplete

func (c ScanCursor) Match(pattern string) ScanMatch {
	c.cs.s = append(c.cs.s, "MATCH", pattern)
	return (ScanMatch)(c)
}

func (c ScanCursor) Count(count int64) ScanCount {
	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
	return (ScanCount)(c)
}

func (c ScanCursor) Type(typ string) ScanType {
	c.cs.s = append(c.cs.s, "TYPE", typ)
	return (ScanType)(c)
}

func (c ScanCursor) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ScanMatch Incomplete

func (c ScanMatch) Count(count int64) ScanCount {
	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
	return (ScanCount)(c)
}

func (c ScanMatch) Type(typ string) ScanType {
	c.cs.s = append(c.cs.s, "TYPE", typ)
	return (ScanType)(c)
}

func (c ScanMatch) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ScanType Incomplete

func (c ScanType) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Sort Incomplete

func (b Builder) Sort() (c Sort) {
	c = Sort{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "SORT")
	return c
}

func (c Sort) Key(key string) SortKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (SortKey)(c)
}

type SortBy Incomplete

func (c SortBy) Limit(offset int64, count int64) SortLimit {
	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
	return (SortLimit)(c)
}

func (c SortBy) Get() SortGet {
	return (SortGet)(c)
}

func (c SortBy) Asc() SortOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortOrderAsc)(c)
}

func (c SortBy) Desc() SortOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortOrderDesc)(c)
}

func (c SortBy) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortBy) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortBy) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortGet Incomplete

func (c SortGet) Get(pattern string) SortGet {
	c.cs.s = append(c.cs.s, "GET", pattern)
	return c
}

func (c SortGet) Asc() SortOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortOrderAsc)(c)
}

func (c SortGet) Desc() SortOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortOrderDesc)(c)
}

func (c SortGet) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortGet) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortGet) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortKey Incomplete

func (c SortKey) By(pattern string) SortBy {
	c.cs.s = append(c.cs.s, "BY", pattern)
	return (SortBy)(c)
}

func (c SortKey) Limit(offset int64, count int64) SortLimit {
	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
	return (SortLimit)(c)
}

func (c SortKey) Get() SortGet {
	return (SortGet)(c)
}

func (c SortKey) Asc() SortOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortOrderAsc)(c)
}

func (c SortKey) Desc() SortOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortOrderDesc)(c)
}

func (c SortKey) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortKey) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortLimit Incomplete

func (c SortLimit) Get() SortGet {
	return (SortGet)(c)
}

func (c SortLimit) Asc() SortOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortOrderAsc)(c)
}

func (c SortLimit) Desc() SortOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortOrderDesc)(c)
}

func (c SortLimit) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortLimit) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortLimit) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortOrderAsc Incomplete

func (c SortOrderAsc) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortOrderAsc) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortOrderAsc) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortOrderDesc Incomplete

func (c SortOrderDesc) Alpha() SortSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortSortingAlpha)(c)
}

func (c SortOrderDesc) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortOrderDesc) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRo Incomplete

func (b Builder) SortRo() (c SortRo) {
	c = SortRo{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "SORT_RO")
	return c
}

func (c SortRo) Key(key string) SortRoKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (SortRoKey)(c)
}

type SortRoBy Incomplete

func (c SortRoBy) Limit(offset int64, count int64) SortRoLimit {
	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
	return (SortRoLimit)(c)
}

func (c SortRoBy) Get() SortRoGet {
	return (SortRoGet)(c)
}

func (c SortRoBy) Asc() SortRoOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortRoOrderAsc)(c)
}

func (c SortRoBy) Desc() SortRoOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortRoOrderDesc)(c)
}

func (c SortRoBy) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoBy) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoBy) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoGet Incomplete

func (c SortRoGet) Get(pattern string) SortRoGet {
	c.cs.s = append(c.cs.s, "GET", pattern)
	return c
}

func (c SortRoGet) Asc() SortRoOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortRoOrderAsc)(c)
}

func (c SortRoGet) Desc() SortRoOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortRoOrderDesc)(c)
}

func (c SortRoGet) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoGet) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoGet) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoKey Incomplete

func (c SortRoKey) By(pattern string) SortRoBy {
	c.cs.s = append(c.cs.s, "BY", pattern)
	return (SortRoBy)(c)
}

func (c SortRoKey) Limit(offset int64, count int64) SortRoLimit {
	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
	return (SortRoLimit)(c)
}

func (c SortRoKey) Get() SortRoGet {
	return (SortRoGet)(c)
}

func (c SortRoKey) Asc() SortRoOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortRoOrderAsc)(c)
}

func (c SortRoKey) Desc() SortRoOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortRoOrderDesc)(c)
}

func (c SortRoKey) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoLimit Incomplete

func (c SortRoLimit) Get() SortRoGet {
	return (SortRoGet)(c)
}

func (c SortRoLimit) Asc() SortRoOrderAsc {
	c.cs.s = append(c.cs.s, "ASC")
	return (SortRoOrderAsc)(c)
}

func (c SortRoLimit) Desc() SortRoOrderDesc {
	c.cs.s = append(c.cs.s, "DESC")
	return (SortRoOrderDesc)(c)
}

func (c SortRoLimit) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoLimit) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoLimit) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoOrderAsc Incomplete

func (c SortRoOrderAsc) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoOrderAsc) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoOrderAsc) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoOrderDesc Incomplete

func (c SortRoOrderDesc) Alpha() SortRoSortingAlpha {
	c.cs.s = append(c.cs.s, "ALPHA")
	return (SortRoSortingAlpha)(c)
}

func (c SortRoOrderDesc) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoOrderDesc) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortRoSortingAlpha Incomplete

func (c SortRoSortingAlpha) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c SortRoSortingAlpha) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortSortingAlpha Incomplete

func (c SortSortingAlpha) Store(destination string) SortStore {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destination)
	} else {
		c.ks = check(c.ks, slot(destination))
	}
	c.cs.s = append(c.cs.s, "STORE", destination)
	return (SortStore)(c)
}

func (c SortSortingAlpha) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type SortStore Incomplete

func (c SortStore) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Touch Incomplete

func (b Builder) Touch() (c Touch) {
	c = Touch{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "TOUCH")
	return c
}

func (c Touch) Key(key ...string) TouchKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return (TouchKey)(c)
}

type TouchKey Incomplete

func (c TouchKey) Key(key ...string) TouchKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return c
}

func (c TouchKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Ttl Incomplete

func (b Builder) Ttl() (c Ttl) {
	c = Ttl{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "TTL")
	return c
}

func (c Ttl) Key(key string) TtlKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (TtlKey)(c)
}

type TtlKey Incomplete

func (c TtlKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c TtlKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Type Incomplete

func (b Builder) Type() (c Type) {
	c = Type{cs: get(), ks: b.ks, cf: int16(readonly)}
	c.cs.s = append(c.cs.s, "TYPE")
	return c
}

func (c Type) Key(key string) TypeKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(key)
	} else {
		c.ks = check(c.ks, slot(key))
	}
	c.cs.s = append(c.cs.s, key)
	return (TypeKey)(c)
}

type TypeKey Incomplete

func (c TypeKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c TypeKey) Cache() Cacheable {
	c.cs.Build()
	return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Unlink Incomplete

func (b Builder) Unlink() (c Unlink) {
	c = Unlink{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "UNLINK")
	return c
}

func (c Unlink) Key(key ...string) UnlinkKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return (UnlinkKey)(c)
}

type UnlinkKey Incomplete

func (c UnlinkKey) Key(key ...string) UnlinkKey {
	if c.ks&NoSlot == NoSlot {
		for _, k := range key {
			c.ks = NoSlot | slot(k)
			break
		}
	} else {
		for _, k := range key {
			c.ks = check(c.ks, slot(k))
		}
	}
	c.cs.s = append(c.cs.s, key...)
	return c
}

func (c UnlinkKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Wait Incomplete

func (b Builder) Wait() (c Wait) {
	c = Wait{cs: get(), ks: b.ks, cf: int16(blockTag)}
	c.cs.s = append(c.cs.s, "WAIT")
	return c
}

func (c Wait) Numreplicas(numreplicas int64) WaitNumreplicas {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numreplicas, 10))
	return (WaitNumreplicas)(c)
}

type WaitNumreplicas Incomplete

func (c WaitNumreplicas) Timeout(timeout int64) WaitTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
	return (WaitTimeout)(c)
}

type WaitTimeout Incomplete

func (c WaitTimeout) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type Waitaof Incomplete

func (b Builder) Waitaof() (c Waitaof) {
	c = Waitaof{cs: get(), ks: b.ks, cf: int16(blockTag)}
	c.cs.s = append(c.cs.s, "WAITAOF")
	return c
}

func (c Waitaof) Numlocal(numlocal int64) WaitaofNumlocal {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numlocal, 10))
	return (WaitaofNumlocal)(c)
}

type WaitaofNumlocal Incomplete

func (c WaitaofNumlocal) Numreplicas(numreplicas int64) WaitaofNumreplicas {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numreplicas, 10))
	return (WaitaofNumreplicas)(c)
}

type WaitaofNumreplicas Incomplete

func (c WaitaofNumreplicas) Timeout(timeout int64) WaitaofTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
	return (WaitaofTimeout)(c)
}

type WaitaofTimeout Incomplete

func (c WaitaofTimeout) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}