gen_sorted_set.go

// Code generated DO NOT EDIT

package cmds

import "strconv"

type Bzmpop Incomplete

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

func (c Bzmpop) Timeout(timeout float64) BzmpopTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
	return (BzmpopTimeout)(c)
}

type BzmpopCount Incomplete

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

type BzmpopKey Incomplete

func (c BzmpopKey) Key(key ...string) BzmpopKey {
	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 BzmpopKey) Min() BzmpopWhereMin {
	c.cs.s = append(c.cs.s, "MIN")
	return (BzmpopWhereMin)(c)
}

func (c BzmpopKey) Max() BzmpopWhereMax {
	c.cs.s = append(c.cs.s, "MAX")
	return (BzmpopWhereMax)(c)
}

type BzmpopNumkeys Incomplete

func (c BzmpopNumkeys) Key(key ...string) BzmpopKey {
	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 (BzmpopKey)(c)
}

type BzmpopTimeout Incomplete

func (c BzmpopTimeout) Numkeys(numkeys int64) BzmpopNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (BzmpopNumkeys)(c)
}

type BzmpopWhereMax Incomplete

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

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

type BzmpopWhereMin Incomplete

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

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

type Bzpopmax Incomplete

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

func (c Bzpopmax) Key(key ...string) BzpopmaxKey {
	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 (BzpopmaxKey)(c)
}

type BzpopmaxKey Incomplete

func (c BzpopmaxKey) Key(key ...string) BzpopmaxKey {
	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 BzpopmaxKey) Timeout(timeout float64) BzpopmaxTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
	return (BzpopmaxTimeout)(c)
}

type BzpopmaxTimeout Incomplete

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

type Bzpopmin Incomplete

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

func (c Bzpopmin) Key(key ...string) BzpopminKey {
	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 (BzpopminKey)(c)
}

type BzpopminKey Incomplete

func (c BzpopminKey) Key(key ...string) BzpopminKey {
	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 BzpopminKey) Timeout(timeout float64) BzpopminTimeout {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
	return (BzpopminTimeout)(c)
}

type BzpopminTimeout Incomplete

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

type Zadd Incomplete

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

func (c Zadd) Key(key string) ZaddKey {
	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 (ZaddKey)(c)
}

type ZaddChangeCh Incomplete

func (c ZaddChangeCh) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddChangeCh) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddComparisonGt Incomplete

func (c ZaddComparisonGt) Ch() ZaddChangeCh {
	c.cs.s = append(c.cs.s, "CH")
	return (ZaddChangeCh)(c)
}

func (c ZaddComparisonGt) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddComparisonGt) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddComparisonLt Incomplete

func (c ZaddComparisonLt) Ch() ZaddChangeCh {
	c.cs.s = append(c.cs.s, "CH")
	return (ZaddChangeCh)(c)
}

func (c ZaddComparisonLt) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddComparisonLt) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddConditionNx Incomplete

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

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

func (c ZaddConditionNx) Ch() ZaddChangeCh {
	c.cs.s = append(c.cs.s, "CH")
	return (ZaddChangeCh)(c)
}

func (c ZaddConditionNx) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddConditionNx) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddConditionXx Incomplete

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

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

func (c ZaddConditionXx) Ch() ZaddChangeCh {
	c.cs.s = append(c.cs.s, "CH")
	return (ZaddChangeCh)(c)
}

func (c ZaddConditionXx) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddConditionXx) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddIncrementIncr Incomplete

func (c ZaddIncrementIncr) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddKey Incomplete

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

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

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

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

func (c ZaddKey) Ch() ZaddChangeCh {
	c.cs.s = append(c.cs.s, "CH")
	return (ZaddChangeCh)(c)
}

func (c ZaddKey) Incr() ZaddIncrementIncr {
	c.cs.s = append(c.cs.s, "INCR")
	return (ZaddIncrementIncr)(c)
}

func (c ZaddKey) ScoreMember() ZaddScoreMember {
	return (ZaddScoreMember)(c)
}

type ZaddScoreMember Incomplete

func (c ZaddScoreMember) ScoreMember(score float64, member string) ZaddScoreMember {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(score, 'f', -1, 64), member)
	return c
}

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

type Zcard Incomplete

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

func (c Zcard) Key(key string) ZcardKey {
	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 (ZcardKey)(c)
}

type ZcardKey Incomplete

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

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

type Zcount Incomplete

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

func (c Zcount) Key(key string) ZcountKey {
	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 (ZcountKey)(c)
}

type ZcountKey Incomplete

func (c ZcountKey) Min(min string) ZcountMin {
	c.cs.s = append(c.cs.s, min)
	return (ZcountMin)(c)
}

type ZcountMax Incomplete

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

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

type ZcountMin Incomplete

func (c ZcountMin) Max(max string) ZcountMax {
	c.cs.s = append(c.cs.s, max)
	return (ZcountMax)(c)
}

type Zdiff Incomplete

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

func (c Zdiff) Numkeys(numkeys int64) ZdiffNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZdiffNumkeys)(c)
}

type ZdiffKey Incomplete

func (c ZdiffKey) Key(key ...string) ZdiffKey {
	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 ZdiffKey) Withscores() ZdiffWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZdiffWithscores)(c)
}

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

type ZdiffNumkeys Incomplete

func (c ZdiffNumkeys) Key(key ...string) ZdiffKey {
	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 (ZdiffKey)(c)
}

type ZdiffWithscores Incomplete

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

type Zdiffstore Incomplete

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

func (c Zdiffstore) Destination(destination string) ZdiffstoreDestination {
	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 (ZdiffstoreDestination)(c)
}

type ZdiffstoreDestination Incomplete

func (c ZdiffstoreDestination) Numkeys(numkeys int64) ZdiffstoreNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZdiffstoreNumkeys)(c)
}

type ZdiffstoreKey Incomplete

func (c ZdiffstoreKey) Key(key ...string) ZdiffstoreKey {
	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 ZdiffstoreKey) Build() Completed {
	c.cs.Build()
	return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type ZdiffstoreNumkeys Incomplete

func (c ZdiffstoreNumkeys) Key(key ...string) ZdiffstoreKey {
	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 (ZdiffstoreKey)(c)
}

type Zincrby Incomplete

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

func (c Zincrby) Key(key string) ZincrbyKey {
	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 (ZincrbyKey)(c)
}

type ZincrbyIncrement Incomplete

func (c ZincrbyIncrement) Member(member string) ZincrbyMember {
	c.cs.s = append(c.cs.s, member)
	return (ZincrbyMember)(c)
}

type ZincrbyKey Incomplete

func (c ZincrbyKey) Increment(increment float64) ZincrbyIncrement {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
	return (ZincrbyIncrement)(c)
}

type ZincrbyMember Incomplete

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

type Zinter Incomplete

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

func (c Zinter) Numkeys(numkeys int64) ZinterNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZinterNumkeys)(c)
}

type ZinterAggregateMax Incomplete

func (c ZinterAggregateMax) Withscores() ZinterWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZinterWithscores)(c)
}

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

type ZinterAggregateMin Incomplete

func (c ZinterAggregateMin) Withscores() ZinterWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZinterWithscores)(c)
}

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

type ZinterAggregateSum Incomplete

func (c ZinterAggregateSum) Withscores() ZinterWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZinterWithscores)(c)
}

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

type ZinterKey Incomplete

func (c ZinterKey) Key(key ...string) ZinterKey {
	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 ZinterKey) Weights(weight ...int64) ZinterWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (ZinterWeights)(c)
}

func (c ZinterKey) AggregateSum() ZinterAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZinterAggregateSum)(c)
}

func (c ZinterKey) AggregateMin() ZinterAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZinterAggregateMin)(c)
}

func (c ZinterKey) AggregateMax() ZinterAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZinterAggregateMax)(c)
}

func (c ZinterKey) Withscores() ZinterWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZinterWithscores)(c)
}

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

type ZinterNumkeys Incomplete

func (c ZinterNumkeys) Key(key ...string) ZinterKey {
	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 (ZinterKey)(c)
}

type ZinterWeights Incomplete

func (c ZinterWeights) Weights(weight ...int64) ZinterWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c ZinterWeights) AggregateSum() ZinterAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZinterAggregateSum)(c)
}

func (c ZinterWeights) AggregateMin() ZinterAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZinterAggregateMin)(c)
}

func (c ZinterWeights) AggregateMax() ZinterAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZinterAggregateMax)(c)
}

func (c ZinterWeights) Withscores() ZinterWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZinterWithscores)(c)
}

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

type ZinterWithscores Incomplete

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

type Zintercard Incomplete

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

func (c Zintercard) Numkeys(numkeys int64) ZintercardNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZintercardNumkeys)(c)
}

type ZintercardKey Incomplete

func (c ZintercardKey) Key(key ...string) ZintercardKey {
	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 ZintercardKey) Limit(limit int64) ZintercardLimit {
	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(limit, 10))
	return (ZintercardLimit)(c)
}

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

type ZintercardLimit Incomplete

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

type ZintercardNumkeys Incomplete

func (c ZintercardNumkeys) Key(key ...string) ZintercardKey {
	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 (ZintercardKey)(c)
}

type Zinterstore Incomplete

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

func (c Zinterstore) Destination(destination string) ZinterstoreDestination {
	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 (ZinterstoreDestination)(c)
}

type ZinterstoreAggregateMax Incomplete

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

type ZinterstoreAggregateMin Incomplete

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

type ZinterstoreAggregateSum Incomplete

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

type ZinterstoreDestination Incomplete

func (c ZinterstoreDestination) Numkeys(numkeys int64) ZinterstoreNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZinterstoreNumkeys)(c)
}

type ZinterstoreKey Incomplete

func (c ZinterstoreKey) Key(key ...string) ZinterstoreKey {
	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 ZinterstoreKey) Weights(weight ...int64) ZinterstoreWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (ZinterstoreWeights)(c)
}

func (c ZinterstoreKey) AggregateSum() ZinterstoreAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZinterstoreAggregateSum)(c)
}

func (c ZinterstoreKey) AggregateMin() ZinterstoreAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZinterstoreAggregateMin)(c)
}

func (c ZinterstoreKey) AggregateMax() ZinterstoreAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZinterstoreAggregateMax)(c)
}

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

type ZinterstoreNumkeys Incomplete

func (c ZinterstoreNumkeys) Key(key ...string) ZinterstoreKey {
	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 (ZinterstoreKey)(c)
}

type ZinterstoreWeights Incomplete

func (c ZinterstoreWeights) Weights(weight ...int64) ZinterstoreWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c ZinterstoreWeights) AggregateSum() ZinterstoreAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZinterstoreAggregateSum)(c)
}

func (c ZinterstoreWeights) AggregateMin() ZinterstoreAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZinterstoreAggregateMin)(c)
}

func (c ZinterstoreWeights) AggregateMax() ZinterstoreAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZinterstoreAggregateMax)(c)
}

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

type Zlexcount Incomplete

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

func (c Zlexcount) Key(key string) ZlexcountKey {
	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 (ZlexcountKey)(c)
}

type ZlexcountKey Incomplete

func (c ZlexcountKey) Min(min string) ZlexcountMin {
	c.cs.s = append(c.cs.s, min)
	return (ZlexcountMin)(c)
}

type ZlexcountMax Incomplete

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

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

type ZlexcountMin Incomplete

func (c ZlexcountMin) Max(max string) ZlexcountMax {
	c.cs.s = append(c.cs.s, max)
	return (ZlexcountMax)(c)
}

type Zmpop Incomplete

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

func (c Zmpop) Numkeys(numkeys int64) ZmpopNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZmpopNumkeys)(c)
}

type ZmpopCount Incomplete

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

type ZmpopKey Incomplete

func (c ZmpopKey) Key(key ...string) ZmpopKey {
	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 ZmpopKey) Min() ZmpopWhereMin {
	c.cs.s = append(c.cs.s, "MIN")
	return (ZmpopWhereMin)(c)
}

func (c ZmpopKey) Max() ZmpopWhereMax {
	c.cs.s = append(c.cs.s, "MAX")
	return (ZmpopWhereMax)(c)
}

type ZmpopNumkeys Incomplete

func (c ZmpopNumkeys) Key(key ...string) ZmpopKey {
	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 (ZmpopKey)(c)
}

type ZmpopWhereMax Incomplete

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

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

type ZmpopWhereMin Incomplete

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

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

type Zmscore Incomplete

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

func (c Zmscore) Key(key string) ZmscoreKey {
	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 (ZmscoreKey)(c)
}

type ZmscoreKey Incomplete

func (c ZmscoreKey) Member(member ...string) ZmscoreMember {
	c.cs.s = append(c.cs.s, member...)
	return (ZmscoreMember)(c)
}

type ZmscoreMember Incomplete

func (c ZmscoreMember) Member(member ...string) ZmscoreMember {
	c.cs.s = append(c.cs.s, member...)
	return c
}

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

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

type Zpopmax Incomplete

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

func (c Zpopmax) Key(key string) ZpopmaxKey {
	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 (ZpopmaxKey)(c)
}

type ZpopmaxCount Incomplete

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

type ZpopmaxKey Incomplete

func (c ZpopmaxKey) Count(count int64) ZpopmaxCount {
	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
	return (ZpopmaxCount)(c)
}

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

type Zpopmin Incomplete

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

func (c Zpopmin) Key(key string) ZpopminKey {
	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 (ZpopminKey)(c)
}

type ZpopminCount Incomplete

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

type ZpopminKey Incomplete

func (c ZpopminKey) Count(count int64) ZpopminCount {
	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
	return (ZpopminCount)(c)
}

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

type Zrandmember Incomplete

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

func (c Zrandmember) Key(key string) ZrandmemberKey {
	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 (ZrandmemberKey)(c)
}

type ZrandmemberKey Incomplete

func (c ZrandmemberKey) Count(count int64) ZrandmemberOptionsCount {
	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
	return (ZrandmemberOptionsCount)(c)
}

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

type ZrandmemberOptionsCount Incomplete

func (c ZrandmemberOptionsCount) Withscores() ZrandmemberOptionsWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrandmemberOptionsWithscores)(c)
}

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

type ZrandmemberOptionsWithscores Incomplete

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

type Zrange Incomplete

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

func (c Zrange) Key(key string) ZrangeKey {
	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 (ZrangeKey)(c)
}

type ZrangeKey Incomplete

func (c ZrangeKey) Min(min string) ZrangeMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrangeMin)(c)
}

type ZrangeLimit Incomplete

func (c ZrangeLimit) Withscores() ZrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangeWithscores)(c)
}

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

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

type ZrangeMax Incomplete

func (c ZrangeMax) Byscore() ZrangeSortbyByscore {
	c.cs.s = append(c.cs.s, "BYSCORE")
	return (ZrangeSortbyByscore)(c)
}

func (c ZrangeMax) Bylex() ZrangeSortbyBylex {
	c.cs.s = append(c.cs.s, "BYLEX")
	return (ZrangeSortbyBylex)(c)
}

func (c ZrangeMax) Rev() ZrangeRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangeRev)(c)
}

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

func (c ZrangeMax) Withscores() ZrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangeWithscores)(c)
}

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

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

type ZrangeMin Incomplete

func (c ZrangeMin) Max(max string) ZrangeMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrangeMax)(c)
}

type ZrangeRev Incomplete

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

func (c ZrangeRev) Withscores() ZrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangeWithscores)(c)
}

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

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

type ZrangeSortbyBylex Incomplete

func (c ZrangeSortbyBylex) Rev() ZrangeRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangeRev)(c)
}

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

func (c ZrangeSortbyBylex) Withscores() ZrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangeWithscores)(c)
}

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

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

type ZrangeSortbyByscore Incomplete

func (c ZrangeSortbyByscore) Rev() ZrangeRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangeRev)(c)
}

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

func (c ZrangeSortbyByscore) Withscores() ZrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangeWithscores)(c)
}

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

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

type ZrangeWithscores Incomplete

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

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

type Zrangebylex Incomplete

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

func (c Zrangebylex) Key(key string) ZrangebylexKey {
	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 (ZrangebylexKey)(c)
}

type ZrangebylexKey Incomplete

func (c ZrangebylexKey) Min(min string) ZrangebylexMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrangebylexMin)(c)
}

type ZrangebylexLimit Incomplete

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

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

type ZrangebylexMax Incomplete

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

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

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

type ZrangebylexMin Incomplete

func (c ZrangebylexMin) Max(max string) ZrangebylexMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrangebylexMax)(c)
}

type Zrangebyscore Incomplete

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

func (c Zrangebyscore) Key(key string) ZrangebyscoreKey {
	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 (ZrangebyscoreKey)(c)
}

type ZrangebyscoreKey Incomplete

func (c ZrangebyscoreKey) Min(min string) ZrangebyscoreMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrangebyscoreMin)(c)
}

type ZrangebyscoreLimit Incomplete

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

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

type ZrangebyscoreMax Incomplete

func (c ZrangebyscoreMax) Withscores() ZrangebyscoreWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrangebyscoreWithscores)(c)
}

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

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

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

type ZrangebyscoreMin Incomplete

func (c ZrangebyscoreMin) Max(max string) ZrangebyscoreMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrangebyscoreMax)(c)
}

type ZrangebyscoreWithscores Incomplete

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

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

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

type Zrangestore Incomplete

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

func (c Zrangestore) Dst(dst string) ZrangestoreDst {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(dst)
	} else {
		c.ks = check(c.ks, slot(dst))
	}
	c.cs.s = append(c.cs.s, dst)
	return (ZrangestoreDst)(c)
}

type ZrangestoreDst Incomplete

func (c ZrangestoreDst) Src(src string) ZrangestoreSrc {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(src)
	} else {
		c.ks = check(c.ks, slot(src))
	}
	c.cs.s = append(c.cs.s, src)
	return (ZrangestoreSrc)(c)
}

type ZrangestoreLimit Incomplete

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

type ZrangestoreMax Incomplete

func (c ZrangestoreMax) Byscore() ZrangestoreSortbyByscore {
	c.cs.s = append(c.cs.s, "BYSCORE")
	return (ZrangestoreSortbyByscore)(c)
}

func (c ZrangestoreMax) Bylex() ZrangestoreSortbyBylex {
	c.cs.s = append(c.cs.s, "BYLEX")
	return (ZrangestoreSortbyBylex)(c)
}

func (c ZrangestoreMax) Rev() ZrangestoreRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangestoreRev)(c)
}

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

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

type ZrangestoreMin Incomplete

func (c ZrangestoreMin) Max(max string) ZrangestoreMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrangestoreMax)(c)
}

type ZrangestoreRev Incomplete

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

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

type ZrangestoreSortbyBylex Incomplete

func (c ZrangestoreSortbyBylex) Rev() ZrangestoreRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangestoreRev)(c)
}

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

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

type ZrangestoreSortbyByscore Incomplete

func (c ZrangestoreSortbyByscore) Rev() ZrangestoreRev {
	c.cs.s = append(c.cs.s, "REV")
	return (ZrangestoreRev)(c)
}

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

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

type ZrangestoreSrc Incomplete

func (c ZrangestoreSrc) Min(min string) ZrangestoreMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrangestoreMin)(c)
}

type Zrank Incomplete

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

func (c Zrank) Key(key string) ZrankKey {
	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 (ZrankKey)(c)
}

type ZrankKey Incomplete

func (c ZrankKey) Member(member string) ZrankMember {
	c.cs.s = append(c.cs.s, member)
	return (ZrankMember)(c)
}

type ZrankMember Incomplete

func (c ZrankMember) Withscore() ZrankWithscore {
	c.cs.s = append(c.cs.s, "WITHSCORE")
	return (ZrankWithscore)(c)
}

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

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

type ZrankWithscore Incomplete

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

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

type Zrem Incomplete

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

func (c Zrem) Key(key string) ZremKey {
	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 (ZremKey)(c)
}

type ZremKey Incomplete

func (c ZremKey) Member(member ...string) ZremMember {
	c.cs.s = append(c.cs.s, member...)
	return (ZremMember)(c)
}

type ZremMember Incomplete

func (c ZremMember) Member(member ...string) ZremMember {
	c.cs.s = append(c.cs.s, member...)
	return c
}

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

type Zremrangebylex Incomplete

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

func (c Zremrangebylex) Key(key string) ZremrangebylexKey {
	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 (ZremrangebylexKey)(c)
}

type ZremrangebylexKey Incomplete

func (c ZremrangebylexKey) Min(min string) ZremrangebylexMin {
	c.cs.s = append(c.cs.s, min)
	return (ZremrangebylexMin)(c)
}

type ZremrangebylexMax Incomplete

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

type ZremrangebylexMin Incomplete

func (c ZremrangebylexMin) Max(max string) ZremrangebylexMax {
	c.cs.s = append(c.cs.s, max)
	return (ZremrangebylexMax)(c)
}

type Zremrangebyrank Incomplete

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

func (c Zremrangebyrank) Key(key string) ZremrangebyrankKey {
	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 (ZremrangebyrankKey)(c)
}

type ZremrangebyrankKey Incomplete

func (c ZremrangebyrankKey) Start(start int64) ZremrangebyrankStart {
	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
	return (ZremrangebyrankStart)(c)
}

type ZremrangebyrankStart Incomplete

func (c ZremrangebyrankStart) Stop(stop int64) ZremrangebyrankStop {
	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
	return (ZremrangebyrankStop)(c)
}

type ZremrangebyrankStop Incomplete

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

type Zremrangebyscore Incomplete

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

func (c Zremrangebyscore) Key(key string) ZremrangebyscoreKey {
	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 (ZremrangebyscoreKey)(c)
}

type ZremrangebyscoreKey Incomplete

func (c ZremrangebyscoreKey) Min(min string) ZremrangebyscoreMin {
	c.cs.s = append(c.cs.s, min)
	return (ZremrangebyscoreMin)(c)
}

type ZremrangebyscoreMax Incomplete

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

type ZremrangebyscoreMin Incomplete

func (c ZremrangebyscoreMin) Max(max string) ZremrangebyscoreMax {
	c.cs.s = append(c.cs.s, max)
	return (ZremrangebyscoreMax)(c)
}

type Zrevrange Incomplete

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

func (c Zrevrange) Key(key string) ZrevrangeKey {
	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 (ZrevrangeKey)(c)
}

type ZrevrangeKey Incomplete

func (c ZrevrangeKey) Start(start int64) ZrevrangeStart {
	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
	return (ZrevrangeStart)(c)
}

type ZrevrangeStart Incomplete

func (c ZrevrangeStart) Stop(stop int64) ZrevrangeStop {
	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
	return (ZrevrangeStop)(c)
}

type ZrevrangeStop Incomplete

func (c ZrevrangeStop) Withscores() ZrevrangeWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrevrangeWithscores)(c)
}

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

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

type ZrevrangeWithscores Incomplete

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

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

type Zrevrangebylex Incomplete

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

func (c Zrevrangebylex) Key(key string) ZrevrangebylexKey {
	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 (ZrevrangebylexKey)(c)
}

type ZrevrangebylexKey Incomplete

func (c ZrevrangebylexKey) Max(max string) ZrevrangebylexMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrevrangebylexMax)(c)
}

type ZrevrangebylexLimit Incomplete

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

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

type ZrevrangebylexMax Incomplete

func (c ZrevrangebylexMax) Min(min string) ZrevrangebylexMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrevrangebylexMin)(c)
}

type ZrevrangebylexMin Incomplete

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

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

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

type Zrevrangebyscore Incomplete

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

func (c Zrevrangebyscore) Key(key string) ZrevrangebyscoreKey {
	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 (ZrevrangebyscoreKey)(c)
}

type ZrevrangebyscoreKey Incomplete

func (c ZrevrangebyscoreKey) Max(max string) ZrevrangebyscoreMax {
	c.cs.s = append(c.cs.s, max)
	return (ZrevrangebyscoreMax)(c)
}

type ZrevrangebyscoreLimit Incomplete

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

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

type ZrevrangebyscoreMax Incomplete

func (c ZrevrangebyscoreMax) Min(min string) ZrevrangebyscoreMin {
	c.cs.s = append(c.cs.s, min)
	return (ZrevrangebyscoreMin)(c)
}

type ZrevrangebyscoreMin Incomplete

func (c ZrevrangebyscoreMin) Withscores() ZrevrangebyscoreWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZrevrangebyscoreWithscores)(c)
}

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

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

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

type ZrevrangebyscoreWithscores Incomplete

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

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

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

type Zrevrank Incomplete

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

func (c Zrevrank) Key(key string) ZrevrankKey {
	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 (ZrevrankKey)(c)
}

type ZrevrankKey Incomplete

func (c ZrevrankKey) Member(member string) ZrevrankMember {
	c.cs.s = append(c.cs.s, member)
	return (ZrevrankMember)(c)
}

type ZrevrankMember Incomplete

func (c ZrevrankMember) Withscore() ZrevrankWithscore {
	c.cs.s = append(c.cs.s, "WITHSCORE")
	return (ZrevrankWithscore)(c)
}

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

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

type ZrevrankWithscore Incomplete

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

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

type Zscan Incomplete

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

func (c Zscan) Key(key string) ZscanKey {
	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 (ZscanKey)(c)
}

type ZscanCount Incomplete

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

type ZscanCursor Incomplete

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

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

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

type ZscanKey Incomplete

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

type ZscanMatch Incomplete

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

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

type Zscore Incomplete

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

func (c Zscore) Key(key string) ZscoreKey {
	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 (ZscoreKey)(c)
}

type ZscoreKey Incomplete

func (c ZscoreKey) Member(member string) ZscoreMember {
	c.cs.s = append(c.cs.s, member)
	return (ZscoreMember)(c)
}

type ZscoreMember Incomplete

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

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

type Zunion Incomplete

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

func (c Zunion) Numkeys(numkeys int64) ZunionNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZunionNumkeys)(c)
}

type ZunionAggregateMax Incomplete

func (c ZunionAggregateMax) Withscores() ZunionWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZunionWithscores)(c)
}

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

type ZunionAggregateMin Incomplete

func (c ZunionAggregateMin) Withscores() ZunionWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZunionWithscores)(c)
}

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

type ZunionAggregateSum Incomplete

func (c ZunionAggregateSum) Withscores() ZunionWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZunionWithscores)(c)
}

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

type ZunionKey Incomplete

func (c ZunionKey) Key(key ...string) ZunionKey {
	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 ZunionKey) Weights(weight ...int64) ZunionWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (ZunionWeights)(c)
}

func (c ZunionKey) AggregateSum() ZunionAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZunionAggregateSum)(c)
}

func (c ZunionKey) AggregateMin() ZunionAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZunionAggregateMin)(c)
}

func (c ZunionKey) AggregateMax() ZunionAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZunionAggregateMax)(c)
}

func (c ZunionKey) Withscores() ZunionWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZunionWithscores)(c)
}

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

type ZunionNumkeys Incomplete

func (c ZunionNumkeys) Key(key ...string) ZunionKey {
	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 (ZunionKey)(c)
}

type ZunionWeights Incomplete

func (c ZunionWeights) Weights(weight ...int64) ZunionWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c ZunionWeights) AggregateSum() ZunionAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZunionAggregateSum)(c)
}

func (c ZunionWeights) AggregateMin() ZunionAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZunionAggregateMin)(c)
}

func (c ZunionWeights) AggregateMax() ZunionAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZunionAggregateMax)(c)
}

func (c ZunionWeights) Withscores() ZunionWithscores {
	c.cs.s = append(c.cs.s, "WITHSCORES")
	return (ZunionWithscores)(c)
}

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

type ZunionWithscores Incomplete

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

type Zunionstore Incomplete

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

func (c Zunionstore) Destination(destination string) ZunionstoreDestination {
	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 (ZunionstoreDestination)(c)
}

type ZunionstoreAggregateMax Incomplete

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

type ZunionstoreAggregateMin Incomplete

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

type ZunionstoreAggregateSum Incomplete

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

type ZunionstoreDestination Incomplete

func (c ZunionstoreDestination) Numkeys(numkeys int64) ZunionstoreNumkeys {
	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
	return (ZunionstoreNumkeys)(c)
}

type ZunionstoreKey Incomplete

func (c ZunionstoreKey) Key(key ...string) ZunionstoreKey {
	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 ZunionstoreKey) Weights(weight ...int64) ZunionstoreWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (ZunionstoreWeights)(c)
}

func (c ZunionstoreKey) AggregateSum() ZunionstoreAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZunionstoreAggregateSum)(c)
}

func (c ZunionstoreKey) AggregateMin() ZunionstoreAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZunionstoreAggregateMin)(c)
}

func (c ZunionstoreKey) AggregateMax() ZunionstoreAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZunionstoreAggregateMax)(c)
}

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

type ZunionstoreNumkeys Incomplete

func (c ZunionstoreNumkeys) Key(key ...string) ZunionstoreKey {
	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 (ZunionstoreKey)(c)
}

type ZunionstoreWeights Incomplete

func (c ZunionstoreWeights) Weights(weight ...int64) ZunionstoreWeights {
	c.cs.s = append(c.cs.s, "WEIGHTS")
	for _, n := range weight {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c ZunionstoreWeights) AggregateSum() ZunionstoreAggregateSum {
	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
	return (ZunionstoreAggregateSum)(c)
}

func (c ZunionstoreWeights) AggregateMin() ZunionstoreAggregateMin {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
	return (ZunionstoreAggregateMin)(c)
}

func (c ZunionstoreWeights) AggregateMax() ZunionstoreAggregateMax {
	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
	return (ZunionstoreAggregateMax)(c)
}

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