// Code generated DO NOT EDIT

package cmds

import "strconv"

type TdigestAdd Incomplete

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

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

type TdigestAddKey Incomplete

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

type TdigestAddValuesValue Incomplete

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

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

type TdigestByrank Incomplete

func (b Builder) TdigestByrank() (c TdigestByrank) {
	c = TdigestByrank{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.BYRANK")
	return c
}

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

type TdigestByrankKey Incomplete

func (c TdigestByrankKey) Rank(rank ...float64) TdigestByrankRank {
	for _, n := range rank {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestByrankRank)(c)
}

type TdigestByrankRank Incomplete

func (c TdigestByrankRank) Rank(rank ...float64) TdigestByrankRank {
	for _, n := range rank {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestByrevrank Incomplete

func (b Builder) TdigestByrevrank() (c TdigestByrevrank) {
	c = TdigestByrevrank{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.BYREVRANK")
	return c
}

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

type TdigestByrevrankKey Incomplete

func (c TdigestByrevrankKey) ReverseRank(reverseRank ...float64) TdigestByrevrankReverseRank {
	for _, n := range reverseRank {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestByrevrankReverseRank)(c)
}

type TdigestByrevrankReverseRank Incomplete

func (c TdigestByrevrankReverseRank) ReverseRank(reverseRank ...float64) TdigestByrevrankReverseRank {
	for _, n := range reverseRank {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestCdf Incomplete

func (b Builder) TdigestCdf() (c TdigestCdf) {
	c = TdigestCdf{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.CDF")
	return c
}

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

type TdigestCdfKey Incomplete

func (c TdigestCdfKey) Value(value ...float64) TdigestCdfValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestCdfValue)(c)
}

type TdigestCdfValue Incomplete

func (c TdigestCdfValue) Value(value ...float64) TdigestCdfValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestCreate Incomplete

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

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

type TdigestCreateCompression Incomplete

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

type TdigestCreateKey Incomplete

func (c TdigestCreateKey) Compression(compression int64) TdigestCreateCompression {
	c.cs.s = append(c.cs.s, "COMPRESSION", strconv.FormatInt(compression, 10))
	return (TdigestCreateCompression)(c)
}

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

type TdigestInfo Incomplete

func (b Builder) TdigestInfo() (c TdigestInfo) {
	c = TdigestInfo{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.INFO")
	return c
}

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

type TdigestInfoKey Incomplete

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

type TdigestMax Incomplete

func (b Builder) TdigestMax() (c TdigestMax) {
	c = TdigestMax{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.MAX")
	return c
}

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

type TdigestMaxKey Incomplete

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

type TdigestMerge Incomplete

func (b Builder) TdigestMerge() (c TdigestMerge) {
	c = TdigestMerge{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.MERGE")
	return c
}

func (c TdigestMerge) DestinationKey(destinationKey string) TdigestMergeDestinationKey {
	if c.ks&NoSlot == NoSlot {
		c.ks = NoSlot | slot(destinationKey)
	} else {
		c.ks = check(c.ks, slot(destinationKey))
	}
	c.cs.s = append(c.cs.s, destinationKey)
	return (TdigestMergeDestinationKey)(c)
}

type TdigestMergeConfigCompression Incomplete

func (c TdigestMergeConfigCompression) Override() TdigestMergeOverride {
	c.cs.s = append(c.cs.s, "OVERRIDE")
	return (TdigestMergeOverride)(c)
}

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

type TdigestMergeDestinationKey Incomplete

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

type TdigestMergeNumkeys Incomplete

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

type TdigestMergeOverride Incomplete

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

type TdigestMergeSourceKey Incomplete

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

func (c TdigestMergeSourceKey) Compression(compression int64) TdigestMergeConfigCompression {
	c.cs.s = append(c.cs.s, "COMPRESSION", strconv.FormatInt(compression, 10))
	return (TdigestMergeConfigCompression)(c)
}

func (c TdigestMergeSourceKey) Override() TdigestMergeOverride {
	c.cs.s = append(c.cs.s, "OVERRIDE")
	return (TdigestMergeOverride)(c)
}

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

type TdigestMin Incomplete

func (b Builder) TdigestMin() (c TdigestMin) {
	c = TdigestMin{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.MIN")
	return c
}

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

type TdigestMinKey Incomplete

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

type TdigestQuantile Incomplete

func (b Builder) TdigestQuantile() (c TdigestQuantile) {
	c = TdigestQuantile{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.QUANTILE")
	return c
}

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

type TdigestQuantileKey Incomplete

func (c TdigestQuantileKey) Quantile(quantile ...float64) TdigestQuantileQuantile {
	for _, n := range quantile {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestQuantileQuantile)(c)
}

type TdigestQuantileQuantile Incomplete

func (c TdigestQuantileQuantile) Quantile(quantile ...float64) TdigestQuantileQuantile {
	for _, n := range quantile {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestRank Incomplete

func (b Builder) TdigestRank() (c TdigestRank) {
	c = TdigestRank{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.RANK")
	return c
}

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

type TdigestRankKey Incomplete

func (c TdigestRankKey) Value(value ...float64) TdigestRankValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestRankValue)(c)
}

type TdigestRankValue Incomplete

func (c TdigestRankValue) Value(value ...float64) TdigestRankValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestReset Incomplete

func (b Builder) TdigestReset() (c TdigestReset) {
	c = TdigestReset{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.RESET")
	return c
}

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

type TdigestResetKey Incomplete

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

type TdigestRevrank Incomplete

func (b Builder) TdigestRevrank() (c TdigestRevrank) {
	c = TdigestRevrank{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.REVRANK")
	return c
}

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

type TdigestRevrankKey Incomplete

func (c TdigestRevrankKey) Value(value ...float64) TdigestRevrankValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return (TdigestRevrankValue)(c)
}

type TdigestRevrankValue Incomplete

func (c TdigestRevrankValue) Value(value ...float64) TdigestRevrankValue {
	for _, n := range value {
		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
	}
	return c
}

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

type TdigestTrimmedMean Incomplete

func (b Builder) TdigestTrimmedMean() (c TdigestTrimmedMean) {
	c = TdigestTrimmedMean{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "TDIGEST.TRIMMED_MEAN")
	return c
}

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

type TdigestTrimmedMeanHighCutQuantile Incomplete

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

type TdigestTrimmedMeanKey Incomplete

func (c TdigestTrimmedMeanKey) LowCutQuantile(lowCutQuantile float64) TdigestTrimmedMeanLowCutQuantile {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(lowCutQuantile, 'f', -1, 64))
	return (TdigestTrimmedMeanLowCutQuantile)(c)
}

type TdigestTrimmedMeanLowCutQuantile Incomplete

func (c TdigestTrimmedMeanLowCutQuantile) HighCutQuantile(highCutQuantile float64) TdigestTrimmedMeanHighCutQuantile {
	c.cs.s = append(c.cs.s, strconv.FormatFloat(highCutQuantile, 'f', -1, 64))
	return (TdigestTrimmedMeanHighCutQuantile)(c)
}