internal/cmds/gen_stream.go
// Code generated DO NOT EDIT
package cmds
import "strconv"
type Xack Incomplete
func (b Builder) Xack() (c Xack) {
c = Xack{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XACK")
return c
}
func (c Xack) Key(key string) XackKey {
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 (XackKey)(c)
}
type XackGroup Incomplete
func (c XackGroup) Id(id ...string) XackId {
c.cs.s = append(c.cs.s, id...)
return (XackId)(c)
}
type XackId Incomplete
func (c XackId) Id(id ...string) XackId {
c.cs.s = append(c.cs.s, id...)
return c
}
func (c XackId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XackKey Incomplete
func (c XackKey) Group(group string) XackGroup {
c.cs.s = append(c.cs.s, group)
return (XackGroup)(c)
}
type Xadd Incomplete
func (b Builder) Xadd() (c Xadd) {
c = Xadd{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XADD")
return c
}
func (c Xadd) Key(key string) XaddKey {
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 (XaddKey)(c)
}
type XaddFieldValue Incomplete
func (c XaddFieldValue) FieldValue(field string, value string) XaddFieldValue {
c.cs.s = append(c.cs.s, field, value)
return c
}
func (c XaddFieldValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XaddId Incomplete
func (c XaddId) FieldValue() XaddFieldValue {
return (XaddFieldValue)(c)
}
type XaddKey Incomplete
func (c XaddKey) Nomkstream() XaddNomkstream {
c.cs.s = append(c.cs.s, "NOMKSTREAM")
return (XaddNomkstream)(c)
}
func (c XaddKey) Maxlen() XaddTrimStrategyMaxlen {
c.cs.s = append(c.cs.s, "MAXLEN")
return (XaddTrimStrategyMaxlen)(c)
}
func (c XaddKey) Minid() XaddTrimStrategyMinid {
c.cs.s = append(c.cs.s, "MINID")
return (XaddTrimStrategyMinid)(c)
}
func (c XaddKey) Id(id string) XaddId {
c.cs.s = append(c.cs.s, id)
return (XaddId)(c)
}
type XaddNomkstream Incomplete
func (c XaddNomkstream) Maxlen() XaddTrimStrategyMaxlen {
c.cs.s = append(c.cs.s, "MAXLEN")
return (XaddTrimStrategyMaxlen)(c)
}
func (c XaddNomkstream) Minid() XaddTrimStrategyMinid {
c.cs.s = append(c.cs.s, "MINID")
return (XaddTrimStrategyMinid)(c)
}
func (c XaddNomkstream) Id(id string) XaddId {
c.cs.s = append(c.cs.s, id)
return (XaddId)(c)
}
type XaddTrimLimit Incomplete
func (c XaddTrimLimit) Id(id string) XaddId {
c.cs.s = append(c.cs.s, id)
return (XaddId)(c)
}
type XaddTrimOperatorAlmost Incomplete
func (c XaddTrimOperatorAlmost) Threshold(threshold string) XaddTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XaddTrimThreshold)(c)
}
type XaddTrimOperatorExact Incomplete
func (c XaddTrimOperatorExact) Threshold(threshold string) XaddTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XaddTrimThreshold)(c)
}
type XaddTrimStrategyMaxlen Incomplete
func (c XaddTrimStrategyMaxlen) Exact() XaddTrimOperatorExact {
c.cs.s = append(c.cs.s, "=")
return (XaddTrimOperatorExact)(c)
}
func (c XaddTrimStrategyMaxlen) Almost() XaddTrimOperatorAlmost {
c.cs.s = append(c.cs.s, "~")
return (XaddTrimOperatorAlmost)(c)
}
func (c XaddTrimStrategyMaxlen) Threshold(threshold string) XaddTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XaddTrimThreshold)(c)
}
type XaddTrimStrategyMinid Incomplete
func (c XaddTrimStrategyMinid) Exact() XaddTrimOperatorExact {
c.cs.s = append(c.cs.s, "=")
return (XaddTrimOperatorExact)(c)
}
func (c XaddTrimStrategyMinid) Almost() XaddTrimOperatorAlmost {
c.cs.s = append(c.cs.s, "~")
return (XaddTrimOperatorAlmost)(c)
}
func (c XaddTrimStrategyMinid) Threshold(threshold string) XaddTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XaddTrimThreshold)(c)
}
type XaddTrimThreshold Incomplete
func (c XaddTrimThreshold) Limit(count int64) XaddTrimLimit {
c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
return (XaddTrimLimit)(c)
}
func (c XaddTrimThreshold) Id(id string) XaddId {
c.cs.s = append(c.cs.s, id)
return (XaddId)(c)
}
type Xautoclaim Incomplete
func (b Builder) Xautoclaim() (c Xautoclaim) {
c = Xautoclaim{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XAUTOCLAIM")
return c
}
func (c Xautoclaim) Key(key string) XautoclaimKey {
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 (XautoclaimKey)(c)
}
type XautoclaimConsumer Incomplete
func (c XautoclaimConsumer) MinIdleTime(minIdleTime string) XautoclaimMinIdleTime {
c.cs.s = append(c.cs.s, minIdleTime)
return (XautoclaimMinIdleTime)(c)
}
type XautoclaimCount Incomplete
func (c XautoclaimCount) Justid() XautoclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XautoclaimJustid)(c)
}
func (c XautoclaimCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XautoclaimGroup Incomplete
func (c XautoclaimGroup) Consumer(consumer string) XautoclaimConsumer {
c.cs.s = append(c.cs.s, consumer)
return (XautoclaimConsumer)(c)
}
type XautoclaimJustid Incomplete
func (c XautoclaimJustid) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XautoclaimKey Incomplete
func (c XautoclaimKey) Group(group string) XautoclaimGroup {
c.cs.s = append(c.cs.s, group)
return (XautoclaimGroup)(c)
}
type XautoclaimMinIdleTime Incomplete
func (c XautoclaimMinIdleTime) Start(start string) XautoclaimStart {
c.cs.s = append(c.cs.s, start)
return (XautoclaimStart)(c)
}
type XautoclaimStart Incomplete
func (c XautoclaimStart) Count(count int64) XautoclaimCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XautoclaimCount)(c)
}
func (c XautoclaimStart) Justid() XautoclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XautoclaimJustid)(c)
}
func (c XautoclaimStart) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xclaim Incomplete
func (b Builder) Xclaim() (c Xclaim) {
c = Xclaim{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XCLAIM")
return c
}
func (c Xclaim) Key(key string) XclaimKey {
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 (XclaimKey)(c)
}
type XclaimConsumer Incomplete
func (c XclaimConsumer) MinIdleTime(minIdleTime string) XclaimMinIdleTime {
c.cs.s = append(c.cs.s, minIdleTime)
return (XclaimMinIdleTime)(c)
}
type XclaimForce Incomplete
func (c XclaimForce) Justid() XclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XclaimJustid)(c)
}
func (c XclaimForce) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimForce) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimGroup Incomplete
func (c XclaimGroup) Consumer(consumer string) XclaimConsumer {
c.cs.s = append(c.cs.s, consumer)
return (XclaimConsumer)(c)
}
type XclaimId Incomplete
func (c XclaimId) Id(id ...string) XclaimId {
c.cs.s = append(c.cs.s, id...)
return c
}
func (c XclaimId) Idle(ms int64) XclaimIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(ms, 10))
return (XclaimIdle)(c)
}
func (c XclaimId) Time(msUnixTime int64) XclaimTime {
c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
return (XclaimTime)(c)
}
func (c XclaimId) Retrycount(count int64) XclaimRetrycount {
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
return (XclaimRetrycount)(c)
}
func (c XclaimId) Force() XclaimForce {
c.cs.s = append(c.cs.s, "FORCE")
return (XclaimForce)(c)
}
func (c XclaimId) Justid() XclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XclaimJustid)(c)
}
func (c XclaimId) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimIdle Incomplete
func (c XclaimIdle) Time(msUnixTime int64) XclaimTime {
c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
return (XclaimTime)(c)
}
func (c XclaimIdle) Retrycount(count int64) XclaimRetrycount {
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
return (XclaimRetrycount)(c)
}
func (c XclaimIdle) Force() XclaimForce {
c.cs.s = append(c.cs.s, "FORCE")
return (XclaimForce)(c)
}
func (c XclaimIdle) Justid() XclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XclaimJustid)(c)
}
func (c XclaimIdle) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimIdle) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimJustid Incomplete
func (c XclaimJustid) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimJustid) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimKey Incomplete
func (c XclaimKey) Group(group string) XclaimGroup {
c.cs.s = append(c.cs.s, group)
return (XclaimGroup)(c)
}
type XclaimLastid Incomplete
func (c XclaimLastid) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimMinIdleTime Incomplete
func (c XclaimMinIdleTime) Id(id ...string) XclaimId {
c.cs.s = append(c.cs.s, id...)
return (XclaimId)(c)
}
type XclaimRetrycount Incomplete
func (c XclaimRetrycount) Force() XclaimForce {
c.cs.s = append(c.cs.s, "FORCE")
return (XclaimForce)(c)
}
func (c XclaimRetrycount) Justid() XclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XclaimJustid)(c)
}
func (c XclaimRetrycount) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimRetrycount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XclaimTime Incomplete
func (c XclaimTime) Retrycount(count int64) XclaimRetrycount {
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
return (XclaimRetrycount)(c)
}
func (c XclaimTime) Force() XclaimForce {
c.cs.s = append(c.cs.s, "FORCE")
return (XclaimForce)(c)
}
func (c XclaimTime) Justid() XclaimJustid {
c.cs.s = append(c.cs.s, "JUSTID")
return (XclaimJustid)(c)
}
func (c XclaimTime) Lastid() XclaimLastid {
c.cs.s = append(c.cs.s, "LASTID")
return (XclaimLastid)(c)
}
func (c XclaimTime) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xdel Incomplete
func (b Builder) Xdel() (c Xdel) {
c = Xdel{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XDEL")
return c
}
func (c Xdel) Key(key string) XdelKey {
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 (XdelKey)(c)
}
type XdelId Incomplete
func (c XdelId) Id(id ...string) XdelId {
c.cs.s = append(c.cs.s, id...)
return c
}
func (c XdelId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XdelKey Incomplete
func (c XdelKey) Id(id ...string) XdelId {
c.cs.s = append(c.cs.s, id...)
return (XdelId)(c)
}
type XgroupCreate Incomplete
func (b Builder) XgroupCreate() (c XgroupCreate) {
c = XgroupCreate{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "CREATE")
return c
}
func (c XgroupCreate) Key(key string) XgroupCreateKey {
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 (XgroupCreateKey)(c)
}
type XgroupCreateEntriesread Incomplete
func (c XgroupCreateEntriesread) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupCreateGroup Incomplete
func (c XgroupCreateGroup) Id(id string) XgroupCreateId {
c.cs.s = append(c.cs.s, id)
return (XgroupCreateId)(c)
}
type XgroupCreateId Incomplete
func (c XgroupCreateId) Mkstream() XgroupCreateMkstream {
c.cs.s = append(c.cs.s, "MKSTREAM")
return (XgroupCreateMkstream)(c)
}
func (c XgroupCreateId) Entriesread(entriesRead int64) XgroupCreateEntriesread {
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
return (XgroupCreateEntriesread)(c)
}
func (c XgroupCreateId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupCreateKey Incomplete
func (c XgroupCreateKey) Group(group string) XgroupCreateGroup {
c.cs.s = append(c.cs.s, group)
return (XgroupCreateGroup)(c)
}
type XgroupCreateMkstream Incomplete
func (c XgroupCreateMkstream) Entriesread(entriesRead int64) XgroupCreateEntriesread {
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
return (XgroupCreateEntriesread)(c)
}
func (c XgroupCreateMkstream) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupCreateconsumer Incomplete
func (b Builder) XgroupCreateconsumer() (c XgroupCreateconsumer) {
c = XgroupCreateconsumer{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "CREATECONSUMER")
return c
}
func (c XgroupCreateconsumer) Key(key string) XgroupCreateconsumerKey {
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 (XgroupCreateconsumerKey)(c)
}
type XgroupCreateconsumerConsumer Incomplete
func (c XgroupCreateconsumerConsumer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupCreateconsumerGroup Incomplete
func (c XgroupCreateconsumerGroup) Consumer(consumer string) XgroupCreateconsumerConsumer {
c.cs.s = append(c.cs.s, consumer)
return (XgroupCreateconsumerConsumer)(c)
}
type XgroupCreateconsumerKey Incomplete
func (c XgroupCreateconsumerKey) Group(group string) XgroupCreateconsumerGroup {
c.cs.s = append(c.cs.s, group)
return (XgroupCreateconsumerGroup)(c)
}
type XgroupDelconsumer Incomplete
func (b Builder) XgroupDelconsumer() (c XgroupDelconsumer) {
c = XgroupDelconsumer{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "DELCONSUMER")
return c
}
func (c XgroupDelconsumer) Key(key string) XgroupDelconsumerKey {
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 (XgroupDelconsumerKey)(c)
}
type XgroupDelconsumerConsumername Incomplete
func (c XgroupDelconsumerConsumername) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupDelconsumerGroup Incomplete
func (c XgroupDelconsumerGroup) Consumername(consumername string) XgroupDelconsumerConsumername {
c.cs.s = append(c.cs.s, consumername)
return (XgroupDelconsumerConsumername)(c)
}
type XgroupDelconsumerKey Incomplete
func (c XgroupDelconsumerKey) Group(group string) XgroupDelconsumerGroup {
c.cs.s = append(c.cs.s, group)
return (XgroupDelconsumerGroup)(c)
}
type XgroupDestroy Incomplete
func (b Builder) XgroupDestroy() (c XgroupDestroy) {
c = XgroupDestroy{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "DESTROY")
return c
}
func (c XgroupDestroy) Key(key string) XgroupDestroyKey {
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 (XgroupDestroyKey)(c)
}
type XgroupDestroyGroup Incomplete
func (c XgroupDestroyGroup) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupDestroyKey Incomplete
func (c XgroupDestroyKey) Group(group string) XgroupDestroyGroup {
c.cs.s = append(c.cs.s, group)
return (XgroupDestroyGroup)(c)
}
type XgroupHelp Incomplete
func (b Builder) XgroupHelp() (c XgroupHelp) {
c = XgroupHelp{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "HELP")
return c
}
func (c XgroupHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupSetid Incomplete
func (b Builder) XgroupSetid() (c XgroupSetid) {
c = XgroupSetid{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XGROUP", "SETID")
return c
}
func (c XgroupSetid) Key(key string) XgroupSetidKey {
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 (XgroupSetidKey)(c)
}
type XgroupSetidEntriesread Incomplete
func (c XgroupSetidEntriesread) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupSetidGroup Incomplete
func (c XgroupSetidGroup) Id(id string) XgroupSetidId {
c.cs.s = append(c.cs.s, id)
return (XgroupSetidId)(c)
}
type XgroupSetidId Incomplete
func (c XgroupSetidId) Entriesread(entriesRead int64) XgroupSetidEntriesread {
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
return (XgroupSetidEntriesread)(c)
}
func (c XgroupSetidId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XgroupSetidKey Incomplete
func (c XgroupSetidKey) Group(group string) XgroupSetidGroup {
c.cs.s = append(c.cs.s, group)
return (XgroupSetidGroup)(c)
}
type XinfoConsumers Incomplete
func (b Builder) XinfoConsumers() (c XinfoConsumers) {
c = XinfoConsumers{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XINFO", "CONSUMERS")
return c
}
func (c XinfoConsumers) Key(key string) XinfoConsumersKey {
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 (XinfoConsumersKey)(c)
}
type XinfoConsumersGroup Incomplete
func (c XinfoConsumersGroup) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XinfoConsumersKey Incomplete
func (c XinfoConsumersKey) Group(group string) XinfoConsumersGroup {
c.cs.s = append(c.cs.s, group)
return (XinfoConsumersGroup)(c)
}
type XinfoGroups Incomplete
func (b Builder) XinfoGroups() (c XinfoGroups) {
c = XinfoGroups{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XINFO", "GROUPS")
return c
}
func (c XinfoGroups) Key(key string) XinfoGroupsKey {
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 (XinfoGroupsKey)(c)
}
type XinfoGroupsKey Incomplete
func (c XinfoGroupsKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XinfoHelp Incomplete
func (b Builder) XinfoHelp() (c XinfoHelp) {
c = XinfoHelp{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XINFO", "HELP")
return c
}
func (c XinfoHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XinfoStream Incomplete
func (b Builder) XinfoStream() (c XinfoStream) {
c = XinfoStream{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XINFO", "STREAM")
return c
}
func (c XinfoStream) Key(key string) XinfoStreamKey {
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 (XinfoStreamKey)(c)
}
type XinfoStreamFullCount Incomplete
func (c XinfoStreamFullCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XinfoStreamFullFull Incomplete
func (c XinfoStreamFullFull) Count(count int64) XinfoStreamFullCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XinfoStreamFullCount)(c)
}
func (c XinfoStreamFullFull) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XinfoStreamKey Incomplete
func (c XinfoStreamKey) Full() XinfoStreamFullFull {
c.cs.s = append(c.cs.s, "FULL")
return (XinfoStreamFullFull)(c)
}
func (c XinfoStreamKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xlen Incomplete
func (b Builder) Xlen() (c Xlen) {
c = Xlen{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XLEN")
return c
}
func (c Xlen) Key(key string) XlenKey {
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 (XlenKey)(c)
}
type XlenKey Incomplete
func (c XlenKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xpending Incomplete
func (b Builder) Xpending() (c Xpending) {
c = Xpending{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XPENDING")
return c
}
func (c Xpending) Key(key string) XpendingKey {
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 (XpendingKey)(c)
}
type XpendingFiltersConsumer Incomplete
func (c XpendingFiltersConsumer) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XpendingFiltersCount Incomplete
func (c XpendingFiltersCount) Consumer(consumer string) XpendingFiltersConsumer {
c.cs.s = append(c.cs.s, consumer)
return (XpendingFiltersConsumer)(c)
}
func (c XpendingFiltersCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XpendingFiltersEnd Incomplete
func (c XpendingFiltersEnd) Count(count int64) XpendingFiltersCount {
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
return (XpendingFiltersCount)(c)
}
type XpendingFiltersIdle Incomplete
func (c XpendingFiltersIdle) Start(start string) XpendingFiltersStart {
c.cs.s = append(c.cs.s, start)
return (XpendingFiltersStart)(c)
}
type XpendingFiltersStart Incomplete
func (c XpendingFiltersStart) End(end string) XpendingFiltersEnd {
c.cs.s = append(c.cs.s, end)
return (XpendingFiltersEnd)(c)
}
type XpendingGroup Incomplete
func (c XpendingGroup) Idle(minIdleTime int64) XpendingFiltersIdle {
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(minIdleTime, 10))
return (XpendingFiltersIdle)(c)
}
func (c XpendingGroup) Start(start string) XpendingFiltersStart {
c.cs.s = append(c.cs.s, start)
return (XpendingFiltersStart)(c)
}
func (c XpendingGroup) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XpendingKey Incomplete
func (c XpendingKey) Group(group string) XpendingGroup {
c.cs.s = append(c.cs.s, group)
return (XpendingGroup)(c)
}
type Xrange Incomplete
func (b Builder) Xrange() (c Xrange) {
c = Xrange{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XRANGE")
return c
}
func (c Xrange) Key(key string) XrangeKey {
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 (XrangeKey)(c)
}
type XrangeCount Incomplete
func (c XrangeCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XrangeEnd Incomplete
func (c XrangeEnd) Count(count int64) XrangeCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XrangeCount)(c)
}
func (c XrangeEnd) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XrangeKey Incomplete
func (c XrangeKey) Start(start string) XrangeStart {
c.cs.s = append(c.cs.s, start)
return (XrangeStart)(c)
}
type XrangeStart Incomplete
func (c XrangeStart) End(end string) XrangeEnd {
c.cs.s = append(c.cs.s, end)
return (XrangeEnd)(c)
}
type Xread Incomplete
func (b Builder) Xread() (c Xread) {
c = Xread{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XREAD")
return c
}
func (c Xread) Count(count int64) XreadCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XreadCount)(c)
}
func (c Xread) Block(milliseconds int64) XreadBlock {
c.cf |= int16(blockTag)
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
return (XreadBlock)(c)
}
func (c Xread) Streams() XreadStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadStreams)(c)
}
type XreadBlock Incomplete
func (c XreadBlock) Streams() XreadStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadStreams)(c)
}
type XreadCount Incomplete
func (c XreadCount) Block(milliseconds int64) XreadBlock {
c.cf |= int16(blockTag)
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
return (XreadBlock)(c)
}
func (c XreadCount) Streams() XreadStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadStreams)(c)
}
type XreadId Incomplete
func (c XreadId) Id(id ...string) XreadId {
c.cs.s = append(c.cs.s, id...)
return c
}
func (c XreadId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XreadKey Incomplete
func (c XreadKey) Key(key ...string) XreadKey {
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 XreadKey) Id(id ...string) XreadId {
c.cs.s = append(c.cs.s, id...)
return (XreadId)(c)
}
type XreadStreams Incomplete
func (c XreadStreams) Key(key ...string) XreadKey {
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 (XreadKey)(c)
}
type Xreadgroup Incomplete
func (b Builder) Xreadgroup() (c Xreadgroup) {
c = Xreadgroup{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XREADGROUP")
return c
}
func (c Xreadgroup) Group(group string, consumer string) XreadgroupGroup {
c.cs.s = append(c.cs.s, "GROUP", group, consumer)
return (XreadgroupGroup)(c)
}
type XreadgroupBlock Incomplete
func (c XreadgroupBlock) Noack() XreadgroupNoack {
c.cs.s = append(c.cs.s, "NOACK")
return (XreadgroupNoack)(c)
}
func (c XreadgroupBlock) Streams() XreadgroupStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadgroupStreams)(c)
}
type XreadgroupCount Incomplete
func (c XreadgroupCount) Block(milliseconds int64) XreadgroupBlock {
c.cf |= int16(blockTag)
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
return (XreadgroupBlock)(c)
}
func (c XreadgroupCount) Noack() XreadgroupNoack {
c.cs.s = append(c.cs.s, "NOACK")
return (XreadgroupNoack)(c)
}
func (c XreadgroupCount) Streams() XreadgroupStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadgroupStreams)(c)
}
type XreadgroupGroup Incomplete
func (c XreadgroupGroup) Count(count int64) XreadgroupCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XreadgroupCount)(c)
}
func (c XreadgroupGroup) Block(milliseconds int64) XreadgroupBlock {
c.cf |= int16(blockTag)
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
return (XreadgroupBlock)(c)
}
func (c XreadgroupGroup) Noack() XreadgroupNoack {
c.cs.s = append(c.cs.s, "NOACK")
return (XreadgroupNoack)(c)
}
func (c XreadgroupGroup) Streams() XreadgroupStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadgroupStreams)(c)
}
type XreadgroupId Incomplete
func (c XreadgroupId) Id(id ...string) XreadgroupId {
c.cs.s = append(c.cs.s, id...)
return c
}
func (c XreadgroupId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XreadgroupKey Incomplete
func (c XreadgroupKey) Key(key ...string) XreadgroupKey {
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 XreadgroupKey) Id(id ...string) XreadgroupId {
c.cs.s = append(c.cs.s, id...)
return (XreadgroupId)(c)
}
type XreadgroupNoack Incomplete
func (c XreadgroupNoack) Streams() XreadgroupStreams {
c.cs.s = append(c.cs.s, "STREAMS")
return (XreadgroupStreams)(c)
}
type XreadgroupStreams Incomplete
func (c XreadgroupStreams) Key(key ...string) XreadgroupKey {
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 (XreadgroupKey)(c)
}
type Xrevrange Incomplete
func (b Builder) Xrevrange() (c Xrevrange) {
c = Xrevrange{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "XREVRANGE")
return c
}
func (c Xrevrange) Key(key string) XrevrangeKey {
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 (XrevrangeKey)(c)
}
type XrevrangeCount Incomplete
func (c XrevrangeCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XrevrangeEnd Incomplete
func (c XrevrangeEnd) Start(start string) XrevrangeStart {
c.cs.s = append(c.cs.s, start)
return (XrevrangeStart)(c)
}
type XrevrangeKey Incomplete
func (c XrevrangeKey) End(end string) XrevrangeEnd {
c.cs.s = append(c.cs.s, end)
return (XrevrangeEnd)(c)
}
type XrevrangeStart Incomplete
func (c XrevrangeStart) Count(count int64) XrevrangeCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (XrevrangeCount)(c)
}
func (c XrevrangeStart) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xsetid Incomplete
func (b Builder) Xsetid() (c Xsetid) {
c = Xsetid{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XSETID")
return c
}
func (c Xsetid) Key(key string) XsetidKey {
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 (XsetidKey)(c)
}
type XsetidEntriesadded Incomplete
func (c XsetidEntriesadded) Maxdeletedid(maxDeletedEntryId string) XsetidMaxdeletedid {
c.cs.s = append(c.cs.s, "MAXDELETEDID", maxDeletedEntryId)
return (XsetidMaxdeletedid)(c)
}
func (c XsetidEntriesadded) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XsetidKey Incomplete
func (c XsetidKey) LastId(lastId string) XsetidLastId {
c.cs.s = append(c.cs.s, lastId)
return (XsetidLastId)(c)
}
type XsetidLastId Incomplete
func (c XsetidLastId) Entriesadded(entriesAdded int64) XsetidEntriesadded {
c.cs.s = append(c.cs.s, "ENTRIESADDED", strconv.FormatInt(entriesAdded, 10))
return (XsetidEntriesadded)(c)
}
func (c XsetidLastId) Maxdeletedid(maxDeletedEntryId string) XsetidMaxdeletedid {
c.cs.s = append(c.cs.s, "MAXDELETEDID", maxDeletedEntryId)
return (XsetidMaxdeletedid)(c)
}
func (c XsetidLastId) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XsetidMaxdeletedid Incomplete
func (c XsetidMaxdeletedid) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Xtrim Incomplete
func (b Builder) Xtrim() (c Xtrim) {
c = Xtrim{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "XTRIM")
return c
}
func (c Xtrim) Key(key string) XtrimKey {
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 (XtrimKey)(c)
}
type XtrimKey Incomplete
func (c XtrimKey) Maxlen() XtrimTrimStrategyMaxlen {
c.cs.s = append(c.cs.s, "MAXLEN")
return (XtrimTrimStrategyMaxlen)(c)
}
func (c XtrimKey) Minid() XtrimTrimStrategyMinid {
c.cs.s = append(c.cs.s, "MINID")
return (XtrimTrimStrategyMinid)(c)
}
type XtrimTrimLimit Incomplete
func (c XtrimTrimLimit) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type XtrimTrimOperatorAlmost Incomplete
func (c XtrimTrimOperatorAlmost) Threshold(threshold string) XtrimTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XtrimTrimThreshold)(c)
}
type XtrimTrimOperatorExact Incomplete
func (c XtrimTrimOperatorExact) Threshold(threshold string) XtrimTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XtrimTrimThreshold)(c)
}
type XtrimTrimStrategyMaxlen Incomplete
func (c XtrimTrimStrategyMaxlen) Exact() XtrimTrimOperatorExact {
c.cs.s = append(c.cs.s, "=")
return (XtrimTrimOperatorExact)(c)
}
func (c XtrimTrimStrategyMaxlen) Almost() XtrimTrimOperatorAlmost {
c.cs.s = append(c.cs.s, "~")
return (XtrimTrimOperatorAlmost)(c)
}
func (c XtrimTrimStrategyMaxlen) Threshold(threshold string) XtrimTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XtrimTrimThreshold)(c)
}
type XtrimTrimStrategyMinid Incomplete
func (c XtrimTrimStrategyMinid) Exact() XtrimTrimOperatorExact {
c.cs.s = append(c.cs.s, "=")
return (XtrimTrimOperatorExact)(c)
}
func (c XtrimTrimStrategyMinid) Almost() XtrimTrimOperatorAlmost {
c.cs.s = append(c.cs.s, "~")
return (XtrimTrimOperatorAlmost)(c)
}
func (c XtrimTrimStrategyMinid) Threshold(threshold string) XtrimTrimThreshold {
c.cs.s = append(c.cs.s, threshold)
return (XtrimTrimThreshold)(c)
}
type XtrimTrimThreshold Incomplete
func (c XtrimTrimThreshold) Limit(count int64) XtrimTrimLimit {
c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
return (XtrimTrimLimit)(c)
}
func (c XtrimTrimThreshold) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}