gen_timeseries.go

// Code generated DO NOT EDIT

package cmds

import "strconv"

type TsAdd Incomplete

func (b Builder) TsAdd() (c TsAdd) {
	c = TsAdd{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.ADD")
	return c
}

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

type TsAddChunkSize Incomplete

func (c TsAddChunkSize) OnDuplicateBlock() TsAddOnDuplicateBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
	return (TsAddOnDuplicateBlock)(c)
}

func (c TsAddChunkSize) OnDuplicateFirst() TsAddOnDuplicateFirst {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
	return (TsAddOnDuplicateFirst)(c)
}

func (c TsAddChunkSize) OnDuplicateLast() TsAddOnDuplicateLast {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
	return (TsAddOnDuplicateLast)(c)
}

func (c TsAddChunkSize) OnDuplicateMin() TsAddOnDuplicateMin {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
	return (TsAddOnDuplicateMin)(c)
}

func (c TsAddChunkSize) OnDuplicateMax() TsAddOnDuplicateMax {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
	return (TsAddOnDuplicateMax)(c)
}

func (c TsAddChunkSize) OnDuplicateSum() TsAddOnDuplicateSum {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
	return (TsAddOnDuplicateSum)(c)
}

func (c TsAddChunkSize) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddEncodingCompressed Incomplete

func (c TsAddEncodingCompressed) ChunkSize(size int64) TsAddChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAddChunkSize)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateBlock() TsAddOnDuplicateBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
	return (TsAddOnDuplicateBlock)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateFirst() TsAddOnDuplicateFirst {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
	return (TsAddOnDuplicateFirst)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateLast() TsAddOnDuplicateLast {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
	return (TsAddOnDuplicateLast)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateMin() TsAddOnDuplicateMin {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
	return (TsAddOnDuplicateMin)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateMax() TsAddOnDuplicateMax {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
	return (TsAddOnDuplicateMax)(c)
}

func (c TsAddEncodingCompressed) OnDuplicateSum() TsAddOnDuplicateSum {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
	return (TsAddOnDuplicateSum)(c)
}

func (c TsAddEncodingCompressed) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddEncodingUncompressed Incomplete

func (c TsAddEncodingUncompressed) ChunkSize(size int64) TsAddChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAddChunkSize)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateBlock() TsAddOnDuplicateBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
	return (TsAddOnDuplicateBlock)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateFirst() TsAddOnDuplicateFirst {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
	return (TsAddOnDuplicateFirst)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateLast() TsAddOnDuplicateLast {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
	return (TsAddOnDuplicateLast)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateMin() TsAddOnDuplicateMin {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
	return (TsAddOnDuplicateMin)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateMax() TsAddOnDuplicateMax {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
	return (TsAddOnDuplicateMax)(c)
}

func (c TsAddEncodingUncompressed) OnDuplicateSum() TsAddOnDuplicateSum {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
	return (TsAddOnDuplicateSum)(c)
}

func (c TsAddEncodingUncompressed) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddKey Incomplete

func (c TsAddKey) Timestamp(timestamp string) TsAddTimestamp {
	c.cs.s = append(c.cs.s, timestamp)
	return (TsAddTimestamp)(c)
}

type TsAddLabels Incomplete

func (c TsAddLabels) Labels(label string, value string) TsAddLabels {
	c.cs.s = append(c.cs.s, label, value)
	return c
}

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

type TsAddOnDuplicateBlock Incomplete

func (c TsAddOnDuplicateBlock) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddOnDuplicateFirst Incomplete

func (c TsAddOnDuplicateFirst) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddOnDuplicateLast Incomplete

func (c TsAddOnDuplicateLast) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddOnDuplicateMax Incomplete

func (c TsAddOnDuplicateMax) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddOnDuplicateMin Incomplete

func (c TsAddOnDuplicateMin) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddOnDuplicateSum Incomplete

func (c TsAddOnDuplicateSum) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddRetention Incomplete

func (c TsAddRetention) EncodingUncompressed() TsAddEncodingUncompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
	return (TsAddEncodingUncompressed)(c)
}

func (c TsAddRetention) EncodingCompressed() TsAddEncodingCompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
	return (TsAddEncodingCompressed)(c)
}

func (c TsAddRetention) ChunkSize(size int64) TsAddChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAddChunkSize)(c)
}

func (c TsAddRetention) OnDuplicateBlock() TsAddOnDuplicateBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
	return (TsAddOnDuplicateBlock)(c)
}

func (c TsAddRetention) OnDuplicateFirst() TsAddOnDuplicateFirst {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
	return (TsAddOnDuplicateFirst)(c)
}

func (c TsAddRetention) OnDuplicateLast() TsAddOnDuplicateLast {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
	return (TsAddOnDuplicateLast)(c)
}

func (c TsAddRetention) OnDuplicateMin() TsAddOnDuplicateMin {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
	return (TsAddOnDuplicateMin)(c)
}

func (c TsAddRetention) OnDuplicateMax() TsAddOnDuplicateMax {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
	return (TsAddOnDuplicateMax)(c)
}

func (c TsAddRetention) OnDuplicateSum() TsAddOnDuplicateSum {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
	return (TsAddOnDuplicateSum)(c)
}

func (c TsAddRetention) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAddTimestamp Incomplete

func (c TsAddTimestamp) Value(value float64) TsAddValue {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
	return (TsAddValue)(c)
}

type TsAddValue Incomplete

func (c TsAddValue) Retention(retentionperiod int64) TsAddRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsAddRetention)(c)
}

func (c TsAddValue) EncodingUncompressed() TsAddEncodingUncompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
	return (TsAddEncodingUncompressed)(c)
}

func (c TsAddValue) EncodingCompressed() TsAddEncodingCompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
	return (TsAddEncodingCompressed)(c)
}

func (c TsAddValue) ChunkSize(size int64) TsAddChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAddChunkSize)(c)
}

func (c TsAddValue) OnDuplicateBlock() TsAddOnDuplicateBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
	return (TsAddOnDuplicateBlock)(c)
}

func (c TsAddValue) OnDuplicateFirst() TsAddOnDuplicateFirst {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
	return (TsAddOnDuplicateFirst)(c)
}

func (c TsAddValue) OnDuplicateLast() TsAddOnDuplicateLast {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
	return (TsAddOnDuplicateLast)(c)
}

func (c TsAddValue) OnDuplicateMin() TsAddOnDuplicateMin {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
	return (TsAddOnDuplicateMin)(c)
}

func (c TsAddValue) OnDuplicateMax() TsAddOnDuplicateMax {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
	return (TsAddOnDuplicateMax)(c)
}

func (c TsAddValue) OnDuplicateSum() TsAddOnDuplicateSum {
	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
	return (TsAddOnDuplicateSum)(c)
}

func (c TsAddValue) Labels() TsAddLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAddLabels)(c)
}

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

type TsAlter Incomplete

func (b Builder) TsAlter() (c TsAlter) {
	c = TsAlter{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.ALTER")
	return c
}

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

type TsAlterChunkSize Incomplete

func (c TsAlterChunkSize) DuplicatePolicyBlock() TsAlterDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsAlterDuplicatePolicyBlock)(c)
}

func (c TsAlterChunkSize) DuplicatePolicyFirst() TsAlterDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsAlterDuplicatePolicyFirst)(c)
}

func (c TsAlterChunkSize) DuplicatePolicyLast() TsAlterDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsAlterDuplicatePolicyLast)(c)
}

func (c TsAlterChunkSize) DuplicatePolicyMin() TsAlterDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsAlterDuplicatePolicyMin)(c)
}

func (c TsAlterChunkSize) DuplicatePolicyMax() TsAlterDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsAlterDuplicatePolicyMax)(c)
}

func (c TsAlterChunkSize) DuplicatePolicySum() TsAlterDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsAlterDuplicatePolicySum)(c)
}

func (c TsAlterChunkSize) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicyBlock Incomplete

func (c TsAlterDuplicatePolicyBlock) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicyFirst Incomplete

func (c TsAlterDuplicatePolicyFirst) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicyLast Incomplete

func (c TsAlterDuplicatePolicyLast) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicyMax Incomplete

func (c TsAlterDuplicatePolicyMax) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicyMin Incomplete

func (c TsAlterDuplicatePolicyMin) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterDuplicatePolicySum Incomplete

func (c TsAlterDuplicatePolicySum) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterKey Incomplete

func (c TsAlterKey) Retention(retentionperiod int64) TsAlterRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsAlterRetention)(c)
}

func (c TsAlterKey) ChunkSize(size int64) TsAlterChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAlterChunkSize)(c)
}

func (c TsAlterKey) DuplicatePolicyBlock() TsAlterDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsAlterDuplicatePolicyBlock)(c)
}

func (c TsAlterKey) DuplicatePolicyFirst() TsAlterDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsAlterDuplicatePolicyFirst)(c)
}

func (c TsAlterKey) DuplicatePolicyLast() TsAlterDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsAlterDuplicatePolicyLast)(c)
}

func (c TsAlterKey) DuplicatePolicyMin() TsAlterDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsAlterDuplicatePolicyMin)(c)
}

func (c TsAlterKey) DuplicatePolicyMax() TsAlterDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsAlterDuplicatePolicyMax)(c)
}

func (c TsAlterKey) DuplicatePolicySum() TsAlterDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsAlterDuplicatePolicySum)(c)
}

func (c TsAlterKey) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsAlterLabels Incomplete

func (c TsAlterLabels) Labels(label string, value string) TsAlterLabels {
	c.cs.s = append(c.cs.s, label, value)
	return c
}

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

type TsAlterRetention Incomplete

func (c TsAlterRetention) ChunkSize(size int64) TsAlterChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsAlterChunkSize)(c)
}

func (c TsAlterRetention) DuplicatePolicyBlock() TsAlterDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsAlterDuplicatePolicyBlock)(c)
}

func (c TsAlterRetention) DuplicatePolicyFirst() TsAlterDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsAlterDuplicatePolicyFirst)(c)
}

func (c TsAlterRetention) DuplicatePolicyLast() TsAlterDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsAlterDuplicatePolicyLast)(c)
}

func (c TsAlterRetention) DuplicatePolicyMin() TsAlterDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsAlterDuplicatePolicyMin)(c)
}

func (c TsAlterRetention) DuplicatePolicyMax() TsAlterDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsAlterDuplicatePolicyMax)(c)
}

func (c TsAlterRetention) DuplicatePolicySum() TsAlterDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsAlterDuplicatePolicySum)(c)
}

func (c TsAlterRetention) Labels() TsAlterLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsAlterLabels)(c)
}

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

type TsCreate Incomplete

func (b Builder) TsCreate() (c TsCreate) {
	c = TsCreate{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.CREATE")
	return c
}

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

type TsCreateChunkSize Incomplete

func (c TsCreateChunkSize) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsCreateDuplicatePolicyBlock)(c)
}

func (c TsCreateChunkSize) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsCreateDuplicatePolicyFirst)(c)
}

func (c TsCreateChunkSize) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsCreateDuplicatePolicyLast)(c)
}

func (c TsCreateChunkSize) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsCreateDuplicatePolicyMin)(c)
}

func (c TsCreateChunkSize) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsCreateDuplicatePolicyMax)(c)
}

func (c TsCreateChunkSize) DuplicatePolicySum() TsCreateDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsCreateDuplicatePolicySum)(c)
}

func (c TsCreateChunkSize) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicyBlock Incomplete

func (c TsCreateDuplicatePolicyBlock) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicyFirst Incomplete

func (c TsCreateDuplicatePolicyFirst) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicyLast Incomplete

func (c TsCreateDuplicatePolicyLast) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicyMax Incomplete

func (c TsCreateDuplicatePolicyMax) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicyMin Incomplete

func (c TsCreateDuplicatePolicyMin) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateDuplicatePolicySum Incomplete

func (c TsCreateDuplicatePolicySum) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateEncodingCompressed Incomplete

func (c TsCreateEncodingCompressed) ChunkSize(size int64) TsCreateChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsCreateChunkSize)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsCreateDuplicatePolicyBlock)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsCreateDuplicatePolicyFirst)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsCreateDuplicatePolicyLast)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsCreateDuplicatePolicyMin)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsCreateDuplicatePolicyMax)(c)
}

func (c TsCreateEncodingCompressed) DuplicatePolicySum() TsCreateDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsCreateDuplicatePolicySum)(c)
}

func (c TsCreateEncodingCompressed) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateEncodingUncompressed Incomplete

func (c TsCreateEncodingUncompressed) ChunkSize(size int64) TsCreateChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsCreateChunkSize)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsCreateDuplicatePolicyBlock)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsCreateDuplicatePolicyFirst)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsCreateDuplicatePolicyLast)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsCreateDuplicatePolicyMin)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsCreateDuplicatePolicyMax)(c)
}

func (c TsCreateEncodingUncompressed) DuplicatePolicySum() TsCreateDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsCreateDuplicatePolicySum)(c)
}

func (c TsCreateEncodingUncompressed) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateKey Incomplete

func (c TsCreateKey) Retention(retentionperiod int64) TsCreateRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsCreateRetention)(c)
}

func (c TsCreateKey) EncodingUncompressed() TsCreateEncodingUncompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
	return (TsCreateEncodingUncompressed)(c)
}

func (c TsCreateKey) EncodingCompressed() TsCreateEncodingCompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
	return (TsCreateEncodingCompressed)(c)
}

func (c TsCreateKey) ChunkSize(size int64) TsCreateChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsCreateChunkSize)(c)
}

func (c TsCreateKey) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsCreateDuplicatePolicyBlock)(c)
}

func (c TsCreateKey) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsCreateDuplicatePolicyFirst)(c)
}

func (c TsCreateKey) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsCreateDuplicatePolicyLast)(c)
}

func (c TsCreateKey) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsCreateDuplicatePolicyMin)(c)
}

func (c TsCreateKey) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsCreateDuplicatePolicyMax)(c)
}

func (c TsCreateKey) DuplicatePolicySum() TsCreateDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsCreateDuplicatePolicySum)(c)
}

func (c TsCreateKey) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreateLabels Incomplete

func (c TsCreateLabels) Labels(label string, value string) TsCreateLabels {
	c.cs.s = append(c.cs.s, label, value)
	return c
}

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

type TsCreateRetention Incomplete

func (c TsCreateRetention) EncodingUncompressed() TsCreateEncodingUncompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
	return (TsCreateEncodingUncompressed)(c)
}

func (c TsCreateRetention) EncodingCompressed() TsCreateEncodingCompressed {
	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
	return (TsCreateEncodingCompressed)(c)
}

func (c TsCreateRetention) ChunkSize(size int64) TsCreateChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsCreateChunkSize)(c)
}

func (c TsCreateRetention) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
	c.cf |= int16(blockTag)
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
	return (TsCreateDuplicatePolicyBlock)(c)
}

func (c TsCreateRetention) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
	return (TsCreateDuplicatePolicyFirst)(c)
}

func (c TsCreateRetention) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
	return (TsCreateDuplicatePolicyLast)(c)
}

func (c TsCreateRetention) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
	return (TsCreateDuplicatePolicyMin)(c)
}

func (c TsCreateRetention) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
	return (TsCreateDuplicatePolicyMax)(c)
}

func (c TsCreateRetention) DuplicatePolicySum() TsCreateDuplicatePolicySum {
	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
	return (TsCreateDuplicatePolicySum)(c)
}

func (c TsCreateRetention) Labels() TsCreateLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsCreateLabels)(c)
}

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

type TsCreaterule Incomplete

func (b Builder) TsCreaterule() (c TsCreaterule) {
	c = TsCreaterule{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.CREATERULE")
	return c
}

func (c TsCreaterule) Sourcekey(sourcekey string) TsCreateruleSourcekey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(sourcekey)
	} else {
		c.ks = check(c.ks, slot(sourcekey))
	}
	c.cs.s = append(c.cs.s, sourcekey)
	return (TsCreateruleSourcekey)(c)
}

type TsCreateruleAggregationAvg Incomplete

func (c TsCreateruleAggregationAvg) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationCount Incomplete

func (c TsCreateruleAggregationCount) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationFirst Incomplete

func (c TsCreateruleAggregationFirst) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationLast Incomplete

func (c TsCreateruleAggregationLast) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationMax Incomplete

func (c TsCreateruleAggregationMax) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationMin Incomplete

func (c TsCreateruleAggregationMin) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationRange Incomplete

func (c TsCreateruleAggregationRange) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationStdP Incomplete

func (c TsCreateruleAggregationStdP) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationStdS Incomplete

func (c TsCreateruleAggregationStdS) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationSum Incomplete

func (c TsCreateruleAggregationSum) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationTwa Incomplete

func (c TsCreateruleAggregationTwa) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationVarP Incomplete

func (c TsCreateruleAggregationVarP) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAggregationVarS Incomplete

func (c TsCreateruleAggregationVarS) Bucketduration(bucketduration int64) TsCreateruleBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsCreateruleBucketduration)(c)
}

type TsCreateruleAligntimestamp Incomplete

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

type TsCreateruleBucketduration Incomplete

func (c TsCreateruleBucketduration) Aligntimestamp(aligntimestamp int64) TsCreateruleAligntimestamp {
	c.cs.s = append(c.cs.s, strconv.FormatInt(aligntimestamp, 10))
	return (TsCreateruleAligntimestamp)(c)
}

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

type TsCreateruleDestkey Incomplete

func (c TsCreateruleDestkey) AggregationAvg() TsCreateruleAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsCreateruleAggregationAvg)(c)
}

func (c TsCreateruleDestkey) AggregationSum() TsCreateruleAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsCreateruleAggregationSum)(c)
}

func (c TsCreateruleDestkey) AggregationMin() TsCreateruleAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsCreateruleAggregationMin)(c)
}

func (c TsCreateruleDestkey) AggregationMax() TsCreateruleAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsCreateruleAggregationMax)(c)
}

func (c TsCreateruleDestkey) AggregationRange() TsCreateruleAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsCreateruleAggregationRange)(c)
}

func (c TsCreateruleDestkey) AggregationCount() TsCreateruleAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsCreateruleAggregationCount)(c)
}

func (c TsCreateruleDestkey) AggregationFirst() TsCreateruleAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsCreateruleAggregationFirst)(c)
}

func (c TsCreateruleDestkey) AggregationLast() TsCreateruleAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsCreateruleAggregationLast)(c)
}

func (c TsCreateruleDestkey) AggregationStdP() TsCreateruleAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsCreateruleAggregationStdP)(c)
}

func (c TsCreateruleDestkey) AggregationStdS() TsCreateruleAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsCreateruleAggregationStdS)(c)
}

func (c TsCreateruleDestkey) AggregationVarP() TsCreateruleAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsCreateruleAggregationVarP)(c)
}

func (c TsCreateruleDestkey) AggregationVarS() TsCreateruleAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsCreateruleAggregationVarS)(c)
}

func (c TsCreateruleDestkey) AggregationTwa() TsCreateruleAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsCreateruleAggregationTwa)(c)
}

type TsCreateruleSourcekey Incomplete

func (c TsCreateruleSourcekey) Destkey(destkey string) TsCreateruleDestkey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destkey)
	} else {
		c.ks = check(c.ks, slot(destkey))
	}
	c.cs.s = append(c.cs.s, destkey)
	return (TsCreateruleDestkey)(c)
}

type TsDecrby Incomplete

func (b Builder) TsDecrby() (c TsDecrby) {
	c = TsDecrby{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.DECRBY")
	return c
}

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

type TsDecrbyChunkSize Incomplete

func (c TsDecrbyChunkSize) Labels() TsDecrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsDecrbyLabels)(c)
}

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

type TsDecrbyKey Incomplete

func (c TsDecrbyKey) Value(value float64) TsDecrbyValue {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
	return (TsDecrbyValue)(c)
}

type TsDecrbyLabels Incomplete

func (c TsDecrbyLabels) Labels(label string, value string) TsDecrbyLabels {
	c.cs.s = append(c.cs.s, label, value)
	return c
}

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

type TsDecrbyRetention Incomplete

func (c TsDecrbyRetention) Uncompressed() TsDecrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsDecrbyUncompressed)(c)
}

func (c TsDecrbyRetention) ChunkSize(size int64) TsDecrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsDecrbyChunkSize)(c)
}

func (c TsDecrbyRetention) Labels() TsDecrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsDecrbyLabels)(c)
}

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

type TsDecrbyTimestamp Incomplete

func (c TsDecrbyTimestamp) Retention(retentionperiod int64) TsDecrbyRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsDecrbyRetention)(c)
}

func (c TsDecrbyTimestamp) Uncompressed() TsDecrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsDecrbyUncompressed)(c)
}

func (c TsDecrbyTimestamp) ChunkSize(size int64) TsDecrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsDecrbyChunkSize)(c)
}

func (c TsDecrbyTimestamp) Labels() TsDecrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsDecrbyLabels)(c)
}

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

type TsDecrbyUncompressed Incomplete

func (c TsDecrbyUncompressed) ChunkSize(size int64) TsDecrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsDecrbyChunkSize)(c)
}

func (c TsDecrbyUncompressed) Labels() TsDecrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsDecrbyLabels)(c)
}

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

type TsDecrbyValue Incomplete

func (c TsDecrbyValue) Timestamp(timestamp string) TsDecrbyTimestamp {
	c.cs.s = append(c.cs.s, "TIMESTAMP", timestamp)
	return (TsDecrbyTimestamp)(c)
}

func (c TsDecrbyValue) Retention(retentionperiod int64) TsDecrbyRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsDecrbyRetention)(c)
}

func (c TsDecrbyValue) Uncompressed() TsDecrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsDecrbyUncompressed)(c)
}

func (c TsDecrbyValue) ChunkSize(size int64) TsDecrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsDecrbyChunkSize)(c)
}

func (c TsDecrbyValue) Labels() TsDecrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsDecrbyLabels)(c)
}

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

type TsDel Incomplete

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

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

type TsDelFromTimestamp Incomplete

func (c TsDelFromTimestamp) ToTimestamp(toTimestamp int64) TsDelToTimestamp {
	c.cs.s = append(c.cs.s, strconv.FormatInt(toTimestamp, 10))
	return (TsDelToTimestamp)(c)
}

type TsDelKey Incomplete

func (c TsDelKey) FromTimestamp(fromTimestamp int64) TsDelFromTimestamp {
	c.cs.s = append(c.cs.s, strconv.FormatInt(fromTimestamp, 10))
	return (TsDelFromTimestamp)(c)
}

type TsDelToTimestamp Incomplete

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

type TsDeleterule Incomplete

func (b Builder) TsDeleterule() (c TsDeleterule) {
	c = TsDeleterule{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.DELETERULE")
	return c
}

func (c TsDeleterule) Sourcekey(sourcekey string) TsDeleteruleSourcekey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(sourcekey)
	} else {
		c.ks = check(c.ks, slot(sourcekey))
	}
	c.cs.s = append(c.cs.s, sourcekey)
	return (TsDeleteruleSourcekey)(c)
}

type TsDeleteruleDestkey Incomplete

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

type TsDeleteruleSourcekey Incomplete

func (c TsDeleteruleSourcekey) Destkey(destkey string) TsDeleteruleDestkey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destkey)
	} else {
		c.ks = check(c.ks, slot(destkey))
	}
	c.cs.s = append(c.cs.s, destkey)
	return (TsDeleteruleDestkey)(c)
}

type TsGet Incomplete

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

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

type TsGetKey Incomplete

func (c TsGetKey) Latest() TsGetLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsGetLatest)(c)
}

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

type TsGetLatest Incomplete

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

type TsIncrby Incomplete

func (b Builder) TsIncrby() (c TsIncrby) {
	c = TsIncrby{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.INCRBY")
	return c
}

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

type TsIncrbyChunkSize Incomplete

func (c TsIncrbyChunkSize) Labels() TsIncrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsIncrbyLabels)(c)
}

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

type TsIncrbyKey Incomplete

func (c TsIncrbyKey) Value(value float64) TsIncrbyValue {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
	return (TsIncrbyValue)(c)
}

type TsIncrbyLabels Incomplete

func (c TsIncrbyLabels) Labels(label string, value string) TsIncrbyLabels {
	c.cs.s = append(c.cs.s, label, value)
	return c
}

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

type TsIncrbyRetention Incomplete

func (c TsIncrbyRetention) Uncompressed() TsIncrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsIncrbyUncompressed)(c)
}

func (c TsIncrbyRetention) ChunkSize(size int64) TsIncrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsIncrbyChunkSize)(c)
}

func (c TsIncrbyRetention) Labels() TsIncrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsIncrbyLabels)(c)
}

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

type TsIncrbyTimestamp Incomplete

func (c TsIncrbyTimestamp) Retention(retentionperiod int64) TsIncrbyRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsIncrbyRetention)(c)
}

func (c TsIncrbyTimestamp) Uncompressed() TsIncrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsIncrbyUncompressed)(c)
}

func (c TsIncrbyTimestamp) ChunkSize(size int64) TsIncrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsIncrbyChunkSize)(c)
}

func (c TsIncrbyTimestamp) Labels() TsIncrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsIncrbyLabels)(c)
}

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

type TsIncrbyUncompressed Incomplete

func (c TsIncrbyUncompressed) ChunkSize(size int64) TsIncrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsIncrbyChunkSize)(c)
}

func (c TsIncrbyUncompressed) Labels() TsIncrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsIncrbyLabels)(c)
}

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

type TsIncrbyValue Incomplete

func (c TsIncrbyValue) Timestamp(timestamp string) TsIncrbyTimestamp {
	c.cs.s = append(c.cs.s, "TIMESTAMP", timestamp)
	return (TsIncrbyTimestamp)(c)
}

func (c TsIncrbyValue) Retention(retentionperiod int64) TsIncrbyRetention {
	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentionperiod, 10))
	return (TsIncrbyRetention)(c)
}

func (c TsIncrbyValue) Uncompressed() TsIncrbyUncompressed {
	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
	return (TsIncrbyUncompressed)(c)
}

func (c TsIncrbyValue) ChunkSize(size int64) TsIncrbyChunkSize {
	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
	return (TsIncrbyChunkSize)(c)
}

func (c TsIncrbyValue) Labels() TsIncrbyLabels {
	c.cs.s = append(c.cs.s, "LABELS")
	return (TsIncrbyLabels)(c)
}

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

type TsInfo Incomplete

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

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

type TsInfoDebug Incomplete

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

type TsInfoKey Incomplete

func (c TsInfoKey) Debug(debug string) TsInfoDebug {
	c.cs.s = append(c.cs.s, debug)
	return (TsInfoDebug)(c)
}

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

type TsMadd Incomplete

func (b Builder) TsMadd() (c TsMadd) {
	c = TsMadd{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.MADD")
	return c
}

func (c TsMadd) KeyTimestampValue() TsMaddKeyTimestampValue {
	return (TsMaddKeyTimestampValue)(c)
}

type TsMaddKeyTimestampValue Incomplete

func (c TsMaddKeyTimestampValue) KeyTimestampValue(key string, timestamp int64, value float64) TsMaddKeyTimestampValue {
	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, strconv.FormatInt(timestamp, 10), strconv.FormatFloat(value, 'f', -1, 64))
	return c
}

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

type TsMget Incomplete

func (b Builder) TsMget() (c TsMget) {
	c = TsMget{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.MGET")
	return c
}

func (c TsMget) Latest() TsMgetLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsMgetLatest)(c)
}

func (c TsMget) Withlabels() TsMgetWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMgetWithlabels)(c)
}

func (c TsMget) SelectedLabels(labels []string) TsMgetSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMgetSelectedLabels)(c)
}

func (c TsMget) Filter(filter ...string) TsMgetFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMgetFilter)(c)
}

type TsMgetFilter Incomplete

func (c TsMgetFilter) Filter(filter ...string) TsMgetFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return c
}

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

type TsMgetLatest Incomplete

func (c TsMgetLatest) Withlabels() TsMgetWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMgetWithlabels)(c)
}

func (c TsMgetLatest) SelectedLabels(labels []string) TsMgetSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMgetSelectedLabels)(c)
}

func (c TsMgetLatest) Filter(filter ...string) TsMgetFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMgetFilter)(c)
}

type TsMgetSelectedLabels Incomplete

func (c TsMgetSelectedLabels) Filter(filter ...string) TsMgetFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMgetFilter)(c)
}

type TsMgetWithlabels Incomplete

func (c TsMgetWithlabels) Filter(filter ...string) TsMgetFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMgetFilter)(c)
}

type TsMrange Incomplete

func (b Builder) TsMrange() (c TsMrange) {
	c = TsMrange{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.MRANGE")
	return c
}

func (c TsMrange) Fromtimestamp(fromtimestamp string) TsMrangeFromtimestamp {
	c.cs.s = append(c.cs.s, fromtimestamp)
	return (TsMrangeFromtimestamp)(c)
}

type TsMrangeAggregationAggregationAvg Incomplete

func (c TsMrangeAggregationAggregationAvg) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationCount Incomplete

func (c TsMrangeAggregationAggregationCount) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationFirst Incomplete

func (c TsMrangeAggregationAggregationFirst) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationLast Incomplete

func (c TsMrangeAggregationAggregationLast) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationMax Incomplete

func (c TsMrangeAggregationAggregationMax) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationMin Incomplete

func (c TsMrangeAggregationAggregationMin) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationRange Incomplete

func (c TsMrangeAggregationAggregationRange) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationStdP Incomplete

func (c TsMrangeAggregationAggregationStdP) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationStdS Incomplete

func (c TsMrangeAggregationAggregationStdS) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationSum Incomplete

func (c TsMrangeAggregationAggregationSum) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationTwa Incomplete

func (c TsMrangeAggregationAggregationTwa) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationVarP Incomplete

func (c TsMrangeAggregationAggregationVarP) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationAggregationVarS Incomplete

func (c TsMrangeAggregationAggregationVarS) Bucketduration(bucketduration int64) TsMrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrangeAggregationBucketduration)(c)
}

type TsMrangeAggregationBucketduration Incomplete

func (c TsMrangeAggregationBucketduration) Buckettimestamp(buckettimestamp string) TsMrangeAggregationBuckettimestamp {
	c.cs.s = append(c.cs.s, "BUCKETTIMESTAMP", buckettimestamp)
	return (TsMrangeAggregationBuckettimestamp)(c)
}

func (c TsMrangeAggregationBucketduration) Empty() TsMrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsMrangeAggregationEmpty)(c)
}

func (c TsMrangeAggregationBucketduration) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeAggregationBuckettimestamp Incomplete

func (c TsMrangeAggregationBuckettimestamp) Empty() TsMrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsMrangeAggregationEmpty)(c)
}

func (c TsMrangeAggregationBuckettimestamp) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeAggregationEmpty Incomplete

func (c TsMrangeAggregationEmpty) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeAlign Incomplete

func (c TsMrangeAlign) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeAlign) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeAlign) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeAlign) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeAlign) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeAlign) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeAlign) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeAlign) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeAlign) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeAlign) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeAlign) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeAlign) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeAlign) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeAlign) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeCount Incomplete

func (c TsMrangeCount) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeCount) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeCount) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeCount) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeCount) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeCount) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeCount) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeCount) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeCount) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeCount) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeCount) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeCount) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeCount) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeCount) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeCount) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeFilter Incomplete

func (c TsMrangeFilter) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return c
}

func (c TsMrangeFilter) Groupby(label string, reduce string, reducer string) TsMrangeGroupby {
	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
	return (TsMrangeGroupby)(c)
}

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

type TsMrangeFilterByTs Incomplete

func (c TsMrangeFilterByTs) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c TsMrangeFilterByTs) FilterByValue(min float64, max float64) TsMrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrangeFilterByValue)(c)
}

func (c TsMrangeFilterByTs) Withlabels() TsMrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrangeWithlabels)(c)
}

func (c TsMrangeFilterByTs) SelectedLabels(labels []string) TsMrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrangeSelectedLabels)(c)
}

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

func (c TsMrangeFilterByTs) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeFilterByTs) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeFilterByTs) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeFilterByTs) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeFilterByTs) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeFilterByTs) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeFilterByTs) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeFilterByTs) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeFilterByTs) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeFilterByTs) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeFilterByTs) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeFilterByTs) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeFilterByTs) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeFilterByTs) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeFilterByTs) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeFilterByValue Incomplete

func (c TsMrangeFilterByValue) Withlabels() TsMrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrangeWithlabels)(c)
}

func (c TsMrangeFilterByValue) SelectedLabels(labels []string) TsMrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrangeSelectedLabels)(c)
}

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

func (c TsMrangeFilterByValue) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeFilterByValue) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeFilterByValue) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeFilterByValue) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeFilterByValue) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeFilterByValue) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeFilterByValue) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeFilterByValue) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeFilterByValue) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeFilterByValue) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeFilterByValue) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeFilterByValue) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeFilterByValue) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeFilterByValue) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeFilterByValue) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeFromtimestamp Incomplete

func (c TsMrangeFromtimestamp) Totimestamp(totimestamp string) TsMrangeTotimestamp {
	c.cs.s = append(c.cs.s, totimestamp)
	return (TsMrangeTotimestamp)(c)
}

type TsMrangeGroupby Incomplete

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

type TsMrangeLatest Incomplete

func (c TsMrangeLatest) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsMrangeFilterByTs)(c)
}

func (c TsMrangeLatest) FilterByValue(min float64, max float64) TsMrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrangeFilterByValue)(c)
}

func (c TsMrangeLatest) Withlabels() TsMrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrangeWithlabels)(c)
}

func (c TsMrangeLatest) SelectedLabels(labels []string) TsMrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrangeSelectedLabels)(c)
}

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

func (c TsMrangeLatest) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeLatest) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeLatest) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeLatest) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeLatest) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeLatest) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeLatest) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeLatest) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeLatest) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeLatest) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeLatest) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeLatest) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeLatest) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeLatest) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeLatest) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeSelectedLabels Incomplete

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

func (c TsMrangeSelectedLabels) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeSelectedLabels) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeSelectedLabels) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeSelectedLabels) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeSelectedLabels) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeSelectedLabels) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeSelectedLabels) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeSelectedLabels) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeSelectedLabels) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeSelectedLabels) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeSelectedLabels) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeSelectedLabels) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeSelectedLabels) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeSelectedLabels) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeSelectedLabels) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeTotimestamp Incomplete

func (c TsMrangeTotimestamp) Latest() TsMrangeLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsMrangeLatest)(c)
}

func (c TsMrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsMrangeFilterByTs)(c)
}

func (c TsMrangeTotimestamp) FilterByValue(min float64, max float64) TsMrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrangeFilterByValue)(c)
}

func (c TsMrangeTotimestamp) Withlabels() TsMrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrangeWithlabels)(c)
}

func (c TsMrangeTotimestamp) SelectedLabels(labels []string) TsMrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrangeSelectedLabels)(c)
}

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

func (c TsMrangeTotimestamp) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeTotimestamp) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeTotimestamp) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeTotimestamp) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeTotimestamp) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeTotimestamp) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeTotimestamp) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeTotimestamp) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeTotimestamp) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeTotimestamp) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeTotimestamp) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeTotimestamp) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeTotimestamp) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeTotimestamp) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeTotimestamp) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrangeWithlabels Incomplete

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

func (c TsMrangeWithlabels) Align(value string) TsMrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrangeAlign)(c)
}

func (c TsMrangeWithlabels) AggregationAvg() TsMrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrangeAggregationAggregationAvg)(c)
}

func (c TsMrangeWithlabels) AggregationSum() TsMrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrangeAggregationAggregationSum)(c)
}

func (c TsMrangeWithlabels) AggregationMin() TsMrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrangeAggregationAggregationMin)(c)
}

func (c TsMrangeWithlabels) AggregationMax() TsMrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrangeAggregationAggregationMax)(c)
}

func (c TsMrangeWithlabels) AggregationRange() TsMrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrangeAggregationAggregationRange)(c)
}

func (c TsMrangeWithlabels) AggregationCount() TsMrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrangeAggregationAggregationCount)(c)
}

func (c TsMrangeWithlabels) AggregationFirst() TsMrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrangeAggregationAggregationFirst)(c)
}

func (c TsMrangeWithlabels) AggregationLast() TsMrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrangeAggregationAggregationLast)(c)
}

func (c TsMrangeWithlabels) AggregationStdP() TsMrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrangeAggregationAggregationStdP)(c)
}

func (c TsMrangeWithlabels) AggregationStdS() TsMrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrangeAggregationAggregationStdS)(c)
}

func (c TsMrangeWithlabels) AggregationVarP() TsMrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrangeAggregationAggregationVarP)(c)
}

func (c TsMrangeWithlabels) AggregationVarS() TsMrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrangeAggregationAggregationVarS)(c)
}

func (c TsMrangeWithlabels) AggregationTwa() TsMrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrangeAggregationAggregationTwa)(c)
}

func (c TsMrangeWithlabels) Filter(filter ...string) TsMrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrangeFilter)(c)
}

type TsMrevrange Incomplete

func (b Builder) TsMrevrange() (c TsMrevrange) {
	c = TsMrevrange{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TS.MREVRANGE")
	return c
}

func (c TsMrevrange) Fromtimestamp(fromtimestamp string) TsMrevrangeFromtimestamp {
	c.cs.s = append(c.cs.s, fromtimestamp)
	return (TsMrevrangeFromtimestamp)(c)
}

type TsMrevrangeAggregationAggregationAvg Incomplete

func (c TsMrevrangeAggregationAggregationAvg) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationCount Incomplete

func (c TsMrevrangeAggregationAggregationCount) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationFirst Incomplete

func (c TsMrevrangeAggregationAggregationFirst) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationLast Incomplete

func (c TsMrevrangeAggregationAggregationLast) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationMax Incomplete

func (c TsMrevrangeAggregationAggregationMax) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationMin Incomplete

func (c TsMrevrangeAggregationAggregationMin) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationRange Incomplete

func (c TsMrevrangeAggregationAggregationRange) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationStdP Incomplete

func (c TsMrevrangeAggregationAggregationStdP) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationStdS Incomplete

func (c TsMrevrangeAggregationAggregationStdS) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationSum Incomplete

func (c TsMrevrangeAggregationAggregationSum) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationTwa Incomplete

func (c TsMrevrangeAggregationAggregationTwa) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationVarP Incomplete

func (c TsMrevrangeAggregationAggregationVarP) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationAggregationVarS Incomplete

func (c TsMrevrangeAggregationAggregationVarS) Bucketduration(bucketduration int64) TsMrevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsMrevrangeAggregationBucketduration)(c)
}

type TsMrevrangeAggregationBucketduration Incomplete

func (c TsMrevrangeAggregationBucketduration) Buckettimestamp(buckettimestamp string) TsMrevrangeAggregationBuckettimestamp {
	c.cs.s = append(c.cs.s, "BUCKETTIMESTAMP", buckettimestamp)
	return (TsMrevrangeAggregationBuckettimestamp)(c)
}

func (c TsMrevrangeAggregationBucketduration) Empty() TsMrevrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsMrevrangeAggregationEmpty)(c)
}

func (c TsMrevrangeAggregationBucketduration) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeAggregationBuckettimestamp Incomplete

func (c TsMrevrangeAggregationBuckettimestamp) Empty() TsMrevrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsMrevrangeAggregationEmpty)(c)
}

func (c TsMrevrangeAggregationBuckettimestamp) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeAggregationEmpty Incomplete

func (c TsMrevrangeAggregationEmpty) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeAlign Incomplete

func (c TsMrevrangeAlign) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeAlign) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeAlign) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeAlign) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeAlign) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeAlign) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeAlign) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeAlign) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeAlign) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeAlign) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeAlign) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeAlign) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeAlign) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeAlign) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeCount Incomplete

func (c TsMrevrangeCount) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeCount) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeCount) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeCount) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeCount) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeCount) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeCount) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeCount) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeCount) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeCount) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeCount) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeCount) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeCount) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeCount) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeCount) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeFilter Incomplete

func (c TsMrevrangeFilter) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return c
}

func (c TsMrevrangeFilter) Groupby(label string, reduce string, reducer string) TsMrevrangeGroupby {
	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
	return (TsMrevrangeGroupby)(c)
}

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

type TsMrevrangeFilterByTs Incomplete

func (c TsMrevrangeFilterByTs) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c TsMrevrangeFilterByTs) FilterByValue(min float64, max float64) TsMrevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrevrangeFilterByValue)(c)
}

func (c TsMrevrangeFilterByTs) Withlabels() TsMrevrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrevrangeWithlabels)(c)
}

func (c TsMrevrangeFilterByTs) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrevrangeSelectedLabels)(c)
}

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

func (c TsMrevrangeFilterByTs) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeFilterByTs) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeFilterByTs) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeFilterByTs) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeFilterByTs) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeFilterByTs) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeFilterByTs) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeFilterByTs) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeFilterByTs) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeFilterByTs) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeFilterByTs) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeFilterByTs) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeFilterByTs) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeFilterByTs) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeFilterByTs) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeFilterByValue Incomplete

func (c TsMrevrangeFilterByValue) Withlabels() TsMrevrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrevrangeWithlabels)(c)
}

func (c TsMrevrangeFilterByValue) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrevrangeSelectedLabels)(c)
}

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

func (c TsMrevrangeFilterByValue) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeFilterByValue) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeFilterByValue) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeFilterByValue) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeFilterByValue) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeFilterByValue) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeFilterByValue) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeFilterByValue) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeFilterByValue) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeFilterByValue) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeFilterByValue) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeFilterByValue) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeFilterByValue) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeFilterByValue) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeFilterByValue) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeFromtimestamp Incomplete

func (c TsMrevrangeFromtimestamp) Totimestamp(totimestamp string) TsMrevrangeTotimestamp {
	c.cs.s = append(c.cs.s, totimestamp)
	return (TsMrevrangeTotimestamp)(c)
}

type TsMrevrangeGroupby Incomplete

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

type TsMrevrangeLatest Incomplete

func (c TsMrevrangeLatest) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsMrevrangeFilterByTs)(c)
}

func (c TsMrevrangeLatest) FilterByValue(min float64, max float64) TsMrevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrevrangeFilterByValue)(c)
}

func (c TsMrevrangeLatest) Withlabels() TsMrevrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrevrangeWithlabels)(c)
}

func (c TsMrevrangeLatest) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrevrangeSelectedLabels)(c)
}

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

func (c TsMrevrangeLatest) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeLatest) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeLatest) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeLatest) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeLatest) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeLatest) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeLatest) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeLatest) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeLatest) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeLatest) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeLatest) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeLatest) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeLatest) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeLatest) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeLatest) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeSelectedLabels Incomplete

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

func (c TsMrevrangeSelectedLabels) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeSelectedLabels) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeSelectedLabels) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeTotimestamp Incomplete

func (c TsMrevrangeTotimestamp) Latest() TsMrevrangeLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsMrevrangeLatest)(c)
}

func (c TsMrevrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsMrevrangeFilterByTs)(c)
}

func (c TsMrevrangeTotimestamp) FilterByValue(min float64, max float64) TsMrevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsMrevrangeFilterByValue)(c)
}

func (c TsMrevrangeTotimestamp) Withlabels() TsMrevrangeWithlabels {
	c.cs.s = append(c.cs.s, "WITHLABELS")
	return (TsMrevrangeWithlabels)(c)
}

func (c TsMrevrangeTotimestamp) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
	c.cs.s = append(c.cs.s, labels...)
	return (TsMrevrangeSelectedLabels)(c)
}

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

func (c TsMrevrangeTotimestamp) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeTotimestamp) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeTotimestamp) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeTotimestamp) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeTotimestamp) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeTotimestamp) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeTotimestamp) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeTotimestamp) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeTotimestamp) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeTotimestamp) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeTotimestamp) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeTotimestamp) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeTotimestamp) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeTotimestamp) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeTotimestamp) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsMrevrangeWithlabels Incomplete

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

func (c TsMrevrangeWithlabels) Align(value string) TsMrevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsMrevrangeAlign)(c)
}

func (c TsMrevrangeWithlabels) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsMrevrangeAggregationAggregationAvg)(c)
}

func (c TsMrevrangeWithlabels) AggregationSum() TsMrevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsMrevrangeAggregationAggregationSum)(c)
}

func (c TsMrevrangeWithlabels) AggregationMin() TsMrevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsMrevrangeAggregationAggregationMin)(c)
}

func (c TsMrevrangeWithlabels) AggregationMax() TsMrevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsMrevrangeAggregationAggregationMax)(c)
}

func (c TsMrevrangeWithlabels) AggregationRange() TsMrevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsMrevrangeAggregationAggregationRange)(c)
}

func (c TsMrevrangeWithlabels) AggregationCount() TsMrevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsMrevrangeAggregationAggregationCount)(c)
}

func (c TsMrevrangeWithlabels) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsMrevrangeAggregationAggregationFirst)(c)
}

func (c TsMrevrangeWithlabels) AggregationLast() TsMrevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsMrevrangeAggregationAggregationLast)(c)
}

func (c TsMrevrangeWithlabels) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsMrevrangeAggregationAggregationStdP)(c)
}

func (c TsMrevrangeWithlabels) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsMrevrangeAggregationAggregationStdS)(c)
}

func (c TsMrevrangeWithlabels) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsMrevrangeAggregationAggregationVarP)(c)
}

func (c TsMrevrangeWithlabels) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsMrevrangeAggregationAggregationVarS)(c)
}

func (c TsMrevrangeWithlabels) AggregationTwa() TsMrevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsMrevrangeAggregationAggregationTwa)(c)
}

func (c TsMrevrangeWithlabels) Filter(filter ...string) TsMrevrangeFilter {
	c.cs.s = append(c.cs.s, "FILTER")
	c.cs.s = append(c.cs.s, filter...)
	return (TsMrevrangeFilter)(c)
}

type TsQueryindex Incomplete

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

func (c TsQueryindex) Filter(filter ...string) TsQueryindexFilter {
	c.cs.s = append(c.cs.s, filter...)
	return (TsQueryindexFilter)(c)
}

type TsQueryindexFilter Incomplete

func (c TsQueryindexFilter) Filter(filter ...string) TsQueryindexFilter {
	c.cs.s = append(c.cs.s, filter...)
	return c
}

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

type TsRange Incomplete

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

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

type TsRangeAggregationAggregationAvg Incomplete

func (c TsRangeAggregationAggregationAvg) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationCount Incomplete

func (c TsRangeAggregationAggregationCount) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationFirst Incomplete

func (c TsRangeAggregationAggregationFirst) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationLast Incomplete

func (c TsRangeAggregationAggregationLast) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationMax Incomplete

func (c TsRangeAggregationAggregationMax) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationMin Incomplete

func (c TsRangeAggregationAggregationMin) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationRange Incomplete

func (c TsRangeAggregationAggregationRange) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationStdP Incomplete

func (c TsRangeAggregationAggregationStdP) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationStdS Incomplete

func (c TsRangeAggregationAggregationStdS) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationSum Incomplete

func (c TsRangeAggregationAggregationSum) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationTwa Incomplete

func (c TsRangeAggregationAggregationTwa) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationVarP Incomplete

func (c TsRangeAggregationAggregationVarP) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationAggregationVarS Incomplete

func (c TsRangeAggregationAggregationVarS) Bucketduration(bucketduration int64) TsRangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRangeAggregationBucketduration)(c)
}

type TsRangeAggregationBucketduration Incomplete

func (c TsRangeAggregationBucketduration) Buckettimestamp(buckettimestamp string) TsRangeAggregationBuckettimestamp {
	c.cs.s = append(c.cs.s, "BUCKETTIMESTAMP", buckettimestamp)
	return (TsRangeAggregationBuckettimestamp)(c)
}

func (c TsRangeAggregationBucketduration) Empty() TsRangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsRangeAggregationEmpty)(c)
}

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

type TsRangeAggregationBuckettimestamp Incomplete

func (c TsRangeAggregationBuckettimestamp) Empty() TsRangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsRangeAggregationEmpty)(c)
}

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

type TsRangeAggregationEmpty Incomplete

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

type TsRangeAlign Incomplete

func (c TsRangeAlign) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeAlign) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeAlign) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeAlign) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeAlign) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeAlign) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeAlign) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeAlign) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeAlign) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeAlign) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeAlign) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeAlign) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeAlign) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRangeCount Incomplete

func (c TsRangeCount) Align(value string) TsRangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRangeAlign)(c)
}

func (c TsRangeCount) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeCount) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeCount) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeCount) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeCount) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeCount) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeCount) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeCount) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeCount) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeCount) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeCount) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeCount) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeCount) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRangeFilterByTs Incomplete

func (c TsRangeFilterByTs) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c TsRangeFilterByTs) FilterByValue(min float64, max float64) TsRangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRangeFilterByValue)(c)
}

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

func (c TsRangeFilterByTs) Align(value string) TsRangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRangeAlign)(c)
}

func (c TsRangeFilterByTs) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeFilterByTs) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeFilterByTs) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeFilterByTs) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeFilterByTs) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeFilterByTs) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeFilterByTs) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeFilterByTs) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeFilterByTs) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeFilterByTs) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeFilterByTs) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeFilterByTs) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeFilterByTs) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRangeFilterByValue Incomplete

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

func (c TsRangeFilterByValue) Align(value string) TsRangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRangeAlign)(c)
}

func (c TsRangeFilterByValue) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeFilterByValue) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeFilterByValue) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeFilterByValue) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeFilterByValue) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeFilterByValue) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeFilterByValue) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeFilterByValue) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeFilterByValue) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeFilterByValue) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeFilterByValue) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeFilterByValue) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeFilterByValue) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRangeFromtimestamp Incomplete

func (c TsRangeFromtimestamp) Totimestamp(totimestamp string) TsRangeTotimestamp {
	c.cs.s = append(c.cs.s, totimestamp)
	return (TsRangeTotimestamp)(c)
}

type TsRangeKey Incomplete

func (c TsRangeKey) Fromtimestamp(fromtimestamp string) TsRangeFromtimestamp {
	c.cs.s = append(c.cs.s, fromtimestamp)
	return (TsRangeFromtimestamp)(c)
}

type TsRangeLatest Incomplete

func (c TsRangeLatest) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsRangeFilterByTs)(c)
}

func (c TsRangeLatest) FilterByValue(min float64, max float64) TsRangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRangeFilterByValue)(c)
}

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

func (c TsRangeLatest) Align(value string) TsRangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRangeAlign)(c)
}

func (c TsRangeLatest) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeLatest) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeLatest) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeLatest) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeLatest) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeLatest) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeLatest) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeLatest) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeLatest) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeLatest) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeLatest) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeLatest) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeLatest) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRangeTotimestamp Incomplete

func (c TsRangeTotimestamp) Latest() TsRangeLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsRangeLatest)(c)
}

func (c TsRangeTotimestamp) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsRangeFilterByTs)(c)
}

func (c TsRangeTotimestamp) FilterByValue(min float64, max float64) TsRangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRangeFilterByValue)(c)
}

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

func (c TsRangeTotimestamp) Align(value string) TsRangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRangeAlign)(c)
}

func (c TsRangeTotimestamp) AggregationAvg() TsRangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRangeAggregationAggregationAvg)(c)
}

func (c TsRangeTotimestamp) AggregationSum() TsRangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRangeAggregationAggregationSum)(c)
}

func (c TsRangeTotimestamp) AggregationMin() TsRangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRangeAggregationAggregationMin)(c)
}

func (c TsRangeTotimestamp) AggregationMax() TsRangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRangeAggregationAggregationMax)(c)
}

func (c TsRangeTotimestamp) AggregationRange() TsRangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRangeAggregationAggregationRange)(c)
}

func (c TsRangeTotimestamp) AggregationCount() TsRangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRangeAggregationAggregationCount)(c)
}

func (c TsRangeTotimestamp) AggregationFirst() TsRangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRangeAggregationAggregationFirst)(c)
}

func (c TsRangeTotimestamp) AggregationLast() TsRangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRangeAggregationAggregationLast)(c)
}

func (c TsRangeTotimestamp) AggregationStdP() TsRangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRangeAggregationAggregationStdP)(c)
}

func (c TsRangeTotimestamp) AggregationStdS() TsRangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRangeAggregationAggregationStdS)(c)
}

func (c TsRangeTotimestamp) AggregationVarP() TsRangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRangeAggregationAggregationVarP)(c)
}

func (c TsRangeTotimestamp) AggregationVarS() TsRangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRangeAggregationAggregationVarS)(c)
}

func (c TsRangeTotimestamp) AggregationTwa() TsRangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRangeAggregationAggregationTwa)(c)
}

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

type TsRevrange Incomplete

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

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

type TsRevrangeAggregationAggregationAvg Incomplete

func (c TsRevrangeAggregationAggregationAvg) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationCount Incomplete

func (c TsRevrangeAggregationAggregationCount) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationFirst Incomplete

func (c TsRevrangeAggregationAggregationFirst) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationLast Incomplete

func (c TsRevrangeAggregationAggregationLast) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationMax Incomplete

func (c TsRevrangeAggregationAggregationMax) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationMin Incomplete

func (c TsRevrangeAggregationAggregationMin) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationRange Incomplete

func (c TsRevrangeAggregationAggregationRange) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationStdP Incomplete

func (c TsRevrangeAggregationAggregationStdP) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationStdS Incomplete

func (c TsRevrangeAggregationAggregationStdS) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationSum Incomplete

func (c TsRevrangeAggregationAggregationSum) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationTwa Incomplete

func (c TsRevrangeAggregationAggregationTwa) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationVarP Incomplete

func (c TsRevrangeAggregationAggregationVarP) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationAggregationVarS Incomplete

func (c TsRevrangeAggregationAggregationVarS) Bucketduration(bucketduration int64) TsRevrangeAggregationBucketduration {
	c.cs.s = append(c.cs.s, strconv.FormatInt(bucketduration, 10))
	return (TsRevrangeAggregationBucketduration)(c)
}

type TsRevrangeAggregationBucketduration Incomplete

func (c TsRevrangeAggregationBucketduration) Buckettimestamp(buckettimestamp string) TsRevrangeAggregationBuckettimestamp {
	c.cs.s = append(c.cs.s, "BUCKETTIMESTAMP", buckettimestamp)
	return (TsRevrangeAggregationBuckettimestamp)(c)
}

func (c TsRevrangeAggregationBucketduration) Empty() TsRevrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsRevrangeAggregationEmpty)(c)
}

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

type TsRevrangeAggregationBuckettimestamp Incomplete

func (c TsRevrangeAggregationBuckettimestamp) Empty() TsRevrangeAggregationEmpty {
	c.cs.s = append(c.cs.s, "EMPTY")
	return (TsRevrangeAggregationEmpty)(c)
}

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

type TsRevrangeAggregationEmpty Incomplete

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

type TsRevrangeAlign Incomplete

func (c TsRevrangeAlign) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeAlign) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeAlign) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeAlign) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeAlign) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeAlign) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeAlign) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeAlign) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeAlign) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeAlign) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeAlign) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeAlign) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeAlign) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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

type TsRevrangeCount Incomplete

func (c TsRevrangeCount) Align(value string) TsRevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRevrangeAlign)(c)
}

func (c TsRevrangeCount) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeCount) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeCount) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeCount) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeCount) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeCount) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeCount) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeCount) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeCount) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeCount) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeCount) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeCount) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeCount) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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

type TsRevrangeFilterByTs Incomplete

func (c TsRevrangeFilterByTs) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return c
}

func (c TsRevrangeFilterByTs) FilterByValue(min float64, max float64) TsRevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRevrangeFilterByValue)(c)
}

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

func (c TsRevrangeFilterByTs) Align(value string) TsRevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRevrangeAlign)(c)
}

func (c TsRevrangeFilterByTs) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeFilterByTs) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeFilterByTs) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeFilterByTs) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeFilterByTs) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeFilterByTs) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeFilterByTs) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeFilterByTs) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeFilterByTs) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeFilterByTs) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeFilterByTs) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeFilterByTs) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeFilterByTs) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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

type TsRevrangeFilterByValue Incomplete

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

func (c TsRevrangeFilterByValue) Align(value string) TsRevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRevrangeAlign)(c)
}

func (c TsRevrangeFilterByValue) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeFilterByValue) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeFilterByValue) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeFilterByValue) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeFilterByValue) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeFilterByValue) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeFilterByValue) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeFilterByValue) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeFilterByValue) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeFilterByValue) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeFilterByValue) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeFilterByValue) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeFilterByValue) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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

type TsRevrangeFromtimestamp Incomplete

func (c TsRevrangeFromtimestamp) Totimestamp(totimestamp string) TsRevrangeTotimestamp {
	c.cs.s = append(c.cs.s, totimestamp)
	return (TsRevrangeTotimestamp)(c)
}

type TsRevrangeKey Incomplete

func (c TsRevrangeKey) Fromtimestamp(fromtimestamp string) TsRevrangeFromtimestamp {
	c.cs.s = append(c.cs.s, fromtimestamp)
	return (TsRevrangeFromtimestamp)(c)
}

type TsRevrangeLatest Incomplete

func (c TsRevrangeLatest) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsRevrangeFilterByTs)(c)
}

func (c TsRevrangeLatest) FilterByValue(min float64, max float64) TsRevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRevrangeFilterByValue)(c)
}

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

func (c TsRevrangeLatest) Align(value string) TsRevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRevrangeAlign)(c)
}

func (c TsRevrangeLatest) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeLatest) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeLatest) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeLatest) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeLatest) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeLatest) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeLatest) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeLatest) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeLatest) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeLatest) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeLatest) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeLatest) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeLatest) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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

type TsRevrangeTotimestamp Incomplete

func (c TsRevrangeTotimestamp) Latest() TsRevrangeLatest {
	c.cs.s = append(c.cs.s, "LATEST")
	return (TsRevrangeLatest)(c)
}

func (c TsRevrangeTotimestamp) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
	for _, n := range timestamp {
		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
	}
	return (TsRevrangeFilterByTs)(c)
}

func (c TsRevrangeTotimestamp) FilterByValue(min float64, max float64) TsRevrangeFilterByValue {
	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
	return (TsRevrangeFilterByValue)(c)
}

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

func (c TsRevrangeTotimestamp) Align(value string) TsRevrangeAlign {
	c.cs.s = append(c.cs.s, "ALIGN", value)
	return (TsRevrangeAlign)(c)
}

func (c TsRevrangeTotimestamp) AggregationAvg() TsRevrangeAggregationAggregationAvg {
	c.cs.s = append(c.cs.s, "AGGREGATION", "AVG")
	return (TsRevrangeAggregationAggregationAvg)(c)
}

func (c TsRevrangeTotimestamp) AggregationSum() TsRevrangeAggregationAggregationSum {
	c.cs.s = append(c.cs.s, "AGGREGATION", "SUM")
	return (TsRevrangeAggregationAggregationSum)(c)
}

func (c TsRevrangeTotimestamp) AggregationMin() TsRevrangeAggregationAggregationMin {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MIN")
	return (TsRevrangeAggregationAggregationMin)(c)
}

func (c TsRevrangeTotimestamp) AggregationMax() TsRevrangeAggregationAggregationMax {
	c.cs.s = append(c.cs.s, "AGGREGATION", "MAX")
	return (TsRevrangeAggregationAggregationMax)(c)
}

func (c TsRevrangeTotimestamp) AggregationRange() TsRevrangeAggregationAggregationRange {
	c.cs.s = append(c.cs.s, "AGGREGATION", "RANGE")
	return (TsRevrangeAggregationAggregationRange)(c)
}

func (c TsRevrangeTotimestamp) AggregationCount() TsRevrangeAggregationAggregationCount {
	c.cs.s = append(c.cs.s, "AGGREGATION", "COUNT")
	return (TsRevrangeAggregationAggregationCount)(c)
}

func (c TsRevrangeTotimestamp) AggregationFirst() TsRevrangeAggregationAggregationFirst {
	c.cs.s = append(c.cs.s, "AGGREGATION", "FIRST")
	return (TsRevrangeAggregationAggregationFirst)(c)
}

func (c TsRevrangeTotimestamp) AggregationLast() TsRevrangeAggregationAggregationLast {
	c.cs.s = append(c.cs.s, "AGGREGATION", "LAST")
	return (TsRevrangeAggregationAggregationLast)(c)
}

func (c TsRevrangeTotimestamp) AggregationStdP() TsRevrangeAggregationAggregationStdP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.P")
	return (TsRevrangeAggregationAggregationStdP)(c)
}

func (c TsRevrangeTotimestamp) AggregationStdS() TsRevrangeAggregationAggregationStdS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "STD.S")
	return (TsRevrangeAggregationAggregationStdS)(c)
}

func (c TsRevrangeTotimestamp) AggregationVarP() TsRevrangeAggregationAggregationVarP {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.P")
	return (TsRevrangeAggregationAggregationVarP)(c)
}

func (c TsRevrangeTotimestamp) AggregationVarS() TsRevrangeAggregationAggregationVarS {
	c.cs.s = append(c.cs.s, "AGGREGATION", "VAR.S")
	return (TsRevrangeAggregationAggregationVarS)(c)
}

func (c TsRevrangeTotimestamp) AggregationTwa() TsRevrangeAggregationAggregationTwa {
	c.cs.s = append(c.cs.s, "AGGREGATION", "TWA")
	return (TsRevrangeAggregationAggregationTwa)(c)
}

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