// Code generated DO NOT EDIT

package cmds

import "strconv"

type JsonArrappend Incomplete

func (b Builder) JsonArrappend() (c JsonArrappend) {
	c = JsonArrappend{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.ARRAPPEND")
	return c
}

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

type JsonArrappendKey Incomplete

func (c JsonArrappendKey) Path(path string) JsonArrappendPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrappendPath)(c)
}

func (c JsonArrappendKey) Value(value ...string) JsonArrappendValue {
	c.cs.s = append(c.cs.s, value...)
	return (JsonArrappendValue)(c)
}

type JsonArrappendPath Incomplete

func (c JsonArrappendPath) Value(value ...string) JsonArrappendValue {
	c.cs.s = append(c.cs.s, value...)
	return (JsonArrappendValue)(c)
}

type JsonArrappendValue Incomplete

func (c JsonArrappendValue) Value(value ...string) JsonArrappendValue {
	c.cs.s = append(c.cs.s, value...)
	return c
}

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

type JsonArrindex Incomplete

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

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

type JsonArrindexKey Incomplete

func (c JsonArrindexKey) Path(path string) JsonArrindexPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrindexPath)(c)
}

type JsonArrindexPath Incomplete

func (c JsonArrindexPath) Value(value string) JsonArrindexValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonArrindexValue)(c)
}

type JsonArrindexStartStart Incomplete

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

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

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

type JsonArrindexStartStop Incomplete

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

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

type JsonArrindexValue Incomplete

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

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

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

type JsonArrinsert Incomplete

func (b Builder) JsonArrinsert() (c JsonArrinsert) {
	c = JsonArrinsert{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.ARRINSERT")
	return c
}

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

type JsonArrinsertIndex Incomplete

func (c JsonArrinsertIndex) Value(value ...string) JsonArrinsertValue {
	c.cs.s = append(c.cs.s, value...)
	return (JsonArrinsertValue)(c)
}

type JsonArrinsertKey Incomplete

func (c JsonArrinsertKey) Path(path string) JsonArrinsertPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrinsertPath)(c)
}

type JsonArrinsertPath Incomplete

func (c JsonArrinsertPath) Index(index int64) JsonArrinsertIndex {
	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
	return (JsonArrinsertIndex)(c)
}

type JsonArrinsertValue Incomplete

func (c JsonArrinsertValue) Value(value ...string) JsonArrinsertValue {
	c.cs.s = append(c.cs.s, value...)
	return c
}

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

type JsonArrlen Incomplete

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

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

type JsonArrlenKey Incomplete

func (c JsonArrlenKey) Path(path string) JsonArrlenPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrlenPath)(c)
}

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

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

type JsonArrlenPath Incomplete

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

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

type JsonArrpop Incomplete

func (b Builder) JsonArrpop() (c JsonArrpop) {
	c = JsonArrpop{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.ARRPOP")
	return c
}

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

type JsonArrpopKey Incomplete

func (c JsonArrpopKey) Path(path string) JsonArrpopPathPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrpopPathPath)(c)
}

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

type JsonArrpopPathIndex Incomplete

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

type JsonArrpopPathPath Incomplete

func (c JsonArrpopPathPath) Index(index int64) JsonArrpopPathIndex {
	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
	return (JsonArrpopPathIndex)(c)
}

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

type JsonArrtrim Incomplete

func (b Builder) JsonArrtrim() (c JsonArrtrim) {
	c = JsonArrtrim{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.ARRTRIM")
	return c
}

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

type JsonArrtrimKey Incomplete

func (c JsonArrtrimKey) Path(path string) JsonArrtrimPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonArrtrimPath)(c)
}

type JsonArrtrimPath Incomplete

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

type JsonArrtrimStart Incomplete

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

type JsonArrtrimStop Incomplete

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

type JsonClear Incomplete

func (b Builder) JsonClear() (c JsonClear) {
	c = JsonClear{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.CLEAR")
	return c
}

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

type JsonClearKey Incomplete

func (c JsonClearKey) Path(path string) JsonClearPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonClearPath)(c)
}

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

type JsonClearPath Incomplete

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

type JsonDebugHelp Incomplete

func (b Builder) JsonDebugHelp() (c JsonDebugHelp) {
	c = JsonDebugHelp{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.DEBUG", "HELP")
	return c
}

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

type JsonDebugMemory Incomplete

func (b Builder) JsonDebugMemory() (c JsonDebugMemory) {
	c = JsonDebugMemory{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.DEBUG", "MEMORY")
	return c
}

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

type JsonDebugMemoryKey Incomplete

func (c JsonDebugMemoryKey) Path(path string) JsonDebugMemoryPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonDebugMemoryPath)(c)
}

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

type JsonDebugMemoryPath Incomplete

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

type JsonDel Incomplete

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

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

type JsonDelKey Incomplete

func (c JsonDelKey) Path(path string) JsonDelPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonDelPath)(c)
}

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

type JsonDelPath Incomplete

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

type JsonForget Incomplete

func (b Builder) JsonForget() (c JsonForget) {
	c = JsonForget{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.FORGET")
	return c
}

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

type JsonForgetKey Incomplete

func (c JsonForgetKey) Path(path string) JsonForgetPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonForgetPath)(c)
}

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

type JsonForgetPath Incomplete

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

type JsonGet Incomplete

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

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

type JsonGetIndent Incomplete

func (c JsonGetIndent) Newline(newline string) JsonGetNewline {
	c.cs.s = append(c.cs.s, "NEWLINE", newline)
	return (JsonGetNewline)(c)
}

func (c JsonGetIndent) Space(space string) JsonGetSpace {
	c.cs.s = append(c.cs.s, "SPACE", space)
	return (JsonGetSpace)(c)
}

func (c JsonGetIndent) Path(path ...string) JsonGetPath {
	c.cs.s = append(c.cs.s, path...)
	return (JsonGetPath)(c)
}

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

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

type JsonGetKey Incomplete

func (c JsonGetKey) Indent(indent string) JsonGetIndent {
	c.cs.s = append(c.cs.s, "INDENT", indent)
	return (JsonGetIndent)(c)
}

func (c JsonGetKey) Newline(newline string) JsonGetNewline {
	c.cs.s = append(c.cs.s, "NEWLINE", newline)
	return (JsonGetNewline)(c)
}

func (c JsonGetKey) Space(space string) JsonGetSpace {
	c.cs.s = append(c.cs.s, "SPACE", space)
	return (JsonGetSpace)(c)
}

func (c JsonGetKey) Path(path ...string) JsonGetPath {
	c.cs.s = append(c.cs.s, path...)
	return (JsonGetPath)(c)
}

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

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

type JsonGetNewline Incomplete

func (c JsonGetNewline) Space(space string) JsonGetSpace {
	c.cs.s = append(c.cs.s, "SPACE", space)
	return (JsonGetSpace)(c)
}

func (c JsonGetNewline) Path(path ...string) JsonGetPath {
	c.cs.s = append(c.cs.s, path...)
	return (JsonGetPath)(c)
}

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

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

type JsonGetPath Incomplete

func (c JsonGetPath) Path(path ...string) JsonGetPath {
	c.cs.s = append(c.cs.s, path...)
	return c
}

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

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

type JsonGetSpace Incomplete

func (c JsonGetSpace) Path(path ...string) JsonGetPath {
	c.cs.s = append(c.cs.s, path...)
	return (JsonGetPath)(c)
}

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

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

type JsonMerge Incomplete

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

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

type JsonMergeKey Incomplete

func (c JsonMergeKey) Path(path string) JsonMergePath {
	c.cs.s = append(c.cs.s, path)
	return (JsonMergePath)(c)
}

type JsonMergePath Incomplete

func (c JsonMergePath) Value(value string) JsonMergeValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonMergeValue)(c)
}

type JsonMergeValue Incomplete

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

type JsonMget Incomplete

func (b Builder) JsonMget() (c JsonMget) {
	c = JsonMget{cs: get(), ks: b.ks, cf: int16(mtGetTag)}
	c.cs.s = append(c.cs.s, "JSON.MGET")
	return c
}

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

type JsonMgetKey Incomplete

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

func (c JsonMgetKey) Path(path string) JsonMgetPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonMgetPath)(c)
}

type JsonMgetPath Incomplete

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

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

type JsonMset Incomplete

func (b Builder) JsonMset() (c JsonMset) {
	c = JsonMset{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.MSET")
	return c
}

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

type JsonMsetTripletKey Incomplete

func (c JsonMsetTripletKey) Path(path string) JsonMsetTripletPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonMsetTripletPath)(c)
}

type JsonMsetTripletPath Incomplete

func (c JsonMsetTripletPath) Value(value string) JsonMsetTripletValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonMsetTripletValue)(c)
}

type JsonMsetTripletValue Incomplete

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

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

type JsonNumincrby Incomplete

func (b Builder) JsonNumincrby() (c JsonNumincrby) {
	c = JsonNumincrby{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.NUMINCRBY")
	return c
}

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

type JsonNumincrbyKey Incomplete

func (c JsonNumincrbyKey) Path(path string) JsonNumincrbyPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonNumincrbyPath)(c)
}

type JsonNumincrbyPath Incomplete

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

type JsonNumincrbyValue Incomplete

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

type JsonNummultby Incomplete

func (b Builder) JsonNummultby() (c JsonNummultby) {
	c = JsonNummultby{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.NUMMULTBY")
	return c
}

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

type JsonNummultbyKey Incomplete

func (c JsonNummultbyKey) Path(path string) JsonNummultbyPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonNummultbyPath)(c)
}

type JsonNummultbyPath Incomplete

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

type JsonNummultbyValue Incomplete

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

type JsonObjkeys Incomplete

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

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

type JsonObjkeysKey Incomplete

func (c JsonObjkeysKey) Path(path string) JsonObjkeysPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonObjkeysPath)(c)
}

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

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

type JsonObjkeysPath Incomplete

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

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

type JsonObjlen Incomplete

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

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

type JsonObjlenKey Incomplete

func (c JsonObjlenKey) Path(path string) JsonObjlenPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonObjlenPath)(c)
}

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

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

type JsonObjlenPath Incomplete

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

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

type JsonResp Incomplete

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

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

type JsonRespKey Incomplete

func (c JsonRespKey) Path(path string) JsonRespPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonRespPath)(c)
}

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

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

type JsonRespPath Incomplete

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

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

type JsonSet Incomplete

func (b Builder) JsonSet() (c JsonSet) {
	c = JsonSet{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.SET")
	return c
}

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

type JsonSetConditionNx Incomplete

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

type JsonSetConditionXx Incomplete

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

type JsonSetKey Incomplete

func (c JsonSetKey) Path(path string) JsonSetPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonSetPath)(c)
}

type JsonSetPath Incomplete

func (c JsonSetPath) Value(value string) JsonSetValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonSetValue)(c)
}

type JsonSetValue Incomplete

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

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

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

type JsonStrappend Incomplete

func (b Builder) JsonStrappend() (c JsonStrappend) {
	c = JsonStrappend{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.STRAPPEND")
	return c
}

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

type JsonStrappendKey Incomplete

func (c JsonStrappendKey) Path(path string) JsonStrappendPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonStrappendPath)(c)
}

func (c JsonStrappendKey) Value(value string) JsonStrappendValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonStrappendValue)(c)
}

type JsonStrappendPath Incomplete

func (c JsonStrappendPath) Value(value string) JsonStrappendValue {
	c.cs.s = append(c.cs.s, value)
	return (JsonStrappendValue)(c)
}

type JsonStrappendValue Incomplete

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

type JsonStrlen Incomplete

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

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

type JsonStrlenKey Incomplete

func (c JsonStrlenKey) Path(path string) JsonStrlenPath {
	c.cs.s = append(c.cs.s, path)
	return (JsonStrlenPath)(c)
}

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

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

type JsonStrlenPath Incomplete

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

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

type JsonToggle Incomplete

func (b Builder) JsonToggle() (c JsonToggle) {
	c = JsonToggle{cs: get(), ks: b.ks}
	c.cs.s = append(c.cs.s, "JSON.TOGGLE")
	return c
}

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

type JsonToggleKey Incomplete

func (c JsonToggleKey) Path(path string) JsonTogglePath {
	c.cs.s = append(c.cs.s, path)
	return (JsonTogglePath)(c)
}

type JsonTogglePath Incomplete

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

type JsonType Incomplete

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

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

type JsonTypeKey Incomplete

func (c JsonTypeKey) Path(path string) JsonTypePath {
	c.cs.s = append(c.cs.s, path)
	return (JsonTypePath)(c)
}

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

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

type JsonTypePath Incomplete

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

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