diff --git a/client.go b/client.go
index ea327ad2..493af785 100644
--- a/client.go
+++ b/client.go
@@ -37,13 +37,13 @@ func (c *SingleClient) Info() map[string]proto.Message {
 
 func (c *SingleClient) Do(ctx context.Context, cmd cmds.Completed) (resp proto.Result) {
 	resp = c.conn.Do(cmd)
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
 func (c *SingleClient) DoCache(ctx context.Context, cmd cmds.Cacheable, ttl time.Duration) (resp proto.Result) {
 	resp = c.conn.DoCache(cmd, ttl)
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
@@ -95,7 +95,7 @@ type DedicatedSingleClient struct {
 
 func (c *DedicatedSingleClient) Do(ctx context.Context, cmd cmds.Completed) (resp proto.Result) {
 	resp = c.wire.Do(cmd)
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
@@ -105,7 +105,7 @@ func (c *DedicatedSingleClient) DoMulti(ctx context.Context, multi ...cmds.Compl
 	}
 	resp = c.wire.DoMulti(multi...)
 	for _, cmd := range multi {
-		c.Cmd.Put(cmd.Commands())
+		c.Cmd.Put(cmd.CommandSlice())
 	}
 	return resp
 }
diff --git a/cluster.go b/cluster.go
index 79a44654..0c137304 100644
--- a/cluster.go
+++ b/cluster.go
@@ -271,7 +271,7 @@ process:
 		}
 	}
 ret:
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
@@ -299,7 +299,7 @@ process:
 		}
 	}
 ret:
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
@@ -394,7 +394,7 @@ func (c *DedicatedClusterClient) Do(ctx context.Context, cmd cmds.SCompleted) (r
 	} else {
 		resp = c.wire.Do(cmds.Completed(cmd))
 	}
-	c.Cmd.Put(cmd.Commands())
+	c.Cmd.Put(cmd.CommandSlice())
 	return resp
 }
 
@@ -414,7 +414,7 @@ func (c *DedicatedClusterClient) DoMulti(ctx context.Context, multi ...cmds.SCom
 		}
 	}
 	for _, cmd := range multi {
-		c.Cmd.Put(cmd.Commands())
+		c.Cmd.Put(cmd.CommandSlice())
 	}
 	return resp
 }
diff --git a/hack/cmds/gen.go b/hack/cmds/gen.go
index bab93d3f..de5e83b7 100644
--- a/hack/cmds/gen.go
+++ b/hack/cmds/gen.go
@@ -517,7 +517,7 @@ func toGoName(paramName string) string {
 }
 
 func printRootBuilder(w io.Writer, root GoStruct, prefix string) {
-	fmt.Fprintf(w, "func (b *%sBuilder) %s() %s%s {\n", prefix, root.FullName, prefix, root.FullName)
+	fmt.Fprintf(w, "func (b *%sBuilder) %s() (c %s%s) {\n", prefix, root.FullName, prefix, root.FullName)
 
 	var appends []string
 	for _, cmd := range root.BuildDef.Command {
@@ -525,11 +525,12 @@ func printRootBuilder(w io.Writer, root GoStruct, prefix string) {
 	}
 
 	if tag := rootCf(root); tag != "" {
-		fmt.Fprintf(w, "\treturn %s%s{cs: append(b.get(), %s), ks: InitSlot, cf: %s}\n", prefix, root.FullName, strings.Join(appends, ", "), tag)
+		fmt.Fprintf(w, "\tc = %s%s{cs: b.get(), ks: InitSlot, cf: %s}\n", prefix, root.FullName, tag)
 	} else {
-		fmt.Fprintf(w, "\treturn %s%s{cs: append(b.get(), %s), ks: InitSlot}\n", prefix, root.FullName, strings.Join(appends, ", "))
+		fmt.Fprintf(w, "\tc = %s%s{cs: b.get(), ks: InitSlot}\n", prefix, root.FullName)
 	}
-
+	fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
+	fmt.Fprintf(w, "\treturn c\n")
 	fmt.Fprintf(w, "}\n\n")
 }
 
@@ -624,11 +625,11 @@ func printBuilder(w io.Writer, parent, next GoStruct, prefix string) {
 
 	if len(appends) == 0 && next.Variadic && len(next.BuildDef.Parameters) == 1 && toGoType(next.BuildDef.Parameters[0].Type) == "string" {
 		appends = append(appends, toGoName(next.BuildDef.Parameters[0].Name)+"...")
-		fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", strings.Join(appends, ", "))
+		fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
 	} else if len(next.BuildDef.Parameters) != 1 && next.Variadic && parent.FullName != next.FullName {
 		// no parameter
 		if len(appends) != 0 {
-			fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", strings.Join(appends, ", "))
+			fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
 		}
 	} else {
 		allstring := true
@@ -642,21 +643,21 @@ func printBuilder(w io.Writer, parent, next GoStruct, prefix string) {
 			for _, p := range next.BuildDef.Parameters {
 				appends = append(appends, toGoName(p.Name))
 			}
-			fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", strings.Join(appends, ", "))
+			fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
 		} else {
 			if len(next.BuildDef.Parameters) == 1 && next.Variadic {
 				if len(appends) != 0 {
-					fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", strings.Join(appends, ", "))
+					fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
 				}
 				if toGoType(next.BuildDef.Parameters[0].Type) == "string" {
-					fmt.Fprintf(w, "\tc.cs = append(c.cs, %s...)\n", toGoName(next.BuildDef.Parameters[0].Name))
+					fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s...)\n", toGoName(next.BuildDef.Parameters[0].Name))
 				} else {
 					fmt.Fprintf(w, "\tfor _, n := range %s {\n", toGoName(next.BuildDef.Parameters[0].Name))
 					switch toGoType(next.BuildDef.Parameters[0].Type) {
 					case "float64":
-						fmt.Fprintf(w, "\t\tc.cs = append(c.cs, strconv.FormatFloat(n, 'f', -1, 64))\n")
+						fmt.Fprintf(w, "\t\tc.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))\n")
 					case "int64":
-						fmt.Fprintf(w, "\t\tc.cs = append(c.cs, strconv.FormatInt(n, 10))\n")
+						fmt.Fprintf(w, "\t\tc.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))\n")
 					default:
 						panic("unexpected param type " + next.BuildDef.Parameters[0].Type)
 					}
@@ -678,9 +679,9 @@ func printBuilder(w io.Writer, parent, next GoStruct, prefix string) {
 						panic("unexpected param type " + next.BuildDef.Parameters[0].Type)
 					}
 				}
-				fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", strings.Join(appends, ", "))
+				fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", strings.Join(appends, ", "))
 				for _, follow := range follows {
-					fmt.Fprintf(w, "\tc.cs = append(c.cs, %s)\n", follow)
+					fmt.Fprintf(w, "\tc.cs.s = append(c.cs.s, %s)\n", follow)
 				}
 			}
 		}
diff --git a/internal/cmds/builder.go b/internal/cmds/builder.go
index cb1dc282..11ff1a3f 100644
--- a/internal/cmds/builder.go
+++ b/internal/cmds/builder.go
@@ -2,15 +2,19 @@ package cmds
 
 import "sync"
 
+type CommandSlice struct {
+	s []string
+}
+
 func NewBuilder() *Builder {
 	return &Builder{sp: sync.Pool{New: func() interface{} {
-		return make([]string, 0, 2)
+		return &CommandSlice{s: make([]string, 0, 2)}
 	}}}
 }
 
 func NewSBuilder() *SBuilder {
 	return &SBuilder{sp: sync.Pool{New: func() interface{} {
-		return make([]string, 0, 2)
+		return &CommandSlice{s: make([]string, 0, 2)}
 	}}}
 }
 
@@ -18,22 +22,24 @@ type Builder struct {
 	sp sync.Pool
 }
 
-func (b *Builder) get() []string {
-	return b.sp.Get().([]string)
+func (b *Builder) get() *CommandSlice {
+	return b.sp.Get().(*CommandSlice)
 }
 
-func (b *Builder) Put(s []string) {
-	b.sp.Put(s[:0])
+func (b *Builder) Put(cs *CommandSlice) {
+	cs.s = cs.s[:0]
+	b.sp.Put(cs)
 }
 
 type SBuilder struct {
 	sp sync.Pool
 }
 
-func (b *SBuilder) get() []string {
-	return b.sp.Get().([]string)
+func (b *SBuilder) get() *CommandSlice {
+	return b.sp.Get().(*CommandSlice)
 }
 
-func (b *SBuilder) Put(s []string) {
-	b.sp.Put(s[:0])
+func (b *SBuilder) Put(cs *CommandSlice) {
+	cs.s = cs.s[:0]
+	b.sp.Put(cs)
 }
diff --git a/internal/cmds/cmds.go b/internal/cmds/cmds.go
index 26fda5cc..88068eb8 100644
--- a/internal/cmds/cmds.go
+++ b/internal/cmds/cmds.go
@@ -12,31 +12,31 @@ const (
 
 var (
 	OptInCmd = Completed{
-		cs: []string{"CLIENT", "CACHING", "YES"},
+		cs: &CommandSlice{s: []string{"CLIENT", "CACHING", "YES"}},
 		cf: optInTag,
 	}
 	PingCmd = Completed{
-		cs: []string{"PING"},
+		cs: &CommandSlice{s: []string{"PING"}},
 	}
 	QuitCmd = Completed{
-		cs: []string{"QUIT"},
+		cs: &CommandSlice{s: []string{"QUIT"}},
 	}
 	SlotCmd = Completed{
-		cs: []string{"CLUSTER", "SLOTS"},
+		cs: &CommandSlice{s: []string{"CLUSTER", "SLOTS"}},
 	}
 	AskingCmd = Completed{
-		cs: []string{"ASKING"},
+		cs: &CommandSlice{s: []string{"ASKING"}},
 	}
 )
 
 type Completed struct {
-	cs []string
+	cs *CommandSlice
 	cf uint16
 	ks uint16
 }
 
 func (c *Completed) IsEmpty() bool {
-	return len(c.cs) == 0
+	return c.cs == nil || len(c.cs.s) == 0
 }
 
 func (c *Completed) IsOptIn() bool {
@@ -60,6 +60,10 @@ func (c *Completed) IsWrite() bool {
 }
 
 func (c *Completed) Commands() []string {
+	return c.cs.s
+}
+
+func (c *Completed) CommandSlice() *CommandSlice {
 	return c.cs
 }
 
@@ -67,6 +71,10 @@ type Cacheable Completed
 type SCompleted Completed
 
 func (c *SCompleted) Commands() []string {
+	return c.cs.s
+}
+
+func (c *SCompleted) CommandSlice() *CommandSlice {
 	return c.cs
 }
 
@@ -81,20 +89,28 @@ func (c *SCacheable) Slot() uint16 {
 }
 
 func (c *SCacheable) Commands() []string {
+	return c.cs.s
+}
+
+func (c *SCacheable) CommandSlice() *CommandSlice {
 	return c.cs
 }
 
 func (c *Cacheable) Commands() []string {
+	return c.cs.s
+}
+
+func (c *Cacheable) CommandSlice() *CommandSlice {
 	return c.cs
 }
 
 func (c *Cacheable) CacheKey() (key, command string) {
-	if len(c.cs) == 2 {
-		return c.cs[1], c.cs[0]
+	if len(c.cs.s) == 2 {
+		return c.cs.s[1], c.cs.s[0]
 	}
 
 	length := 0
-	for i, v := range c.cs {
+	for i, v := range c.cs.s {
 		if i == 1 {
 			continue
 		}
@@ -102,7 +118,7 @@ func (c *Cacheable) CacheKey() (key, command string) {
 	}
 	sb := strings.Builder{}
 	sb.Grow(length)
-	for i, v := range c.cs {
+	for i, v := range c.cs.s {
 		if i == 1 {
 			key = v
 		} else {
@@ -112,16 +128,16 @@ func (c *Cacheable) CacheKey() (key, command string) {
 	return key, sb.String()
 }
 
-func NewCompleted(cs []string) Completed {
-	return Completed{cs: cs}
+func NewCompleted(ss []string) Completed {
+	return Completed{cs: &CommandSlice{s: ss}}
 }
 
-func NewBlockingCompleted(cs []string) Completed {
-	return Completed{cs: cs, cf: blockTag}
+func NewBlockingCompleted(ss []string) Completed {
+	return Completed{cs: &CommandSlice{s: ss}, cf: blockTag}
 }
 
-func NewReadOnlyCompleted(cs []string) Completed {
-	return Completed{cs: cs, cf: readonly}
+func NewReadOnlyCompleted(ss []string) Completed {
+	return Completed{cs: &CommandSlice{s: ss}, cf: readonly}
 }
 
 func NewMultiCompleted(cs [][]string) []Completed {
diff --git a/internal/cmds/gen.go b/internal/cmds/gen.go
index 9f21ec71..47dc5355 100644
--- a/internal/cmds/gen.go
+++ b/internal/cmds/gen.go
@@ -8,21 +8,25 @@ type AclCat Completed
 
 type SAclCat SCompleted
 
-func (b *Builder) AclCat() AclCat {
-	return AclCat{cs: append(b.get(), "ACL", "CAT"), ks: InitSlot}
+func (b *Builder) AclCat() (c AclCat) {
+	c = AclCat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "CAT")
+	return c
 }
 
-func (b *SBuilder) AclCat() SAclCat {
-	return SAclCat{cs: append(b.get(), "ACL", "CAT"), ks: InitSlot}
+func (b *SBuilder) AclCat() (c SAclCat) {
+	c = SAclCat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "CAT")
+	return c
 }
 
 func (c AclCat) Categoryname(categoryname string) AclCatCategoryname {
-	c.cs = append(c.cs, categoryname)
+	c.cs.s = append(c.cs.s, categoryname)
 	return (AclCatCategoryname)(c)
 }
 
 func (c SAclCat) Categoryname(categoryname string) SAclCatCategoryname {
-	c.cs = append(c.cs, categoryname)
+	c.cs.s = append(c.cs.s, categoryname)
 	return (SAclCatCategoryname)(c)
 }
 
@@ -50,21 +54,25 @@ type AclDeluser Completed
 
 type SAclDeluser SCompleted
 
-func (b *Builder) AclDeluser() AclDeluser {
-	return AclDeluser{cs: append(b.get(), "ACL", "DELUSER"), ks: InitSlot}
+func (b *Builder) AclDeluser() (c AclDeluser) {
+	c = AclDeluser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "DELUSER")
+	return c
 }
 
-func (b *SBuilder) AclDeluser() SAclDeluser {
-	return SAclDeluser{cs: append(b.get(), "ACL", "DELUSER"), ks: InitSlot}
+func (b *SBuilder) AclDeluser() (c SAclDeluser) {
+	c = SAclDeluser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "DELUSER")
+	return c
 }
 
 func (c AclDeluser) Username(username ...string) AclDeluserUsername {
-	c.cs = append(c.cs, username...)
+	c.cs.s = append(c.cs.s, username...)
 	return (AclDeluserUsername)(c)
 }
 
 func (c SAclDeluser) Username(username ...string) SAclDeluserUsername {
-	c.cs = append(c.cs, username...)
+	c.cs.s = append(c.cs.s, username...)
 	return (SAclDeluserUsername)(c)
 }
 
@@ -73,12 +81,12 @@ type AclDeluserUsername Completed
 type SAclDeluserUsername SCompleted
 
 func (c AclDeluserUsername) Username(username ...string) AclDeluserUsername {
-	c.cs = append(c.cs, username...)
+	c.cs.s = append(c.cs.s, username...)
 	return c
 }
 
 func (c SAclDeluserUsername) Username(username ...string) SAclDeluserUsername {
-	c.cs = append(c.cs, username...)
+	c.cs.s = append(c.cs.s, username...)
 	return c
 }
 
@@ -94,21 +102,25 @@ type AclGenpass Completed
 
 type SAclGenpass SCompleted
 
-func (b *Builder) AclGenpass() AclGenpass {
-	return AclGenpass{cs: append(b.get(), "ACL", "GENPASS"), ks: InitSlot}
+func (b *Builder) AclGenpass() (c AclGenpass) {
+	c = AclGenpass{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "GENPASS")
+	return c
 }
 
-func (b *SBuilder) AclGenpass() SAclGenpass {
-	return SAclGenpass{cs: append(b.get(), "ACL", "GENPASS"), ks: InitSlot}
+func (b *SBuilder) AclGenpass() (c SAclGenpass) {
+	c = SAclGenpass{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "GENPASS")
+	return c
 }
 
 func (c AclGenpass) Bits(bits int64) AclGenpassBits {
-	c.cs = append(c.cs, strconv.FormatInt(bits, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(bits, 10))
 	return (AclGenpassBits)(c)
 }
 
 func (c SAclGenpass) Bits(bits int64) SAclGenpassBits {
-	c.cs = append(c.cs, strconv.FormatInt(bits, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(bits, 10))
 	return (SAclGenpassBits)(c)
 }
 
@@ -136,21 +148,25 @@ type AclGetuser Completed
 
 type SAclGetuser SCompleted
 
-func (b *Builder) AclGetuser() AclGetuser {
-	return AclGetuser{cs: append(b.get(), "ACL", "GETUSER"), ks: InitSlot}
+func (b *Builder) AclGetuser() (c AclGetuser) {
+	c = AclGetuser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "GETUSER")
+	return c
 }
 
-func (b *SBuilder) AclGetuser() SAclGetuser {
-	return SAclGetuser{cs: append(b.get(), "ACL", "GETUSER"), ks: InitSlot}
+func (b *SBuilder) AclGetuser() (c SAclGetuser) {
+	c = SAclGetuser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "GETUSER")
+	return c
 }
 
 func (c AclGetuser) Username(username string) AclGetuserUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (AclGetuserUsername)(c)
 }
 
 func (c SAclGetuser) Username(username string) SAclGetuserUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (SAclGetuserUsername)(c)
 }
 
@@ -170,12 +186,16 @@ type AclHelp Completed
 
 type SAclHelp SCompleted
 
-func (b *Builder) AclHelp() AclHelp {
-	return AclHelp{cs: append(b.get(), "ACL", "HELP"), ks: InitSlot}
+func (b *Builder) AclHelp() (c AclHelp) {
+	c = AclHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "HELP")
+	return c
 }
 
-func (b *SBuilder) AclHelp() SAclHelp {
-	return SAclHelp{cs: append(b.get(), "ACL", "HELP"), ks: InitSlot}
+func (b *SBuilder) AclHelp() (c SAclHelp) {
+	c = SAclHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "HELP")
+	return c
 }
 
 func (c AclHelp) Build() Completed {
@@ -190,12 +210,16 @@ type AclList Completed
 
 type SAclList SCompleted
 
-func (b *Builder) AclList() AclList {
-	return AclList{cs: append(b.get(), "ACL", "LIST"), ks: InitSlot}
+func (b *Builder) AclList() (c AclList) {
+	c = AclList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LIST")
+	return c
 }
 
-func (b *SBuilder) AclList() SAclList {
-	return SAclList{cs: append(b.get(), "ACL", "LIST"), ks: InitSlot}
+func (b *SBuilder) AclList() (c SAclList) {
+	c = SAclList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LIST")
+	return c
 }
 
 func (c AclList) Build() Completed {
@@ -210,12 +234,16 @@ type AclLoad Completed
 
 type SAclLoad SCompleted
 
-func (b *Builder) AclLoad() AclLoad {
-	return AclLoad{cs: append(b.get(), "ACL", "LOAD"), ks: InitSlot}
+func (b *Builder) AclLoad() (c AclLoad) {
+	c = AclLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LOAD")
+	return c
 }
 
-func (b *SBuilder) AclLoad() SAclLoad {
-	return SAclLoad{cs: append(b.get(), "ACL", "LOAD"), ks: InitSlot}
+func (b *SBuilder) AclLoad() (c SAclLoad) {
+	c = SAclLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LOAD")
+	return c
 }
 
 func (c AclLoad) Build() Completed {
@@ -230,21 +258,25 @@ type AclLog Completed
 
 type SAclLog SCompleted
 
-func (b *Builder) AclLog() AclLog {
-	return AclLog{cs: append(b.get(), "ACL", "LOG"), ks: InitSlot}
+func (b *Builder) AclLog() (c AclLog) {
+	c = AclLog{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LOG")
+	return c
 }
 
-func (b *SBuilder) AclLog() SAclLog {
-	return SAclLog{cs: append(b.get(), "ACL", "LOG"), ks: InitSlot}
+func (b *SBuilder) AclLog() (c SAclLog) {
+	c = SAclLog{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "LOG")
+	return c
 }
 
 func (c AclLog) CountOrReset(countOrReset string) AclLogCountOrReset {
-	c.cs = append(c.cs, countOrReset)
+	c.cs.s = append(c.cs.s, countOrReset)
 	return (AclLogCountOrReset)(c)
 }
 
 func (c SAclLog) CountOrReset(countOrReset string) SAclLogCountOrReset {
-	c.cs = append(c.cs, countOrReset)
+	c.cs.s = append(c.cs.s, countOrReset)
 	return (SAclLogCountOrReset)(c)
 }
 
@@ -272,12 +304,16 @@ type AclSave Completed
 
 type SAclSave SCompleted
 
-func (b *Builder) AclSave() AclSave {
-	return AclSave{cs: append(b.get(), "ACL", "SAVE"), ks: InitSlot}
+func (b *Builder) AclSave() (c AclSave) {
+	c = AclSave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "SAVE")
+	return c
 }
 
-func (b *SBuilder) AclSave() SAclSave {
-	return SAclSave{cs: append(b.get(), "ACL", "SAVE"), ks: InitSlot}
+func (b *SBuilder) AclSave() (c SAclSave) {
+	c = SAclSave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "SAVE")
+	return c
 }
 
 func (c AclSave) Build() Completed {
@@ -292,21 +328,25 @@ type AclSetuser Completed
 
 type SAclSetuser SCompleted
 
-func (b *Builder) AclSetuser() AclSetuser {
-	return AclSetuser{cs: append(b.get(), "ACL", "SETUSER"), ks: InitSlot}
+func (b *Builder) AclSetuser() (c AclSetuser) {
+	c = AclSetuser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "SETUSER")
+	return c
 }
 
-func (b *SBuilder) AclSetuser() SAclSetuser {
-	return SAclSetuser{cs: append(b.get(), "ACL", "SETUSER"), ks: InitSlot}
+func (b *SBuilder) AclSetuser() (c SAclSetuser) {
+	c = SAclSetuser{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "SETUSER")
+	return c
 }
 
 func (c AclSetuser) Username(username string) AclSetuserUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (AclSetuserUsername)(c)
 }
 
 func (c SAclSetuser) Username(username string) SAclSetuserUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (SAclSetuserUsername)(c)
 }
 
@@ -315,12 +355,12 @@ type AclSetuserRule Completed
 type SAclSetuserRule SCompleted
 
 func (c AclSetuserRule) Rule(rule ...string) AclSetuserRule {
-	c.cs = append(c.cs, rule...)
+	c.cs.s = append(c.cs.s, rule...)
 	return c
 }
 
 func (c SAclSetuserRule) Rule(rule ...string) SAclSetuserRule {
-	c.cs = append(c.cs, rule...)
+	c.cs.s = append(c.cs.s, rule...)
 	return c
 }
 
@@ -337,12 +377,12 @@ type AclSetuserUsername Completed
 type SAclSetuserUsername SCompleted
 
 func (c AclSetuserUsername) Rule(rule ...string) AclSetuserRule {
-	c.cs = append(c.cs, rule...)
+	c.cs.s = append(c.cs.s, rule...)
 	return (AclSetuserRule)(c)
 }
 
 func (c SAclSetuserUsername) Rule(rule ...string) SAclSetuserRule {
-	c.cs = append(c.cs, rule...)
+	c.cs.s = append(c.cs.s, rule...)
 	return (SAclSetuserRule)(c)
 }
 
@@ -358,12 +398,16 @@ type AclUsers Completed
 
 type SAclUsers SCompleted
 
-func (b *Builder) AclUsers() AclUsers {
-	return AclUsers{cs: append(b.get(), "ACL", "USERS"), ks: InitSlot}
+func (b *Builder) AclUsers() (c AclUsers) {
+	c = AclUsers{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "USERS")
+	return c
 }
 
-func (b *SBuilder) AclUsers() SAclUsers {
-	return SAclUsers{cs: append(b.get(), "ACL", "USERS"), ks: InitSlot}
+func (b *SBuilder) AclUsers() (c SAclUsers) {
+	c = SAclUsers{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "USERS")
+	return c
 }
 
 func (c AclUsers) Build() Completed {
@@ -378,12 +422,16 @@ type AclWhoami Completed
 
 type SAclWhoami SCompleted
 
-func (b *Builder) AclWhoami() AclWhoami {
-	return AclWhoami{cs: append(b.get(), "ACL", "WHOAMI"), ks: InitSlot}
+func (b *Builder) AclWhoami() (c AclWhoami) {
+	c = AclWhoami{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "WHOAMI")
+	return c
 }
 
-func (b *SBuilder) AclWhoami() SAclWhoami {
-	return SAclWhoami{cs: append(b.get(), "ACL", "WHOAMI"), ks: InitSlot}
+func (b *SBuilder) AclWhoami() (c SAclWhoami) {
+	c = SAclWhoami{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ACL", "WHOAMI")
+	return c
 }
 
 func (c AclWhoami) Build() Completed {
@@ -398,22 +446,26 @@ type Append Completed
 
 type SAppend SCompleted
 
-func (b *Builder) Append() Append {
-	return Append{cs: append(b.get(), "APPEND"), ks: InitSlot}
+func (b *Builder) Append() (c Append) {
+	c = Append{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "APPEND")
+	return c
 }
 
-func (b *SBuilder) Append() SAppend {
-	return SAppend{cs: append(b.get(), "APPEND"), ks: InitSlot}
+func (b *SBuilder) Append() (c SAppend) {
+	c = SAppend{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "APPEND")
+	return c
 }
 
 func (c Append) Key(key string) AppendKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (AppendKey)(c)
 }
 
 func (c SAppend) Key(key string) SAppendKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SAppendKey)(c)
 }
 
@@ -422,12 +474,12 @@ type AppendKey Completed
 type SAppendKey SCompleted
 
 func (c AppendKey) Value(value string) AppendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (AppendValue)(c)
 }
 
 func (c SAppendKey) Value(value string) SAppendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SAppendValue)(c)
 }
 
@@ -447,12 +499,16 @@ type Asking Completed
 
 type SAsking SCompleted
 
-func (b *Builder) Asking() Asking {
-	return Asking{cs: append(b.get(), "ASKING"), ks: InitSlot}
+func (b *Builder) Asking() (c Asking) {
+	c = Asking{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ASKING")
+	return c
 }
 
-func (b *SBuilder) Asking() SAsking {
-	return SAsking{cs: append(b.get(), "ASKING"), ks: InitSlot}
+func (b *SBuilder) Asking() (c SAsking) {
+	c = SAsking{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ASKING")
+	return c
 }
 
 func (c Asking) Build() Completed {
@@ -467,31 +523,35 @@ type Auth Completed
 
 type SAuth SCompleted
 
-func (b *Builder) Auth() Auth {
-	return Auth{cs: append(b.get(), "AUTH"), ks: InitSlot}
+func (b *Builder) Auth() (c Auth) {
+	c = Auth{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "AUTH")
+	return c
 }
 
-func (b *SBuilder) Auth() SAuth {
-	return SAuth{cs: append(b.get(), "AUTH"), ks: InitSlot}
+func (b *SBuilder) Auth() (c SAuth) {
+	c = SAuth{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "AUTH")
+	return c
 }
 
 func (c Auth) Username(username string) AuthUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (AuthUsername)(c)
 }
 
 func (c SAuth) Username(username string) SAuthUsername {
-	c.cs = append(c.cs, username)
+	c.cs.s = append(c.cs.s, username)
 	return (SAuthUsername)(c)
 }
 
 func (c Auth) Password(password string) AuthPassword {
-	c.cs = append(c.cs, password)
+	c.cs.s = append(c.cs.s, password)
 	return (AuthPassword)(c)
 }
 
 func (c SAuth) Password(password string) SAuthPassword {
-	c.cs = append(c.cs, password)
+	c.cs.s = append(c.cs.s, password)
 	return (SAuthPassword)(c)
 }
 
@@ -512,12 +572,12 @@ type AuthUsername Completed
 type SAuthUsername SCompleted
 
 func (c AuthUsername) Password(password string) AuthPassword {
-	c.cs = append(c.cs, password)
+	c.cs.s = append(c.cs.s, password)
 	return (AuthPassword)(c)
 }
 
 func (c SAuthUsername) Password(password string) SAuthPassword {
-	c.cs = append(c.cs, password)
+	c.cs.s = append(c.cs.s, password)
 	return (SAuthPassword)(c)
 }
 
@@ -525,22 +585,26 @@ type BfAdd Completed
 
 type SBfAdd SCompleted
 
-func (b *Builder) BfAdd() BfAdd {
-	return BfAdd{cs: append(b.get(), "BF.ADD"), ks: InitSlot}
+func (b *Builder) BfAdd() (c BfAdd) {
+	c = BfAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.ADD")
+	return c
 }
 
-func (b *SBuilder) BfAdd() SBfAdd {
-	return SBfAdd{cs: append(b.get(), "BF.ADD"), ks: InitSlot}
+func (b *SBuilder) BfAdd() (c SBfAdd) {
+	c = SBfAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.ADD")
+	return c
 }
 
 func (c BfAdd) Key(key string) BfAddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfAddKey)(c)
 }
 
 func (c SBfAdd) Key(key string) SBfAddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfAddKey)(c)
 }
 
@@ -561,12 +625,12 @@ type BfAddKey Completed
 type SBfAddKey SCompleted
 
 func (c BfAddKey) Item(item string) BfAddItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (BfAddItem)(c)
 }
 
 func (c SBfAddKey) Item(item string) SBfAddItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SBfAddItem)(c)
 }
 
@@ -574,22 +638,26 @@ type BfExists Completed
 
 type SBfExists SCompleted
 
-func (b *Builder) BfExists() BfExists {
-	return BfExists{cs: append(b.get(), "BF.EXISTS"), ks: InitSlot, cf: readonly}
+func (b *Builder) BfExists() (c BfExists) {
+	c = BfExists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.EXISTS")
+	return c
 }
 
-func (b *SBuilder) BfExists() SBfExists {
-	return SBfExists{cs: append(b.get(), "BF.EXISTS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) BfExists() (c SBfExists) {
+	c = SBfExists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.EXISTS")
+	return c
 }
 
 func (c BfExists) Key(key string) BfExistsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfExistsKey)(c)
 }
 
 func (c SBfExists) Key(key string) SBfExistsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfExistsKey)(c)
 }
 
@@ -618,12 +686,12 @@ type BfExistsKey Completed
 type SBfExistsKey SCompleted
 
 func (c BfExistsKey) Item(item string) BfExistsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (BfExistsItem)(c)
 }
 
 func (c SBfExistsKey) Item(item string) SBfExistsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SBfExistsItem)(c)
 }
 
@@ -631,22 +699,26 @@ type BfInfo Completed
 
 type SBfInfo SCompleted
 
-func (b *Builder) BfInfo() BfInfo {
-	return BfInfo{cs: append(b.get(), "BF.INFO"), ks: InitSlot, cf: readonly}
+func (b *Builder) BfInfo() (c BfInfo) {
+	c = BfInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.INFO")
+	return c
 }
 
-func (b *SBuilder) BfInfo() SBfInfo {
-	return SBfInfo{cs: append(b.get(), "BF.INFO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) BfInfo() (c SBfInfo) {
+	c = SBfInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.INFO")
+	return c
 }
 
 func (c BfInfo) Key(key string) BfInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfInfoKey)(c)
 }
 
 func (c SBfInfo) Key(key string) SBfInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfInfoKey)(c)
 }
 
@@ -674,22 +746,26 @@ type BfInsert Completed
 
 type SBfInsert SCompleted
 
-func (b *Builder) BfInsert() BfInsert {
-	return BfInsert{cs: append(b.get(), "BF.INSERT"), ks: InitSlot}
+func (b *Builder) BfInsert() (c BfInsert) {
+	c = BfInsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.INSERT")
+	return c
 }
 
-func (b *SBuilder) BfInsert() SBfInsert {
-	return SBfInsert{cs: append(b.get(), "BF.INSERT"), ks: InitSlot}
+func (b *SBuilder) BfInsert() (c SBfInsert) {
+	c = SBfInsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.INSERT")
+	return c
 }
 
 func (c BfInsert) Key(key string) BfInsertKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfInsertKey)(c)
 }
 
 func (c SBfInsert) Key(key string) SBfInsertKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfInsertKey)(c)
 }
 
@@ -698,52 +774,52 @@ type BfInsertCapacity Completed
 type SBfInsertCapacity SCompleted
 
 func (c BfInsertCapacity) Error(error float64) BfInsertError {
-	c.cs = append(c.cs, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
 	return (BfInsertError)(c)
 }
 
 func (c SBfInsertCapacity) Error(error float64) SBfInsertError {
-	c.cs = append(c.cs, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
 	return (SBfInsertError)(c)
 }
 
 func (c BfInsertCapacity) Expansion(expansion int64) BfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (BfInsertExpansion)(c)
 }
 
 func (c SBfInsertCapacity) Expansion(expansion int64) SBfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SBfInsertExpansion)(c)
 }
 
 func (c BfInsertCapacity) Nocreate() BfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (BfInsertNocreate)(c)
 }
 
 func (c SBfInsertCapacity) Nocreate() SBfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SBfInsertNocreate)(c)
 }
 
 func (c BfInsertCapacity) Nonscaling() BfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfInsertNonscaling)(c)
 }
 
 func (c SBfInsertCapacity) Nonscaling() SBfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfInsertNonscaling)(c)
 }
 
 func (c BfInsertCapacity) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertCapacity) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -752,42 +828,42 @@ type BfInsertError Completed
 type SBfInsertError SCompleted
 
 func (c BfInsertError) Expansion(expansion int64) BfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (BfInsertExpansion)(c)
 }
 
 func (c SBfInsertError) Expansion(expansion int64) SBfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SBfInsertExpansion)(c)
 }
 
 func (c BfInsertError) Nocreate() BfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (BfInsertNocreate)(c)
 }
 
 func (c SBfInsertError) Nocreate() SBfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SBfInsertNocreate)(c)
 }
 
 func (c BfInsertError) Nonscaling() BfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfInsertNonscaling)(c)
 }
 
 func (c SBfInsertError) Nonscaling() SBfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfInsertNonscaling)(c)
 }
 
 func (c BfInsertError) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertError) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -796,32 +872,32 @@ type BfInsertExpansion Completed
 type SBfInsertExpansion SCompleted
 
 func (c BfInsertExpansion) Nocreate() BfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (BfInsertNocreate)(c)
 }
 
 func (c SBfInsertExpansion) Nocreate() SBfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SBfInsertNocreate)(c)
 }
 
 func (c BfInsertExpansion) Nonscaling() BfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfInsertNonscaling)(c)
 }
 
 func (c SBfInsertExpansion) Nonscaling() SBfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfInsertNonscaling)(c)
 }
 
 func (c BfInsertExpansion) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertExpansion) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -830,12 +906,12 @@ type BfInsertItem Completed
 type SBfInsertItem SCompleted
 
 func (c BfInsertItem) Item(item ...string) BfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SBfInsertItem) Item(item ...string) SBfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -852,12 +928,12 @@ type BfInsertItems Completed
 type SBfInsertItems SCompleted
 
 func (c BfInsertItems) Item(item ...string) BfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (BfInsertItem)(c)
 }
 
 func (c SBfInsertItems) Item(item ...string) SBfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SBfInsertItem)(c)
 }
 
@@ -866,62 +942,62 @@ type BfInsertKey Completed
 type SBfInsertKey SCompleted
 
 func (c BfInsertKey) Capacity(capacity int64) BfInsertCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (BfInsertCapacity)(c)
 }
 
 func (c SBfInsertKey) Capacity(capacity int64) SBfInsertCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (SBfInsertCapacity)(c)
 }
 
 func (c BfInsertKey) Error(error float64) BfInsertError {
-	c.cs = append(c.cs, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
 	return (BfInsertError)(c)
 }
 
 func (c SBfInsertKey) Error(error float64) SBfInsertError {
-	c.cs = append(c.cs, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
 	return (SBfInsertError)(c)
 }
 
 func (c BfInsertKey) Expansion(expansion int64) BfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (BfInsertExpansion)(c)
 }
 
 func (c SBfInsertKey) Expansion(expansion int64) SBfInsertExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SBfInsertExpansion)(c)
 }
 
 func (c BfInsertKey) Nocreate() BfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (BfInsertNocreate)(c)
 }
 
 func (c SBfInsertKey) Nocreate() SBfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SBfInsertNocreate)(c)
 }
 
 func (c BfInsertKey) Nonscaling() BfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfInsertNonscaling)(c)
 }
 
 func (c SBfInsertKey) Nonscaling() SBfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfInsertNonscaling)(c)
 }
 
 func (c BfInsertKey) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertKey) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -930,22 +1006,22 @@ type BfInsertNocreate Completed
 type SBfInsertNocreate SCompleted
 
 func (c BfInsertNocreate) Nonscaling() BfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfInsertNonscaling)(c)
 }
 
 func (c SBfInsertNocreate) Nonscaling() SBfInsertNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfInsertNonscaling)(c)
 }
 
 func (c BfInsertNocreate) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertNocreate) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -954,12 +1030,12 @@ type BfInsertNonscaling Completed
 type SBfInsertNonscaling SCompleted
 
 func (c BfInsertNonscaling) Items() BfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (BfInsertItems)(c)
 }
 
 func (c SBfInsertNonscaling) Items() SBfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SBfInsertItems)(c)
 }
 
@@ -967,22 +1043,26 @@ type BfLoadchunk Completed
 
 type SBfLoadchunk SCompleted
 
-func (b *Builder) BfLoadchunk() BfLoadchunk {
-	return BfLoadchunk{cs: append(b.get(), "BF.LOADCHUNK"), ks: InitSlot}
+func (b *Builder) BfLoadchunk() (c BfLoadchunk) {
+	c = BfLoadchunk{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.LOADCHUNK")
+	return c
 }
 
-func (b *SBuilder) BfLoadchunk() SBfLoadchunk {
-	return SBfLoadchunk{cs: append(b.get(), "BF.LOADCHUNK"), ks: InitSlot}
+func (b *SBuilder) BfLoadchunk() (c SBfLoadchunk) {
+	c = SBfLoadchunk{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.LOADCHUNK")
+	return c
 }
 
 func (c BfLoadchunk) Key(key string) BfLoadchunkKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfLoadchunkKey)(c)
 }
 
 func (c SBfLoadchunk) Key(key string) SBfLoadchunkKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfLoadchunkKey)(c)
 }
 
@@ -1003,12 +1083,12 @@ type BfLoadchunkIterator Completed
 type SBfLoadchunkIterator SCompleted
 
 func (c BfLoadchunkIterator) Data(data string) BfLoadchunkData {
-	c.cs = append(c.cs, data)
+	c.cs.s = append(c.cs.s, data)
 	return (BfLoadchunkData)(c)
 }
 
 func (c SBfLoadchunkIterator) Data(data string) SBfLoadchunkData {
-	c.cs = append(c.cs, data)
+	c.cs.s = append(c.cs.s, data)
 	return (SBfLoadchunkData)(c)
 }
 
@@ -1017,12 +1097,12 @@ type BfLoadchunkKey Completed
 type SBfLoadchunkKey SCompleted
 
 func (c BfLoadchunkKey) Iterator(iterator int64) BfLoadchunkIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (BfLoadchunkIterator)(c)
 }
 
 func (c SBfLoadchunkKey) Iterator(iterator int64) SBfLoadchunkIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (SBfLoadchunkIterator)(c)
 }
 
@@ -1030,22 +1110,26 @@ type BfMadd Completed
 
 type SBfMadd SCompleted
 
-func (b *Builder) BfMadd() BfMadd {
-	return BfMadd{cs: append(b.get(), "BF.MADD"), ks: InitSlot}
+func (b *Builder) BfMadd() (c BfMadd) {
+	c = BfMadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.MADD")
+	return c
 }
 
-func (b *SBuilder) BfMadd() SBfMadd {
-	return SBfMadd{cs: append(b.get(), "BF.MADD"), ks: InitSlot}
+func (b *SBuilder) BfMadd() (c SBfMadd) {
+	c = SBfMadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.MADD")
+	return c
 }
 
 func (c BfMadd) Key(key string) BfMaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfMaddKey)(c)
 }
 
 func (c SBfMadd) Key(key string) SBfMaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfMaddKey)(c)
 }
 
@@ -1054,12 +1138,12 @@ type BfMaddItem Completed
 type SBfMaddItem SCompleted
 
 func (c BfMaddItem) Item(item ...string) BfMaddItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SBfMaddItem) Item(item ...string) SBfMaddItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -1076,12 +1160,12 @@ type BfMaddKey Completed
 type SBfMaddKey SCompleted
 
 func (c BfMaddKey) Item(item ...string) BfMaddItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (BfMaddItem)(c)
 }
 
 func (c SBfMaddKey) Item(item ...string) SBfMaddItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SBfMaddItem)(c)
 }
 
@@ -1089,22 +1173,26 @@ type BfMexists Completed
 
 type SBfMexists SCompleted
 
-func (b *Builder) BfMexists() BfMexists {
-	return BfMexists{cs: append(b.get(), "BF.MEXISTS"), ks: InitSlot, cf: readonly}
+func (b *Builder) BfMexists() (c BfMexists) {
+	c = BfMexists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.MEXISTS")
+	return c
 }
 
-func (b *SBuilder) BfMexists() SBfMexists {
-	return SBfMexists{cs: append(b.get(), "BF.MEXISTS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) BfMexists() (c SBfMexists) {
+	c = SBfMexists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.MEXISTS")
+	return c
 }
 
 func (c BfMexists) Key(key string) BfMexistsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfMexistsKey)(c)
 }
 
 func (c SBfMexists) Key(key string) SBfMexistsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfMexistsKey)(c)
 }
 
@@ -1113,12 +1201,12 @@ type BfMexistsItem Completed
 type SBfMexistsItem SCompleted
 
 func (c BfMexistsItem) Item(item ...string) BfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SBfMexistsItem) Item(item ...string) SBfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -1135,12 +1223,12 @@ type BfMexistsKey Completed
 type SBfMexistsKey SCompleted
 
 func (c BfMexistsKey) Item(item ...string) BfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (BfMexistsItem)(c)
 }
 
 func (c SBfMexistsKey) Item(item ...string) SBfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SBfMexistsItem)(c)
 }
 
@@ -1148,22 +1236,26 @@ type BfReserve Completed
 
 type SBfReserve SCompleted
 
-func (b *Builder) BfReserve() BfReserve {
-	return BfReserve{cs: append(b.get(), "BF.RESERVE"), ks: InitSlot}
+func (b *Builder) BfReserve() (c BfReserve) {
+	c = BfReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.RESERVE")
+	return c
 }
 
-func (b *SBuilder) BfReserve() SBfReserve {
-	return SBfReserve{cs: append(b.get(), "BF.RESERVE"), ks: InitSlot}
+func (b *SBuilder) BfReserve() (c SBfReserve) {
+	c = SBfReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BF.RESERVE")
+	return c
 }
 
 func (c BfReserve) Key(key string) BfReserveKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfReserveKey)(c)
 }
 
 func (c SBfReserve) Key(key string) SBfReserveKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfReserveKey)(c)
 }
 
@@ -1172,22 +1264,22 @@ type BfReserveCapacity Completed
 type SBfReserveCapacity SCompleted
 
 func (c BfReserveCapacity) Expansion(expansion int64) BfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (BfReserveExpansion)(c)
 }
 
 func (c SBfReserveCapacity) Expansion(expansion int64) SBfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SBfReserveExpansion)(c)
 }
 
 func (c BfReserveCapacity) Nonscaling() BfReserveNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfReserveNonscaling)(c)
 }
 
 func (c SBfReserveCapacity) Nonscaling() SBfReserveNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfReserveNonscaling)(c)
 }
 
@@ -1204,12 +1296,12 @@ type BfReserveErrorRate Completed
 type SBfReserveErrorRate SCompleted
 
 func (c BfReserveErrorRate) Capacity(capacity int64) BfReserveCapacity {
-	c.cs = append(c.cs, strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
 	return (BfReserveCapacity)(c)
 }
 
 func (c SBfReserveErrorRate) Capacity(capacity int64) SBfReserveCapacity {
-	c.cs = append(c.cs, strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
 	return (SBfReserveCapacity)(c)
 }
 
@@ -1218,12 +1310,12 @@ type BfReserveExpansion Completed
 type SBfReserveExpansion SCompleted
 
 func (c BfReserveExpansion) Nonscaling() BfReserveNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (BfReserveNonscaling)(c)
 }
 
 func (c SBfReserveExpansion) Nonscaling() SBfReserveNonscaling {
-	c.cs = append(c.cs, "NONSCALING")
+	c.cs.s = append(c.cs.s, "NONSCALING")
 	return (SBfReserveNonscaling)(c)
 }
 
@@ -1240,12 +1332,12 @@ type BfReserveKey Completed
 type SBfReserveKey SCompleted
 
 func (c BfReserveKey) ErrorRate(errorRate float64) BfReserveErrorRate {
-	c.cs = append(c.cs, strconv.FormatFloat(errorRate, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(errorRate, 'f', -1, 64))
 	return (BfReserveErrorRate)(c)
 }
 
 func (c SBfReserveKey) ErrorRate(errorRate float64) SBfReserveErrorRate {
-	c.cs = append(c.cs, strconv.FormatFloat(errorRate, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(errorRate, 'f', -1, 64))
 	return (SBfReserveErrorRate)(c)
 }
 
@@ -1265,22 +1357,26 @@ type BfScandump Completed
 
 type SBfScandump SCompleted
 
-func (b *Builder) BfScandump() BfScandump {
-	return BfScandump{cs: append(b.get(), "BF.SCANDUMP"), ks: InitSlot, cf: readonly}
+func (b *Builder) BfScandump() (c BfScandump) {
+	c = BfScandump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.SCANDUMP")
+	return c
 }
 
-func (b *SBuilder) BfScandump() SBfScandump {
-	return SBfScandump{cs: append(b.get(), "BF.SCANDUMP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) BfScandump() (c SBfScandump) {
+	c = SBfScandump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BF.SCANDUMP")
+	return c
 }
 
 func (c BfScandump) Key(key string) BfScandumpKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BfScandumpKey)(c)
 }
 
 func (c SBfScandump) Key(key string) SBfScandumpKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBfScandumpKey)(c)
 }
 
@@ -1301,12 +1397,12 @@ type BfScandumpKey Completed
 type SBfScandumpKey SCompleted
 
 func (c BfScandumpKey) Iterator(iterator int64) BfScandumpIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (BfScandumpIterator)(c)
 }
 
 func (c SBfScandumpKey) Iterator(iterator int64) SBfScandumpIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (SBfScandumpIterator)(c)
 }
 
@@ -1314,12 +1410,16 @@ type Bgrewriteaof Completed
 
 type SBgrewriteaof SCompleted
 
-func (b *Builder) Bgrewriteaof() Bgrewriteaof {
-	return Bgrewriteaof{cs: append(b.get(), "BGREWRITEAOF"), ks: InitSlot}
+func (b *Builder) Bgrewriteaof() (c Bgrewriteaof) {
+	c = Bgrewriteaof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BGREWRITEAOF")
+	return c
 }
 
-func (b *SBuilder) Bgrewriteaof() SBgrewriteaof {
-	return SBgrewriteaof{cs: append(b.get(), "BGREWRITEAOF"), ks: InitSlot}
+func (b *SBuilder) Bgrewriteaof() (c SBgrewriteaof) {
+	c = SBgrewriteaof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BGREWRITEAOF")
+	return c
 }
 
 func (c Bgrewriteaof) Build() Completed {
@@ -1334,21 +1434,25 @@ type Bgsave Completed
 
 type SBgsave SCompleted
 
-func (b *Builder) Bgsave() Bgsave {
-	return Bgsave{cs: append(b.get(), "BGSAVE"), ks: InitSlot}
+func (b *Builder) Bgsave() (c Bgsave) {
+	c = Bgsave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BGSAVE")
+	return c
 }
 
-func (b *SBuilder) Bgsave() SBgsave {
-	return SBgsave{cs: append(b.get(), "BGSAVE"), ks: InitSlot}
+func (b *SBuilder) Bgsave() (c SBgsave) {
+	c = SBgsave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BGSAVE")
+	return c
 }
 
 func (c Bgsave) Schedule() BgsaveSchedule {
-	c.cs = append(c.cs, "SCHEDULE")
+	c.cs.s = append(c.cs.s, "SCHEDULE")
 	return (BgsaveSchedule)(c)
 }
 
 func (c SBgsave) Schedule() SBgsaveSchedule {
-	c.cs = append(c.cs, "SCHEDULE")
+	c.cs.s = append(c.cs.s, "SCHEDULE")
 	return (SBgsaveSchedule)(c)
 }
 
@@ -1376,22 +1480,26 @@ type Bitcount Completed
 
 type SBitcount SCompleted
 
-func (b *Builder) Bitcount() Bitcount {
-	return Bitcount{cs: append(b.get(), "BITCOUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Bitcount() (c Bitcount) {
+	c = Bitcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITCOUNT")
+	return c
 }
 
-func (b *SBuilder) Bitcount() SBitcount {
-	return SBitcount{cs: append(b.get(), "BITCOUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Bitcount() (c SBitcount) {
+	c = SBitcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITCOUNT")
+	return c
 }
 
 func (c Bitcount) Key(key string) BitcountKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BitcountKey)(c)
 }
 
 func (c SBitcount) Key(key string) SBitcountKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBitcountKey)(c)
 }
 
@@ -1400,22 +1508,22 @@ type BitcountIndexEnd Completed
 type SBitcountIndexEnd SCompleted
 
 func (c BitcountIndexEnd) Byte() BitcountIndexIndexUnitByte {
-	c.cs = append(c.cs, "BYTE")
+	c.cs.s = append(c.cs.s, "BYTE")
 	return (BitcountIndexIndexUnitByte)(c)
 }
 
 func (c SBitcountIndexEnd) Byte() SBitcountIndexIndexUnitByte {
-	c.cs = append(c.cs, "BYTE")
+	c.cs.s = append(c.cs.s, "BYTE")
 	return (SBitcountIndexIndexUnitByte)(c)
 }
 
 func (c BitcountIndexEnd) Bit() BitcountIndexIndexUnitBit {
-	c.cs = append(c.cs, "BIT")
+	c.cs.s = append(c.cs.s, "BIT")
 	return (BitcountIndexIndexUnitBit)(c)
 }
 
 func (c SBitcountIndexEnd) Bit() SBitcountIndexIndexUnitBit {
-	c.cs = append(c.cs, "BIT")
+	c.cs.s = append(c.cs.s, "BIT")
 	return (SBitcountIndexIndexUnitBit)(c)
 }
 
@@ -1480,12 +1588,12 @@ type BitcountIndexStart Completed
 type SBitcountIndexStart SCompleted
 
 func (c BitcountIndexStart) End(end int64) BitcountIndexEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (BitcountIndexEnd)(c)
 }
 
 func (c SBitcountIndexStart) End(end int64) SBitcountIndexEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (SBitcountIndexEnd)(c)
 }
 
@@ -1494,12 +1602,12 @@ type BitcountKey Completed
 type SBitcountKey SCompleted
 
 func (c BitcountKey) Start(start int64) BitcountIndexStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (BitcountIndexStart)(c)
 }
 
 func (c SBitcountKey) Start(start int64) SBitcountIndexStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SBitcountIndexStart)(c)
 }
 
@@ -1523,22 +1631,26 @@ type Bitfield Completed
 
 type SBitfield SCompleted
 
-func (b *Builder) Bitfield() Bitfield {
-	return Bitfield{cs: append(b.get(), "BITFIELD"), ks: InitSlot}
+func (b *Builder) Bitfield() (c Bitfield) {
+	c = Bitfield{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BITFIELD")
+	return c
 }
 
-func (b *SBuilder) Bitfield() SBitfield {
-	return SBitfield{cs: append(b.get(), "BITFIELD"), ks: InitSlot}
+func (b *SBuilder) Bitfield() (c SBitfield) {
+	c = SBitfield{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BITFIELD")
+	return c
 }
 
 func (c Bitfield) Key(key string) BitfieldKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BitfieldKey)(c)
 }
 
 func (c SBitfield) Key(key string) SBitfieldKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBitfieldKey)(c)
 }
 
@@ -1547,52 +1659,52 @@ type BitfieldGet Completed
 type SBitfieldGet SCompleted
 
 func (c BitfieldGet) Set(encoding string, offset int64, value int64) BitfieldSet {
-	c.cs = append(c.cs, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
 	return (BitfieldSet)(c)
 }
 
 func (c SBitfieldGet) Set(encoding string, offset int64, value int64) SBitfieldSet {
-	c.cs = append(c.cs, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
 	return (SBitfieldSet)(c)
 }
 
 func (c BitfieldGet) Incrby(encoding string, offset int64, increment int64) BitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (BitfieldIncrby)(c)
 }
 
 func (c SBitfieldGet) Incrby(encoding string, offset int64, increment int64) SBitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (SBitfieldIncrby)(c)
 }
 
 func (c BitfieldGet) OverflowWrap() BitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (BitfieldOverflowWrap)(c)
 }
 
 func (c SBitfieldGet) OverflowWrap() SBitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (SBitfieldOverflowWrap)(c)
 }
 
 func (c BitfieldGet) OverflowSat() BitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (BitfieldOverflowSat)(c)
 }
 
 func (c SBitfieldGet) OverflowSat() SBitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (SBitfieldOverflowSat)(c)
 }
 
 func (c BitfieldGet) OverflowFail() BitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (BitfieldOverflowFail)(c)
 }
 
 func (c SBitfieldGet) OverflowFail() SBitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (SBitfieldOverflowFail)(c)
 }
 
@@ -1609,32 +1721,32 @@ type BitfieldIncrby Completed
 type SBitfieldIncrby SCompleted
 
 func (c BitfieldIncrby) OverflowWrap() BitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (BitfieldOverflowWrap)(c)
 }
 
 func (c SBitfieldIncrby) OverflowWrap() SBitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (SBitfieldOverflowWrap)(c)
 }
 
 func (c BitfieldIncrby) OverflowSat() BitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (BitfieldOverflowSat)(c)
 }
 
 func (c SBitfieldIncrby) OverflowSat() SBitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (SBitfieldOverflowSat)(c)
 }
 
 func (c BitfieldIncrby) OverflowFail() BitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (BitfieldOverflowFail)(c)
 }
 
 func (c SBitfieldIncrby) OverflowFail() SBitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (SBitfieldOverflowFail)(c)
 }
 
@@ -1651,62 +1763,62 @@ type BitfieldKey Completed
 type SBitfieldKey SCompleted
 
 func (c BitfieldKey) Get(encoding string, offset int64) BitfieldGet {
-	c.cs = append(c.cs, "GET", encoding, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
 	return (BitfieldGet)(c)
 }
 
 func (c SBitfieldKey) Get(encoding string, offset int64) SBitfieldGet {
-	c.cs = append(c.cs, "GET", encoding, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
 	return (SBitfieldGet)(c)
 }
 
 func (c BitfieldKey) Set(encoding string, offset int64, value int64) BitfieldSet {
-	c.cs = append(c.cs, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
 	return (BitfieldSet)(c)
 }
 
 func (c SBitfieldKey) Set(encoding string, offset int64, value int64) SBitfieldSet {
-	c.cs = append(c.cs, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
 	return (SBitfieldSet)(c)
 }
 
 func (c BitfieldKey) Incrby(encoding string, offset int64, increment int64) BitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (BitfieldIncrby)(c)
 }
 
 func (c SBitfieldKey) Incrby(encoding string, offset int64, increment int64) SBitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (SBitfieldIncrby)(c)
 }
 
 func (c BitfieldKey) OverflowWrap() BitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (BitfieldOverflowWrap)(c)
 }
 
 func (c SBitfieldKey) OverflowWrap() SBitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (SBitfieldOverflowWrap)(c)
 }
 
 func (c BitfieldKey) OverflowSat() BitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (BitfieldOverflowSat)(c)
 }
 
 func (c SBitfieldKey) OverflowSat() SBitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (SBitfieldOverflowSat)(c)
 }
 
 func (c BitfieldKey) OverflowFail() BitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (BitfieldOverflowFail)(c)
 }
 
 func (c SBitfieldKey) OverflowFail() SBitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (SBitfieldOverflowFail)(c)
 }
 
@@ -1758,22 +1870,26 @@ type BitfieldRo Completed
 
 type SBitfieldRo SCompleted
 
-func (b *Builder) BitfieldRo() BitfieldRo {
-	return BitfieldRo{cs: append(b.get(), "BITFIELD_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) BitfieldRo() (c BitfieldRo) {
+	c = BitfieldRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITFIELD_RO")
+	return c
 }
 
-func (b *SBuilder) BitfieldRo() SBitfieldRo {
-	return SBitfieldRo{cs: append(b.get(), "BITFIELD_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) BitfieldRo() (c SBitfieldRo) {
+	c = SBitfieldRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITFIELD_RO")
+	return c
 }
 
 func (c BitfieldRo) Key(key string) BitfieldRoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BitfieldRoKey)(c)
 }
 
 func (c SBitfieldRo) Key(key string) SBitfieldRoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBitfieldRoKey)(c)
 }
 
@@ -1802,12 +1918,12 @@ type BitfieldRoKey Completed
 type SBitfieldRoKey SCompleted
 
 func (c BitfieldRoKey) Get(encoding string, offset int64) BitfieldRoGet {
-	c.cs = append(c.cs, "GET", encoding, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
 	return (BitfieldRoGet)(c)
 }
 
 func (c SBitfieldRoKey) Get(encoding string, offset int64) SBitfieldRoGet {
-	c.cs = append(c.cs, "GET", encoding, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
 	return (SBitfieldRoGet)(c)
 }
 
@@ -1816,42 +1932,42 @@ type BitfieldSet Completed
 type SBitfieldSet SCompleted
 
 func (c BitfieldSet) Incrby(encoding string, offset int64, increment int64) BitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (BitfieldIncrby)(c)
 }
 
 func (c SBitfieldSet) Incrby(encoding string, offset int64, increment int64) SBitfieldIncrby {
-	c.cs = append(c.cs, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
 	return (SBitfieldIncrby)(c)
 }
 
 func (c BitfieldSet) OverflowWrap() BitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (BitfieldOverflowWrap)(c)
 }
 
 func (c SBitfieldSet) OverflowWrap() SBitfieldOverflowWrap {
-	c.cs = append(c.cs, "OVERFLOW", "WRAP")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
 	return (SBitfieldOverflowWrap)(c)
 }
 
 func (c BitfieldSet) OverflowSat() BitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (BitfieldOverflowSat)(c)
 }
 
 func (c SBitfieldSet) OverflowSat() SBitfieldOverflowSat {
-	c.cs = append(c.cs, "OVERFLOW", "SAT")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
 	return (SBitfieldOverflowSat)(c)
 }
 
 func (c BitfieldSet) OverflowFail() BitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (BitfieldOverflowFail)(c)
 }
 
 func (c SBitfieldSet) OverflowFail() SBitfieldOverflowFail {
-	c.cs = append(c.cs, "OVERFLOW", "FAIL")
+	c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
 	return (SBitfieldOverflowFail)(c)
 }
 
@@ -1867,21 +1983,25 @@ type Bitop Completed
 
 type SBitop SCompleted
 
-func (b *Builder) Bitop() Bitop {
-	return Bitop{cs: append(b.get(), "BITOP"), ks: InitSlot}
+func (b *Builder) Bitop() (c Bitop) {
+	c = Bitop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BITOP")
+	return c
 }
 
-func (b *SBuilder) Bitop() SBitop {
-	return SBitop{cs: append(b.get(), "BITOP"), ks: InitSlot}
+func (b *SBuilder) Bitop() (c SBitop) {
+	c = SBitop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "BITOP")
+	return c
 }
 
 func (c Bitop) Operation(operation string) BitopOperation {
-	c.cs = append(c.cs, operation)
+	c.cs.s = append(c.cs.s, operation)
 	return (BitopOperation)(c)
 }
 
 func (c SBitop) Operation(operation string) SBitopOperation {
-	c.cs = append(c.cs, operation)
+	c.cs.s = append(c.cs.s, operation)
 	return (SBitopOperation)(c)
 }
 
@@ -1890,7 +2010,7 @@ type BitopDestkey Completed
 type SBitopDestkey SCompleted
 
 func (c BitopDestkey) Key(key ...string) BitopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BitopKey)(c)
 }
 
@@ -1898,7 +2018,7 @@ func (c SBitopDestkey) Key(key ...string) SBitopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBitopKey)(c)
 }
 
@@ -1907,7 +2027,7 @@ type BitopKey Completed
 type SBitopKey SCompleted
 
 func (c BitopKey) Key(key ...string) BitopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -1915,7 +2035,7 @@ func (c SBitopKey) Key(key ...string) SBitopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -1932,13 +2052,13 @@ type BitopOperation Completed
 type SBitopOperation SCompleted
 
 func (c BitopOperation) Destkey(destkey string) BitopDestkey {
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (BitopDestkey)(c)
 }
 
 func (c SBitopOperation) Destkey(destkey string) SBitopDestkey {
 	c.ks = checkSlot(c.ks, slot(destkey))
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (SBitopDestkey)(c)
 }
 
@@ -1946,22 +2066,26 @@ type Bitpos Completed
 
 type SBitpos SCompleted
 
-func (b *Builder) Bitpos() Bitpos {
-	return Bitpos{cs: append(b.get(), "BITPOS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Bitpos() (c Bitpos) {
+	c = Bitpos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITPOS")
+	return c
 }
 
-func (b *SBuilder) Bitpos() SBitpos {
-	return SBitpos{cs: append(b.get(), "BITPOS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Bitpos() (c SBitpos) {
+	c = SBitpos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "BITPOS")
+	return c
 }
 
 func (c Bitpos) Key(key string) BitposKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (BitposKey)(c)
 }
 
 func (c SBitpos) Key(key string) SBitposKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SBitposKey)(c)
 }
 
@@ -1970,12 +2094,12 @@ type BitposBit Completed
 type SBitposBit SCompleted
 
 func (c BitposBit) Start(start int64) BitposIndexStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (BitposIndexStart)(c)
 }
 
 func (c SBitposBit) Start(start int64) SBitposIndexStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SBitposIndexStart)(c)
 }
 
@@ -2000,22 +2124,22 @@ type BitposIndexEndIndexEnd Completed
 type SBitposIndexEndIndexEnd SCompleted
 
 func (c BitposIndexEndIndexEnd) Byte() BitposIndexEndIndexIndexUnitByte {
-	c.cs = append(c.cs, "BYTE")
+	c.cs.s = append(c.cs.s, "BYTE")
 	return (BitposIndexEndIndexIndexUnitByte)(c)
 }
 
 func (c SBitposIndexEndIndexEnd) Byte() SBitposIndexEndIndexIndexUnitByte {
-	c.cs = append(c.cs, "BYTE")
+	c.cs.s = append(c.cs.s, "BYTE")
 	return (SBitposIndexEndIndexIndexUnitByte)(c)
 }
 
 func (c BitposIndexEndIndexEnd) Bit() BitposIndexEndIndexIndexUnitBit {
-	c.cs = append(c.cs, "BIT")
+	c.cs.s = append(c.cs.s, "BIT")
 	return (BitposIndexEndIndexIndexUnitBit)(c)
 }
 
 func (c SBitposIndexEndIndexEnd) Bit() SBitposIndexEndIndexIndexUnitBit {
-	c.cs = append(c.cs, "BIT")
+	c.cs.s = append(c.cs.s, "BIT")
 	return (SBitposIndexEndIndexIndexUnitBit)(c)
 }
 
@@ -2080,12 +2204,12 @@ type BitposIndexStart Completed
 type SBitposIndexStart SCompleted
 
 func (c BitposIndexStart) End(end int64) BitposIndexEndIndexEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (BitposIndexEndIndexEnd)(c)
 }
 
 func (c SBitposIndexStart) End(end int64) SBitposIndexEndIndexEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (SBitposIndexEndIndexEnd)(c)
 }
 
@@ -2110,12 +2234,12 @@ type BitposKey Completed
 type SBitposKey SCompleted
 
 func (c BitposKey) Bit(bit int64) BitposBit {
-	c.cs = append(c.cs, strconv.FormatInt(bit, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(bit, 10))
 	return (BitposBit)(c)
 }
 
 func (c SBitposKey) Bit(bit int64) SBitposBit {
-	c.cs = append(c.cs, strconv.FormatInt(bit, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(bit, 10))
 	return (SBitposBit)(c)
 }
 
@@ -2123,22 +2247,26 @@ type Blmove Completed
 
 type SBlmove SCompleted
 
-func (b *Builder) Blmove() Blmove {
-	return Blmove{cs: append(b.get(), "BLMOVE"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Blmove() (c Blmove) {
+	c = Blmove{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLMOVE")
+	return c
 }
 
-func (b *SBuilder) Blmove() SBlmove {
-	return SBlmove{cs: append(b.get(), "BLMOVE"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Blmove() (c SBlmove) {
+	c = SBlmove{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLMOVE")
+	return c
 }
 
 func (c Blmove) Source(source string) BlmoveSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (BlmoveSource)(c)
 }
 
 func (c SBlmove) Source(source string) SBlmoveSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SBlmoveSource)(c)
 }
 
@@ -2147,22 +2275,22 @@ type BlmoveDestination Completed
 type SBlmoveDestination SCompleted
 
 func (c BlmoveDestination) Left() BlmoveWherefromLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (BlmoveWherefromLeft)(c)
 }
 
 func (c SBlmoveDestination) Left() SBlmoveWherefromLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SBlmoveWherefromLeft)(c)
 }
 
 func (c BlmoveDestination) Right() BlmoveWherefromRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (BlmoveWherefromRight)(c)
 }
 
 func (c SBlmoveDestination) Right() SBlmoveWherefromRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SBlmoveWherefromRight)(c)
 }
 
@@ -2171,13 +2299,13 @@ type BlmoveSource Completed
 type SBlmoveSource SCompleted
 
 func (c BlmoveSource) Destination(destination string) BlmoveDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (BlmoveDestination)(c)
 }
 
 func (c SBlmoveSource) Destination(destination string) SBlmoveDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SBlmoveDestination)(c)
 }
 
@@ -2198,22 +2326,22 @@ type BlmoveWherefromLeft Completed
 type SBlmoveWherefromLeft SCompleted
 
 func (c BlmoveWherefromLeft) Left() BlmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (BlmoveWheretoLeft)(c)
 }
 
 func (c SBlmoveWherefromLeft) Left() SBlmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SBlmoveWheretoLeft)(c)
 }
 
 func (c BlmoveWherefromLeft) Right() BlmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (BlmoveWheretoRight)(c)
 }
 
 func (c SBlmoveWherefromLeft) Right() SBlmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SBlmoveWheretoRight)(c)
 }
 
@@ -2222,22 +2350,22 @@ type BlmoveWherefromRight Completed
 type SBlmoveWherefromRight SCompleted
 
 func (c BlmoveWherefromRight) Left() BlmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (BlmoveWheretoLeft)(c)
 }
 
 func (c SBlmoveWherefromRight) Left() SBlmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SBlmoveWheretoLeft)(c)
 }
 
 func (c BlmoveWherefromRight) Right() BlmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (BlmoveWheretoRight)(c)
 }
 
 func (c SBlmoveWherefromRight) Right() SBlmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SBlmoveWheretoRight)(c)
 }
 
@@ -2246,12 +2374,12 @@ type BlmoveWheretoLeft Completed
 type SBlmoveWheretoLeft SCompleted
 
 func (c BlmoveWheretoLeft) Timeout(timeout float64) BlmoveTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BlmoveTimeout)(c)
 }
 
 func (c SBlmoveWheretoLeft) Timeout(timeout float64) SBlmoveTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBlmoveTimeout)(c)
 }
 
@@ -2260,12 +2388,12 @@ type BlmoveWheretoRight Completed
 type SBlmoveWheretoRight SCompleted
 
 func (c BlmoveWheretoRight) Timeout(timeout float64) BlmoveTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BlmoveTimeout)(c)
 }
 
 func (c SBlmoveWheretoRight) Timeout(timeout float64) SBlmoveTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBlmoveTimeout)(c)
 }
 
@@ -2273,21 +2401,25 @@ type Blmpop Completed
 
 type SBlmpop SCompleted
 
-func (b *Builder) Blmpop() Blmpop {
-	return Blmpop{cs: append(b.get(), "BLMPOP"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Blmpop() (c Blmpop) {
+	c = Blmpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLMPOP")
+	return c
 }
 
-func (b *SBuilder) Blmpop() SBlmpop {
-	return SBlmpop{cs: append(b.get(), "BLMPOP"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Blmpop() (c SBlmpop) {
+	c = SBlmpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLMPOP")
+	return c
 }
 
 func (c Blmpop) Timeout(timeout float64) BlmpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BlmpopTimeout)(c)
 }
 
 func (c SBlmpop) Timeout(timeout float64) SBlmpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBlmpopTimeout)(c)
 }
 
@@ -2308,7 +2440,7 @@ type BlmpopKey Completed
 type SBlmpopKey SCompleted
 
 func (c BlmpopKey) Key(key ...string) BlmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2316,27 +2448,27 @@ func (c SBlmpopKey) Key(key ...string) SBlmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BlmpopKey) Left() BlmpopWhereLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (BlmpopWhereLeft)(c)
 }
 
 func (c SBlmpopKey) Left() SBlmpopWhereLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SBlmpopWhereLeft)(c)
 }
 
 func (c BlmpopKey) Right() BlmpopWhereRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (BlmpopWhereRight)(c)
 }
 
 func (c SBlmpopKey) Right() SBlmpopWhereRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SBlmpopWhereRight)(c)
 }
 
@@ -2345,7 +2477,7 @@ type BlmpopNumkeys Completed
 type SBlmpopNumkeys SCompleted
 
 func (c BlmpopNumkeys) Key(key ...string) BlmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BlmpopKey)(c)
 }
 
@@ -2353,7 +2485,7 @@ func (c SBlmpopNumkeys) Key(key ...string) SBlmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBlmpopKey)(c)
 }
 
@@ -2362,12 +2494,12 @@ type BlmpopTimeout Completed
 type SBlmpopTimeout SCompleted
 
 func (c BlmpopTimeout) Numkeys(numkeys int64) BlmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (BlmpopNumkeys)(c)
 }
 
 func (c SBlmpopTimeout) Numkeys(numkeys int64) SBlmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SBlmpopNumkeys)(c)
 }
 
@@ -2376,12 +2508,12 @@ type BlmpopWhereLeft Completed
 type SBlmpopWhereLeft SCompleted
 
 func (c BlmpopWhereLeft) Count(count int64) BlmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (BlmpopCount)(c)
 }
 
 func (c SBlmpopWhereLeft) Count(count int64) SBlmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SBlmpopCount)(c)
 }
 
@@ -2398,12 +2530,12 @@ type BlmpopWhereRight Completed
 type SBlmpopWhereRight SCompleted
 
 func (c BlmpopWhereRight) Count(count int64) BlmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (BlmpopCount)(c)
 }
 
 func (c SBlmpopWhereRight) Count(count int64) SBlmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SBlmpopCount)(c)
 }
 
@@ -2419,16 +2551,20 @@ type Blpop Completed
 
 type SBlpop SCompleted
 
-func (b *Builder) Blpop() Blpop {
-	return Blpop{cs: append(b.get(), "BLPOP"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Blpop() (c Blpop) {
+	c = Blpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLPOP")
+	return c
 }
 
-func (b *SBuilder) Blpop() SBlpop {
-	return SBlpop{cs: append(b.get(), "BLPOP"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Blpop() (c SBlpop) {
+	c = SBlpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BLPOP")
+	return c
 }
 
 func (c Blpop) Key(key ...string) BlpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BlpopKey)(c)
 }
 
@@ -2436,7 +2572,7 @@ func (c SBlpop) Key(key ...string) SBlpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBlpopKey)(c)
 }
 
@@ -2445,7 +2581,7 @@ type BlpopKey Completed
 type SBlpopKey SCompleted
 
 func (c BlpopKey) Key(key ...string) BlpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2453,17 +2589,17 @@ func (c SBlpopKey) Key(key ...string) SBlpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BlpopKey) Timeout(timeout float64) BlpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BlpopTimeout)(c)
 }
 
 func (c SBlpopKey) Timeout(timeout float64) SBlpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBlpopTimeout)(c)
 }
 
@@ -2483,16 +2619,20 @@ type Brpop Completed
 
 type SBrpop SCompleted
 
-func (b *Builder) Brpop() Brpop {
-	return Brpop{cs: append(b.get(), "BRPOP"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Brpop() (c Brpop) {
+	c = Brpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BRPOP")
+	return c
 }
 
-func (b *SBuilder) Brpop() SBrpop {
-	return SBrpop{cs: append(b.get(), "BRPOP"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Brpop() (c SBrpop) {
+	c = SBrpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BRPOP")
+	return c
 }
 
 func (c Brpop) Key(key ...string) BrpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BrpopKey)(c)
 }
 
@@ -2500,7 +2640,7 @@ func (c SBrpop) Key(key ...string) SBrpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBrpopKey)(c)
 }
 
@@ -2509,7 +2649,7 @@ type BrpopKey Completed
 type SBrpopKey SCompleted
 
 func (c BrpopKey) Key(key ...string) BrpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2517,17 +2657,17 @@ func (c SBrpopKey) Key(key ...string) SBrpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BrpopKey) Timeout(timeout float64) BrpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BrpopTimeout)(c)
 }
 
 func (c SBrpopKey) Timeout(timeout float64) SBrpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBrpopTimeout)(c)
 }
 
@@ -2547,22 +2687,26 @@ type Brpoplpush Completed
 
 type SBrpoplpush SCompleted
 
-func (b *Builder) Brpoplpush() Brpoplpush {
-	return Brpoplpush{cs: append(b.get(), "BRPOPLPUSH"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Brpoplpush() (c Brpoplpush) {
+	c = Brpoplpush{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BRPOPLPUSH")
+	return c
 }
 
-func (b *SBuilder) Brpoplpush() SBrpoplpush {
-	return SBrpoplpush{cs: append(b.get(), "BRPOPLPUSH"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Brpoplpush() (c SBrpoplpush) {
+	c = SBrpoplpush{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BRPOPLPUSH")
+	return c
 }
 
 func (c Brpoplpush) Source(source string) BrpoplpushSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (BrpoplpushSource)(c)
 }
 
 func (c SBrpoplpush) Source(source string) SBrpoplpushSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SBrpoplpushSource)(c)
 }
 
@@ -2571,12 +2715,12 @@ type BrpoplpushDestination Completed
 type SBrpoplpushDestination SCompleted
 
 func (c BrpoplpushDestination) Timeout(timeout float64) BrpoplpushTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BrpoplpushTimeout)(c)
 }
 
 func (c SBrpoplpushDestination) Timeout(timeout float64) SBrpoplpushTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBrpoplpushTimeout)(c)
 }
 
@@ -2585,13 +2729,13 @@ type BrpoplpushSource Completed
 type SBrpoplpushSource SCompleted
 
 func (c BrpoplpushSource) Destination(destination string) BrpoplpushDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (BrpoplpushDestination)(c)
 }
 
 func (c SBrpoplpushSource) Destination(destination string) SBrpoplpushDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SBrpoplpushDestination)(c)
 }
 
@@ -2611,21 +2755,25 @@ type Bzmpop Completed
 
 type SBzmpop SCompleted
 
-func (b *Builder) Bzmpop() Bzmpop {
-	return Bzmpop{cs: append(b.get(), "BZMPOP"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Bzmpop() (c Bzmpop) {
+	c = Bzmpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZMPOP")
+	return c
 }
 
-func (b *SBuilder) Bzmpop() SBzmpop {
-	return SBzmpop{cs: append(b.get(), "BZMPOP"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Bzmpop() (c SBzmpop) {
+	c = SBzmpop{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZMPOP")
+	return c
 }
 
 func (c Bzmpop) Timeout(timeout float64) BzmpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BzmpopTimeout)(c)
 }
 
 func (c SBzmpop) Timeout(timeout float64) SBzmpopTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBzmpopTimeout)(c)
 }
 
@@ -2646,7 +2794,7 @@ type BzmpopKey Completed
 type SBzmpopKey SCompleted
 
 func (c BzmpopKey) Key(key ...string) BzmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2654,27 +2802,27 @@ func (c SBzmpopKey) Key(key ...string) SBzmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BzmpopKey) Min() BzmpopWhereMin {
-	c.cs = append(c.cs, "MIN")
+	c.cs.s = append(c.cs.s, "MIN")
 	return (BzmpopWhereMin)(c)
 }
 
 func (c SBzmpopKey) Min() SBzmpopWhereMin {
-	c.cs = append(c.cs, "MIN")
+	c.cs.s = append(c.cs.s, "MIN")
 	return (SBzmpopWhereMin)(c)
 }
 
 func (c BzmpopKey) Max() BzmpopWhereMax {
-	c.cs = append(c.cs, "MAX")
+	c.cs.s = append(c.cs.s, "MAX")
 	return (BzmpopWhereMax)(c)
 }
 
 func (c SBzmpopKey) Max() SBzmpopWhereMax {
-	c.cs = append(c.cs, "MAX")
+	c.cs.s = append(c.cs.s, "MAX")
 	return (SBzmpopWhereMax)(c)
 }
 
@@ -2683,7 +2831,7 @@ type BzmpopNumkeys Completed
 type SBzmpopNumkeys SCompleted
 
 func (c BzmpopNumkeys) Key(key ...string) BzmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BzmpopKey)(c)
 }
 
@@ -2691,7 +2839,7 @@ func (c SBzmpopNumkeys) Key(key ...string) SBzmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBzmpopKey)(c)
 }
 
@@ -2700,12 +2848,12 @@ type BzmpopTimeout Completed
 type SBzmpopTimeout SCompleted
 
 func (c BzmpopTimeout) Numkeys(numkeys int64) BzmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (BzmpopNumkeys)(c)
 }
 
 func (c SBzmpopTimeout) Numkeys(numkeys int64) SBzmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SBzmpopNumkeys)(c)
 }
 
@@ -2714,12 +2862,12 @@ type BzmpopWhereMax Completed
 type SBzmpopWhereMax SCompleted
 
 func (c BzmpopWhereMax) Count(count int64) BzmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (BzmpopCount)(c)
 }
 
 func (c SBzmpopWhereMax) Count(count int64) SBzmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SBzmpopCount)(c)
 }
 
@@ -2736,12 +2884,12 @@ type BzmpopWhereMin Completed
 type SBzmpopWhereMin SCompleted
 
 func (c BzmpopWhereMin) Count(count int64) BzmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (BzmpopCount)(c)
 }
 
 func (c SBzmpopWhereMin) Count(count int64) SBzmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SBzmpopCount)(c)
 }
 
@@ -2757,16 +2905,20 @@ type Bzpopmax Completed
 
 type SBzpopmax SCompleted
 
-func (b *Builder) Bzpopmax() Bzpopmax {
-	return Bzpopmax{cs: append(b.get(), "BZPOPMAX"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Bzpopmax() (c Bzpopmax) {
+	c = Bzpopmax{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZPOPMAX")
+	return c
 }
 
-func (b *SBuilder) Bzpopmax() SBzpopmax {
-	return SBzpopmax{cs: append(b.get(), "BZPOPMAX"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Bzpopmax() (c SBzpopmax) {
+	c = SBzpopmax{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZPOPMAX")
+	return c
 }
 
 func (c Bzpopmax) Key(key ...string) BzpopmaxKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BzpopmaxKey)(c)
 }
 
@@ -2774,7 +2926,7 @@ func (c SBzpopmax) Key(key ...string) SBzpopmaxKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBzpopmaxKey)(c)
 }
 
@@ -2783,7 +2935,7 @@ type BzpopmaxKey Completed
 type SBzpopmaxKey SCompleted
 
 func (c BzpopmaxKey) Key(key ...string) BzpopmaxKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2791,17 +2943,17 @@ func (c SBzpopmaxKey) Key(key ...string) SBzpopmaxKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BzpopmaxKey) Timeout(timeout float64) BzpopmaxTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BzpopmaxTimeout)(c)
 }
 
 func (c SBzpopmaxKey) Timeout(timeout float64) SBzpopmaxTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBzpopmaxTimeout)(c)
 }
 
@@ -2821,16 +2973,20 @@ type Bzpopmin Completed
 
 type SBzpopmin SCompleted
 
-func (b *Builder) Bzpopmin() Bzpopmin {
-	return Bzpopmin{cs: append(b.get(), "BZPOPMIN"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Bzpopmin() (c Bzpopmin) {
+	c = Bzpopmin{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZPOPMIN")
+	return c
 }
 
-func (b *SBuilder) Bzpopmin() SBzpopmin {
-	return SBzpopmin{cs: append(b.get(), "BZPOPMIN"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Bzpopmin() (c SBzpopmin) {
+	c = SBzpopmin{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "BZPOPMIN")
+	return c
 }
 
 func (c Bzpopmin) Key(key ...string) BzpopminKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (BzpopminKey)(c)
 }
 
@@ -2838,7 +2994,7 @@ func (c SBzpopmin) Key(key ...string) SBzpopminKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SBzpopminKey)(c)
 }
 
@@ -2847,7 +3003,7 @@ type BzpopminKey Completed
 type SBzpopminKey SCompleted
 
 func (c BzpopminKey) Key(key ...string) BzpopminKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -2855,17 +3011,17 @@ func (c SBzpopminKey) Key(key ...string) SBzpopminKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c BzpopminKey) Timeout(timeout float64) BzpopminTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (BzpopminTimeout)(c)
 }
 
 func (c SBzpopminKey) Timeout(timeout float64) SBzpopminTimeout {
-	c.cs = append(c.cs, strconv.FormatFloat(timeout, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(timeout, 'f', -1, 64))
 	return (SBzpopminTimeout)(c)
 }
 
@@ -2885,22 +3041,26 @@ type CfAdd Completed
 
 type SCfAdd SCompleted
 
-func (b *Builder) CfAdd() CfAdd {
-	return CfAdd{cs: append(b.get(), "CF.ADD"), ks: InitSlot}
+func (b *Builder) CfAdd() (c CfAdd) {
+	c = CfAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.ADD")
+	return c
 }
 
-func (b *SBuilder) CfAdd() SCfAdd {
-	return SCfAdd{cs: append(b.get(), "CF.ADD"), ks: InitSlot}
+func (b *SBuilder) CfAdd() (c SCfAdd) {
+	c = SCfAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.ADD")
+	return c
 }
 
 func (c CfAdd) Key(key string) CfAddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfAddKey)(c)
 }
 
 func (c SCfAdd) Key(key string) SCfAddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfAddKey)(c)
 }
 
@@ -2921,12 +3081,12 @@ type CfAddKey Completed
 type SCfAddKey SCompleted
 
 func (c CfAddKey) Item(item string) CfAddItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CfAddItem)(c)
 }
 
 func (c SCfAddKey) Item(item string) SCfAddItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCfAddItem)(c)
 }
 
@@ -2934,22 +3094,26 @@ type CfAddnx Completed
 
 type SCfAddnx SCompleted
 
-func (b *Builder) CfAddnx() CfAddnx {
-	return CfAddnx{cs: append(b.get(), "CF.ADDNX"), ks: InitSlot}
+func (b *Builder) CfAddnx() (c CfAddnx) {
+	c = CfAddnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.ADDNX")
+	return c
 }
 
-func (b *SBuilder) CfAddnx() SCfAddnx {
-	return SCfAddnx{cs: append(b.get(), "CF.ADDNX"), ks: InitSlot}
+func (b *SBuilder) CfAddnx() (c SCfAddnx) {
+	c = SCfAddnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.ADDNX")
+	return c
 }
 
 func (c CfAddnx) Key(key string) CfAddnxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfAddnxKey)(c)
 }
 
 func (c SCfAddnx) Key(key string) SCfAddnxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfAddnxKey)(c)
 }
 
@@ -2958,12 +3122,12 @@ type CfAddnxItem Completed
 type SCfAddnxItem SCompleted
 
 func (c CfAddnxItem) Item(item ...string) CfAddnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SCfAddnxItem) Item(item ...string) SCfAddnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -2980,12 +3144,12 @@ type CfAddnxKey Completed
 type SCfAddnxKey SCompleted
 
 func (c CfAddnxKey) Item(item ...string) CfAddnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (CfAddnxItem)(c)
 }
 
 func (c SCfAddnxKey) Item(item ...string) SCfAddnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SCfAddnxItem)(c)
 }
 
@@ -2993,22 +3157,26 @@ type CfCount Completed
 
 type SCfCount SCompleted
 
-func (b *Builder) CfCount() CfCount {
-	return CfCount{cs: append(b.get(), "CF.COUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) CfCount() (c CfCount) {
+	c = CfCount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.COUNT")
+	return c
 }
 
-func (b *SBuilder) CfCount() SCfCount {
-	return SCfCount{cs: append(b.get(), "CF.COUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CfCount() (c SCfCount) {
+	c = SCfCount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.COUNT")
+	return c
 }
 
 func (c CfCount) Key(key string) CfCountKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfCountKey)(c)
 }
 
 func (c SCfCount) Key(key string) SCfCountKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfCountKey)(c)
 }
 
@@ -3037,12 +3205,12 @@ type CfCountKey Completed
 type SCfCountKey SCompleted
 
 func (c CfCountKey) Item(item string) CfCountItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CfCountItem)(c)
 }
 
 func (c SCfCountKey) Item(item string) SCfCountItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCfCountItem)(c)
 }
 
@@ -3050,22 +3218,26 @@ type CfDel Completed
 
 type SCfDel SCompleted
 
-func (b *Builder) CfDel() CfDel {
-	return CfDel{cs: append(b.get(), "CF.DEL"), ks: InitSlot}
+func (b *Builder) CfDel() (c CfDel) {
+	c = CfDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.DEL")
+	return c
 }
 
-func (b *SBuilder) CfDel() SCfDel {
-	return SCfDel{cs: append(b.get(), "CF.DEL"), ks: InitSlot}
+func (b *SBuilder) CfDel() (c SCfDel) {
+	c = SCfDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.DEL")
+	return c
 }
 
 func (c CfDel) Key(key string) CfDelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfDelKey)(c)
 }
 
 func (c SCfDel) Key(key string) SCfDelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfDelKey)(c)
 }
 
@@ -3086,12 +3258,12 @@ type CfDelKey Completed
 type SCfDelKey SCompleted
 
 func (c CfDelKey) Item(item string) CfDelItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CfDelItem)(c)
 }
 
 func (c SCfDelKey) Item(item string) SCfDelItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCfDelItem)(c)
 }
 
@@ -3099,22 +3271,26 @@ type CfExists Completed
 
 type SCfExists SCompleted
 
-func (b *Builder) CfExists() CfExists {
-	return CfExists{cs: append(b.get(), "CF.EXISTS"), ks: InitSlot, cf: readonly}
+func (b *Builder) CfExists() (c CfExists) {
+	c = CfExists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.EXISTS")
+	return c
 }
 
-func (b *SBuilder) CfExists() SCfExists {
-	return SCfExists{cs: append(b.get(), "CF.EXISTS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CfExists() (c SCfExists) {
+	c = SCfExists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.EXISTS")
+	return c
 }
 
 func (c CfExists) Key(key string) CfExistsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfExistsKey)(c)
 }
 
 func (c SCfExists) Key(key string) SCfExistsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfExistsKey)(c)
 }
 
@@ -3143,12 +3319,12 @@ type CfExistsKey Completed
 type SCfExistsKey SCompleted
 
 func (c CfExistsKey) Item(item string) CfExistsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CfExistsItem)(c)
 }
 
 func (c SCfExistsKey) Item(item string) SCfExistsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCfExistsItem)(c)
 }
 
@@ -3156,22 +3332,26 @@ type CfInfo Completed
 
 type SCfInfo SCompleted
 
-func (b *Builder) CfInfo() CfInfo {
-	return CfInfo{cs: append(b.get(), "CF.INFO"), ks: InitSlot, cf: readonly}
+func (b *Builder) CfInfo() (c CfInfo) {
+	c = CfInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.INFO")
+	return c
 }
 
-func (b *SBuilder) CfInfo() SCfInfo {
-	return SCfInfo{cs: append(b.get(), "CF.INFO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CfInfo() (c SCfInfo) {
+	c = SCfInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.INFO")
+	return c
 }
 
 func (c CfInfo) Key(key string) CfInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfInfoKey)(c)
 }
 
 func (c SCfInfo) Key(key string) SCfInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfInfoKey)(c)
 }
 
@@ -3199,22 +3379,26 @@ type CfInsert Completed
 
 type SCfInsert SCompleted
 
-func (b *Builder) CfInsert() CfInsert {
-	return CfInsert{cs: append(b.get(), "CF.INSERT"), ks: InitSlot}
+func (b *Builder) CfInsert() (c CfInsert) {
+	c = CfInsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.INSERT")
+	return c
 }
 
-func (b *SBuilder) CfInsert() SCfInsert {
-	return SCfInsert{cs: append(b.get(), "CF.INSERT"), ks: InitSlot}
+func (b *SBuilder) CfInsert() (c SCfInsert) {
+	c = SCfInsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.INSERT")
+	return c
 }
 
 func (c CfInsert) Key(key string) CfInsertKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfInsertKey)(c)
 }
 
 func (c SCfInsert) Key(key string) SCfInsertKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfInsertKey)(c)
 }
 
@@ -3223,22 +3407,22 @@ type CfInsertCapacity Completed
 type SCfInsertCapacity SCompleted
 
 func (c CfInsertCapacity) Nocreate() CfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (CfInsertNocreate)(c)
 }
 
 func (c SCfInsertCapacity) Nocreate() SCfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SCfInsertNocreate)(c)
 }
 
 func (c CfInsertCapacity) Items() CfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertItems)(c)
 }
 
 func (c SCfInsertCapacity) Items() SCfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertItems)(c)
 }
 
@@ -3247,12 +3431,12 @@ type CfInsertItem Completed
 type SCfInsertItem SCompleted
 
 func (c CfInsertItem) Item(item ...string) CfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SCfInsertItem) Item(item ...string) SCfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -3269,12 +3453,12 @@ type CfInsertItems Completed
 type SCfInsertItems SCompleted
 
 func (c CfInsertItems) Item(item ...string) CfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (CfInsertItem)(c)
 }
 
 func (c SCfInsertItems) Item(item ...string) SCfInsertItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SCfInsertItem)(c)
 }
 
@@ -3283,32 +3467,32 @@ type CfInsertKey Completed
 type SCfInsertKey SCompleted
 
 func (c CfInsertKey) Capacity(capacity int64) CfInsertCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (CfInsertCapacity)(c)
 }
 
 func (c SCfInsertKey) Capacity(capacity int64) SCfInsertCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (SCfInsertCapacity)(c)
 }
 
 func (c CfInsertKey) Nocreate() CfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (CfInsertNocreate)(c)
 }
 
 func (c SCfInsertKey) Nocreate() SCfInsertNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SCfInsertNocreate)(c)
 }
 
 func (c CfInsertKey) Items() CfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertItems)(c)
 }
 
 func (c SCfInsertKey) Items() SCfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertItems)(c)
 }
 
@@ -3317,12 +3501,12 @@ type CfInsertNocreate Completed
 type SCfInsertNocreate SCompleted
 
 func (c CfInsertNocreate) Items() CfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertItems)(c)
 }
 
 func (c SCfInsertNocreate) Items() SCfInsertItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertItems)(c)
 }
 
@@ -3330,22 +3514,26 @@ type CfInsertnx Completed
 
 type SCfInsertnx SCompleted
 
-func (b *Builder) CfInsertnx() CfInsertnx {
-	return CfInsertnx{cs: append(b.get(), "CF.INSERTNX"), ks: InitSlot}
+func (b *Builder) CfInsertnx() (c CfInsertnx) {
+	c = CfInsertnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.INSERTNX")
+	return c
 }
 
-func (b *SBuilder) CfInsertnx() SCfInsertnx {
-	return SCfInsertnx{cs: append(b.get(), "CF.INSERTNX"), ks: InitSlot}
+func (b *SBuilder) CfInsertnx() (c SCfInsertnx) {
+	c = SCfInsertnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.INSERTNX")
+	return c
 }
 
 func (c CfInsertnx) Key(key string) CfInsertnxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfInsertnxKey)(c)
 }
 
 func (c SCfInsertnx) Key(key string) SCfInsertnxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfInsertnxKey)(c)
 }
 
@@ -3354,22 +3542,22 @@ type CfInsertnxCapacity Completed
 type SCfInsertnxCapacity SCompleted
 
 func (c CfInsertnxCapacity) Nocreate() CfInsertnxNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (CfInsertnxNocreate)(c)
 }
 
 func (c SCfInsertnxCapacity) Nocreate() SCfInsertnxNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SCfInsertnxNocreate)(c)
 }
 
 func (c CfInsertnxCapacity) Items() CfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertnxItems)(c)
 }
 
 func (c SCfInsertnxCapacity) Items() SCfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertnxItems)(c)
 }
 
@@ -3378,12 +3566,12 @@ type CfInsertnxItem Completed
 type SCfInsertnxItem SCompleted
 
 func (c CfInsertnxItem) Item(item ...string) CfInsertnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SCfInsertnxItem) Item(item ...string) SCfInsertnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -3400,12 +3588,12 @@ type CfInsertnxItems Completed
 type SCfInsertnxItems SCompleted
 
 func (c CfInsertnxItems) Item(item ...string) CfInsertnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (CfInsertnxItem)(c)
 }
 
 func (c SCfInsertnxItems) Item(item ...string) SCfInsertnxItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SCfInsertnxItem)(c)
 }
 
@@ -3414,32 +3602,32 @@ type CfInsertnxKey Completed
 type SCfInsertnxKey SCompleted
 
 func (c CfInsertnxKey) Capacity(capacity int64) CfInsertnxCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (CfInsertnxCapacity)(c)
 }
 
 func (c SCfInsertnxKey) Capacity(capacity int64) SCfInsertnxCapacity {
-	c.cs = append(c.cs, "CAPACITY", strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
 	return (SCfInsertnxCapacity)(c)
 }
 
 func (c CfInsertnxKey) Nocreate() CfInsertnxNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (CfInsertnxNocreate)(c)
 }
 
 func (c SCfInsertnxKey) Nocreate() SCfInsertnxNocreate {
-	c.cs = append(c.cs, "NOCREATE")
+	c.cs.s = append(c.cs.s, "NOCREATE")
 	return (SCfInsertnxNocreate)(c)
 }
 
 func (c CfInsertnxKey) Items() CfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertnxItems)(c)
 }
 
 func (c SCfInsertnxKey) Items() SCfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertnxItems)(c)
 }
 
@@ -3448,12 +3636,12 @@ type CfInsertnxNocreate Completed
 type SCfInsertnxNocreate SCompleted
 
 func (c CfInsertnxNocreate) Items() CfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (CfInsertnxItems)(c)
 }
 
 func (c SCfInsertnxNocreate) Items() SCfInsertnxItems {
-	c.cs = append(c.cs, "ITEMS")
+	c.cs.s = append(c.cs.s, "ITEMS")
 	return (SCfInsertnxItems)(c)
 }
 
@@ -3461,22 +3649,26 @@ type CfLoadchunk Completed
 
 type SCfLoadchunk SCompleted
 
-func (b *Builder) CfLoadchunk() CfLoadchunk {
-	return CfLoadchunk{cs: append(b.get(), "CF.LOADCHUNK"), ks: InitSlot}
+func (b *Builder) CfLoadchunk() (c CfLoadchunk) {
+	c = CfLoadchunk{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.LOADCHUNK")
+	return c
 }
 
-func (b *SBuilder) CfLoadchunk() SCfLoadchunk {
-	return SCfLoadchunk{cs: append(b.get(), "CF.LOADCHUNK"), ks: InitSlot}
+func (b *SBuilder) CfLoadchunk() (c SCfLoadchunk) {
+	c = SCfLoadchunk{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.LOADCHUNK")
+	return c
 }
 
 func (c CfLoadchunk) Key(key string) CfLoadchunkKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfLoadchunkKey)(c)
 }
 
 func (c SCfLoadchunk) Key(key string) SCfLoadchunkKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfLoadchunkKey)(c)
 }
 
@@ -3497,12 +3689,12 @@ type CfLoadchunkIterator Completed
 type SCfLoadchunkIterator SCompleted
 
 func (c CfLoadchunkIterator) Data(data string) CfLoadchunkData {
-	c.cs = append(c.cs, data)
+	c.cs.s = append(c.cs.s, data)
 	return (CfLoadchunkData)(c)
 }
 
 func (c SCfLoadchunkIterator) Data(data string) SCfLoadchunkData {
-	c.cs = append(c.cs, data)
+	c.cs.s = append(c.cs.s, data)
 	return (SCfLoadchunkData)(c)
 }
 
@@ -3511,12 +3703,12 @@ type CfLoadchunkKey Completed
 type SCfLoadchunkKey SCompleted
 
 func (c CfLoadchunkKey) Iterator(iterator int64) CfLoadchunkIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (CfLoadchunkIterator)(c)
 }
 
 func (c SCfLoadchunkKey) Iterator(iterator int64) SCfLoadchunkIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (SCfLoadchunkIterator)(c)
 }
 
@@ -3524,22 +3716,26 @@ type CfMexists Completed
 
 type SCfMexists SCompleted
 
-func (b *Builder) CfMexists() CfMexists {
-	return CfMexists{cs: append(b.get(), "CF.MEXISTS"), ks: InitSlot}
+func (b *Builder) CfMexists() (c CfMexists) {
+	c = CfMexists{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.MEXISTS")
+	return c
 }
 
-func (b *SBuilder) CfMexists() SCfMexists {
-	return SCfMexists{cs: append(b.get(), "CF.MEXISTS"), ks: InitSlot}
+func (b *SBuilder) CfMexists() (c SCfMexists) {
+	c = SCfMexists{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.MEXISTS")
+	return c
 }
 
 func (c CfMexists) Key(key string) CfMexistsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfMexistsKey)(c)
 }
 
 func (c SCfMexists) Key(key string) SCfMexistsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfMexistsKey)(c)
 }
 
@@ -3548,12 +3744,12 @@ type CfMexistsItem Completed
 type SCfMexistsItem SCompleted
 
 func (c CfMexistsItem) Item(item ...string) CfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SCfMexistsItem) Item(item ...string) SCfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -3570,12 +3766,12 @@ type CfMexistsKey Completed
 type SCfMexistsKey SCompleted
 
 func (c CfMexistsKey) Item(item ...string) CfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (CfMexistsItem)(c)
 }
 
 func (c SCfMexistsKey) Item(item ...string) SCfMexistsItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SCfMexistsItem)(c)
 }
 
@@ -3583,22 +3779,26 @@ type CfReserve Completed
 
 type SCfReserve SCompleted
 
-func (b *Builder) CfReserve() CfReserve {
-	return CfReserve{cs: append(b.get(), "CF.RESERVE"), ks: InitSlot}
+func (b *Builder) CfReserve() (c CfReserve) {
+	c = CfReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.RESERVE")
+	return c
 }
 
-func (b *SBuilder) CfReserve() SCfReserve {
-	return SCfReserve{cs: append(b.get(), "CF.RESERVE"), ks: InitSlot}
+func (b *SBuilder) CfReserve() (c SCfReserve) {
+	c = SCfReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CF.RESERVE")
+	return c
 }
 
 func (c CfReserve) Key(key string) CfReserveKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfReserveKey)(c)
 }
 
 func (c SCfReserve) Key(key string) SCfReserveKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfReserveKey)(c)
 }
 
@@ -3607,22 +3807,22 @@ type CfReserveBucketsize Completed
 type SCfReserveBucketsize SCompleted
 
 func (c CfReserveBucketsize) Maxiterations(maxiterations int64) CfReserveMaxiterations {
-	c.cs = append(c.cs, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
+	c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
 	return (CfReserveMaxiterations)(c)
 }
 
 func (c SCfReserveBucketsize) Maxiterations(maxiterations int64) SCfReserveMaxiterations {
-	c.cs = append(c.cs, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
+	c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
 	return (SCfReserveMaxiterations)(c)
 }
 
 func (c CfReserveBucketsize) Expansion(expansion int64) CfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (CfReserveExpansion)(c)
 }
 
 func (c SCfReserveBucketsize) Expansion(expansion int64) SCfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SCfReserveExpansion)(c)
 }
 
@@ -3639,32 +3839,32 @@ type CfReserveCapacity Completed
 type SCfReserveCapacity SCompleted
 
 func (c CfReserveCapacity) Bucketsize(bucketsize int64) CfReserveBucketsize {
-	c.cs = append(c.cs, "BUCKETSIZE", strconv.FormatInt(bucketsize, 10))
+	c.cs.s = append(c.cs.s, "BUCKETSIZE", strconv.FormatInt(bucketsize, 10))
 	return (CfReserveBucketsize)(c)
 }
 
 func (c SCfReserveCapacity) Bucketsize(bucketsize int64) SCfReserveBucketsize {
-	c.cs = append(c.cs, "BUCKETSIZE", strconv.FormatInt(bucketsize, 10))
+	c.cs.s = append(c.cs.s, "BUCKETSIZE", strconv.FormatInt(bucketsize, 10))
 	return (SCfReserveBucketsize)(c)
 }
 
 func (c CfReserveCapacity) Maxiterations(maxiterations int64) CfReserveMaxiterations {
-	c.cs = append(c.cs, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
+	c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
 	return (CfReserveMaxiterations)(c)
 }
 
 func (c SCfReserveCapacity) Maxiterations(maxiterations int64) SCfReserveMaxiterations {
-	c.cs = append(c.cs, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
+	c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
 	return (SCfReserveMaxiterations)(c)
 }
 
 func (c CfReserveCapacity) Expansion(expansion int64) CfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (CfReserveExpansion)(c)
 }
 
 func (c SCfReserveCapacity) Expansion(expansion int64) SCfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SCfReserveExpansion)(c)
 }
 
@@ -3693,12 +3893,12 @@ type CfReserveKey Completed
 type SCfReserveKey SCompleted
 
 func (c CfReserveKey) Capacity(capacity int64) CfReserveCapacity {
-	c.cs = append(c.cs, strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
 	return (CfReserveCapacity)(c)
 }
 
 func (c SCfReserveKey) Capacity(capacity int64) SCfReserveCapacity {
-	c.cs = append(c.cs, strconv.FormatInt(capacity, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
 	return (SCfReserveCapacity)(c)
 }
 
@@ -3707,12 +3907,12 @@ type CfReserveMaxiterations Completed
 type SCfReserveMaxiterations SCompleted
 
 func (c CfReserveMaxiterations) Expansion(expansion int64) CfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (CfReserveExpansion)(c)
 }
 
 func (c SCfReserveMaxiterations) Expansion(expansion int64) SCfReserveExpansion {
-	c.cs = append(c.cs, "EXPANSION", strconv.FormatInt(expansion, 10))
+	c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
 	return (SCfReserveExpansion)(c)
 }
 
@@ -3728,22 +3928,26 @@ type CfScandump Completed
 
 type SCfScandump SCompleted
 
-func (b *Builder) CfScandump() CfScandump {
-	return CfScandump{cs: append(b.get(), "CF.SCANDUMP"), ks: InitSlot, cf: readonly}
+func (b *Builder) CfScandump() (c CfScandump) {
+	c = CfScandump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.SCANDUMP")
+	return c
 }
 
-func (b *SBuilder) CfScandump() SCfScandump {
-	return SCfScandump{cs: append(b.get(), "CF.SCANDUMP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CfScandump() (c SCfScandump) {
+	c = SCfScandump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CF.SCANDUMP")
+	return c
 }
 
 func (c CfScandump) Key(key string) CfScandumpKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CfScandumpKey)(c)
 }
 
 func (c SCfScandump) Key(key string) SCfScandumpKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCfScandumpKey)(c)
 }
 
@@ -3764,12 +3968,12 @@ type CfScandumpKey Completed
 type SCfScandumpKey SCompleted
 
 func (c CfScandumpKey) Iterator(iterator int64) CfScandumpIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (CfScandumpIterator)(c)
 }
 
 func (c SCfScandumpKey) Iterator(iterator int64) SCfScandumpIterator {
-	c.cs = append(c.cs, strconv.FormatInt(iterator, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
 	return (SCfScandumpIterator)(c)
 }
 
@@ -3777,31 +3981,35 @@ type ClientCaching Completed
 
 type SClientCaching SCompleted
 
-func (b *Builder) ClientCaching() ClientCaching {
-	return ClientCaching{cs: append(b.get(), "CLIENT", "CACHING"), ks: InitSlot}
+func (b *Builder) ClientCaching() (c ClientCaching) {
+	c = ClientCaching{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "CACHING")
+	return c
 }
 
-func (b *SBuilder) ClientCaching() SClientCaching {
-	return SClientCaching{cs: append(b.get(), "CLIENT", "CACHING"), ks: InitSlot}
+func (b *SBuilder) ClientCaching() (c SClientCaching) {
+	c = SClientCaching{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "CACHING")
+	return c
 }
 
 func (c ClientCaching) Yes() ClientCachingModeYes {
-	c.cs = append(c.cs, "YES")
+	c.cs.s = append(c.cs.s, "YES")
 	return (ClientCachingModeYes)(c)
 }
 
 func (c SClientCaching) Yes() SClientCachingModeYes {
-	c.cs = append(c.cs, "YES")
+	c.cs.s = append(c.cs.s, "YES")
 	return (SClientCachingModeYes)(c)
 }
 
 func (c ClientCaching) No() ClientCachingModeNo {
-	c.cs = append(c.cs, "NO")
+	c.cs.s = append(c.cs.s, "NO")
 	return (ClientCachingModeNo)(c)
 }
 
 func (c SClientCaching) No() SClientCachingModeNo {
-	c.cs = append(c.cs, "NO")
+	c.cs.s = append(c.cs.s, "NO")
 	return (SClientCachingModeNo)(c)
 }
 
@@ -3833,12 +4041,16 @@ type ClientGetname Completed
 
 type SClientGetname SCompleted
 
-func (b *Builder) ClientGetname() ClientGetname {
-	return ClientGetname{cs: append(b.get(), "CLIENT", "GETNAME"), ks: InitSlot}
+func (b *Builder) ClientGetname() (c ClientGetname) {
+	c = ClientGetname{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "GETNAME")
+	return c
 }
 
-func (b *SBuilder) ClientGetname() SClientGetname {
-	return SClientGetname{cs: append(b.get(), "CLIENT", "GETNAME"), ks: InitSlot}
+func (b *SBuilder) ClientGetname() (c SClientGetname) {
+	c = SClientGetname{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "GETNAME")
+	return c
 }
 
 func (c ClientGetname) Build() Completed {
@@ -3853,12 +4065,16 @@ type ClientGetredir Completed
 
 type SClientGetredir SCompleted
 
-func (b *Builder) ClientGetredir() ClientGetredir {
-	return ClientGetredir{cs: append(b.get(), "CLIENT", "GETREDIR"), ks: InitSlot}
+func (b *Builder) ClientGetredir() (c ClientGetredir) {
+	c = ClientGetredir{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "GETREDIR")
+	return c
 }
 
-func (b *SBuilder) ClientGetredir() SClientGetredir {
-	return SClientGetredir{cs: append(b.get(), "CLIENT", "GETREDIR"), ks: InitSlot}
+func (b *SBuilder) ClientGetredir() (c SClientGetredir) {
+	c = SClientGetredir{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "GETREDIR")
+	return c
 }
 
 func (c ClientGetredir) Build() Completed {
@@ -3873,12 +4089,16 @@ type ClientId Completed
 
 type SClientId SCompleted
 
-func (b *Builder) ClientId() ClientId {
-	return ClientId{cs: append(b.get(), "CLIENT", "ID"), ks: InitSlot}
+func (b *Builder) ClientId() (c ClientId) {
+	c = ClientId{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "ID")
+	return c
 }
 
-func (b *SBuilder) ClientId() SClientId {
-	return SClientId{cs: append(b.get(), "CLIENT", "ID"), ks: InitSlot}
+func (b *SBuilder) ClientId() (c SClientId) {
+	c = SClientId{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "ID")
+	return c
 }
 
 func (c ClientId) Build() Completed {
@@ -3893,12 +4113,16 @@ type ClientInfo Completed
 
 type SClientInfo SCompleted
 
-func (b *Builder) ClientInfo() ClientInfo {
-	return ClientInfo{cs: append(b.get(), "CLIENT", "INFO"), ks: InitSlot}
+func (b *Builder) ClientInfo() (c ClientInfo) {
+	c = ClientInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "INFO")
+	return c
 }
 
-func (b *SBuilder) ClientInfo() SClientInfo {
-	return SClientInfo{cs: append(b.get(), "CLIENT", "INFO"), ks: InitSlot}
+func (b *SBuilder) ClientInfo() (c SClientInfo) {
+	c = SClientInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "INFO")
+	return c
 }
 
 func (c ClientInfo) Build() Completed {
@@ -3913,111 +4137,115 @@ type ClientKill Completed
 
 type SClientKill SCompleted
 
-func (b *Builder) ClientKill() ClientKill {
-	return ClientKill{cs: append(b.get(), "CLIENT", "KILL"), ks: InitSlot}
+func (b *Builder) ClientKill() (c ClientKill) {
+	c = ClientKill{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "KILL")
+	return c
 }
 
-func (b *SBuilder) ClientKill() SClientKill {
-	return SClientKill{cs: append(b.get(), "CLIENT", "KILL"), ks: InitSlot}
+func (b *SBuilder) ClientKill() (c SClientKill) {
+	c = SClientKill{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "KILL")
+	return c
 }
 
 func (c ClientKill) IpPort(ipPort string) ClientKillIpPort {
-	c.cs = append(c.cs, ipPort)
+	c.cs.s = append(c.cs.s, ipPort)
 	return (ClientKillIpPort)(c)
 }
 
 func (c SClientKill) IpPort(ipPort string) SClientKillIpPort {
-	c.cs = append(c.cs, ipPort)
+	c.cs.s = append(c.cs.s, ipPort)
 	return (SClientKillIpPort)(c)
 }
 
 func (c ClientKill) Id(clientId int64) ClientKillId {
-	c.cs = append(c.cs, "ID", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
 	return (ClientKillId)(c)
 }
 
 func (c SClientKill) Id(clientId int64) SClientKillId {
-	c.cs = append(c.cs, "ID", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
 	return (SClientKillId)(c)
 }
 
 func (c ClientKill) TypeNormal() ClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (ClientKillTypeNormal)(c)
 }
 
 func (c SClientKill) TypeNormal() SClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (SClientKillTypeNormal)(c)
 }
 
 func (c ClientKill) TypeMaster() ClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (ClientKillTypeMaster)(c)
 }
 
 func (c SClientKill) TypeMaster() SClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (SClientKillTypeMaster)(c)
 }
 
 func (c ClientKill) TypeSlave() ClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (ClientKillTypeSlave)(c)
 }
 
 func (c SClientKill) TypeSlave() SClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (SClientKillTypeSlave)(c)
 }
 
 func (c ClientKill) TypePubsub() ClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (ClientKillTypePubsub)(c)
 }
 
 func (c SClientKill) TypePubsub() SClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (SClientKillTypePubsub)(c)
 }
 
 func (c ClientKill) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKill) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKill) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKill) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKill) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKill) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKill) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKill) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4034,22 +4262,22 @@ type ClientKillAddr Completed
 type SClientKillAddr SCompleted
 
 func (c ClientKillAddr) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillAddr) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillAddr) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillAddr) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4066,82 +4294,82 @@ type ClientKillId Completed
 type SClientKillId SCompleted
 
 func (c ClientKillId) TypeNormal() ClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (ClientKillTypeNormal)(c)
 }
 
 func (c SClientKillId) TypeNormal() SClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (SClientKillTypeNormal)(c)
 }
 
 func (c ClientKillId) TypeMaster() ClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (ClientKillTypeMaster)(c)
 }
 
 func (c SClientKillId) TypeMaster() SClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (SClientKillTypeMaster)(c)
 }
 
 func (c ClientKillId) TypeSlave() ClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (ClientKillTypeSlave)(c)
 }
 
 func (c SClientKillId) TypeSlave() SClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (SClientKillTypeSlave)(c)
 }
 
 func (c ClientKillId) TypePubsub() ClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (ClientKillTypePubsub)(c)
 }
 
 func (c SClientKillId) TypePubsub() SClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (SClientKillTypePubsub)(c)
 }
 
 func (c ClientKillId) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillId) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillId) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillId) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillId) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillId) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillId) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillId) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4158,92 +4386,92 @@ type ClientKillIpPort Completed
 type SClientKillIpPort SCompleted
 
 func (c ClientKillIpPort) Id(clientId int64) ClientKillId {
-	c.cs = append(c.cs, "ID", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
 	return (ClientKillId)(c)
 }
 
 func (c SClientKillIpPort) Id(clientId int64) SClientKillId {
-	c.cs = append(c.cs, "ID", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "ID", strconv.FormatInt(clientId, 10))
 	return (SClientKillId)(c)
 }
 
 func (c ClientKillIpPort) TypeNormal() ClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (ClientKillTypeNormal)(c)
 }
 
 func (c SClientKillIpPort) TypeNormal() SClientKillTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (SClientKillTypeNormal)(c)
 }
 
 func (c ClientKillIpPort) TypeMaster() ClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (ClientKillTypeMaster)(c)
 }
 
 func (c SClientKillIpPort) TypeMaster() SClientKillTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (SClientKillTypeMaster)(c)
 }
 
 func (c ClientKillIpPort) TypeSlave() ClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (ClientKillTypeSlave)(c)
 }
 
 func (c SClientKillIpPort) TypeSlave() SClientKillTypeSlave {
-	c.cs = append(c.cs, "TYPE", "slave")
+	c.cs.s = append(c.cs.s, "TYPE", "slave")
 	return (SClientKillTypeSlave)(c)
 }
 
 func (c ClientKillIpPort) TypePubsub() ClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (ClientKillTypePubsub)(c)
 }
 
 func (c SClientKillIpPort) TypePubsub() SClientKillTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (SClientKillTypePubsub)(c)
 }
 
 func (c ClientKillIpPort) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillIpPort) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillIpPort) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillIpPort) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillIpPort) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillIpPort) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillIpPort) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillIpPort) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4260,12 +4488,12 @@ type ClientKillLaddr Completed
 type SClientKillLaddr SCompleted
 
 func (c ClientKillLaddr) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillLaddr) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4294,42 +4522,42 @@ type ClientKillTypeMaster Completed
 type SClientKillTypeMaster SCompleted
 
 func (c ClientKillTypeMaster) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillTypeMaster) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillTypeMaster) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillTypeMaster) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillTypeMaster) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillTypeMaster) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillTypeMaster) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillTypeMaster) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4346,42 +4574,42 @@ type ClientKillTypeNormal Completed
 type SClientKillTypeNormal SCompleted
 
 func (c ClientKillTypeNormal) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillTypeNormal) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillTypeNormal) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillTypeNormal) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillTypeNormal) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillTypeNormal) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillTypeNormal) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillTypeNormal) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4398,42 +4626,42 @@ type ClientKillTypePubsub Completed
 type SClientKillTypePubsub SCompleted
 
 func (c ClientKillTypePubsub) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillTypePubsub) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillTypePubsub) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillTypePubsub) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillTypePubsub) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillTypePubsub) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillTypePubsub) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillTypePubsub) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4450,42 +4678,42 @@ type ClientKillTypeSlave Completed
 type SClientKillTypeSlave SCompleted
 
 func (c ClientKillTypeSlave) User(username string) ClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (ClientKillUser)(c)
 }
 
 func (c SClientKillTypeSlave) User(username string) SClientKillUser {
-	c.cs = append(c.cs, "USER", username)
+	c.cs.s = append(c.cs.s, "USER", username)
 	return (SClientKillUser)(c)
 }
 
 func (c ClientKillTypeSlave) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillTypeSlave) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillTypeSlave) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillTypeSlave) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillTypeSlave) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillTypeSlave) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4502,32 +4730,32 @@ type ClientKillUser Completed
 type SClientKillUser SCompleted
 
 func (c ClientKillUser) Addr(ipPort string) ClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (ClientKillAddr)(c)
 }
 
 func (c SClientKillUser) Addr(ipPort string) SClientKillAddr {
-	c.cs = append(c.cs, "ADDR", ipPort)
+	c.cs.s = append(c.cs.s, "ADDR", ipPort)
 	return (SClientKillAddr)(c)
 }
 
 func (c ClientKillUser) Laddr(ipPort string) ClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (ClientKillLaddr)(c)
 }
 
 func (c SClientKillUser) Laddr(ipPort string) SClientKillLaddr {
-	c.cs = append(c.cs, "LADDR", ipPort)
+	c.cs.s = append(c.cs.s, "LADDR", ipPort)
 	return (SClientKillLaddr)(c)
 }
 
 func (c ClientKillUser) Skipme(yesNo string) ClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (ClientKillSkipme)(c)
 }
 
 func (c SClientKillUser) Skipme(yesNo string) SClientKillSkipme {
-	c.cs = append(c.cs, "SKIPME", yesNo)
+	c.cs.s = append(c.cs.s, "SKIPME", yesNo)
 	return (SClientKillSkipme)(c)
 }
 
@@ -4543,61 +4771,65 @@ type ClientList Completed
 
 type SClientList SCompleted
 
-func (b *Builder) ClientList() ClientList {
-	return ClientList{cs: append(b.get(), "CLIENT", "LIST"), ks: InitSlot}
+func (b *Builder) ClientList() (c ClientList) {
+	c = ClientList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "LIST")
+	return c
 }
 
-func (b *SBuilder) ClientList() SClientList {
-	return SClientList{cs: append(b.get(), "CLIENT", "LIST"), ks: InitSlot}
+func (b *SBuilder) ClientList() (c SClientList) {
+	c = SClientList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "LIST")
+	return c
 }
 
 func (c ClientList) TypeNormal() ClientListTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (ClientListTypeNormal)(c)
 }
 
 func (c SClientList) TypeNormal() SClientListTypeNormal {
-	c.cs = append(c.cs, "TYPE", "normal")
+	c.cs.s = append(c.cs.s, "TYPE", "normal")
 	return (SClientListTypeNormal)(c)
 }
 
 func (c ClientList) TypeMaster() ClientListTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (ClientListTypeMaster)(c)
 }
 
 func (c SClientList) TypeMaster() SClientListTypeMaster {
-	c.cs = append(c.cs, "TYPE", "master")
+	c.cs.s = append(c.cs.s, "TYPE", "master")
 	return (SClientListTypeMaster)(c)
 }
 
 func (c ClientList) TypeReplica() ClientListTypeReplica {
-	c.cs = append(c.cs, "TYPE", "replica")
+	c.cs.s = append(c.cs.s, "TYPE", "replica")
 	return (ClientListTypeReplica)(c)
 }
 
 func (c SClientList) TypeReplica() SClientListTypeReplica {
-	c.cs = append(c.cs, "TYPE", "replica")
+	c.cs.s = append(c.cs.s, "TYPE", "replica")
 	return (SClientListTypeReplica)(c)
 }
 
 func (c ClientList) TypePubsub() ClientListTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (ClientListTypePubsub)(c)
 }
 
 func (c SClientList) TypePubsub() SClientListTypePubsub {
-	c.cs = append(c.cs, "TYPE", "pubsub")
+	c.cs.s = append(c.cs.s, "TYPE", "pubsub")
 	return (SClientListTypePubsub)(c)
 }
 
 func (c ClientList) Id() ClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (ClientListIdId)(c)
 }
 
 func (c SClientList) Id() SClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (SClientListIdId)(c)
 }
 
@@ -4615,14 +4847,14 @@ type SClientListIdClientId SCompleted
 
 func (c ClientListIdClientId) ClientId(clientId ...int64) ClientListIdClientId {
 	for _, n := range clientId {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SClientListIdClientId) ClientId(clientId ...int64) SClientListIdClientId {
 	for _, n := range clientId {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
@@ -4641,14 +4873,14 @@ type SClientListIdId SCompleted
 
 func (c ClientListIdId) ClientId(clientId ...int64) ClientListIdClientId {
 	for _, n := range clientId {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ClientListIdClientId)(c)
 }
 
 func (c SClientListIdId) ClientId(clientId ...int64) SClientListIdClientId {
 	for _, n := range clientId {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SClientListIdClientId)(c)
 }
@@ -4658,12 +4890,12 @@ type ClientListTypeMaster Completed
 type SClientListTypeMaster SCompleted
 
 func (c ClientListTypeMaster) Id() ClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (ClientListIdId)(c)
 }
 
 func (c SClientListTypeMaster) Id() SClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (SClientListIdId)(c)
 }
 
@@ -4680,12 +4912,12 @@ type ClientListTypeNormal Completed
 type SClientListTypeNormal SCompleted
 
 func (c ClientListTypeNormal) Id() ClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (ClientListIdId)(c)
 }
 
 func (c SClientListTypeNormal) Id() SClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (SClientListIdId)(c)
 }
 
@@ -4702,12 +4934,12 @@ type ClientListTypePubsub Completed
 type SClientListTypePubsub SCompleted
 
 func (c ClientListTypePubsub) Id() ClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (ClientListIdId)(c)
 }
 
 func (c SClientListTypePubsub) Id() SClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (SClientListIdId)(c)
 }
 
@@ -4724,12 +4956,12 @@ type ClientListTypeReplica Completed
 type SClientListTypeReplica SCompleted
 
 func (c ClientListTypeReplica) Id() ClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (ClientListIdId)(c)
 }
 
 func (c SClientListTypeReplica) Id() SClientListIdId {
-	c.cs = append(c.cs, "ID")
+	c.cs.s = append(c.cs.s, "ID")
 	return (SClientListIdId)(c)
 }
 
@@ -4745,31 +4977,35 @@ type ClientNoEvict Completed
 
 type SClientNoEvict SCompleted
 
-func (b *Builder) ClientNoEvict() ClientNoEvict {
-	return ClientNoEvict{cs: append(b.get(), "CLIENT", "NO-EVICT"), ks: InitSlot}
+func (b *Builder) ClientNoEvict() (c ClientNoEvict) {
+	c = ClientNoEvict{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "NO-EVICT")
+	return c
 }
 
-func (b *SBuilder) ClientNoEvict() SClientNoEvict {
-	return SClientNoEvict{cs: append(b.get(), "CLIENT", "NO-EVICT"), ks: InitSlot}
+func (b *SBuilder) ClientNoEvict() (c SClientNoEvict) {
+	c = SClientNoEvict{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "NO-EVICT")
+	return c
 }
 
 func (c ClientNoEvict) On() ClientNoEvictEnabledOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (ClientNoEvictEnabledOn)(c)
 }
 
 func (c SClientNoEvict) On() SClientNoEvictEnabledOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (SClientNoEvictEnabledOn)(c)
 }
 
 func (c ClientNoEvict) Off() ClientNoEvictEnabledOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (ClientNoEvictEnabledOff)(c)
 }
 
 func (c SClientNoEvict) Off() SClientNoEvictEnabledOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (SClientNoEvictEnabledOff)(c)
 }
 
@@ -4801,21 +5037,25 @@ type ClientPause Completed
 
 type SClientPause SCompleted
 
-func (b *Builder) ClientPause() ClientPause {
-	return ClientPause{cs: append(b.get(), "CLIENT", "PAUSE"), ks: InitSlot, cf: blockTag}
+func (b *Builder) ClientPause() (c ClientPause) {
+	c = ClientPause{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "CLIENT", "PAUSE")
+	return c
 }
 
-func (b *SBuilder) ClientPause() SClientPause {
-	return SClientPause{cs: append(b.get(), "CLIENT", "PAUSE"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) ClientPause() (c SClientPause) {
+	c = SClientPause{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "CLIENT", "PAUSE")
+	return c
 }
 
 func (c ClientPause) Timeout(timeout int64) ClientPauseTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (ClientPauseTimeout)(c)
 }
 
 func (c SClientPause) Timeout(timeout int64) SClientPauseTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (SClientPauseTimeout)(c)
 }
 
@@ -4848,22 +5088,22 @@ type ClientPauseTimeout Completed
 type SClientPauseTimeout SCompleted
 
 func (c ClientPauseTimeout) Write() ClientPauseModeWrite {
-	c.cs = append(c.cs, "WRITE")
+	c.cs.s = append(c.cs.s, "WRITE")
 	return (ClientPauseModeWrite)(c)
 }
 
 func (c SClientPauseTimeout) Write() SClientPauseModeWrite {
-	c.cs = append(c.cs, "WRITE")
+	c.cs.s = append(c.cs.s, "WRITE")
 	return (SClientPauseModeWrite)(c)
 }
 
 func (c ClientPauseTimeout) All() ClientPauseModeAll {
-	c.cs = append(c.cs, "ALL")
+	c.cs.s = append(c.cs.s, "ALL")
 	return (ClientPauseModeAll)(c)
 }
 
 func (c SClientPauseTimeout) All() SClientPauseModeAll {
-	c.cs = append(c.cs, "ALL")
+	c.cs.s = append(c.cs.s, "ALL")
 	return (SClientPauseModeAll)(c)
 }
 
@@ -4879,41 +5119,45 @@ type ClientReply Completed
 
 type SClientReply SCompleted
 
-func (b *Builder) ClientReply() ClientReply {
-	return ClientReply{cs: append(b.get(), "CLIENT", "REPLY"), ks: InitSlot}
+func (b *Builder) ClientReply() (c ClientReply) {
+	c = ClientReply{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "REPLY")
+	return c
 }
 
-func (b *SBuilder) ClientReply() SClientReply {
-	return SClientReply{cs: append(b.get(), "CLIENT", "REPLY"), ks: InitSlot}
+func (b *SBuilder) ClientReply() (c SClientReply) {
+	c = SClientReply{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "REPLY")
+	return c
 }
 
 func (c ClientReply) On() ClientReplyReplyModeOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (ClientReplyReplyModeOn)(c)
 }
 
 func (c SClientReply) On() SClientReplyReplyModeOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (SClientReplyReplyModeOn)(c)
 }
 
 func (c ClientReply) Off() ClientReplyReplyModeOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (ClientReplyReplyModeOff)(c)
 }
 
 func (c SClientReply) Off() SClientReplyReplyModeOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (SClientReplyReplyModeOff)(c)
 }
 
 func (c ClientReply) Skip() ClientReplyReplyModeSkip {
-	c.cs = append(c.cs, "SKIP")
+	c.cs.s = append(c.cs.s, "SKIP")
 	return (ClientReplyReplyModeSkip)(c)
 }
 
 func (c SClientReply) Skip() SClientReplyReplyModeSkip {
-	c.cs = append(c.cs, "SKIP")
+	c.cs.s = append(c.cs.s, "SKIP")
 	return (SClientReplyReplyModeSkip)(c)
 }
 
@@ -4957,21 +5201,25 @@ type ClientSetname Completed
 
 type SClientSetname SCompleted
 
-func (b *Builder) ClientSetname() ClientSetname {
-	return ClientSetname{cs: append(b.get(), "CLIENT", "SETNAME"), ks: InitSlot}
+func (b *Builder) ClientSetname() (c ClientSetname) {
+	c = ClientSetname{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "SETNAME")
+	return c
 }
 
-func (b *SBuilder) ClientSetname() SClientSetname {
-	return SClientSetname{cs: append(b.get(), "CLIENT", "SETNAME"), ks: InitSlot}
+func (b *SBuilder) ClientSetname() (c SClientSetname) {
+	c = SClientSetname{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "SETNAME")
+	return c
 }
 
 func (c ClientSetname) ConnectionName(connectionName string) ClientSetnameConnectionName {
-	c.cs = append(c.cs, connectionName)
+	c.cs.s = append(c.cs.s, connectionName)
 	return (ClientSetnameConnectionName)(c)
 }
 
 func (c SClientSetname) ConnectionName(connectionName string) SClientSetnameConnectionName {
-	c.cs = append(c.cs, connectionName)
+	c.cs.s = append(c.cs.s, connectionName)
 	return (SClientSetnameConnectionName)(c)
 }
 
@@ -4991,31 +5239,35 @@ type ClientTracking Completed
 
 type SClientTracking SCompleted
 
-func (b *Builder) ClientTracking() ClientTracking {
-	return ClientTracking{cs: append(b.get(), "CLIENT", "TRACKING"), ks: InitSlot}
+func (b *Builder) ClientTracking() (c ClientTracking) {
+	c = ClientTracking{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "TRACKING")
+	return c
 }
 
-func (b *SBuilder) ClientTracking() SClientTracking {
-	return SClientTracking{cs: append(b.get(), "CLIENT", "TRACKING"), ks: InitSlot}
+func (b *SBuilder) ClientTracking() (c SClientTracking) {
+	c = SClientTracking{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "TRACKING")
+	return c
 }
 
 func (c ClientTracking) On() ClientTrackingStatusOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (ClientTrackingStatusOn)(c)
 }
 
 func (c SClientTracking) On() SClientTrackingStatusOn {
-	c.cs = append(c.cs, "ON")
+	c.cs.s = append(c.cs.s, "ON")
 	return (SClientTrackingStatusOn)(c)
 }
 
 func (c ClientTracking) Off() ClientTrackingStatusOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (ClientTrackingStatusOff)(c)
 }
 
 func (c SClientTracking) Off() SClientTrackingStatusOff {
-	c.cs = append(c.cs, "OFF")
+	c.cs.s = append(c.cs.s, "OFF")
 	return (SClientTrackingStatusOff)(c)
 }
 
@@ -5024,32 +5276,32 @@ type ClientTrackingBcast Completed
 type SClientTrackingBcast SCompleted
 
 func (c ClientTrackingBcast) Optin() ClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (ClientTrackingOptin)(c)
 }
 
 func (c SClientTrackingBcast) Optin() SClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (SClientTrackingOptin)(c)
 }
 
 func (c ClientTrackingBcast) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingBcast) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingBcast) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingBcast) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5078,22 +5330,22 @@ type ClientTrackingOptin Completed
 type SClientTrackingOptin SCompleted
 
 func (c ClientTrackingOptin) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingOptin) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingOptin) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingOptin) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5110,12 +5362,12 @@ type ClientTrackingOptout Completed
 type SClientTrackingOptout SCompleted
 
 func (c ClientTrackingOptout) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingOptout) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5132,54 +5384,54 @@ type ClientTrackingPrefix Completed
 type SClientTrackingPrefix SCompleted
 
 func (c ClientTrackingPrefix) Prefix(prefix ...string) ClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return c
 }
 
 func (c SClientTrackingPrefix) Prefix(prefix ...string) SClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return c
 }
 
 func (c ClientTrackingPrefix) Bcast() ClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (ClientTrackingBcast)(c)
 }
 
 func (c SClientTrackingPrefix) Bcast() SClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (SClientTrackingBcast)(c)
 }
 
 func (c ClientTrackingPrefix) Optin() ClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (ClientTrackingOptin)(c)
 }
 
 func (c SClientTrackingPrefix) Optin() SClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (SClientTrackingOptin)(c)
 }
 
 func (c ClientTrackingPrefix) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingPrefix) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingPrefix) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingPrefix) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5196,54 +5448,54 @@ type ClientTrackingRedirect Completed
 type SClientTrackingRedirect SCompleted
 
 func (c ClientTrackingRedirect) Prefix(prefix ...string) ClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (ClientTrackingPrefix)(c)
 }
 
 func (c SClientTrackingRedirect) Prefix(prefix ...string) SClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (SClientTrackingPrefix)(c)
 }
 
 func (c ClientTrackingRedirect) Bcast() ClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (ClientTrackingBcast)(c)
 }
 
 func (c SClientTrackingRedirect) Bcast() SClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (SClientTrackingBcast)(c)
 }
 
 func (c ClientTrackingRedirect) Optin() ClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (ClientTrackingOptin)(c)
 }
 
 func (c SClientTrackingRedirect) Optin() SClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (SClientTrackingOptin)(c)
 }
 
 func (c ClientTrackingRedirect) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingRedirect) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingRedirect) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingRedirect) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5260,64 +5512,64 @@ type ClientTrackingStatusOff Completed
 type SClientTrackingStatusOff SCompleted
 
 func (c ClientTrackingStatusOff) Redirect(clientId int64) ClientTrackingRedirect {
-	c.cs = append(c.cs, "REDIRECT", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
 	return (ClientTrackingRedirect)(c)
 }
 
 func (c SClientTrackingStatusOff) Redirect(clientId int64) SClientTrackingRedirect {
-	c.cs = append(c.cs, "REDIRECT", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
 	return (SClientTrackingRedirect)(c)
 }
 
 func (c ClientTrackingStatusOff) Prefix(prefix ...string) ClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (ClientTrackingPrefix)(c)
 }
 
 func (c SClientTrackingStatusOff) Prefix(prefix ...string) SClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (SClientTrackingPrefix)(c)
 }
 
 func (c ClientTrackingStatusOff) Bcast() ClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (ClientTrackingBcast)(c)
 }
 
 func (c SClientTrackingStatusOff) Bcast() SClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (SClientTrackingBcast)(c)
 }
 
 func (c ClientTrackingStatusOff) Optin() ClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (ClientTrackingOptin)(c)
 }
 
 func (c SClientTrackingStatusOff) Optin() SClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (SClientTrackingOptin)(c)
 }
 
 func (c ClientTrackingStatusOff) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingStatusOff) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingStatusOff) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingStatusOff) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5334,64 +5586,64 @@ type ClientTrackingStatusOn Completed
 type SClientTrackingStatusOn SCompleted
 
 func (c ClientTrackingStatusOn) Redirect(clientId int64) ClientTrackingRedirect {
-	c.cs = append(c.cs, "REDIRECT", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
 	return (ClientTrackingRedirect)(c)
 }
 
 func (c SClientTrackingStatusOn) Redirect(clientId int64) SClientTrackingRedirect {
-	c.cs = append(c.cs, "REDIRECT", strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, "REDIRECT", strconv.FormatInt(clientId, 10))
 	return (SClientTrackingRedirect)(c)
 }
 
 func (c ClientTrackingStatusOn) Prefix(prefix ...string) ClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (ClientTrackingPrefix)(c)
 }
 
 func (c SClientTrackingStatusOn) Prefix(prefix ...string) SClientTrackingPrefix {
-	c.cs = append(c.cs, "PREFIX")
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, "PREFIX")
+	c.cs.s = append(c.cs.s, prefix...)
 	return (SClientTrackingPrefix)(c)
 }
 
 func (c ClientTrackingStatusOn) Bcast() ClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (ClientTrackingBcast)(c)
 }
 
 func (c SClientTrackingStatusOn) Bcast() SClientTrackingBcast {
-	c.cs = append(c.cs, "BCAST")
+	c.cs.s = append(c.cs.s, "BCAST")
 	return (SClientTrackingBcast)(c)
 }
 
 func (c ClientTrackingStatusOn) Optin() ClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (ClientTrackingOptin)(c)
 }
 
 func (c SClientTrackingStatusOn) Optin() SClientTrackingOptin {
-	c.cs = append(c.cs, "OPTIN")
+	c.cs.s = append(c.cs.s, "OPTIN")
 	return (SClientTrackingOptin)(c)
 }
 
 func (c ClientTrackingStatusOn) Optout() ClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (ClientTrackingOptout)(c)
 }
 
 func (c SClientTrackingStatusOn) Optout() SClientTrackingOptout {
-	c.cs = append(c.cs, "OPTOUT")
+	c.cs.s = append(c.cs.s, "OPTOUT")
 	return (SClientTrackingOptout)(c)
 }
 
 func (c ClientTrackingStatusOn) Noloop() ClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (ClientTrackingNoloop)(c)
 }
 
 func (c SClientTrackingStatusOn) Noloop() SClientTrackingNoloop {
-	c.cs = append(c.cs, "NOLOOP")
+	c.cs.s = append(c.cs.s, "NOLOOP")
 	return (SClientTrackingNoloop)(c)
 }
 
@@ -5407,12 +5659,16 @@ type ClientTrackinginfo Completed
 
 type SClientTrackinginfo SCompleted
 
-func (b *Builder) ClientTrackinginfo() ClientTrackinginfo {
-	return ClientTrackinginfo{cs: append(b.get(), "CLIENT", "TRACKINGINFO"), ks: InitSlot}
+func (b *Builder) ClientTrackinginfo() (c ClientTrackinginfo) {
+	c = ClientTrackinginfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "TRACKINGINFO")
+	return c
 }
 
-func (b *SBuilder) ClientTrackinginfo() SClientTrackinginfo {
-	return SClientTrackinginfo{cs: append(b.get(), "CLIENT", "TRACKINGINFO"), ks: InitSlot}
+func (b *SBuilder) ClientTrackinginfo() (c SClientTrackinginfo) {
+	c = SClientTrackinginfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "TRACKINGINFO")
+	return c
 }
 
 func (c ClientTrackinginfo) Build() Completed {
@@ -5427,21 +5683,25 @@ type ClientUnblock Completed
 
 type SClientUnblock SCompleted
 
-func (b *Builder) ClientUnblock() ClientUnblock {
-	return ClientUnblock{cs: append(b.get(), "CLIENT", "UNBLOCK"), ks: InitSlot}
+func (b *Builder) ClientUnblock() (c ClientUnblock) {
+	c = ClientUnblock{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "UNBLOCK")
+	return c
 }
 
-func (b *SBuilder) ClientUnblock() SClientUnblock {
-	return SClientUnblock{cs: append(b.get(), "CLIENT", "UNBLOCK"), ks: InitSlot}
+func (b *SBuilder) ClientUnblock() (c SClientUnblock) {
+	c = SClientUnblock{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "UNBLOCK")
+	return c
 }
 
 func (c ClientUnblock) ClientId(clientId int64) ClientUnblockClientId {
-	c.cs = append(c.cs, strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(clientId, 10))
 	return (ClientUnblockClientId)(c)
 }
 
 func (c SClientUnblock) ClientId(clientId int64) SClientUnblockClientId {
-	c.cs = append(c.cs, strconv.FormatInt(clientId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(clientId, 10))
 	return (SClientUnblockClientId)(c)
 }
 
@@ -5450,22 +5710,22 @@ type ClientUnblockClientId Completed
 type SClientUnblockClientId SCompleted
 
 func (c ClientUnblockClientId) Timeout() ClientUnblockUnblockTypeTimeout {
-	c.cs = append(c.cs, "TIMEOUT")
+	c.cs.s = append(c.cs.s, "TIMEOUT")
 	return (ClientUnblockUnblockTypeTimeout)(c)
 }
 
 func (c SClientUnblockClientId) Timeout() SClientUnblockUnblockTypeTimeout {
-	c.cs = append(c.cs, "TIMEOUT")
+	c.cs.s = append(c.cs.s, "TIMEOUT")
 	return (SClientUnblockUnblockTypeTimeout)(c)
 }
 
 func (c ClientUnblockClientId) Error() ClientUnblockUnblockTypeError {
-	c.cs = append(c.cs, "ERROR")
+	c.cs.s = append(c.cs.s, "ERROR")
 	return (ClientUnblockUnblockTypeError)(c)
 }
 
 func (c SClientUnblockClientId) Error() SClientUnblockUnblockTypeError {
-	c.cs = append(c.cs, "ERROR")
+	c.cs.s = append(c.cs.s, "ERROR")
 	return (SClientUnblockUnblockTypeError)(c)
 }
 
@@ -5505,12 +5765,16 @@ type ClientUnpause Completed
 
 type SClientUnpause SCompleted
 
-func (b *Builder) ClientUnpause() ClientUnpause {
-	return ClientUnpause{cs: append(b.get(), "CLIENT", "UNPAUSE"), ks: InitSlot}
+func (b *Builder) ClientUnpause() (c ClientUnpause) {
+	c = ClientUnpause{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "UNPAUSE")
+	return c
 }
 
-func (b *SBuilder) ClientUnpause() SClientUnpause {
-	return SClientUnpause{cs: append(b.get(), "CLIENT", "UNPAUSE"), ks: InitSlot}
+func (b *SBuilder) ClientUnpause() (c SClientUnpause) {
+	c = SClientUnpause{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLIENT", "UNPAUSE")
+	return c
 }
 
 func (c ClientUnpause) Build() Completed {
@@ -5525,24 +5789,28 @@ type ClusterAddslots Completed
 
 type SClusterAddslots SCompleted
 
-func (b *Builder) ClusterAddslots() ClusterAddslots {
-	return ClusterAddslots{cs: append(b.get(), "CLUSTER", "ADDSLOTS"), ks: InitSlot}
+func (b *Builder) ClusterAddslots() (c ClusterAddslots) {
+	c = ClusterAddslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "ADDSLOTS")
+	return c
 }
 
-func (b *SBuilder) ClusterAddslots() SClusterAddslots {
-	return SClusterAddslots{cs: append(b.get(), "CLUSTER", "ADDSLOTS"), ks: InitSlot}
+func (b *SBuilder) ClusterAddslots() (c SClusterAddslots) {
+	c = SClusterAddslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "ADDSLOTS")
+	return c
 }
 
 func (c ClusterAddslots) Slot(slot ...int64) ClusterAddslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ClusterAddslotsSlot)(c)
 }
 
 func (c SClusterAddslots) Slot(slot ...int64) SClusterAddslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SClusterAddslotsSlot)(c)
 }
@@ -5553,14 +5821,14 @@ type SClusterAddslotsSlot SCompleted
 
 func (c ClusterAddslotsSlot) Slot(slot ...int64) ClusterAddslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SClusterAddslotsSlot) Slot(slot ...int64) SClusterAddslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
@@ -5577,12 +5845,16 @@ type ClusterAddslotsrange Completed
 
 type SClusterAddslotsrange SCompleted
 
-func (b *Builder) ClusterAddslotsrange() ClusterAddslotsrange {
-	return ClusterAddslotsrange{cs: append(b.get(), "CLUSTER", "ADDSLOTSRANGE"), ks: InitSlot}
+func (b *Builder) ClusterAddslotsrange() (c ClusterAddslotsrange) {
+	c = ClusterAddslotsrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "ADDSLOTSRANGE")
+	return c
 }
 
-func (b *SBuilder) ClusterAddslotsrange() SClusterAddslotsrange {
-	return SClusterAddslotsrange{cs: append(b.get(), "CLUSTER", "ADDSLOTSRANGE"), ks: InitSlot}
+func (b *SBuilder) ClusterAddslotsrange() (c SClusterAddslotsrange) {
+	c = SClusterAddslotsrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "ADDSLOTSRANGE")
+	return c
 }
 
 func (c ClusterAddslotsrange) StartSlotEndSlot() ClusterAddslotsrangeStartSlotEndSlot {
@@ -5598,12 +5870,12 @@ type ClusterAddslotsrangeStartSlotEndSlot Completed
 type SClusterAddslotsrangeStartSlotEndSlot SCompleted
 
 func (c ClusterAddslotsrangeStartSlotEndSlot) StartSlotEndSlot(startSlot int64, endSlot int64) ClusterAddslotsrangeStartSlotEndSlot {
-	c.cs = append(c.cs, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
 	return c
 }
 
 func (c SClusterAddslotsrangeStartSlotEndSlot) StartSlotEndSlot(startSlot int64, endSlot int64) SClusterAddslotsrangeStartSlotEndSlot {
-	c.cs = append(c.cs, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
 	return c
 }
 
@@ -5619,12 +5891,16 @@ type ClusterBumpepoch Completed
 
 type SClusterBumpepoch SCompleted
 
-func (b *Builder) ClusterBumpepoch() ClusterBumpepoch {
-	return ClusterBumpepoch{cs: append(b.get(), "CLUSTER", "BUMPEPOCH"), ks: InitSlot}
+func (b *Builder) ClusterBumpepoch() (c ClusterBumpepoch) {
+	c = ClusterBumpepoch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "BUMPEPOCH")
+	return c
 }
 
-func (b *SBuilder) ClusterBumpepoch() SClusterBumpepoch {
-	return SClusterBumpepoch{cs: append(b.get(), "CLUSTER", "BUMPEPOCH"), ks: InitSlot}
+func (b *SBuilder) ClusterBumpepoch() (c SClusterBumpepoch) {
+	c = SClusterBumpepoch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "BUMPEPOCH")
+	return c
 }
 
 func (c ClusterBumpepoch) Build() Completed {
@@ -5639,21 +5915,25 @@ type ClusterCountFailureReports Completed
 
 type SClusterCountFailureReports SCompleted
 
-func (b *Builder) ClusterCountFailureReports() ClusterCountFailureReports {
-	return ClusterCountFailureReports{cs: append(b.get(), "CLUSTER", "COUNT-FAILURE-REPORTS"), ks: InitSlot}
+func (b *Builder) ClusterCountFailureReports() (c ClusterCountFailureReports) {
+	c = ClusterCountFailureReports{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "COUNT-FAILURE-REPORTS")
+	return c
 }
 
-func (b *SBuilder) ClusterCountFailureReports() SClusterCountFailureReports {
-	return SClusterCountFailureReports{cs: append(b.get(), "CLUSTER", "COUNT-FAILURE-REPORTS"), ks: InitSlot}
+func (b *SBuilder) ClusterCountFailureReports() (c SClusterCountFailureReports) {
+	c = SClusterCountFailureReports{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "COUNT-FAILURE-REPORTS")
+	return c
 }
 
 func (c ClusterCountFailureReports) NodeId(nodeId string) ClusterCountFailureReportsNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterCountFailureReportsNodeId)(c)
 }
 
 func (c SClusterCountFailureReports) NodeId(nodeId string) SClusterCountFailureReportsNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterCountFailureReportsNodeId)(c)
 }
 
@@ -5673,21 +5953,25 @@ type ClusterCountkeysinslot Completed
 
 type SClusterCountkeysinslot SCompleted
 
-func (b *Builder) ClusterCountkeysinslot() ClusterCountkeysinslot {
-	return ClusterCountkeysinslot{cs: append(b.get(), "CLUSTER", "COUNTKEYSINSLOT"), ks: InitSlot}
+func (b *Builder) ClusterCountkeysinslot() (c ClusterCountkeysinslot) {
+	c = ClusterCountkeysinslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "COUNTKEYSINSLOT")
+	return c
 }
 
-func (b *SBuilder) ClusterCountkeysinslot() SClusterCountkeysinslot {
-	return SClusterCountkeysinslot{cs: append(b.get(), "CLUSTER", "COUNTKEYSINSLOT"), ks: InitSlot}
+func (b *SBuilder) ClusterCountkeysinslot() (c SClusterCountkeysinslot) {
+	c = SClusterCountkeysinslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "COUNTKEYSINSLOT")
+	return c
 }
 
 func (c ClusterCountkeysinslot) Slot(slot int64) ClusterCountkeysinslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (ClusterCountkeysinslotSlot)(c)
 }
 
 func (c SClusterCountkeysinslot) Slot(slot int64) SClusterCountkeysinslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (SClusterCountkeysinslotSlot)(c)
 }
 
@@ -5707,24 +5991,28 @@ type ClusterDelslots Completed
 
 type SClusterDelslots SCompleted
 
-func (b *Builder) ClusterDelslots() ClusterDelslots {
-	return ClusterDelslots{cs: append(b.get(), "CLUSTER", "DELSLOTS"), ks: InitSlot}
+func (b *Builder) ClusterDelslots() (c ClusterDelslots) {
+	c = ClusterDelslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "DELSLOTS")
+	return c
 }
 
-func (b *SBuilder) ClusterDelslots() SClusterDelslots {
-	return SClusterDelslots{cs: append(b.get(), "CLUSTER", "DELSLOTS"), ks: InitSlot}
+func (b *SBuilder) ClusterDelslots() (c SClusterDelslots) {
+	c = SClusterDelslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "DELSLOTS")
+	return c
 }
 
 func (c ClusterDelslots) Slot(slot ...int64) ClusterDelslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ClusterDelslotsSlot)(c)
 }
 
 func (c SClusterDelslots) Slot(slot ...int64) SClusterDelslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SClusterDelslotsSlot)(c)
 }
@@ -5735,14 +6023,14 @@ type SClusterDelslotsSlot SCompleted
 
 func (c ClusterDelslotsSlot) Slot(slot ...int64) ClusterDelslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SClusterDelslotsSlot) Slot(slot ...int64) SClusterDelslotsSlot {
 	for _, n := range slot {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
@@ -5759,12 +6047,16 @@ type ClusterDelslotsrange Completed
 
 type SClusterDelslotsrange SCompleted
 
-func (b *Builder) ClusterDelslotsrange() ClusterDelslotsrange {
-	return ClusterDelslotsrange{cs: append(b.get(), "CLUSTER", "DELSLOTSRANGE"), ks: InitSlot}
+func (b *Builder) ClusterDelslotsrange() (c ClusterDelslotsrange) {
+	c = ClusterDelslotsrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "DELSLOTSRANGE")
+	return c
 }
 
-func (b *SBuilder) ClusterDelslotsrange() SClusterDelslotsrange {
-	return SClusterDelslotsrange{cs: append(b.get(), "CLUSTER", "DELSLOTSRANGE"), ks: InitSlot}
+func (b *SBuilder) ClusterDelslotsrange() (c SClusterDelslotsrange) {
+	c = SClusterDelslotsrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "DELSLOTSRANGE")
+	return c
 }
 
 func (c ClusterDelslotsrange) StartSlotEndSlot() ClusterDelslotsrangeStartSlotEndSlot {
@@ -5780,12 +6072,12 @@ type ClusterDelslotsrangeStartSlotEndSlot Completed
 type SClusterDelslotsrangeStartSlotEndSlot SCompleted
 
 func (c ClusterDelslotsrangeStartSlotEndSlot) StartSlotEndSlot(startSlot int64, endSlot int64) ClusterDelslotsrangeStartSlotEndSlot {
-	c.cs = append(c.cs, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
 	return c
 }
 
 func (c SClusterDelslotsrangeStartSlotEndSlot) StartSlotEndSlot(startSlot int64, endSlot int64) SClusterDelslotsrangeStartSlotEndSlot {
-	c.cs = append(c.cs, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(startSlot, 10), strconv.FormatInt(endSlot, 10))
 	return c
 }
 
@@ -5801,31 +6093,35 @@ type ClusterFailover Completed
 
 type SClusterFailover SCompleted
 
-func (b *Builder) ClusterFailover() ClusterFailover {
-	return ClusterFailover{cs: append(b.get(), "CLUSTER", "FAILOVER"), ks: InitSlot}
+func (b *Builder) ClusterFailover() (c ClusterFailover) {
+	c = ClusterFailover{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FAILOVER")
+	return c
 }
 
-func (b *SBuilder) ClusterFailover() SClusterFailover {
-	return SClusterFailover{cs: append(b.get(), "CLUSTER", "FAILOVER"), ks: InitSlot}
+func (b *SBuilder) ClusterFailover() (c SClusterFailover) {
+	c = SClusterFailover{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FAILOVER")
+	return c
 }
 
 func (c ClusterFailover) Force() ClusterFailoverOptionsForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (ClusterFailoverOptionsForce)(c)
 }
 
 func (c SClusterFailover) Force() SClusterFailoverOptionsForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SClusterFailoverOptionsForce)(c)
 }
 
 func (c ClusterFailover) Takeover() ClusterFailoverOptionsTakeover {
-	c.cs = append(c.cs, "TAKEOVER")
+	c.cs.s = append(c.cs.s, "TAKEOVER")
 	return (ClusterFailoverOptionsTakeover)(c)
 }
 
 func (c SClusterFailover) Takeover() SClusterFailoverOptionsTakeover {
-	c.cs = append(c.cs, "TAKEOVER")
+	c.cs.s = append(c.cs.s, "TAKEOVER")
 	return (SClusterFailoverOptionsTakeover)(c)
 }
 
@@ -5865,12 +6161,16 @@ type ClusterFlushslots Completed
 
 type SClusterFlushslots SCompleted
 
-func (b *Builder) ClusterFlushslots() ClusterFlushslots {
-	return ClusterFlushslots{cs: append(b.get(), "CLUSTER", "FLUSHSLOTS"), ks: InitSlot}
+func (b *Builder) ClusterFlushslots() (c ClusterFlushslots) {
+	c = ClusterFlushslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FLUSHSLOTS")
+	return c
 }
 
-func (b *SBuilder) ClusterFlushslots() SClusterFlushslots {
-	return SClusterFlushslots{cs: append(b.get(), "CLUSTER", "FLUSHSLOTS"), ks: InitSlot}
+func (b *SBuilder) ClusterFlushslots() (c SClusterFlushslots) {
+	c = SClusterFlushslots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FLUSHSLOTS")
+	return c
 }
 
 func (c ClusterFlushslots) Build() Completed {
@@ -5885,21 +6185,25 @@ type ClusterForget Completed
 
 type SClusterForget SCompleted
 
-func (b *Builder) ClusterForget() ClusterForget {
-	return ClusterForget{cs: append(b.get(), "CLUSTER", "FORGET"), ks: InitSlot}
+func (b *Builder) ClusterForget() (c ClusterForget) {
+	c = ClusterForget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FORGET")
+	return c
 }
 
-func (b *SBuilder) ClusterForget() SClusterForget {
-	return SClusterForget{cs: append(b.get(), "CLUSTER", "FORGET"), ks: InitSlot}
+func (b *SBuilder) ClusterForget() (c SClusterForget) {
+	c = SClusterForget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "FORGET")
+	return c
 }
 
 func (c ClusterForget) NodeId(nodeId string) ClusterForgetNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterForgetNodeId)(c)
 }
 
 func (c SClusterForget) NodeId(nodeId string) SClusterForgetNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterForgetNodeId)(c)
 }
 
@@ -5919,21 +6223,25 @@ type ClusterGetkeysinslot Completed
 
 type SClusterGetkeysinslot SCompleted
 
-func (b *Builder) ClusterGetkeysinslot() ClusterGetkeysinslot {
-	return ClusterGetkeysinslot{cs: append(b.get(), "CLUSTER", "GETKEYSINSLOT"), ks: InitSlot}
+func (b *Builder) ClusterGetkeysinslot() (c ClusterGetkeysinslot) {
+	c = ClusterGetkeysinslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "GETKEYSINSLOT")
+	return c
 }
 
-func (b *SBuilder) ClusterGetkeysinslot() SClusterGetkeysinslot {
-	return SClusterGetkeysinslot{cs: append(b.get(), "CLUSTER", "GETKEYSINSLOT"), ks: InitSlot}
+func (b *SBuilder) ClusterGetkeysinslot() (c SClusterGetkeysinslot) {
+	c = SClusterGetkeysinslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "GETKEYSINSLOT")
+	return c
 }
 
 func (c ClusterGetkeysinslot) Slot(slot int64) ClusterGetkeysinslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (ClusterGetkeysinslotSlot)(c)
 }
 
 func (c SClusterGetkeysinslot) Slot(slot int64) SClusterGetkeysinslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (SClusterGetkeysinslotSlot)(c)
 }
 
@@ -5954,12 +6262,12 @@ type ClusterGetkeysinslotSlot Completed
 type SClusterGetkeysinslotSlot SCompleted
 
 func (c ClusterGetkeysinslotSlot) Count(count int64) ClusterGetkeysinslotCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (ClusterGetkeysinslotCount)(c)
 }
 
 func (c SClusterGetkeysinslotSlot) Count(count int64) SClusterGetkeysinslotCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SClusterGetkeysinslotCount)(c)
 }
 
@@ -5967,12 +6275,16 @@ type ClusterInfo Completed
 
 type SClusterInfo SCompleted
 
-func (b *Builder) ClusterInfo() ClusterInfo {
-	return ClusterInfo{cs: append(b.get(), "CLUSTER", "INFO"), ks: InitSlot}
+func (b *Builder) ClusterInfo() (c ClusterInfo) {
+	c = ClusterInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "INFO")
+	return c
 }
 
-func (b *SBuilder) ClusterInfo() SClusterInfo {
-	return SClusterInfo{cs: append(b.get(), "CLUSTER", "INFO"), ks: InitSlot}
+func (b *SBuilder) ClusterInfo() (c SClusterInfo) {
+	c = SClusterInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "INFO")
+	return c
 }
 
 func (c ClusterInfo) Build() Completed {
@@ -5987,21 +6299,25 @@ type ClusterKeyslot Completed
 
 type SClusterKeyslot SCompleted
 
-func (b *Builder) ClusterKeyslot() ClusterKeyslot {
-	return ClusterKeyslot{cs: append(b.get(), "CLUSTER", "KEYSLOT"), ks: InitSlot}
+func (b *Builder) ClusterKeyslot() (c ClusterKeyslot) {
+	c = ClusterKeyslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "KEYSLOT")
+	return c
 }
 
-func (b *SBuilder) ClusterKeyslot() SClusterKeyslot {
-	return SClusterKeyslot{cs: append(b.get(), "CLUSTER", "KEYSLOT"), ks: InitSlot}
+func (b *SBuilder) ClusterKeyslot() (c SClusterKeyslot) {
+	c = SClusterKeyslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "KEYSLOT")
+	return c
 }
 
 func (c ClusterKeyslot) Key(key string) ClusterKeyslotKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ClusterKeyslotKey)(c)
 }
 
 func (c SClusterKeyslot) Key(key string) SClusterKeyslotKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SClusterKeyslotKey)(c)
 }
 
@@ -6021,21 +6337,25 @@ type ClusterMeet Completed
 
 type SClusterMeet SCompleted
 
-func (b *Builder) ClusterMeet() ClusterMeet {
-	return ClusterMeet{cs: append(b.get(), "CLUSTER", "MEET"), ks: InitSlot}
+func (b *Builder) ClusterMeet() (c ClusterMeet) {
+	c = ClusterMeet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "MEET")
+	return c
 }
 
-func (b *SBuilder) ClusterMeet() SClusterMeet {
-	return SClusterMeet{cs: append(b.get(), "CLUSTER", "MEET"), ks: InitSlot}
+func (b *SBuilder) ClusterMeet() (c SClusterMeet) {
+	c = SClusterMeet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "MEET")
+	return c
 }
 
 func (c ClusterMeet) Ip(ip string) ClusterMeetIp {
-	c.cs = append(c.cs, ip)
+	c.cs.s = append(c.cs.s, ip)
 	return (ClusterMeetIp)(c)
 }
 
 func (c SClusterMeet) Ip(ip string) SClusterMeetIp {
-	c.cs = append(c.cs, ip)
+	c.cs.s = append(c.cs.s, ip)
 	return (SClusterMeetIp)(c)
 }
 
@@ -6044,12 +6364,12 @@ type ClusterMeetIp Completed
 type SClusterMeetIp SCompleted
 
 func (c ClusterMeetIp) Port(port int64) ClusterMeetPort {
-	c.cs = append(c.cs, strconv.FormatInt(port, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
 	return (ClusterMeetPort)(c)
 }
 
 func (c SClusterMeetIp) Port(port int64) SClusterMeetPort {
-	c.cs = append(c.cs, strconv.FormatInt(port, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
 	return (SClusterMeetPort)(c)
 }
 
@@ -6069,12 +6389,16 @@ type ClusterMyid Completed
 
 type SClusterMyid SCompleted
 
-func (b *Builder) ClusterMyid() ClusterMyid {
-	return ClusterMyid{cs: append(b.get(), "CLUSTER", "MYID"), ks: InitSlot}
+func (b *Builder) ClusterMyid() (c ClusterMyid) {
+	c = ClusterMyid{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "MYID")
+	return c
 }
 
-func (b *SBuilder) ClusterMyid() SClusterMyid {
-	return SClusterMyid{cs: append(b.get(), "CLUSTER", "MYID"), ks: InitSlot}
+func (b *SBuilder) ClusterMyid() (c SClusterMyid) {
+	c = SClusterMyid{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "MYID")
+	return c
 }
 
 func (c ClusterMyid) Build() Completed {
@@ -6089,12 +6413,16 @@ type ClusterNodes Completed
 
 type SClusterNodes SCompleted
 
-func (b *Builder) ClusterNodes() ClusterNodes {
-	return ClusterNodes{cs: append(b.get(), "CLUSTER", "NODES"), ks: InitSlot}
+func (b *Builder) ClusterNodes() (c ClusterNodes) {
+	c = ClusterNodes{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "NODES")
+	return c
 }
 
-func (b *SBuilder) ClusterNodes() SClusterNodes {
-	return SClusterNodes{cs: append(b.get(), "CLUSTER", "NODES"), ks: InitSlot}
+func (b *SBuilder) ClusterNodes() (c SClusterNodes) {
+	c = SClusterNodes{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "NODES")
+	return c
 }
 
 func (c ClusterNodes) Build() Completed {
@@ -6109,21 +6437,25 @@ type ClusterReplicas Completed
 
 type SClusterReplicas SCompleted
 
-func (b *Builder) ClusterReplicas() ClusterReplicas {
-	return ClusterReplicas{cs: append(b.get(), "CLUSTER", "REPLICAS"), ks: InitSlot}
+func (b *Builder) ClusterReplicas() (c ClusterReplicas) {
+	c = ClusterReplicas{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "REPLICAS")
+	return c
 }
 
-func (b *SBuilder) ClusterReplicas() SClusterReplicas {
-	return SClusterReplicas{cs: append(b.get(), "CLUSTER", "REPLICAS"), ks: InitSlot}
+func (b *SBuilder) ClusterReplicas() (c SClusterReplicas) {
+	c = SClusterReplicas{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "REPLICAS")
+	return c
 }
 
 func (c ClusterReplicas) NodeId(nodeId string) ClusterReplicasNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterReplicasNodeId)(c)
 }
 
 func (c SClusterReplicas) NodeId(nodeId string) SClusterReplicasNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterReplicasNodeId)(c)
 }
 
@@ -6143,21 +6475,25 @@ type ClusterReplicate Completed
 
 type SClusterReplicate SCompleted
 
-func (b *Builder) ClusterReplicate() ClusterReplicate {
-	return ClusterReplicate{cs: append(b.get(), "CLUSTER", "REPLICATE"), ks: InitSlot}
+func (b *Builder) ClusterReplicate() (c ClusterReplicate) {
+	c = ClusterReplicate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "REPLICATE")
+	return c
 }
 
-func (b *SBuilder) ClusterReplicate() SClusterReplicate {
-	return SClusterReplicate{cs: append(b.get(), "CLUSTER", "REPLICATE"), ks: InitSlot}
+func (b *SBuilder) ClusterReplicate() (c SClusterReplicate) {
+	c = SClusterReplicate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "REPLICATE")
+	return c
 }
 
 func (c ClusterReplicate) NodeId(nodeId string) ClusterReplicateNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterReplicateNodeId)(c)
 }
 
 func (c SClusterReplicate) NodeId(nodeId string) SClusterReplicateNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterReplicateNodeId)(c)
 }
 
@@ -6177,31 +6513,35 @@ type ClusterReset Completed
 
 type SClusterReset SCompleted
 
-func (b *Builder) ClusterReset() ClusterReset {
-	return ClusterReset{cs: append(b.get(), "CLUSTER", "RESET"), ks: InitSlot}
+func (b *Builder) ClusterReset() (c ClusterReset) {
+	c = ClusterReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "RESET")
+	return c
 }
 
-func (b *SBuilder) ClusterReset() SClusterReset {
-	return SClusterReset{cs: append(b.get(), "CLUSTER", "RESET"), ks: InitSlot}
+func (b *SBuilder) ClusterReset() (c SClusterReset) {
+	c = SClusterReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "RESET")
+	return c
 }
 
 func (c ClusterReset) Hard() ClusterResetResetTypeHard {
-	c.cs = append(c.cs, "HARD")
+	c.cs.s = append(c.cs.s, "HARD")
 	return (ClusterResetResetTypeHard)(c)
 }
 
 func (c SClusterReset) Hard() SClusterResetResetTypeHard {
-	c.cs = append(c.cs, "HARD")
+	c.cs.s = append(c.cs.s, "HARD")
 	return (SClusterResetResetTypeHard)(c)
 }
 
 func (c ClusterReset) Soft() ClusterResetResetTypeSoft {
-	c.cs = append(c.cs, "SOFT")
+	c.cs.s = append(c.cs.s, "SOFT")
 	return (ClusterResetResetTypeSoft)(c)
 }
 
 func (c SClusterReset) Soft() SClusterResetResetTypeSoft {
-	c.cs = append(c.cs, "SOFT")
+	c.cs.s = append(c.cs.s, "SOFT")
 	return (SClusterResetResetTypeSoft)(c)
 }
 
@@ -6241,12 +6581,16 @@ type ClusterSaveconfig Completed
 
 type SClusterSaveconfig SCompleted
 
-func (b *Builder) ClusterSaveconfig() ClusterSaveconfig {
-	return ClusterSaveconfig{cs: append(b.get(), "CLUSTER", "SAVECONFIG"), ks: InitSlot}
+func (b *Builder) ClusterSaveconfig() (c ClusterSaveconfig) {
+	c = ClusterSaveconfig{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SAVECONFIG")
+	return c
 }
 
-func (b *SBuilder) ClusterSaveconfig() SClusterSaveconfig {
-	return SClusterSaveconfig{cs: append(b.get(), "CLUSTER", "SAVECONFIG"), ks: InitSlot}
+func (b *SBuilder) ClusterSaveconfig() (c SClusterSaveconfig) {
+	c = SClusterSaveconfig{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SAVECONFIG")
+	return c
 }
 
 func (c ClusterSaveconfig) Build() Completed {
@@ -6261,21 +6605,25 @@ type ClusterSetConfigEpoch Completed
 
 type SClusterSetConfigEpoch SCompleted
 
-func (b *Builder) ClusterSetConfigEpoch() ClusterSetConfigEpoch {
-	return ClusterSetConfigEpoch{cs: append(b.get(), "CLUSTER", "SET-CONFIG-EPOCH"), ks: InitSlot}
+func (b *Builder) ClusterSetConfigEpoch() (c ClusterSetConfigEpoch) {
+	c = ClusterSetConfigEpoch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SET-CONFIG-EPOCH")
+	return c
 }
 
-func (b *SBuilder) ClusterSetConfigEpoch() SClusterSetConfigEpoch {
-	return SClusterSetConfigEpoch{cs: append(b.get(), "CLUSTER", "SET-CONFIG-EPOCH"), ks: InitSlot}
+func (b *SBuilder) ClusterSetConfigEpoch() (c SClusterSetConfigEpoch) {
+	c = SClusterSetConfigEpoch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SET-CONFIG-EPOCH")
+	return c
 }
 
 func (c ClusterSetConfigEpoch) ConfigEpoch(configEpoch int64) ClusterSetConfigEpochConfigEpoch {
-	c.cs = append(c.cs, strconv.FormatInt(configEpoch, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(configEpoch, 10))
 	return (ClusterSetConfigEpochConfigEpoch)(c)
 }
 
 func (c SClusterSetConfigEpoch) ConfigEpoch(configEpoch int64) SClusterSetConfigEpochConfigEpoch {
-	c.cs = append(c.cs, strconv.FormatInt(configEpoch, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(configEpoch, 10))
 	return (SClusterSetConfigEpochConfigEpoch)(c)
 }
 
@@ -6295,21 +6643,25 @@ type ClusterSetslot Completed
 
 type SClusterSetslot SCompleted
 
-func (b *Builder) ClusterSetslot() ClusterSetslot {
-	return ClusterSetslot{cs: append(b.get(), "CLUSTER", "SETSLOT"), ks: InitSlot}
+func (b *Builder) ClusterSetslot() (c ClusterSetslot) {
+	c = ClusterSetslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SETSLOT")
+	return c
 }
 
-func (b *SBuilder) ClusterSetslot() SClusterSetslot {
-	return SClusterSetslot{cs: append(b.get(), "CLUSTER", "SETSLOT"), ks: InitSlot}
+func (b *SBuilder) ClusterSetslot() (c SClusterSetslot) {
+	c = SClusterSetslot{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SETSLOT")
+	return c
 }
 
 func (c ClusterSetslot) Slot(slot int64) ClusterSetslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (ClusterSetslotSlot)(c)
 }
 
 func (c SClusterSetslot) Slot(slot int64) SClusterSetslotSlot {
-	c.cs = append(c.cs, strconv.FormatInt(slot, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(slot, 10))
 	return (SClusterSetslotSlot)(c)
 }
 
@@ -6330,42 +6682,42 @@ type ClusterSetslotSlot Completed
 type SClusterSetslotSlot SCompleted
 
 func (c ClusterSetslotSlot) Importing() ClusterSetslotSubcommandImporting {
-	c.cs = append(c.cs, "IMPORTING")
+	c.cs.s = append(c.cs.s, "IMPORTING")
 	return (ClusterSetslotSubcommandImporting)(c)
 }
 
 func (c SClusterSetslotSlot) Importing() SClusterSetslotSubcommandImporting {
-	c.cs = append(c.cs, "IMPORTING")
+	c.cs.s = append(c.cs.s, "IMPORTING")
 	return (SClusterSetslotSubcommandImporting)(c)
 }
 
 func (c ClusterSetslotSlot) Migrating() ClusterSetslotSubcommandMigrating {
-	c.cs = append(c.cs, "MIGRATING")
+	c.cs.s = append(c.cs.s, "MIGRATING")
 	return (ClusterSetslotSubcommandMigrating)(c)
 }
 
 func (c SClusterSetslotSlot) Migrating() SClusterSetslotSubcommandMigrating {
-	c.cs = append(c.cs, "MIGRATING")
+	c.cs.s = append(c.cs.s, "MIGRATING")
 	return (SClusterSetslotSubcommandMigrating)(c)
 }
 
 func (c ClusterSetslotSlot) Stable() ClusterSetslotSubcommandStable {
-	c.cs = append(c.cs, "STABLE")
+	c.cs.s = append(c.cs.s, "STABLE")
 	return (ClusterSetslotSubcommandStable)(c)
 }
 
 func (c SClusterSetslotSlot) Stable() SClusterSetslotSubcommandStable {
-	c.cs = append(c.cs, "STABLE")
+	c.cs.s = append(c.cs.s, "STABLE")
 	return (SClusterSetslotSubcommandStable)(c)
 }
 
 func (c ClusterSetslotSlot) Node() ClusterSetslotSubcommandNode {
-	c.cs = append(c.cs, "NODE")
+	c.cs.s = append(c.cs.s, "NODE")
 	return (ClusterSetslotSubcommandNode)(c)
 }
 
 func (c SClusterSetslotSlot) Node() SClusterSetslotSubcommandNode {
-	c.cs = append(c.cs, "NODE")
+	c.cs.s = append(c.cs.s, "NODE")
 	return (SClusterSetslotSubcommandNode)(c)
 }
 
@@ -6374,12 +6726,12 @@ type ClusterSetslotSubcommandImporting Completed
 type SClusterSetslotSubcommandImporting SCompleted
 
 func (c ClusterSetslotSubcommandImporting) NodeId(nodeId string) ClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterSetslotNodeId)(c)
 }
 
 func (c SClusterSetslotSubcommandImporting) NodeId(nodeId string) SClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterSetslotNodeId)(c)
 }
 
@@ -6396,12 +6748,12 @@ type ClusterSetslotSubcommandMigrating Completed
 type SClusterSetslotSubcommandMigrating SCompleted
 
 func (c ClusterSetslotSubcommandMigrating) NodeId(nodeId string) ClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterSetslotNodeId)(c)
 }
 
 func (c SClusterSetslotSubcommandMigrating) NodeId(nodeId string) SClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterSetslotNodeId)(c)
 }
 
@@ -6418,12 +6770,12 @@ type ClusterSetslotSubcommandNode Completed
 type SClusterSetslotSubcommandNode SCompleted
 
 func (c ClusterSetslotSubcommandNode) NodeId(nodeId string) ClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterSetslotNodeId)(c)
 }
 
 func (c SClusterSetslotSubcommandNode) NodeId(nodeId string) SClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterSetslotNodeId)(c)
 }
 
@@ -6440,12 +6792,12 @@ type ClusterSetslotSubcommandStable Completed
 type SClusterSetslotSubcommandStable SCompleted
 
 func (c ClusterSetslotSubcommandStable) NodeId(nodeId string) ClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterSetslotNodeId)(c)
 }
 
 func (c SClusterSetslotSubcommandStable) NodeId(nodeId string) SClusterSetslotNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterSetslotNodeId)(c)
 }
 
@@ -6461,21 +6813,25 @@ type ClusterSlaves Completed
 
 type SClusterSlaves SCompleted
 
-func (b *Builder) ClusterSlaves() ClusterSlaves {
-	return ClusterSlaves{cs: append(b.get(), "CLUSTER", "SLAVES"), ks: InitSlot}
+func (b *Builder) ClusterSlaves() (c ClusterSlaves) {
+	c = ClusterSlaves{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SLAVES")
+	return c
 }
 
-func (b *SBuilder) ClusterSlaves() SClusterSlaves {
-	return SClusterSlaves{cs: append(b.get(), "CLUSTER", "SLAVES"), ks: InitSlot}
+func (b *SBuilder) ClusterSlaves() (c SClusterSlaves) {
+	c = SClusterSlaves{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SLAVES")
+	return c
 }
 
 func (c ClusterSlaves) NodeId(nodeId string) ClusterSlavesNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (ClusterSlavesNodeId)(c)
 }
 
 func (c SClusterSlaves) NodeId(nodeId string) SClusterSlavesNodeId {
-	c.cs = append(c.cs, nodeId)
+	c.cs.s = append(c.cs.s, nodeId)
 	return (SClusterSlavesNodeId)(c)
 }
 
@@ -6495,12 +6851,16 @@ type ClusterSlots Completed
 
 type SClusterSlots SCompleted
 
-func (b *Builder) ClusterSlots() ClusterSlots {
-	return ClusterSlots{cs: append(b.get(), "CLUSTER", "SLOTS"), ks: InitSlot}
+func (b *Builder) ClusterSlots() (c ClusterSlots) {
+	c = ClusterSlots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SLOTS")
+	return c
 }
 
-func (b *SBuilder) ClusterSlots() SClusterSlots {
-	return SClusterSlots{cs: append(b.get(), "CLUSTER", "SLOTS"), ks: InitSlot}
+func (b *SBuilder) ClusterSlots() (c SClusterSlots) {
+	c = SClusterSlots{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CLUSTER", "SLOTS")
+	return c
 }
 
 func (c ClusterSlots) Build() Completed {
@@ -6515,22 +6875,26 @@ type CmsIncrby Completed
 
 type SCmsIncrby SCompleted
 
-func (b *Builder) CmsIncrby() CmsIncrby {
-	return CmsIncrby{cs: append(b.get(), "CMS.INCRBY"), ks: InitSlot}
+func (b *Builder) CmsIncrby() (c CmsIncrby) {
+	c = CmsIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INCRBY")
+	return c
 }
 
-func (b *SBuilder) CmsIncrby() SCmsIncrby {
-	return SCmsIncrby{cs: append(b.get(), "CMS.INCRBY"), ks: InitSlot}
+func (b *SBuilder) CmsIncrby() (c SCmsIncrby) {
+	c = SCmsIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INCRBY")
+	return c
 }
 
 func (c CmsIncrby) Key(key string) CmsIncrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CmsIncrbyKey)(c)
 }
 
 func (c SCmsIncrby) Key(key string) SCmsIncrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCmsIncrbyKey)(c)
 }
 
@@ -6539,12 +6903,12 @@ type CmsIncrbyItemsIncrement Completed
 type SCmsIncrbyItemsIncrement SCompleted
 
 func (c CmsIncrbyItemsIncrement) Item(item string) CmsIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CmsIncrbyItemsItem)(c)
 }
 
 func (c SCmsIncrbyItemsIncrement) Item(item string) SCmsIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCmsIncrbyItemsItem)(c)
 }
 
@@ -6561,12 +6925,12 @@ type CmsIncrbyItemsItem Completed
 type SCmsIncrbyItemsItem SCompleted
 
 func (c CmsIncrbyItemsItem) Increment(increment int64) CmsIncrbyItemsIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (CmsIncrbyItemsIncrement)(c)
 }
 
 func (c SCmsIncrbyItemsItem) Increment(increment int64) SCmsIncrbyItemsIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (SCmsIncrbyItemsIncrement)(c)
 }
 
@@ -6575,12 +6939,12 @@ type CmsIncrbyKey Completed
 type SCmsIncrbyKey SCompleted
 
 func (c CmsIncrbyKey) Item(item string) CmsIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (CmsIncrbyItemsItem)(c)
 }
 
 func (c SCmsIncrbyKey) Item(item string) SCmsIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (SCmsIncrbyItemsItem)(c)
 }
 
@@ -6588,22 +6952,26 @@ type CmsInfo Completed
 
 type SCmsInfo SCompleted
 
-func (b *Builder) CmsInfo() CmsInfo {
-	return CmsInfo{cs: append(b.get(), "CMS.INFO"), ks: InitSlot, cf: readonly}
+func (b *Builder) CmsInfo() (c CmsInfo) {
+	c = CmsInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CMS.INFO")
+	return c
 }
 
-func (b *SBuilder) CmsInfo() SCmsInfo {
-	return SCmsInfo{cs: append(b.get(), "CMS.INFO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CmsInfo() (c SCmsInfo) {
+	c = SCmsInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CMS.INFO")
+	return c
 }
 
 func (c CmsInfo) Key(key string) CmsInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CmsInfoKey)(c)
 }
 
 func (c SCmsInfo) Key(key string) SCmsInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCmsInfoKey)(c)
 }
 
@@ -6631,22 +6999,26 @@ type CmsInitbydim Completed
 
 type SCmsInitbydim SCompleted
 
-func (b *Builder) CmsInitbydim() CmsInitbydim {
-	return CmsInitbydim{cs: append(b.get(), "CMS.INITBYDIM"), ks: InitSlot}
+func (b *Builder) CmsInitbydim() (c CmsInitbydim) {
+	c = CmsInitbydim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INITBYDIM")
+	return c
 }
 
-func (b *SBuilder) CmsInitbydim() SCmsInitbydim {
-	return SCmsInitbydim{cs: append(b.get(), "CMS.INITBYDIM"), ks: InitSlot}
+func (b *SBuilder) CmsInitbydim() (c SCmsInitbydim) {
+	c = SCmsInitbydim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INITBYDIM")
+	return c
 }
 
 func (c CmsInitbydim) Key(key string) CmsInitbydimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CmsInitbydimKey)(c)
 }
 
 func (c SCmsInitbydim) Key(key string) SCmsInitbydimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCmsInitbydimKey)(c)
 }
 
@@ -6667,12 +7039,12 @@ type CmsInitbydimKey Completed
 type SCmsInitbydimKey SCompleted
 
 func (c CmsInitbydimKey) Width(width int64) CmsInitbydimWidth {
-	c.cs = append(c.cs, strconv.FormatInt(width, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(width, 10))
 	return (CmsInitbydimWidth)(c)
 }
 
 func (c SCmsInitbydimKey) Width(width int64) SCmsInitbydimWidth {
-	c.cs = append(c.cs, strconv.FormatInt(width, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(width, 10))
 	return (SCmsInitbydimWidth)(c)
 }
 
@@ -6681,12 +7053,12 @@ type CmsInitbydimWidth Completed
 type SCmsInitbydimWidth SCompleted
 
 func (c CmsInitbydimWidth) Depth(depth int64) CmsInitbydimDepth {
-	c.cs = append(c.cs, strconv.FormatInt(depth, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(depth, 10))
 	return (CmsInitbydimDepth)(c)
 }
 
 func (c SCmsInitbydimWidth) Depth(depth int64) SCmsInitbydimDepth {
-	c.cs = append(c.cs, strconv.FormatInt(depth, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(depth, 10))
 	return (SCmsInitbydimDepth)(c)
 }
 
@@ -6694,22 +7066,26 @@ type CmsInitbyprob Completed
 
 type SCmsInitbyprob SCompleted
 
-func (b *Builder) CmsInitbyprob() CmsInitbyprob {
-	return CmsInitbyprob{cs: append(b.get(), "CMS.INITBYPROB"), ks: InitSlot}
+func (b *Builder) CmsInitbyprob() (c CmsInitbyprob) {
+	c = CmsInitbyprob{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INITBYPROB")
+	return c
 }
 
-func (b *SBuilder) CmsInitbyprob() SCmsInitbyprob {
-	return SCmsInitbyprob{cs: append(b.get(), "CMS.INITBYPROB"), ks: InitSlot}
+func (b *SBuilder) CmsInitbyprob() (c SCmsInitbyprob) {
+	c = SCmsInitbyprob{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.INITBYPROB")
+	return c
 }
 
 func (c CmsInitbyprob) Key(key string) CmsInitbyprobKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CmsInitbyprobKey)(c)
 }
 
 func (c SCmsInitbyprob) Key(key string) SCmsInitbyprobKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCmsInitbyprobKey)(c)
 }
 
@@ -6718,12 +7094,12 @@ type CmsInitbyprobError Completed
 type SCmsInitbyprobError SCompleted
 
 func (c CmsInitbyprobError) Probability(probability float64) CmsInitbyprobProbability {
-	c.cs = append(c.cs, strconv.FormatFloat(probability, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(probability, 'f', -1, 64))
 	return (CmsInitbyprobProbability)(c)
 }
 
 func (c SCmsInitbyprobError) Probability(probability float64) SCmsInitbyprobProbability {
-	c.cs = append(c.cs, strconv.FormatFloat(probability, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(probability, 'f', -1, 64))
 	return (SCmsInitbyprobProbability)(c)
 }
 
@@ -6732,12 +7108,12 @@ type CmsInitbyprobKey Completed
 type SCmsInitbyprobKey SCompleted
 
 func (c CmsInitbyprobKey) Error(error float64) CmsInitbyprobError {
-	c.cs = append(c.cs, strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(error, 'f', -1, 64))
 	return (CmsInitbyprobError)(c)
 }
 
 func (c SCmsInitbyprobKey) Error(error float64) SCmsInitbyprobError {
-	c.cs = append(c.cs, strconv.FormatFloat(error, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(error, 'f', -1, 64))
 	return (SCmsInitbyprobError)(c)
 }
 
@@ -6757,22 +7133,26 @@ type CmsMerge Completed
 
 type SCmsMerge SCompleted
 
-func (b *Builder) CmsMerge() CmsMerge {
-	return CmsMerge{cs: append(b.get(), "CMS.MERGE"), ks: InitSlot}
+func (b *Builder) CmsMerge() (c CmsMerge) {
+	c = CmsMerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.MERGE")
+	return c
 }
 
-func (b *SBuilder) CmsMerge() SCmsMerge {
-	return SCmsMerge{cs: append(b.get(), "CMS.MERGE"), ks: InitSlot}
+func (b *SBuilder) CmsMerge() (c SCmsMerge) {
+	c = SCmsMerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CMS.MERGE")
+	return c
 }
 
 func (c CmsMerge) Destination(destination string) CmsMergeDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (CmsMergeDestination)(c)
 }
 
 func (c SCmsMerge) Destination(destination string) SCmsMergeDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SCmsMergeDestination)(c)
 }
 
@@ -6781,12 +7161,12 @@ type CmsMergeDestination Completed
 type SCmsMergeDestination SCompleted
 
 func (c CmsMergeDestination) Numkeys(numkeys int64) CmsMergeNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (CmsMergeNumkeys)(c)
 }
 
 func (c SCmsMergeDestination) Numkeys(numkeys int64) SCmsMergeNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SCmsMergeNumkeys)(c)
 }
 
@@ -6795,7 +7175,7 @@ type CmsMergeNumkeys Completed
 type SCmsMergeNumkeys SCompleted
 
 func (c CmsMergeNumkeys) Source(source ...string) CmsMergeSource {
-	c.cs = append(c.cs, source...)
+	c.cs.s = append(c.cs.s, source...)
 	return (CmsMergeSource)(c)
 }
 
@@ -6803,7 +7183,7 @@ func (c SCmsMergeNumkeys) Source(source ...string) SCmsMergeSource {
 	for _, k := range source {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, source...)
+	c.cs.s = append(c.cs.s, source...)
 	return (SCmsMergeSource)(c)
 }
 
@@ -6812,7 +7192,7 @@ type CmsMergeSource Completed
 type SCmsMergeSource SCompleted
 
 func (c CmsMergeSource) Source(source ...string) CmsMergeSource {
-	c.cs = append(c.cs, source...)
+	c.cs.s = append(c.cs.s, source...)
 	return c
 }
 
@@ -6820,17 +7200,17 @@ func (c SCmsMergeSource) Source(source ...string) SCmsMergeSource {
 	for _, k := range source {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, source...)
+	c.cs.s = append(c.cs.s, source...)
 	return c
 }
 
 func (c CmsMergeSource) Weights() CmsMergeWeightWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	return (CmsMergeWeightWeights)(c)
 }
 
 func (c SCmsMergeSource) Weights() SCmsMergeWeightWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	return (SCmsMergeWeightWeights)(c)
 }
 
@@ -6848,14 +7228,14 @@ type SCmsMergeWeightWeight SCompleted
 
 func (c CmsMergeWeightWeight) Weight(weight ...float64) CmsMergeWeightWeight {
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatFloat(n, 'f', -1, 64))
+		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
 	}
 	return c
 }
 
 func (c SCmsMergeWeightWeight) Weight(weight ...float64) SCmsMergeWeightWeight {
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatFloat(n, 'f', -1, 64))
+		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
 	}
 	return c
 }
@@ -6874,14 +7254,14 @@ type SCmsMergeWeightWeights SCompleted
 
 func (c CmsMergeWeightWeights) Weight(weight ...float64) CmsMergeWeightWeight {
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatFloat(n, 'f', -1, 64))
+		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
 	}
 	return (CmsMergeWeightWeight)(c)
 }
 
 func (c SCmsMergeWeightWeights) Weight(weight ...float64) SCmsMergeWeightWeight {
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatFloat(n, 'f', -1, 64))
+		c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
 	}
 	return (SCmsMergeWeightWeight)(c)
 }
@@ -6890,22 +7270,26 @@ type CmsQuery Completed
 
 type SCmsQuery SCompleted
 
-func (b *Builder) CmsQuery() CmsQuery {
-	return CmsQuery{cs: append(b.get(), "CMS.QUERY"), ks: InitSlot, cf: readonly}
+func (b *Builder) CmsQuery() (c CmsQuery) {
+	c = CmsQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CMS.QUERY")
+	return c
 }
 
-func (b *SBuilder) CmsQuery() SCmsQuery {
-	return SCmsQuery{cs: append(b.get(), "CMS.QUERY"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) CmsQuery() (c SCmsQuery) {
+	c = SCmsQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "CMS.QUERY")
+	return c
 }
 
 func (c CmsQuery) Key(key string) CmsQueryKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (CmsQueryKey)(c)
 }
 
 func (c SCmsQuery) Key(key string) SCmsQueryKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SCmsQueryKey)(c)
 }
 
@@ -6914,12 +7298,12 @@ type CmsQueryItem Completed
 type SCmsQueryItem SCompleted
 
 func (c CmsQueryItem) Item(item ...string) CmsQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c SCmsQueryItem) Item(item ...string) SCmsQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -6944,12 +7328,12 @@ type CmsQueryKey Completed
 type SCmsQueryKey SCompleted
 
 func (c CmsQueryKey) Item(item ...string) CmsQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (CmsQueryItem)(c)
 }
 
 func (c SCmsQueryKey) Item(item ...string) SCmsQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (SCmsQueryItem)(c)
 }
 
@@ -6957,12 +7341,16 @@ type Command Completed
 
 type SCommand SCompleted
 
-func (b *Builder) Command() Command {
-	return Command{cs: append(b.get(), "COMMAND"), ks: InitSlot}
+func (b *Builder) Command() (c Command) {
+	c = Command{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND")
+	return c
 }
 
-func (b *SBuilder) Command() SCommand {
-	return SCommand{cs: append(b.get(), "COMMAND"), ks: InitSlot}
+func (b *SBuilder) Command() (c SCommand) {
+	c = SCommand{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND")
+	return c
 }
 
 func (c Command) Build() Completed {
@@ -6977,12 +7365,16 @@ type CommandCount Completed
 
 type SCommandCount SCompleted
 
-func (b *Builder) CommandCount() CommandCount {
-	return CommandCount{cs: append(b.get(), "COMMAND", "COUNT"), ks: InitSlot}
+func (b *Builder) CommandCount() (c CommandCount) {
+	c = CommandCount{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "COUNT")
+	return c
 }
 
-func (b *SBuilder) CommandCount() SCommandCount {
-	return SCommandCount{cs: append(b.get(), "COMMAND", "COUNT"), ks: InitSlot}
+func (b *SBuilder) CommandCount() (c SCommandCount) {
+	c = SCommandCount{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "COUNT")
+	return c
 }
 
 func (c CommandCount) Build() Completed {
@@ -6997,12 +7389,16 @@ type CommandGetkeys Completed
 
 type SCommandGetkeys SCompleted
 
-func (b *Builder) CommandGetkeys() CommandGetkeys {
-	return CommandGetkeys{cs: append(b.get(), "COMMAND", "GETKEYS"), ks: InitSlot}
+func (b *Builder) CommandGetkeys() (c CommandGetkeys) {
+	c = CommandGetkeys{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "GETKEYS")
+	return c
 }
 
-func (b *SBuilder) CommandGetkeys() SCommandGetkeys {
-	return SCommandGetkeys{cs: append(b.get(), "COMMAND", "GETKEYS"), ks: InitSlot}
+func (b *SBuilder) CommandGetkeys() (c SCommandGetkeys) {
+	c = SCommandGetkeys{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "GETKEYS")
+	return c
 }
 
 func (c CommandGetkeys) Build() Completed {
@@ -7017,21 +7413,25 @@ type CommandInfo Completed
 
 type SCommandInfo SCompleted
 
-func (b *Builder) CommandInfo() CommandInfo {
-	return CommandInfo{cs: append(b.get(), "COMMAND", "INFO"), ks: InitSlot}
+func (b *Builder) CommandInfo() (c CommandInfo) {
+	c = CommandInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "INFO")
+	return c
 }
 
-func (b *SBuilder) CommandInfo() SCommandInfo {
-	return SCommandInfo{cs: append(b.get(), "COMMAND", "INFO"), ks: InitSlot}
+func (b *SBuilder) CommandInfo() (c SCommandInfo) {
+	c = SCommandInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COMMAND", "INFO")
+	return c
 }
 
 func (c CommandInfo) CommandName(commandName ...string) CommandInfoCommandName {
-	c.cs = append(c.cs, commandName...)
+	c.cs.s = append(c.cs.s, commandName...)
 	return (CommandInfoCommandName)(c)
 }
 
 func (c SCommandInfo) CommandName(commandName ...string) SCommandInfoCommandName {
-	c.cs = append(c.cs, commandName...)
+	c.cs.s = append(c.cs.s, commandName...)
 	return (SCommandInfoCommandName)(c)
 }
 
@@ -7040,12 +7440,12 @@ type CommandInfoCommandName Completed
 type SCommandInfoCommandName SCompleted
 
 func (c CommandInfoCommandName) CommandName(commandName ...string) CommandInfoCommandName {
-	c.cs = append(c.cs, commandName...)
+	c.cs.s = append(c.cs.s, commandName...)
 	return c
 }
 
 func (c SCommandInfoCommandName) CommandName(commandName ...string) SCommandInfoCommandName {
-	c.cs = append(c.cs, commandName...)
+	c.cs.s = append(c.cs.s, commandName...)
 	return c
 }
 
@@ -7061,21 +7461,25 @@ type ConfigGet Completed
 
 type SConfigGet SCompleted
 
-func (b *Builder) ConfigGet() ConfigGet {
-	return ConfigGet{cs: append(b.get(), "CONFIG", "GET"), ks: InitSlot}
+func (b *Builder) ConfigGet() (c ConfigGet) {
+	c = ConfigGet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "GET")
+	return c
 }
 
-func (b *SBuilder) ConfigGet() SConfigGet {
-	return SConfigGet{cs: append(b.get(), "CONFIG", "GET"), ks: InitSlot}
+func (b *SBuilder) ConfigGet() (c SConfigGet) {
+	c = SConfigGet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "GET")
+	return c
 }
 
 func (c ConfigGet) Parameter(parameter ...string) ConfigGetParameter {
-	c.cs = append(c.cs, parameter...)
+	c.cs.s = append(c.cs.s, parameter...)
 	return (ConfigGetParameter)(c)
 }
 
 func (c SConfigGet) Parameter(parameter ...string) SConfigGetParameter {
-	c.cs = append(c.cs, parameter...)
+	c.cs.s = append(c.cs.s, parameter...)
 	return (SConfigGetParameter)(c)
 }
 
@@ -7084,12 +7488,12 @@ type ConfigGetParameter Completed
 type SConfigGetParameter SCompleted
 
 func (c ConfigGetParameter) Parameter(parameter ...string) ConfigGetParameter {
-	c.cs = append(c.cs, parameter...)
+	c.cs.s = append(c.cs.s, parameter...)
 	return c
 }
 
 func (c SConfigGetParameter) Parameter(parameter ...string) SConfigGetParameter {
-	c.cs = append(c.cs, parameter...)
+	c.cs.s = append(c.cs.s, parameter...)
 	return c
 }
 
@@ -7105,12 +7509,16 @@ type ConfigResetstat Completed
 
 type SConfigResetstat SCompleted
 
-func (b *Builder) ConfigResetstat() ConfigResetstat {
-	return ConfigResetstat{cs: append(b.get(), "CONFIG", "RESETSTAT"), ks: InitSlot}
+func (b *Builder) ConfigResetstat() (c ConfigResetstat) {
+	c = ConfigResetstat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "RESETSTAT")
+	return c
 }
 
-func (b *SBuilder) ConfigResetstat() SConfigResetstat {
-	return SConfigResetstat{cs: append(b.get(), "CONFIG", "RESETSTAT"), ks: InitSlot}
+func (b *SBuilder) ConfigResetstat() (c SConfigResetstat) {
+	c = SConfigResetstat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "RESETSTAT")
+	return c
 }
 
 func (c ConfigResetstat) Build() Completed {
@@ -7125,12 +7533,16 @@ type ConfigRewrite Completed
 
 type SConfigRewrite SCompleted
 
-func (b *Builder) ConfigRewrite() ConfigRewrite {
-	return ConfigRewrite{cs: append(b.get(), "CONFIG", "REWRITE"), ks: InitSlot}
+func (b *Builder) ConfigRewrite() (c ConfigRewrite) {
+	c = ConfigRewrite{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "REWRITE")
+	return c
 }
 
-func (b *SBuilder) ConfigRewrite() SConfigRewrite {
-	return SConfigRewrite{cs: append(b.get(), "CONFIG", "REWRITE"), ks: InitSlot}
+func (b *SBuilder) ConfigRewrite() (c SConfigRewrite) {
+	c = SConfigRewrite{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "REWRITE")
+	return c
 }
 
 func (c ConfigRewrite) Build() Completed {
@@ -7145,12 +7557,16 @@ type ConfigSet Completed
 
 type SConfigSet SCompleted
 
-func (b *Builder) ConfigSet() ConfigSet {
-	return ConfigSet{cs: append(b.get(), "CONFIG", "SET"), ks: InitSlot}
+func (b *Builder) ConfigSet() (c ConfigSet) {
+	c = ConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "SET")
+	return c
 }
 
-func (b *SBuilder) ConfigSet() SConfigSet {
-	return SConfigSet{cs: append(b.get(), "CONFIG", "SET"), ks: InitSlot}
+func (b *SBuilder) ConfigSet() (c SConfigSet) {
+	c = SConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "CONFIG", "SET")
+	return c
 }
 
 func (c ConfigSet) ParameterValue() ConfigSetParameterValue {
@@ -7166,12 +7582,12 @@ type ConfigSetParameterValue Completed
 type SConfigSetParameterValue SCompleted
 
 func (c ConfigSetParameterValue) ParameterValue(parameter string, value string) ConfigSetParameterValue {
-	c.cs = append(c.cs, parameter, value)
+	c.cs.s = append(c.cs.s, parameter, value)
 	return c
 }
 
 func (c SConfigSetParameterValue) ParameterValue(parameter string, value string) SConfigSetParameterValue {
-	c.cs = append(c.cs, parameter, value)
+	c.cs.s = append(c.cs.s, parameter, value)
 	return c
 }
 
@@ -7187,22 +7603,26 @@ type Copy Completed
 
 type SCopy SCompleted
 
-func (b *Builder) Copy() Copy {
-	return Copy{cs: append(b.get(), "COPY"), ks: InitSlot}
+func (b *Builder) Copy() (c Copy) {
+	c = Copy{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COPY")
+	return c
 }
 
-func (b *SBuilder) Copy() SCopy {
-	return SCopy{cs: append(b.get(), "COPY"), ks: InitSlot}
+func (b *SBuilder) Copy() (c SCopy) {
+	c = SCopy{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "COPY")
+	return c
 }
 
 func (c Copy) Source(source string) CopySource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (CopySource)(c)
 }
 
 func (c SCopy) Source(source string) SCopySource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SCopySource)(c)
 }
 
@@ -7211,12 +7631,12 @@ type CopyDb Completed
 type SCopyDb SCompleted
 
 func (c CopyDb) Replace() CopyReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (CopyReplace)(c)
 }
 
 func (c SCopyDb) Replace() SCopyReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (SCopyReplace)(c)
 }
 
@@ -7233,22 +7653,22 @@ type CopyDestination Completed
 type SCopyDestination SCompleted
 
 func (c CopyDestination) Db(destinationDb int64) CopyDb {
-	c.cs = append(c.cs, "DB", strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(destinationDb, 10))
 	return (CopyDb)(c)
 }
 
 func (c SCopyDestination) Db(destinationDb int64) SCopyDb {
-	c.cs = append(c.cs, "DB", strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, "DB", strconv.FormatInt(destinationDb, 10))
 	return (SCopyDb)(c)
 }
 
 func (c CopyDestination) Replace() CopyReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (CopyReplace)(c)
 }
 
 func (c SCopyDestination) Replace() SCopyReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (SCopyReplace)(c)
 }
 
@@ -7277,13 +7697,13 @@ type CopySource Completed
 type SCopySource SCompleted
 
 func (c CopySource) Destination(destination string) CopyDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (CopyDestination)(c)
 }
 
 func (c SCopySource) Destination(destination string) SCopyDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SCopyDestination)(c)
 }
 
@@ -7291,12 +7711,16 @@ type Dbsize Completed
 
 type SDbsize SCompleted
 
-func (b *Builder) Dbsize() Dbsize {
-	return Dbsize{cs: append(b.get(), "DBSIZE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Dbsize() (c Dbsize) {
+	c = Dbsize{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "DBSIZE")
+	return c
 }
 
-func (b *SBuilder) Dbsize() SDbsize {
-	return SDbsize{cs: append(b.get(), "DBSIZE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Dbsize() (c SDbsize) {
+	c = SDbsize{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "DBSIZE")
+	return c
 }
 
 func (c Dbsize) Build() Completed {
@@ -7311,22 +7735,26 @@ type DebugObject Completed
 
 type SDebugObject SCompleted
 
-func (b *Builder) DebugObject() DebugObject {
-	return DebugObject{cs: append(b.get(), "DEBUG", "OBJECT"), ks: InitSlot}
+func (b *Builder) DebugObject() (c DebugObject) {
+	c = DebugObject{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEBUG", "OBJECT")
+	return c
 }
 
-func (b *SBuilder) DebugObject() SDebugObject {
-	return SDebugObject{cs: append(b.get(), "DEBUG", "OBJECT"), ks: InitSlot}
+func (b *SBuilder) DebugObject() (c SDebugObject) {
+	c = SDebugObject{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEBUG", "OBJECT")
+	return c
 }
 
 func (c DebugObject) Key(key string) DebugObjectKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (DebugObjectKey)(c)
 }
 
 func (c SDebugObject) Key(key string) SDebugObjectKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SDebugObjectKey)(c)
 }
 
@@ -7346,12 +7774,16 @@ type DebugSegfault Completed
 
 type SDebugSegfault SCompleted
 
-func (b *Builder) DebugSegfault() DebugSegfault {
-	return DebugSegfault{cs: append(b.get(), "DEBUG", "SEGFAULT"), ks: InitSlot}
+func (b *Builder) DebugSegfault() (c DebugSegfault) {
+	c = DebugSegfault{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEBUG", "SEGFAULT")
+	return c
 }
 
-func (b *SBuilder) DebugSegfault() SDebugSegfault {
-	return SDebugSegfault{cs: append(b.get(), "DEBUG", "SEGFAULT"), ks: InitSlot}
+func (b *SBuilder) DebugSegfault() (c SDebugSegfault) {
+	c = SDebugSegfault{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEBUG", "SEGFAULT")
+	return c
 }
 
 func (c DebugSegfault) Build() Completed {
@@ -7366,22 +7798,26 @@ type Decr Completed
 
 type SDecr SCompleted
 
-func (b *Builder) Decr() Decr {
-	return Decr{cs: append(b.get(), "DECR"), ks: InitSlot}
+func (b *Builder) Decr() (c Decr) {
+	c = Decr{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DECR")
+	return c
 }
 
-func (b *SBuilder) Decr() SDecr {
-	return SDecr{cs: append(b.get(), "DECR"), ks: InitSlot}
+func (b *SBuilder) Decr() (c SDecr) {
+	c = SDecr{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DECR")
+	return c
 }
 
 func (c Decr) Key(key string) DecrKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (DecrKey)(c)
 }
 
 func (c SDecr) Key(key string) SDecrKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SDecrKey)(c)
 }
 
@@ -7401,22 +7837,26 @@ type Decrby Completed
 
 type SDecrby SCompleted
 
-func (b *Builder) Decrby() Decrby {
-	return Decrby{cs: append(b.get(), "DECRBY"), ks: InitSlot}
+func (b *Builder) Decrby() (c Decrby) {
+	c = Decrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DECRBY")
+	return c
 }
 
-func (b *SBuilder) Decrby() SDecrby {
-	return SDecrby{cs: append(b.get(), "DECRBY"), ks: InitSlot}
+func (b *SBuilder) Decrby() (c SDecrby) {
+	c = SDecrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DECRBY")
+	return c
 }
 
 func (c Decrby) Key(key string) DecrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (DecrbyKey)(c)
 }
 
 func (c SDecrby) Key(key string) SDecrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SDecrbyKey)(c)
 }
 
@@ -7437,12 +7877,12 @@ type DecrbyKey Completed
 type SDecrbyKey SCompleted
 
 func (c DecrbyKey) Decrement(decrement int64) DecrbyDecrement {
-	c.cs = append(c.cs, strconv.FormatInt(decrement, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(decrement, 10))
 	return (DecrbyDecrement)(c)
 }
 
 func (c SDecrbyKey) Decrement(decrement int64) SDecrbyDecrement {
-	c.cs = append(c.cs, strconv.FormatInt(decrement, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(decrement, 10))
 	return (SDecrbyDecrement)(c)
 }
 
@@ -7450,16 +7890,20 @@ type Del Completed
 
 type SDel SCompleted
 
-func (b *Builder) Del() Del {
-	return Del{cs: append(b.get(), "DEL"), ks: InitSlot}
+func (b *Builder) Del() (c Del) {
+	c = Del{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEL")
+	return c
 }
 
-func (b *SBuilder) Del() SDel {
-	return SDel{cs: append(b.get(), "DEL"), ks: InitSlot}
+func (b *SBuilder) Del() (c SDel) {
+	c = SDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DEL")
+	return c
 }
 
 func (c Del) Key(key ...string) DelKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (DelKey)(c)
 }
 
@@ -7467,7 +7911,7 @@ func (c SDel) Key(key ...string) SDelKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SDelKey)(c)
 }
 
@@ -7476,7 +7920,7 @@ type DelKey Completed
 type SDelKey SCompleted
 
 func (c DelKey) Key(key ...string) DelKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7484,7 +7928,7 @@ func (c SDelKey) Key(key ...string) SDelKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7500,12 +7944,16 @@ type Discard Completed
 
 type SDiscard SCompleted
 
-func (b *Builder) Discard() Discard {
-	return Discard{cs: append(b.get(), "DISCARD"), ks: InitSlot}
+func (b *Builder) Discard() (c Discard) {
+	c = Discard{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DISCARD")
+	return c
 }
 
-func (b *SBuilder) Discard() SDiscard {
-	return SDiscard{cs: append(b.get(), "DISCARD"), ks: InitSlot}
+func (b *SBuilder) Discard() (c SDiscard) {
+	c = SDiscard{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "DISCARD")
+	return c
 }
 
 func (c Discard) Build() Completed {
@@ -7520,22 +7968,26 @@ type Dump Completed
 
 type SDump SCompleted
 
-func (b *Builder) Dump() Dump {
-	return Dump{cs: append(b.get(), "DUMP"), ks: InitSlot, cf: readonly}
+func (b *Builder) Dump() (c Dump) {
+	c = Dump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "DUMP")
+	return c
 }
 
-func (b *SBuilder) Dump() SDump {
-	return SDump{cs: append(b.get(), "DUMP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Dump() (c SDump) {
+	c = SDump{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "DUMP")
+	return c
 }
 
 func (c Dump) Key(key string) DumpKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (DumpKey)(c)
 }
 
 func (c SDump) Key(key string) SDumpKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SDumpKey)(c)
 }
 
@@ -7555,21 +8007,25 @@ type Echo Completed
 
 type SEcho SCompleted
 
-func (b *Builder) Echo() Echo {
-	return Echo{cs: append(b.get(), "ECHO"), ks: InitSlot}
+func (b *Builder) Echo() (c Echo) {
+	c = Echo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ECHO")
+	return c
 }
 
-func (b *SBuilder) Echo() SEcho {
-	return SEcho{cs: append(b.get(), "ECHO"), ks: InitSlot}
+func (b *SBuilder) Echo() (c SEcho) {
+	c = SEcho{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ECHO")
+	return c
 }
 
 func (c Echo) Message(message string) EchoMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (EchoMessage)(c)
 }
 
 func (c SEcho) Message(message string) SEchoMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (SEchoMessage)(c)
 }
 
@@ -7589,21 +8045,25 @@ type Eval Completed
 
 type SEval SCompleted
 
-func (b *Builder) Eval() Eval {
-	return Eval{cs: append(b.get(), "EVAL"), ks: InitSlot}
+func (b *Builder) Eval() (c Eval) {
+	c = Eval{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EVAL")
+	return c
 }
 
-func (b *SBuilder) Eval() SEval {
-	return SEval{cs: append(b.get(), "EVAL"), ks: InitSlot}
+func (b *SBuilder) Eval() (c SEval) {
+	c = SEval{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EVAL")
+	return c
 }
 
 func (c Eval) Script(script string) EvalScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (EvalScript)(c)
 }
 
 func (c SEval) Script(script string) SEvalScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (SEvalScript)(c)
 }
 
@@ -7612,12 +8072,12 @@ type EvalArg Completed
 type SEvalArg SCompleted
 
 func (c EvalArg) Arg(arg ...string) EvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SEvalArg) Arg(arg ...string) SEvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
@@ -7634,7 +8094,7 @@ type EvalKey Completed
 type SEvalKey SCompleted
 
 func (c EvalKey) Key(key ...string) EvalKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7642,17 +8102,17 @@ func (c SEvalKey) Key(key ...string) SEvalKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c EvalKey) Arg(arg ...string) EvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalArg)(c)
 }
 
 func (c SEvalKey) Arg(arg ...string) SEvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalArg)(c)
 }
 
@@ -7669,7 +8129,7 @@ type EvalNumkeys Completed
 type SEvalNumkeys SCompleted
 
 func (c EvalNumkeys) Key(key ...string) EvalKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (EvalKey)(c)
 }
 
@@ -7677,17 +8137,17 @@ func (c SEvalNumkeys) Key(key ...string) SEvalKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SEvalKey)(c)
 }
 
 func (c EvalNumkeys) Arg(arg ...string) EvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalArg)(c)
 }
 
 func (c SEvalNumkeys) Arg(arg ...string) SEvalArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalArg)(c)
 }
 
@@ -7703,21 +8163,25 @@ type EvalRo Completed
 
 type SEvalRo SCompleted
 
-func (b *Builder) EvalRo() EvalRo {
-	return EvalRo{cs: append(b.get(), "EVAL_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) EvalRo() (c EvalRo) {
+	c = EvalRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EVAL_RO")
+	return c
 }
 
-func (b *SBuilder) EvalRo() SEvalRo {
-	return SEvalRo{cs: append(b.get(), "EVAL_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) EvalRo() (c SEvalRo) {
+	c = SEvalRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EVAL_RO")
+	return c
 }
 
 func (c EvalRo) Script(script string) EvalRoScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (EvalRoScript)(c)
 }
 
 func (c SEvalRo) Script(script string) SEvalRoScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (SEvalRoScript)(c)
 }
 
@@ -7726,12 +8190,12 @@ type EvalRoArg Completed
 type SEvalRoArg SCompleted
 
 func (c EvalRoArg) Arg(arg ...string) EvalRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SEvalRoArg) Arg(arg ...string) SEvalRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
@@ -7748,7 +8212,7 @@ type EvalRoKey Completed
 type SEvalRoKey SCompleted
 
 func (c EvalRoKey) Key(key ...string) EvalRoKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7756,17 +8220,17 @@ func (c SEvalRoKey) Key(key ...string) SEvalRoKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c EvalRoKey) Arg(arg ...string) EvalRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalRoArg)(c)
 }
 
 func (c SEvalRoKey) Arg(arg ...string) SEvalRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalRoArg)(c)
 }
 
@@ -7775,7 +8239,7 @@ type EvalRoNumkeys Completed
 type SEvalRoNumkeys SCompleted
 
 func (c EvalRoNumkeys) Key(key ...string) EvalRoKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (EvalRoKey)(c)
 }
 
@@ -7783,7 +8247,7 @@ func (c SEvalRoNumkeys) Key(key ...string) SEvalRoKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SEvalRoKey)(c)
 }
 
@@ -7792,12 +8256,12 @@ type EvalRoScript Completed
 type SEvalRoScript SCompleted
 
 func (c EvalRoScript) Numkeys(numkeys int64) EvalRoNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (EvalRoNumkeys)(c)
 }
 
 func (c SEvalRoScript) Numkeys(numkeys int64) SEvalRoNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SEvalRoNumkeys)(c)
 }
 
@@ -7806,12 +8270,12 @@ type EvalScript Completed
 type SEvalScript SCompleted
 
 func (c EvalScript) Numkeys(numkeys int64) EvalNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (EvalNumkeys)(c)
 }
 
 func (c SEvalScript) Numkeys(numkeys int64) SEvalNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SEvalNumkeys)(c)
 }
 
@@ -7819,21 +8283,25 @@ type Evalsha Completed
 
 type SEvalsha SCompleted
 
-func (b *Builder) Evalsha() Evalsha {
-	return Evalsha{cs: append(b.get(), "EVALSHA"), ks: InitSlot}
+func (b *Builder) Evalsha() (c Evalsha) {
+	c = Evalsha{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EVALSHA")
+	return c
 }
 
-func (b *SBuilder) Evalsha() SEvalsha {
-	return SEvalsha{cs: append(b.get(), "EVALSHA"), ks: InitSlot}
+func (b *SBuilder) Evalsha() (c SEvalsha) {
+	c = SEvalsha{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EVALSHA")
+	return c
 }
 
 func (c Evalsha) Sha1(sha1 string) EvalshaSha1 {
-	c.cs = append(c.cs, sha1)
+	c.cs.s = append(c.cs.s, sha1)
 	return (EvalshaSha1)(c)
 }
 
 func (c SEvalsha) Sha1(sha1 string) SEvalshaSha1 {
-	c.cs = append(c.cs, sha1)
+	c.cs.s = append(c.cs.s, sha1)
 	return (SEvalshaSha1)(c)
 }
 
@@ -7842,12 +8310,12 @@ type EvalshaArg Completed
 type SEvalshaArg SCompleted
 
 func (c EvalshaArg) Arg(arg ...string) EvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SEvalshaArg) Arg(arg ...string) SEvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
@@ -7864,7 +8332,7 @@ type EvalshaKey Completed
 type SEvalshaKey SCompleted
 
 func (c EvalshaKey) Key(key ...string) EvalshaKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7872,17 +8340,17 @@ func (c SEvalshaKey) Key(key ...string) SEvalshaKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c EvalshaKey) Arg(arg ...string) EvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalshaArg)(c)
 }
 
 func (c SEvalshaKey) Arg(arg ...string) SEvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalshaArg)(c)
 }
 
@@ -7899,7 +8367,7 @@ type EvalshaNumkeys Completed
 type SEvalshaNumkeys SCompleted
 
 func (c EvalshaNumkeys) Key(key ...string) EvalshaKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (EvalshaKey)(c)
 }
 
@@ -7907,17 +8375,17 @@ func (c SEvalshaNumkeys) Key(key ...string) SEvalshaKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SEvalshaKey)(c)
 }
 
 func (c EvalshaNumkeys) Arg(arg ...string) EvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalshaArg)(c)
 }
 
 func (c SEvalshaNumkeys) Arg(arg ...string) SEvalshaArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalshaArg)(c)
 }
 
@@ -7933,21 +8401,25 @@ type EvalshaRo Completed
 
 type SEvalshaRo SCompleted
 
-func (b *Builder) EvalshaRo() EvalshaRo {
-	return EvalshaRo{cs: append(b.get(), "EVALSHA_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) EvalshaRo() (c EvalshaRo) {
+	c = EvalshaRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EVALSHA_RO")
+	return c
 }
 
-func (b *SBuilder) EvalshaRo() SEvalshaRo {
-	return SEvalshaRo{cs: append(b.get(), "EVALSHA_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) EvalshaRo() (c SEvalshaRo) {
+	c = SEvalshaRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EVALSHA_RO")
+	return c
 }
 
 func (c EvalshaRo) Sha1(sha1 string) EvalshaRoSha1 {
-	c.cs = append(c.cs, sha1)
+	c.cs.s = append(c.cs.s, sha1)
 	return (EvalshaRoSha1)(c)
 }
 
 func (c SEvalshaRo) Sha1(sha1 string) SEvalshaRoSha1 {
-	c.cs = append(c.cs, sha1)
+	c.cs.s = append(c.cs.s, sha1)
 	return (SEvalshaRoSha1)(c)
 }
 
@@ -7956,12 +8428,12 @@ type EvalshaRoArg Completed
 type SEvalshaRoArg SCompleted
 
 func (c EvalshaRoArg) Arg(arg ...string) EvalshaRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SEvalshaRoArg) Arg(arg ...string) SEvalshaRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
@@ -7978,7 +8450,7 @@ type EvalshaRoKey Completed
 type SEvalshaRoKey SCompleted
 
 func (c EvalshaRoKey) Key(key ...string) EvalshaRoKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -7986,17 +8458,17 @@ func (c SEvalshaRoKey) Key(key ...string) SEvalshaRoKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c EvalshaRoKey) Arg(arg ...string) EvalshaRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (EvalshaRoArg)(c)
 }
 
 func (c SEvalshaRoKey) Arg(arg ...string) SEvalshaRoArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SEvalshaRoArg)(c)
 }
 
@@ -8005,7 +8477,7 @@ type EvalshaRoNumkeys Completed
 type SEvalshaRoNumkeys SCompleted
 
 func (c EvalshaRoNumkeys) Key(key ...string) EvalshaRoKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (EvalshaRoKey)(c)
 }
 
@@ -8013,7 +8485,7 @@ func (c SEvalshaRoNumkeys) Key(key ...string) SEvalshaRoKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SEvalshaRoKey)(c)
 }
 
@@ -8022,12 +8494,12 @@ type EvalshaRoSha1 Completed
 type SEvalshaRoSha1 SCompleted
 
 func (c EvalshaRoSha1) Numkeys(numkeys int64) EvalshaRoNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (EvalshaRoNumkeys)(c)
 }
 
 func (c SEvalshaRoSha1) Numkeys(numkeys int64) SEvalshaRoNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SEvalshaRoNumkeys)(c)
 }
 
@@ -8036,12 +8508,12 @@ type EvalshaSha1 Completed
 type SEvalshaSha1 SCompleted
 
 func (c EvalshaSha1) Numkeys(numkeys int64) EvalshaNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (EvalshaNumkeys)(c)
 }
 
 func (c SEvalshaSha1) Numkeys(numkeys int64) SEvalshaNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SEvalshaNumkeys)(c)
 }
 
@@ -8049,12 +8521,16 @@ type Exec Completed
 
 type SExec SCompleted
 
-func (b *Builder) Exec() Exec {
-	return Exec{cs: append(b.get(), "EXEC"), ks: InitSlot}
+func (b *Builder) Exec() (c Exec) {
+	c = Exec{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXEC")
+	return c
 }
 
-func (b *SBuilder) Exec() SExec {
-	return SExec{cs: append(b.get(), "EXEC"), ks: InitSlot}
+func (b *SBuilder) Exec() (c SExec) {
+	c = SExec{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXEC")
+	return c
 }
 
 func (c Exec) Build() Completed {
@@ -8069,16 +8545,20 @@ type Exists Completed
 
 type SExists SCompleted
 
-func (b *Builder) Exists() Exists {
-	return Exists{cs: append(b.get(), "EXISTS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Exists() (c Exists) {
+	c = Exists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EXISTS")
+	return c
 }
 
-func (b *SBuilder) Exists() SExists {
-	return SExists{cs: append(b.get(), "EXISTS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Exists() (c SExists) {
+	c = SExists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EXISTS")
+	return c
 }
 
 func (c Exists) Key(key ...string) ExistsKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ExistsKey)(c)
 }
 
@@ -8086,7 +8566,7 @@ func (c SExists) Key(key ...string) SExistsKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SExistsKey)(c)
 }
 
@@ -8095,7 +8575,7 @@ type ExistsKey Completed
 type SExistsKey SCompleted
 
 func (c ExistsKey) Key(key ...string) ExistsKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -8103,7 +8583,7 @@ func (c SExistsKey) Key(key ...string) SExistsKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -8119,22 +8599,26 @@ type Expire Completed
 
 type SExpire SCompleted
 
-func (b *Builder) Expire() Expire {
-	return Expire{cs: append(b.get(), "EXPIRE"), ks: InitSlot}
+func (b *Builder) Expire() (c Expire) {
+	c = Expire{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXPIRE")
+	return c
 }
 
-func (b *SBuilder) Expire() SExpire {
-	return SExpire{cs: append(b.get(), "EXPIRE"), ks: InitSlot}
+func (b *SBuilder) Expire() (c SExpire) {
+	c = SExpire{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXPIRE")
+	return c
 }
 
 func (c Expire) Key(key string) ExpireKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ExpireKey)(c)
 }
 
 func (c SExpire) Key(key string) SExpireKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SExpireKey)(c)
 }
 
@@ -8191,12 +8675,12 @@ type ExpireKey Completed
 type SExpireKey SCompleted
 
 func (c ExpireKey) Seconds(seconds int64) ExpireSeconds {
-	c.cs = append(c.cs, strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
 	return (ExpireSeconds)(c)
 }
 
 func (c SExpireKey) Seconds(seconds int64) SExpireSeconds {
-	c.cs = append(c.cs, strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
 	return (SExpireSeconds)(c)
 }
 
@@ -8205,42 +8689,42 @@ type ExpireSeconds Completed
 type SExpireSeconds SCompleted
 
 func (c ExpireSeconds) Nx() ExpireConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (ExpireConditionNx)(c)
 }
 
 func (c SExpireSeconds) Nx() SExpireConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SExpireConditionNx)(c)
 }
 
 func (c ExpireSeconds) Xx() ExpireConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (ExpireConditionXx)(c)
 }
 
 func (c SExpireSeconds) Xx() SExpireConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SExpireConditionXx)(c)
 }
 
 func (c ExpireSeconds) Gt() ExpireConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (ExpireConditionGt)(c)
 }
 
 func (c SExpireSeconds) Gt() SExpireConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SExpireConditionGt)(c)
 }
 
 func (c ExpireSeconds) Lt() ExpireConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (ExpireConditionLt)(c)
 }
 
 func (c SExpireSeconds) Lt() SExpireConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SExpireConditionLt)(c)
 }
 
@@ -8256,22 +8740,26 @@ type Expireat Completed
 
 type SExpireat SCompleted
 
-func (b *Builder) Expireat() Expireat {
-	return Expireat{cs: append(b.get(), "EXPIREAT"), ks: InitSlot}
+func (b *Builder) Expireat() (c Expireat) {
+	c = Expireat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXPIREAT")
+	return c
 }
 
-func (b *SBuilder) Expireat() SExpireat {
-	return SExpireat{cs: append(b.get(), "EXPIREAT"), ks: InitSlot}
+func (b *SBuilder) Expireat() (c SExpireat) {
+	c = SExpireat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "EXPIREAT")
+	return c
 }
 
 func (c Expireat) Key(key string) ExpireatKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ExpireatKey)(c)
 }
 
 func (c SExpireat) Key(key string) SExpireatKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SExpireatKey)(c)
 }
 
@@ -8328,12 +8816,12 @@ type ExpireatKey Completed
 type SExpireatKey SCompleted
 
 func (c ExpireatKey) Timestamp(timestamp int64) ExpireatTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (ExpireatTimestamp)(c)
 }
 
 func (c SExpireatKey) Timestamp(timestamp int64) SExpireatTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (SExpireatTimestamp)(c)
 }
 
@@ -8342,42 +8830,42 @@ type ExpireatTimestamp Completed
 type SExpireatTimestamp SCompleted
 
 func (c ExpireatTimestamp) Nx() ExpireatConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (ExpireatConditionNx)(c)
 }
 
 func (c SExpireatTimestamp) Nx() SExpireatConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SExpireatConditionNx)(c)
 }
 
 func (c ExpireatTimestamp) Xx() ExpireatConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (ExpireatConditionXx)(c)
 }
 
 func (c SExpireatTimestamp) Xx() SExpireatConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SExpireatConditionXx)(c)
 }
 
 func (c ExpireatTimestamp) Gt() ExpireatConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (ExpireatConditionGt)(c)
 }
 
 func (c SExpireatTimestamp) Gt() SExpireatConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SExpireatConditionGt)(c)
 }
 
 func (c ExpireatTimestamp) Lt() ExpireatConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (ExpireatConditionLt)(c)
 }
 
 func (c SExpireatTimestamp) Lt() SExpireatConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SExpireatConditionLt)(c)
 }
 
@@ -8393,22 +8881,26 @@ type Expiretime Completed
 
 type SExpiretime SCompleted
 
-func (b *Builder) Expiretime() Expiretime {
-	return Expiretime{cs: append(b.get(), "EXPIRETIME"), ks: InitSlot, cf: readonly}
+func (b *Builder) Expiretime() (c Expiretime) {
+	c = Expiretime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EXPIRETIME")
+	return c
 }
 
-func (b *SBuilder) Expiretime() SExpiretime {
-	return SExpiretime{cs: append(b.get(), "EXPIRETIME"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Expiretime() (c SExpiretime) {
+	c = SExpiretime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "EXPIRETIME")
+	return c
 }
 
 func (c Expiretime) Key(key string) ExpiretimeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ExpiretimeKey)(c)
 }
 
 func (c SExpiretime) Key(key string) SExpiretimeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SExpiretimeKey)(c)
 }
 
@@ -8436,41 +8928,45 @@ type Failover Completed
 
 type SFailover SCompleted
 
-func (b *Builder) Failover() Failover {
-	return Failover{cs: append(b.get(), "FAILOVER"), ks: InitSlot}
+func (b *Builder) Failover() (c Failover) {
+	c = Failover{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FAILOVER")
+	return c
 }
 
-func (b *SBuilder) Failover() SFailover {
-	return SFailover{cs: append(b.get(), "FAILOVER"), ks: InitSlot}
+func (b *SBuilder) Failover() (c SFailover) {
+	c = SFailover{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FAILOVER")
+	return c
 }
 
 func (c Failover) To() FailoverTargetTo {
-	c.cs = append(c.cs, "TO")
+	c.cs.s = append(c.cs.s, "TO")
 	return (FailoverTargetTo)(c)
 }
 
 func (c SFailover) To() SFailoverTargetTo {
-	c.cs = append(c.cs, "TO")
+	c.cs.s = append(c.cs.s, "TO")
 	return (SFailoverTargetTo)(c)
 }
 
 func (c Failover) Abort() FailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (FailoverAbort)(c)
 }
 
 func (c SFailover) Abort() SFailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (SFailoverAbort)(c)
 }
 
 func (c Failover) Timeout(milliseconds int64) FailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (FailoverTimeout)(c)
 }
 
 func (c SFailover) Timeout(milliseconds int64) SFailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (SFailoverTimeout)(c)
 }
 
@@ -8487,12 +8983,12 @@ type FailoverAbort Completed
 type SFailoverAbort SCompleted
 
 func (c FailoverAbort) Timeout(milliseconds int64) FailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (FailoverTimeout)(c)
 }
 
 func (c SFailoverAbort) Timeout(milliseconds int64) SFailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (SFailoverTimeout)(c)
 }
 
@@ -8509,22 +9005,22 @@ type FailoverTargetForce Completed
 type SFailoverTargetForce SCompleted
 
 func (c FailoverTargetForce) Abort() FailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (FailoverAbort)(c)
 }
 
 func (c SFailoverTargetForce) Abort() SFailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (SFailoverAbort)(c)
 }
 
 func (c FailoverTargetForce) Timeout(milliseconds int64) FailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (FailoverTimeout)(c)
 }
 
 func (c SFailoverTargetForce) Timeout(milliseconds int64) SFailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (SFailoverTimeout)(c)
 }
 
@@ -8541,12 +9037,12 @@ type FailoverTargetHost Completed
 type SFailoverTargetHost SCompleted
 
 func (c FailoverTargetHost) Port(port int64) FailoverTargetPort {
-	c.cs = append(c.cs, strconv.FormatInt(port, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
 	return (FailoverTargetPort)(c)
 }
 
 func (c SFailoverTargetHost) Port(port int64) SFailoverTargetPort {
-	c.cs = append(c.cs, strconv.FormatInt(port, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
 	return (SFailoverTargetPort)(c)
 }
 
@@ -8555,32 +9051,32 @@ type FailoverTargetPort Completed
 type SFailoverTargetPort SCompleted
 
 func (c FailoverTargetPort) Force() FailoverTargetForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (FailoverTargetForce)(c)
 }
 
 func (c SFailoverTargetPort) Force() SFailoverTargetForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SFailoverTargetForce)(c)
 }
 
 func (c FailoverTargetPort) Abort() FailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (FailoverAbort)(c)
 }
 
 func (c SFailoverTargetPort) Abort() SFailoverAbort {
-	c.cs = append(c.cs, "ABORT")
+	c.cs.s = append(c.cs.s, "ABORT")
 	return (SFailoverAbort)(c)
 }
 
 func (c FailoverTargetPort) Timeout(milliseconds int64) FailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (FailoverTimeout)(c)
 }
 
 func (c SFailoverTargetPort) Timeout(milliseconds int64) SFailoverTimeout {
-	c.cs = append(c.cs, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
 	return (SFailoverTimeout)(c)
 }
 
@@ -8597,12 +9093,12 @@ type FailoverTargetTo Completed
 type SFailoverTargetTo SCompleted
 
 func (c FailoverTargetTo) Host(host string) FailoverTargetHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (FailoverTargetHost)(c)
 }
 
 func (c SFailoverTargetTo) Host(host string) SFailoverTargetHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (SFailoverTargetHost)(c)
 }
 
@@ -8622,31 +9118,35 @@ type Flushall Completed
 
 type SFlushall SCompleted
 
-func (b *Builder) Flushall() Flushall {
-	return Flushall{cs: append(b.get(), "FLUSHALL"), ks: InitSlot}
+func (b *Builder) Flushall() (c Flushall) {
+	c = Flushall{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FLUSHALL")
+	return c
 }
 
-func (b *SBuilder) Flushall() SFlushall {
-	return SFlushall{cs: append(b.get(), "FLUSHALL"), ks: InitSlot}
+func (b *SBuilder) Flushall() (c SFlushall) {
+	c = SFlushall{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FLUSHALL")
+	return c
 }
 
 func (c Flushall) Async() FlushallAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (FlushallAsync)(c)
 }
 
 func (c SFlushall) Async() SFlushallAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (SFlushallAsync)(c)
 }
 
 func (c Flushall) Sync() FlushallAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (FlushallAsyncSync)(c)
 }
 
 func (c SFlushall) Sync() SFlushallAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (SFlushallAsyncSync)(c)
 }
 
@@ -8686,31 +9186,35 @@ type Flushdb Completed
 
 type SFlushdb SCompleted
 
-func (b *Builder) Flushdb() Flushdb {
-	return Flushdb{cs: append(b.get(), "FLUSHDB"), ks: InitSlot}
+func (b *Builder) Flushdb() (c Flushdb) {
+	c = Flushdb{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FLUSHDB")
+	return c
 }
 
-func (b *SBuilder) Flushdb() SFlushdb {
-	return SFlushdb{cs: append(b.get(), "FLUSHDB"), ks: InitSlot}
+func (b *SBuilder) Flushdb() (c SFlushdb) {
+	c = SFlushdb{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FLUSHDB")
+	return c
 }
 
 func (c Flushdb) Async() FlushdbAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (FlushdbAsync)(c)
 }
 
 func (c SFlushdb) Async() SFlushdbAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (SFlushdbAsync)(c)
 }
 
 func (c Flushdb) Sync() FlushdbAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (FlushdbAsyncSync)(c)
 }
 
 func (c SFlushdb) Sync() SFlushdbAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (SFlushdbAsyncSync)(c)
 }
 
@@ -8750,21 +9254,25 @@ type FtAggregate Completed
 
 type SFtAggregate SCompleted
 
-func (b *Builder) FtAggregate() FtAggregate {
-	return FtAggregate{cs: append(b.get(), "FT.AGGREGATE"), ks: InitSlot}
+func (b *Builder) FtAggregate() (c FtAggregate) {
+	c = FtAggregate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.AGGREGATE")
+	return c
 }
 
-func (b *SBuilder) FtAggregate() SFtAggregate {
-	return SFtAggregate{cs: append(b.get(), "FT.AGGREGATE"), ks: InitSlot}
+func (b *SBuilder) FtAggregate() (c SFtAggregate) {
+	c = SFtAggregate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.AGGREGATE")
+	return c
 }
 
 func (c FtAggregate) Index(index string) FtAggregateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtAggregateIndex)(c)
 }
 
 func (c SFtAggregate) Index(index string) SFtAggregateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtAggregateIndex)(c)
 }
 
@@ -8773,12 +9281,12 @@ type FtAggregateApplyApply Completed
 type SFtAggregateApplyApply SCompleted
 
 func (c FtAggregateApplyApply) As(name string) FtAggregateApplyAs {
-	c.cs = append(c.cs, "AS", name)
+	c.cs.s = append(c.cs.s, "AS", name)
 	return (FtAggregateApplyAs)(c)
 }
 
 func (c SFtAggregateApplyApply) As(name string) SFtAggregateApplyAs {
-	c.cs = append(c.cs, "AS", name)
+	c.cs.s = append(c.cs.s, "AS", name)
 	return (SFtAggregateApplyAs)(c)
 }
 
@@ -8787,42 +9295,42 @@ type FtAggregateApplyAs Completed
 type SFtAggregateApplyAs SCompleted
 
 func (c FtAggregateApplyAs) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateApplyAs) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateApplyAs) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateApplyAs) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateApplyAs) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateApplyAs) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateApplyAs) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateApplyAs) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -8839,12 +9347,12 @@ type FtAggregateCursorCount Completed
 type SFtAggregateCursorCount SCompleted
 
 func (c FtAggregateCursorCount) Maxidle(idleTime int64) FtAggregateCursorMaxidle {
-	c.cs = append(c.cs, "MAXIDLE", strconv.FormatInt(idleTime, 10))
+	c.cs.s = append(c.cs.s, "MAXIDLE", strconv.FormatInt(idleTime, 10))
 	return (FtAggregateCursorMaxidle)(c)
 }
 
 func (c SFtAggregateCursorCount) Maxidle(idleTime int64) SFtAggregateCursorMaxidle {
-	c.cs = append(c.cs, "MAXIDLE", strconv.FormatInt(idleTime, 10))
+	c.cs.s = append(c.cs.s, "MAXIDLE", strconv.FormatInt(idleTime, 10))
 	return (SFtAggregateCursorMaxidle)(c)
 }
 
@@ -8873,22 +9381,22 @@ type FtAggregateCursorWithcursor Completed
 type SFtAggregateCursorWithcursor SCompleted
 
 func (c FtAggregateCursorWithcursor) Count(readSize int64) FtAggregateCursorCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(readSize, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(readSize, 10))
 	return (FtAggregateCursorCount)(c)
 }
 
 func (c SFtAggregateCursorWithcursor) Count(readSize int64) SFtAggregateCursorCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(readSize, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(readSize, 10))
 	return (SFtAggregateCursorCount)(c)
 }
 
 func (c FtAggregateCursorWithcursor) Maxidle(idleTime int64) FtAggregateCursorMaxidle {
-	c.cs = append(c.cs, "MAXIDLE", strconv.FormatInt(idleTime, 10))
+	c.cs.s = append(c.cs.s, "MAXIDLE", strconv.FormatInt(idleTime, 10))
 	return (FtAggregateCursorMaxidle)(c)
 }
 
 func (c SFtAggregateCursorWithcursor) Maxidle(idleTime int64) SFtAggregateCursorMaxidle {
-	c.cs = append(c.cs, "MAXIDLE", strconv.FormatInt(idleTime, 10))
+	c.cs.s = append(c.cs.s, "MAXIDLE", strconv.FormatInt(idleTime, 10))
 	return (SFtAggregateCursorMaxidle)(c)
 }
 
@@ -8905,12 +9413,12 @@ type FtAggregateFilter Completed
 type SFtAggregateFilter SCompleted
 
 func (c FtAggregateFilter) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateFilter) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -8927,12 +9435,12 @@ type FtAggregateGroupbyGroupby Completed
 type SFtAggregateGroupbyGroupby SCompleted
 
 func (c FtAggregateGroupbyGroupby) Property(property ...string) FtAggregateGroupbyProperty {
-	c.cs = append(c.cs, property...)
+	c.cs.s = append(c.cs.s, property...)
 	return (FtAggregateGroupbyProperty)(c)
 }
 
 func (c SFtAggregateGroupbyGroupby) Property(property ...string) SFtAggregateGroupbyProperty {
-	c.cs = append(c.cs, property...)
+	c.cs.s = append(c.cs.s, property...)
 	return (SFtAggregateGroupbyProperty)(c)
 }
 
@@ -8941,82 +9449,82 @@ type FtAggregateGroupbyProperty Completed
 type SFtAggregateGroupbyProperty SCompleted
 
 func (c FtAggregateGroupbyProperty) Property(property ...string) FtAggregateGroupbyProperty {
-	c.cs = append(c.cs, property...)
+	c.cs.s = append(c.cs.s, property...)
 	return c
 }
 
 func (c SFtAggregateGroupbyProperty) Property(property ...string) SFtAggregateGroupbyProperty {
-	c.cs = append(c.cs, property...)
+	c.cs.s = append(c.cs.s, property...)
 	return c
 }
 
 func (c FtAggregateGroupbyProperty) Reduce(function string) FtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (FtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Reduce(function string) SFtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (SFtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateGroupbyProperty) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateGroupbyProperty) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9033,92 +9541,92 @@ type FtAggregateGroupbyReduceArg Completed
 type SFtAggregateGroupbyReduceArg SCompleted
 
 func (c FtAggregateGroupbyReduceArg) Arg(arg ...string) FtAggregateGroupbyReduceArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SFtAggregateGroupbyReduceArg) Arg(arg ...string) SFtAggregateGroupbyReduceArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c FtAggregateGroupbyReduceArg) As(name string) FtAggregateGroupbyReduceAs {
-	c.cs = append(c.cs, "AS", name)
+	c.cs.s = append(c.cs.s, "AS", name)
 	return (FtAggregateGroupbyReduceAs)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) As(name string) SFtAggregateGroupbyReduceAs {
-	c.cs = append(c.cs, "AS", name)
+	c.cs.s = append(c.cs.s, "AS", name)
 	return (SFtAggregateGroupbyReduceAs)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Reduce(function string) FtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (FtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Reduce(function string) SFtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (SFtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateGroupbyReduceArg) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateGroupbyReduceArg) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9135,72 +9643,72 @@ type FtAggregateGroupbyReduceAs Completed
 type SFtAggregateGroupbyReduceAs SCompleted
 
 func (c FtAggregateGroupbyReduceAs) Reduce(function string) FtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (FtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Reduce(function string) SFtAggregateGroupbyReduceReduce {
-	c.cs = append(c.cs, "REDUCE", function)
+	c.cs.s = append(c.cs.s, "REDUCE", function)
 	return (SFtAggregateGroupbyReduceReduce)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateGroupbyReduceAs) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateGroupbyReduceAs) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9217,12 +9725,12 @@ type FtAggregateGroupbyReduceNargs Completed
 type SFtAggregateGroupbyReduceNargs SCompleted
 
 func (c FtAggregateGroupbyReduceNargs) Arg(arg ...string) FtAggregateGroupbyReduceArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (FtAggregateGroupbyReduceArg)(c)
 }
 
 func (c SFtAggregateGroupbyReduceNargs) Arg(arg ...string) SFtAggregateGroupbyReduceArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SFtAggregateGroupbyReduceArg)(c)
 }
 
@@ -9231,12 +9739,12 @@ type FtAggregateGroupbyReduceReduce Completed
 type SFtAggregateGroupbyReduceReduce SCompleted
 
 func (c FtAggregateGroupbyReduceReduce) Nargs(nargs int64) FtAggregateGroupbyReduceNargs {
-	c.cs = append(c.cs, strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyReduceNargs)(c)
 }
 
 func (c SFtAggregateGroupbyReduceReduce) Nargs(nargs int64) SFtAggregateGroupbyReduceNargs {
-	c.cs = append(c.cs, strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyReduceNargs)(c)
 }
 
@@ -9245,12 +9753,12 @@ type FtAggregateIndex Completed
 type SFtAggregateIndex SCompleted
 
 func (c FtAggregateIndex) Query(query string) FtAggregateQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (FtAggregateQuery)(c)
 }
 
 func (c SFtAggregateIndex) Query(query string) SFtAggregateQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SFtAggregateQuery)(c)
 }
 
@@ -9259,12 +9767,12 @@ type FtAggregateLimitLimit Completed
 type SFtAggregateLimitLimit SCompleted
 
 func (c FtAggregateLimitLimit) OffsetNum(offset int64, num int64) FtAggregateLimitOffsetNum {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
 	return (FtAggregateLimitOffsetNum)(c)
 }
 
 func (c SFtAggregateLimitLimit) OffsetNum(offset int64, num int64) SFtAggregateLimitOffsetNum {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
 	return (SFtAggregateLimitOffsetNum)(c)
 }
 
@@ -9273,22 +9781,22 @@ type FtAggregateLimitOffsetNum Completed
 type SFtAggregateLimitOffsetNum SCompleted
 
 func (c FtAggregateLimitOffsetNum) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateLimitOffsetNum) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateLimitOffsetNum) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateLimitOffsetNum) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9305,82 +9813,82 @@ type FtAggregateLoadField Completed
 type SFtAggregateLoadField SCompleted
 
 func (c FtAggregateLoadField) Field(field ...string) FtAggregateLoadField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SFtAggregateLoadField) Field(field ...string) SFtAggregateLoadField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c FtAggregateLoadField) LoadAll() FtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (FtAggregateLoadallLoadAll)(c)
 }
 
 func (c SFtAggregateLoadField) LoadAll() SFtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (SFtAggregateLoadallLoadAll)(c)
 }
 
 func (c FtAggregateLoadField) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateLoadField) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateLoadField) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateLoadField) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateLoadField) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateLoadField) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateLoadField) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateLoadField) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateLoadField) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateLoadField) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateLoadField) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateLoadField) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9397,12 +9905,12 @@ type FtAggregateLoadLoad Completed
 type SFtAggregateLoadLoad SCompleted
 
 func (c FtAggregateLoadLoad) Field(field ...string) FtAggregateLoadField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (FtAggregateLoadField)(c)
 }
 
 func (c SFtAggregateLoadLoad) Field(field ...string) SFtAggregateLoadField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SFtAggregateLoadField)(c)
 }
 
@@ -9411,62 +9919,62 @@ type FtAggregateLoadallLoadAll Completed
 type SFtAggregateLoadallLoadAll SCompleted
 
 func (c FtAggregateLoadallLoadAll) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateLoadallLoadAll) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateLoadallLoadAll) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateLoadallLoadAll) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateLoadallLoadAll) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateLoadallLoadAll) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateLoadallLoadAll) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9483,92 +9991,92 @@ type FtAggregateQuery Completed
 type SFtAggregateQuery SCompleted
 
 func (c FtAggregateQuery) Verbatim() FtAggregateVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (FtAggregateVerbatim)(c)
 }
 
 func (c SFtAggregateQuery) Verbatim() SFtAggregateVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (SFtAggregateVerbatim)(c)
 }
 
 func (c FtAggregateQuery) Load(count string) FtAggregateLoadLoad {
-	c.cs = append(c.cs, "LOAD", count)
+	c.cs.s = append(c.cs.s, "LOAD", count)
 	return (FtAggregateLoadLoad)(c)
 }
 
 func (c SFtAggregateQuery) Load(count string) SFtAggregateLoadLoad {
-	c.cs = append(c.cs, "LOAD", count)
+	c.cs.s = append(c.cs.s, "LOAD", count)
 	return (SFtAggregateLoadLoad)(c)
 }
 
 func (c FtAggregateQuery) LoadAll() FtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (FtAggregateLoadallLoadAll)(c)
 }
 
 func (c SFtAggregateQuery) LoadAll() SFtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (SFtAggregateLoadallLoadAll)(c)
 }
 
 func (c FtAggregateQuery) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateQuery) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateQuery) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateQuery) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateQuery) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateQuery) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateQuery) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateQuery) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateQuery) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateQuery) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateQuery) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateQuery) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9585,62 +10093,62 @@ type FtAggregateSortbyFieldsOrderAsc Completed
 type SFtAggregateSortbyFieldsOrderAsc SCompleted
 
 func (c FtAggregateSortbyFieldsOrderAsc) Property(property string) FtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (FtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Property(property string) SFtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (SFtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderAsc) Max(num int64) FtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (FtAggregateSortbyMax)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Max(num int64) SFtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (SFtAggregateSortbyMax)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderAsc) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderAsc) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderAsc) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderAsc) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderAsc) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9657,62 +10165,62 @@ type FtAggregateSortbyFieldsOrderDesc Completed
 type SFtAggregateSortbyFieldsOrderDesc SCompleted
 
 func (c FtAggregateSortbyFieldsOrderDesc) Property(property string) FtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (FtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Property(property string) SFtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (SFtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderDesc) Max(num int64) FtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (FtAggregateSortbyMax)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Max(num int64) SFtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (SFtAggregateSortbyMax)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderDesc) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderDesc) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderDesc) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateSortbyFieldsOrderDesc) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateSortbyFieldsOrderDesc) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9729,22 +10237,22 @@ type FtAggregateSortbyFieldsProperty Completed
 type SFtAggregateSortbyFieldsProperty SCompleted
 
 func (c FtAggregateSortbyFieldsProperty) Asc() FtAggregateSortbyFieldsOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (FtAggregateSortbyFieldsOrderAsc)(c)
 }
 
 func (c SFtAggregateSortbyFieldsProperty) Asc() SFtAggregateSortbyFieldsOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SFtAggregateSortbyFieldsOrderAsc)(c)
 }
 
 func (c FtAggregateSortbyFieldsProperty) Desc() FtAggregateSortbyFieldsOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (FtAggregateSortbyFieldsOrderDesc)(c)
 }
 
 func (c SFtAggregateSortbyFieldsProperty) Desc() SFtAggregateSortbyFieldsOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SFtAggregateSortbyFieldsOrderDesc)(c)
 }
 
@@ -9753,42 +10261,42 @@ type FtAggregateSortbyMax Completed
 type SFtAggregateSortbyMax SCompleted
 
 func (c FtAggregateSortbyMax) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateSortbyMax) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateSortbyMax) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateSortbyMax) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateSortbyMax) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateSortbyMax) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateSortbyMax) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateSortbyMax) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9805,62 +10313,62 @@ type FtAggregateSortbySortby Completed
 type SFtAggregateSortbySortby SCompleted
 
 func (c FtAggregateSortbySortby) Property(property string) FtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (FtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c SFtAggregateSortbySortby) Property(property string) SFtAggregateSortbyFieldsProperty {
-	c.cs = append(c.cs, property)
+	c.cs.s = append(c.cs.s, property)
 	return (SFtAggregateSortbyFieldsProperty)(c)
 }
 
 func (c FtAggregateSortbySortby) Max(num int64) FtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (FtAggregateSortbyMax)(c)
 }
 
 func (c SFtAggregateSortbySortby) Max(num int64) SFtAggregateSortbyMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(num, 10))
 	return (SFtAggregateSortbyMax)(c)
 }
 
 func (c FtAggregateSortbySortby) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateSortbySortby) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateSortbySortby) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateSortbySortby) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateSortbySortby) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateSortbySortby) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateSortbySortby) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateSortbySortby) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9877,82 +10385,82 @@ type FtAggregateVerbatim Completed
 type SFtAggregateVerbatim SCompleted
 
 func (c FtAggregateVerbatim) Load(count string) FtAggregateLoadLoad {
-	c.cs = append(c.cs, "LOAD", count)
+	c.cs.s = append(c.cs.s, "LOAD", count)
 	return (FtAggregateLoadLoad)(c)
 }
 
 func (c SFtAggregateVerbatim) Load(count string) SFtAggregateLoadLoad {
-	c.cs = append(c.cs, "LOAD", count)
+	c.cs.s = append(c.cs.s, "LOAD", count)
 	return (SFtAggregateLoadLoad)(c)
 }
 
 func (c FtAggregateVerbatim) LoadAll() FtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (FtAggregateLoadallLoadAll)(c)
 }
 
 func (c SFtAggregateVerbatim) LoadAll() SFtAggregateLoadallLoadAll {
-	c.cs = append(c.cs, "LOAD", "*")
+	c.cs.s = append(c.cs.s, "LOAD", "*")
 	return (SFtAggregateLoadallLoadAll)(c)
 }
 
 func (c FtAggregateVerbatim) Groupby(nargs int64) FtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateGroupbyGroupby)(c)
 }
 
 func (c SFtAggregateVerbatim) Groupby(nargs int64) SFtAggregateGroupbyGroupby {
-	c.cs = append(c.cs, "GROUPBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "GROUPBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateGroupbyGroupby)(c)
 }
 
 func (c FtAggregateVerbatim) Sortby(nargs int64) FtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (FtAggregateSortbySortby)(c)
 }
 
 func (c SFtAggregateVerbatim) Sortby(nargs int64) SFtAggregateSortbySortby {
-	c.cs = append(c.cs, "SORTBY", strconv.FormatInt(nargs, 10))
+	c.cs.s = append(c.cs.s, "SORTBY", strconv.FormatInt(nargs, 10))
 	return (SFtAggregateSortbySortby)(c)
 }
 
 func (c FtAggregateVerbatim) Apply(expression string) FtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (FtAggregateApplyApply)(c)
 }
 
 func (c SFtAggregateVerbatim) Apply(expression string) SFtAggregateApplyApply {
-	c.cs = append(c.cs, "APPLY", expression)
+	c.cs.s = append(c.cs.s, "APPLY", expression)
 	return (SFtAggregateApplyApply)(c)
 }
 
 func (c FtAggregateVerbatim) Limit() FtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtAggregateLimitLimit)(c)
 }
 
 func (c SFtAggregateVerbatim) Limit() SFtAggregateLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtAggregateLimitLimit)(c)
 }
 
 func (c FtAggregateVerbatim) Filter(filter string) FtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (FtAggregateFilter)(c)
 }
 
 func (c SFtAggregateVerbatim) Filter(filter string) SFtAggregateFilter {
-	c.cs = append(c.cs, "FILTER", filter)
+	c.cs.s = append(c.cs.s, "FILTER", filter)
 	return (SFtAggregateFilter)(c)
 }
 
 func (c FtAggregateVerbatim) Withcursor() FtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (FtAggregateCursorWithcursor)(c)
 }
 
 func (c SFtAggregateVerbatim) Withcursor() SFtAggregateCursorWithcursor {
-	c.cs = append(c.cs, "WITHCURSOR")
+	c.cs.s = append(c.cs.s, "WITHCURSOR")
 	return (SFtAggregateCursorWithcursor)(c)
 }
 
@@ -9968,21 +10476,25 @@ type FtAliasadd Completed
 
 type SFtAliasadd SCompleted
 
-func (b *Builder) FtAliasadd() FtAliasadd {
-	return FtAliasadd{cs: append(b.get(), "FT.ALIASADD"), ks: InitSlot}
+func (b *Builder) FtAliasadd() (c FtAliasadd) {
+	c = FtAliasadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASADD")
+	return c
 }
 
-func (b *SBuilder) FtAliasadd() SFtAliasadd {
-	return SFtAliasadd{cs: append(b.get(), "FT.ALIASADD"), ks: InitSlot}
+func (b *SBuilder) FtAliasadd() (c SFtAliasadd) {
+	c = SFtAliasadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASADD")
+	return c
 }
 
 func (c FtAliasadd) Alias(alias string) FtAliasaddAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (FtAliasaddAlias)(c)
 }
 
 func (c SFtAliasadd) Alias(alias string) SFtAliasaddAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (SFtAliasaddAlias)(c)
 }
 
@@ -9991,12 +10503,12 @@ type FtAliasaddAlias Completed
 type SFtAliasaddAlias SCompleted
 
 func (c FtAliasaddAlias) Index(index string) FtAliasaddIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtAliasaddIndex)(c)
 }
 
 func (c SFtAliasaddAlias) Index(index string) SFtAliasaddIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtAliasaddIndex)(c)
 }
 
@@ -10016,21 +10528,25 @@ type FtAliasdel Completed
 
 type SFtAliasdel SCompleted
 
-func (b *Builder) FtAliasdel() FtAliasdel {
-	return FtAliasdel{cs: append(b.get(), "FT.ALIASDEL"), ks: InitSlot}
+func (b *Builder) FtAliasdel() (c FtAliasdel) {
+	c = FtAliasdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASDEL")
+	return c
 }
 
-func (b *SBuilder) FtAliasdel() SFtAliasdel {
-	return SFtAliasdel{cs: append(b.get(), "FT.ALIASDEL"), ks: InitSlot}
+func (b *SBuilder) FtAliasdel() (c SFtAliasdel) {
+	c = SFtAliasdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASDEL")
+	return c
 }
 
 func (c FtAliasdel) Alias(alias string) FtAliasdelAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (FtAliasdelAlias)(c)
 }
 
 func (c SFtAliasdel) Alias(alias string) SFtAliasdelAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (SFtAliasdelAlias)(c)
 }
 
@@ -10050,21 +10566,25 @@ type FtAliasupdate Completed
 
 type SFtAliasupdate SCompleted
 
-func (b *Builder) FtAliasupdate() FtAliasupdate {
-	return FtAliasupdate{cs: append(b.get(), "FT.ALIASUPDATE"), ks: InitSlot}
+func (b *Builder) FtAliasupdate() (c FtAliasupdate) {
+	c = FtAliasupdate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASUPDATE")
+	return c
 }
 
-func (b *SBuilder) FtAliasupdate() SFtAliasupdate {
-	return SFtAliasupdate{cs: append(b.get(), "FT.ALIASUPDATE"), ks: InitSlot}
+func (b *SBuilder) FtAliasupdate() (c SFtAliasupdate) {
+	c = SFtAliasupdate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALIASUPDATE")
+	return c
 }
 
 func (c FtAliasupdate) Alias(alias string) FtAliasupdateAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (FtAliasupdateAlias)(c)
 }
 
 func (c SFtAliasupdate) Alias(alias string) SFtAliasupdateAlias {
-	c.cs = append(c.cs, alias)
+	c.cs.s = append(c.cs.s, alias)
 	return (SFtAliasupdateAlias)(c)
 }
 
@@ -10073,12 +10593,12 @@ type FtAliasupdateAlias Completed
 type SFtAliasupdateAlias SCompleted
 
 func (c FtAliasupdateAlias) Index(index string) FtAliasupdateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtAliasupdateIndex)(c)
 }
 
 func (c SFtAliasupdateAlias) Index(index string) SFtAliasupdateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtAliasupdateIndex)(c)
 }
 
@@ -10098,21 +10618,25 @@ type FtAlter Completed
 
 type SFtAlter SCompleted
 
-func (b *Builder) FtAlter() FtAlter {
-	return FtAlter{cs: append(b.get(), "FT.ALTER"), ks: InitSlot}
+func (b *Builder) FtAlter() (c FtAlter) {
+	c = FtAlter{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALTER")
+	return c
 }
 
-func (b *SBuilder) FtAlter() SFtAlter {
-	return SFtAlter{cs: append(b.get(), "FT.ALTER"), ks: InitSlot}
+func (b *SBuilder) FtAlter() (c SFtAlter) {
+	c = SFtAlter{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.ALTER")
+	return c
 }
 
 func (c FtAlter) Index(index string) FtAlterIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtAlterIndex)(c)
 }
 
 func (c SFtAlter) Index(index string) SFtAlterIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtAlterIndex)(c)
 }
 
@@ -10121,12 +10645,12 @@ type FtAlterAdd Completed
 type SFtAlterAdd SCompleted
 
 func (c FtAlterAdd) Field(field string) FtAlterField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (FtAlterField)(c)
 }
 
 func (c SFtAlterAdd) Field(field string) SFtAlterField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SFtAlterField)(c)
 }
 
@@ -10135,12 +10659,12 @@ type FtAlterField Completed
 type SFtAlterField SCompleted
 
 func (c FtAlterField) Options(options string) FtAlterOptions {
-	c.cs = append(c.cs, options)
+	c.cs.s = append(c.cs.s, options)
 	return (FtAlterOptions)(c)
 }
 
 func (c SFtAlterField) Options(options string) SFtAlterOptions {
-	c.cs = append(c.cs, options)
+	c.cs.s = append(c.cs.s, options)
 	return (SFtAlterOptions)(c)
 }
 
@@ -10149,12 +10673,12 @@ type FtAlterIndex Completed
 type SFtAlterIndex SCompleted
 
 func (c FtAlterIndex) Schema() FtAlterSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtAlterSchema)(c)
 }
 
 func (c SFtAlterIndex) Schema() SFtAlterSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtAlterSchema)(c)
 }
 
@@ -10175,12 +10699,12 @@ type FtAlterSchema Completed
 type SFtAlterSchema SCompleted
 
 func (c FtAlterSchema) Add() FtAlterAdd {
-	c.cs = append(c.cs, "ADD")
+	c.cs.s = append(c.cs.s, "ADD")
 	return (FtAlterAdd)(c)
 }
 
 func (c SFtAlterSchema) Add() SFtAlterAdd {
-	c.cs = append(c.cs, "ADD")
+	c.cs.s = append(c.cs.s, "ADD")
 	return (SFtAlterAdd)(c)
 }
 
@@ -10188,21 +10712,25 @@ type FtConfigGet Completed
 
 type SFtConfigGet SCompleted
 
-func (b *Builder) FtConfigGet() FtConfigGet {
-	return FtConfigGet{cs: append(b.get(), "FT.CONFIG", "GET"), ks: InitSlot}
+func (b *Builder) FtConfigGet() (c FtConfigGet) {
+	c = FtConfigGet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "GET")
+	return c
 }
 
-func (b *SBuilder) FtConfigGet() SFtConfigGet {
-	return SFtConfigGet{cs: append(b.get(), "FT.CONFIG", "GET"), ks: InitSlot}
+func (b *SBuilder) FtConfigGet() (c SFtConfigGet) {
+	c = SFtConfigGet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "GET")
+	return c
 }
 
 func (c FtConfigGet) Option(option string) FtConfigGetOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (FtConfigGetOption)(c)
 }
 
 func (c SFtConfigGet) Option(option string) SFtConfigGetOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (SFtConfigGetOption)(c)
 }
 
@@ -10211,12 +10739,12 @@ type FtConfigGetOption Completed
 type SFtConfigGetOption SCompleted
 
 func (c FtConfigGetOption) Value(value string) FtConfigGetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (FtConfigGetValue)(c)
 }
 
 func (c SFtConfigGetOption) Value(value string) SFtConfigGetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SFtConfigGetValue)(c)
 }
 
@@ -10236,21 +10764,25 @@ type FtConfigHelp Completed
 
 type SFtConfigHelp SCompleted
 
-func (b *Builder) FtConfigHelp() FtConfigHelp {
-	return FtConfigHelp{cs: append(b.get(), "FT.CONFIG", "HELP"), ks: InitSlot}
+func (b *Builder) FtConfigHelp() (c FtConfigHelp) {
+	c = FtConfigHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "HELP")
+	return c
 }
 
-func (b *SBuilder) FtConfigHelp() SFtConfigHelp {
-	return SFtConfigHelp{cs: append(b.get(), "FT.CONFIG", "HELP"), ks: InitSlot}
+func (b *SBuilder) FtConfigHelp() (c SFtConfigHelp) {
+	c = SFtConfigHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "HELP")
+	return c
 }
 
 func (c FtConfigHelp) Option(option string) FtConfigHelpOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (FtConfigHelpOption)(c)
 }
 
 func (c SFtConfigHelp) Option(option string) SFtConfigHelpOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (SFtConfigHelpOption)(c)
 }
 
@@ -10270,21 +10802,25 @@ type FtConfigSet Completed
 
 type SFtConfigSet SCompleted
 
-func (b *Builder) FtConfigSet() FtConfigSet {
-	return FtConfigSet{cs: append(b.get(), "FT.CONFIG", "SET"), ks: InitSlot}
+func (b *Builder) FtConfigSet() (c FtConfigSet) {
+	c = FtConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "SET")
+	return c
 }
 
-func (b *SBuilder) FtConfigSet() SFtConfigSet {
-	return SFtConfigSet{cs: append(b.get(), "FT.CONFIG", "SET"), ks: InitSlot}
+func (b *SBuilder) FtConfigSet() (c SFtConfigSet) {
+	c = SFtConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CONFIG", "SET")
+	return c
 }
 
 func (c FtConfigSet) Option(option string) FtConfigSetOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (FtConfigSetOption)(c)
 }
 
 func (c SFtConfigSet) Option(option string) SFtConfigSetOption {
-	c.cs = append(c.cs, option)
+	c.cs.s = append(c.cs.s, option)
 	return (SFtConfigSetOption)(c)
 }
 
@@ -10304,21 +10840,25 @@ type FtCreate Completed
 
 type SFtCreate SCompleted
 
-func (b *Builder) FtCreate() FtCreate {
-	return FtCreate{cs: append(b.get(), "FT.CREATE"), ks: InitSlot}
+func (b *Builder) FtCreate() (c FtCreate) {
+	c = FtCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CREATE")
+	return c
 }
 
-func (b *SBuilder) FtCreate() SFtCreate {
-	return SFtCreate{cs: append(b.get(), "FT.CREATE"), ks: InitSlot}
+func (b *SBuilder) FtCreate() (c SFtCreate) {
+	c = SFtCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CREATE")
+	return c
 }
 
 func (c FtCreate) Index(index string) FtCreateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtCreateIndex)(c)
 }
 
 func (c SFtCreate) Index(index string) SFtCreateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtCreateIndex)(c)
 }
 
@@ -10327,42 +10867,42 @@ type FtCreateFieldAs Completed
 type SFtCreateFieldAs SCompleted
 
 func (c FtCreateFieldAs) Text() FtCreateFieldFieldTypeText {
-	c.cs = append(c.cs, "TEXT")
+	c.cs.s = append(c.cs.s, "TEXT")
 	return (FtCreateFieldFieldTypeText)(c)
 }
 
 func (c SFtCreateFieldAs) Text() SFtCreateFieldFieldTypeText {
-	c.cs = append(c.cs, "TEXT")
+	c.cs.s = append(c.cs.s, "TEXT")
 	return (SFtCreateFieldFieldTypeText)(c)
 }
 
 func (c FtCreateFieldAs) Tag() FtCreateFieldFieldTypeTag {
-	c.cs = append(c.cs, "TAG")
+	c.cs.s = append(c.cs.s, "TAG")
 	return (FtCreateFieldFieldTypeTag)(c)
 }
 
 func (c SFtCreateFieldAs) Tag() SFtCreateFieldFieldTypeTag {
-	c.cs = append(c.cs, "TAG")
+	c.cs.s = append(c.cs.s, "TAG")
 	return (SFtCreateFieldFieldTypeTag)(c)
 }
 
 func (c FtCreateFieldAs) Numeric() FtCreateFieldFieldTypeNumeric {
-	c.cs = append(c.cs, "NUMERIC")
+	c.cs.s = append(c.cs.s, "NUMERIC")
 	return (FtCreateFieldFieldTypeNumeric)(c)
 }
 
 func (c SFtCreateFieldAs) Numeric() SFtCreateFieldFieldTypeNumeric {
-	c.cs = append(c.cs, "NUMERIC")
+	c.cs.s = append(c.cs.s, "NUMERIC")
 	return (SFtCreateFieldFieldTypeNumeric)(c)
 }
 
 func (c FtCreateFieldAs) Geo() FtCreateFieldFieldTypeGeo {
-	c.cs = append(c.cs, "GEO")
+	c.cs.s = append(c.cs.s, "GEO")
 	return (FtCreateFieldFieldTypeGeo)(c)
 }
 
 func (c SFtCreateFieldAs) Geo() SFtCreateFieldFieldTypeGeo {
-	c.cs = append(c.cs, "GEO")
+	c.cs.s = append(c.cs.s, "GEO")
 	return (SFtCreateFieldFieldTypeGeo)(c)
 }
 
@@ -10371,52 +10911,52 @@ type FtCreateFieldFieldName Completed
 type SFtCreateFieldFieldName SCompleted
 
 func (c FtCreateFieldFieldName) As(alias string) FtCreateFieldAs {
-	c.cs = append(c.cs, "AS", alias)
+	c.cs.s = append(c.cs.s, "AS", alias)
 	return (FtCreateFieldAs)(c)
 }
 
 func (c SFtCreateFieldFieldName) As(alias string) SFtCreateFieldAs {
-	c.cs = append(c.cs, "AS", alias)
+	c.cs.s = append(c.cs.s, "AS", alias)
 	return (SFtCreateFieldAs)(c)
 }
 
 func (c FtCreateFieldFieldName) Text() FtCreateFieldFieldTypeText {
-	c.cs = append(c.cs, "TEXT")
+	c.cs.s = append(c.cs.s, "TEXT")
 	return (FtCreateFieldFieldTypeText)(c)
 }
 
 func (c SFtCreateFieldFieldName) Text() SFtCreateFieldFieldTypeText {
-	c.cs = append(c.cs, "TEXT")
+	c.cs.s = append(c.cs.s, "TEXT")
 	return (SFtCreateFieldFieldTypeText)(c)
 }
 
 func (c FtCreateFieldFieldName) Tag() FtCreateFieldFieldTypeTag {
-	c.cs = append(c.cs, "TAG")
+	c.cs.s = append(c.cs.s, "TAG")
 	return (FtCreateFieldFieldTypeTag)(c)
 }
 
 func (c SFtCreateFieldFieldName) Tag() SFtCreateFieldFieldTypeTag {
-	c.cs = append(c.cs, "TAG")
+	c.cs.s = append(c.cs.s, "TAG")
 	return (SFtCreateFieldFieldTypeTag)(c)
 }
 
 func (c FtCreateFieldFieldName) Numeric() FtCreateFieldFieldTypeNumeric {
-	c.cs = append(c.cs, "NUMERIC")
+	c.cs.s = append(c.cs.s, "NUMERIC")
 	return (FtCreateFieldFieldTypeNumeric)(c)
 }
 
 func (c SFtCreateFieldFieldName) Numeric() SFtCreateFieldFieldTypeNumeric {
-	c.cs = append(c.cs, "NUMERIC")
+	c.cs.s = append(c.cs.s, "NUMERIC")
 	return (SFtCreateFieldFieldTypeNumeric)(c)
 }
 
 func (c FtCreateFieldFieldName) Geo() FtCreateFieldFieldTypeGeo {
-	c.cs = append(c.cs, "GEO")
+	c.cs.s = append(c.cs.s, "GEO")
 	return (FtCreateFieldFieldTypeGeo)(c)
 }
 
 func (c SFtCreateFieldFieldName) Geo() SFtCreateFieldFieldTypeGeo {
-	c.cs = append(c.cs, "GEO")
+	c.cs.s = append(c.cs.s, "GEO")
 	return (SFtCreateFieldFieldTypeGeo)(c)
 }
 
@@ -10425,32 +10965,32 @@ type FtCreateFieldFieldTypeGeo Completed
 type SFtCreateFieldFieldTypeGeo SCompleted
 
 func (c FtCreateFieldFieldTypeGeo) Sortable() FtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (FtCreateFieldSortableSortable)(c)
 }
 
 func (c SFtCreateFieldFieldTypeGeo) Sortable() SFtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (SFtCreateFieldSortableSortable)(c)
 }
 
 func (c FtCreateFieldFieldTypeGeo) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldFieldTypeGeo) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldFieldTypeGeo) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldFieldTypeGeo) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10467,32 +11007,32 @@ type FtCreateFieldFieldTypeNumeric Completed
 type SFtCreateFieldFieldTypeNumeric SCompleted
 
 func (c FtCreateFieldFieldTypeNumeric) Sortable() FtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (FtCreateFieldSortableSortable)(c)
 }
 
 func (c SFtCreateFieldFieldTypeNumeric) Sortable() SFtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (SFtCreateFieldSortableSortable)(c)
 }
 
 func (c FtCreateFieldFieldTypeNumeric) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldFieldTypeNumeric) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldFieldTypeNumeric) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldFieldTypeNumeric) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10509,32 +11049,32 @@ type FtCreateFieldFieldTypeTag Completed
 type SFtCreateFieldFieldTypeTag SCompleted
 
 func (c FtCreateFieldFieldTypeTag) Sortable() FtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (FtCreateFieldSortableSortable)(c)
 }
 
 func (c SFtCreateFieldFieldTypeTag) Sortable() SFtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (SFtCreateFieldSortableSortable)(c)
 }
 
 func (c FtCreateFieldFieldTypeTag) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldFieldTypeTag) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldFieldTypeTag) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldFieldTypeTag) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10551,32 +11091,32 @@ type FtCreateFieldFieldTypeText Completed
 type SFtCreateFieldFieldTypeText SCompleted
 
 func (c FtCreateFieldFieldTypeText) Sortable() FtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (FtCreateFieldSortableSortable)(c)
 }
 
 func (c SFtCreateFieldFieldTypeText) Sortable() SFtCreateFieldSortableSortable {
-	c.cs = append(c.cs, "SORTABLE")
+	c.cs.s = append(c.cs.s, "SORTABLE")
 	return (SFtCreateFieldSortableSortable)(c)
 }
 
 func (c FtCreateFieldFieldTypeText) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldFieldTypeText) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldFieldTypeText) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldFieldTypeText) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10593,12 +11133,12 @@ type FtCreateFieldNoindex Completed
 type SFtCreateFieldNoindex SCompleted
 
 func (c FtCreateFieldNoindex) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldNoindex) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10615,32 +11155,32 @@ type FtCreateFieldSortableSortable Completed
 type SFtCreateFieldSortableSortable SCompleted
 
 func (c FtCreateFieldSortableSortable) Unf() FtCreateFieldSortableUnf {
-	c.cs = append(c.cs, "UNF")
+	c.cs.s = append(c.cs.s, "UNF")
 	return (FtCreateFieldSortableUnf)(c)
 }
 
 func (c SFtCreateFieldSortableSortable) Unf() SFtCreateFieldSortableUnf {
-	c.cs = append(c.cs, "UNF")
+	c.cs.s = append(c.cs.s, "UNF")
 	return (SFtCreateFieldSortableUnf)(c)
 }
 
 func (c FtCreateFieldSortableSortable) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldSortableSortable) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldSortableSortable) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldSortableSortable) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10657,22 +11197,22 @@ type FtCreateFieldSortableUnf Completed
 type SFtCreateFieldSortableUnf SCompleted
 
 func (c FtCreateFieldSortableUnf) Noindex() FtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (FtCreateFieldNoindex)(c)
 }
 
 func (c SFtCreateFieldSortableUnf) Noindex() SFtCreateFieldNoindex {
-	c.cs = append(c.cs, "NOINDEX")
+	c.cs.s = append(c.cs.s, "NOINDEX")
 	return (SFtCreateFieldNoindex)(c)
 }
 
 func (c FtCreateFieldSortableUnf) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateFieldSortableUnf) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -10689,162 +11229,162 @@ type FtCreateIndex Completed
 type SFtCreateIndex SCompleted
 
 func (c FtCreateIndex) OnHash() FtCreateOnHash {
-	c.cs = append(c.cs, "ON", "HASH")
+	c.cs.s = append(c.cs.s, "ON", "HASH")
 	return (FtCreateOnHash)(c)
 }
 
 func (c SFtCreateIndex) OnHash() SFtCreateOnHash {
-	c.cs = append(c.cs, "ON", "HASH")
+	c.cs.s = append(c.cs.s, "ON", "HASH")
 	return (SFtCreateOnHash)(c)
 }
 
 func (c FtCreateIndex) OnJson() FtCreateOnJson {
-	c.cs = append(c.cs, "ON", "JSON")
+	c.cs.s = append(c.cs.s, "ON", "JSON")
 	return (FtCreateOnJson)(c)
 }
 
 func (c SFtCreateIndex) OnJson() SFtCreateOnJson {
-	c.cs = append(c.cs, "ON", "JSON")
+	c.cs.s = append(c.cs.s, "ON", "JSON")
 	return (SFtCreateOnJson)(c)
 }
 
 func (c FtCreateIndex) Prefix(count int64) FtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (FtCreatePrefixCount)(c)
 }
 
 func (c SFtCreateIndex) Prefix(count int64) SFtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (SFtCreatePrefixCount)(c)
 }
 
 func (c FtCreateIndex) Language(defaultLang string) FtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (FtCreateLanguage)(c)
 }
 
 func (c SFtCreateIndex) Language(defaultLang string) SFtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (SFtCreateLanguage)(c)
 }
 
 func (c FtCreateIndex) LanguageField(langAttribute string) FtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (FtCreateLanguageField)(c)
 }
 
 func (c SFtCreateIndex) LanguageField(langAttribute string) SFtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (SFtCreateLanguageField)(c)
 }
 
 func (c FtCreateIndex) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreateIndex) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreateIndex) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateIndex) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateIndex) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateIndex) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateIndex) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateIndex) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateIndex) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateIndex) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateIndex) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateIndex) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateIndex) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateIndex) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateIndex) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateIndex) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateIndex) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateIndex) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateIndex) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateIndex) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateIndex) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateIndex) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -10853,122 +11393,122 @@ type FtCreateLanguage Completed
 type SFtCreateLanguage SCompleted
 
 func (c FtCreateLanguage) LanguageField(langAttribute string) FtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (FtCreateLanguageField)(c)
 }
 
 func (c SFtCreateLanguage) LanguageField(langAttribute string) SFtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (SFtCreateLanguageField)(c)
 }
 
 func (c FtCreateLanguage) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreateLanguage) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreateLanguage) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateLanguage) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateLanguage) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateLanguage) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateLanguage) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateLanguage) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateLanguage) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateLanguage) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateLanguage) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateLanguage) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateLanguage) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateLanguage) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateLanguage) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateLanguage) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateLanguage) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateLanguage) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateLanguage) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateLanguage) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateLanguage) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateLanguage) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -10977,112 +11517,112 @@ type FtCreateLanguageField Completed
 type SFtCreateLanguageField SCompleted
 
 func (c FtCreateLanguageField) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreateLanguageField) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreateLanguageField) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateLanguageField) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateLanguageField) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateLanguageField) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateLanguageField) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateLanguageField) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateLanguageField) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateLanguageField) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateLanguageField) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateLanguageField) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateLanguageField) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateLanguageField) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateLanguageField) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateLanguageField) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateLanguageField) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateLanguageField) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateLanguageField) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateLanguageField) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateLanguageField) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateLanguageField) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11091,72 +11631,72 @@ type FtCreateMaxtextfields Completed
 type SFtCreateMaxtextfields SCompleted
 
 func (c FtCreateMaxtextfields) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateMaxtextfields) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateMaxtextfields) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateMaxtextfields) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateMaxtextfields) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateMaxtextfields) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateMaxtextfields) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateMaxtextfields) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateMaxtextfields) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateMaxtextfields) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateMaxtextfields) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateMaxtextfields) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateMaxtextfields) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateMaxtextfields) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11165,32 +11705,32 @@ type FtCreateNofields Completed
 type SFtCreateNofields SCompleted
 
 func (c FtCreateNofields) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateNofields) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateNofields) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateNofields) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateNofields) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateNofields) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11199,22 +11739,22 @@ type FtCreateNofreqs Completed
 type SFtCreateNofreqs SCompleted
 
 func (c FtCreateNofreqs) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateNofreqs) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateNofreqs) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateNofreqs) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11223,42 +11763,42 @@ type FtCreateNohl Completed
 type SFtCreateNohl SCompleted
 
 func (c FtCreateNohl) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateNohl) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateNohl) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateNohl) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateNohl) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateNohl) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateNohl) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateNohl) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11267,52 +11807,52 @@ type FtCreateNooffsets Completed
 type SFtCreateNooffsets SCompleted
 
 func (c FtCreateNooffsets) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateNooffsets) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateNooffsets) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateNooffsets) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateNooffsets) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateNooffsets) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateNooffsets) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateNooffsets) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateNooffsets) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateNooffsets) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11321,142 +11861,142 @@ type FtCreateOnHash Completed
 type SFtCreateOnHash SCompleted
 
 func (c FtCreateOnHash) Prefix(count int64) FtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (FtCreatePrefixCount)(c)
 }
 
 func (c SFtCreateOnHash) Prefix(count int64) SFtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (SFtCreatePrefixCount)(c)
 }
 
 func (c FtCreateOnHash) Language(defaultLang string) FtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (FtCreateLanguage)(c)
 }
 
 func (c SFtCreateOnHash) Language(defaultLang string) SFtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (SFtCreateLanguage)(c)
 }
 
 func (c FtCreateOnHash) LanguageField(langAttribute string) FtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (FtCreateLanguageField)(c)
 }
 
 func (c SFtCreateOnHash) LanguageField(langAttribute string) SFtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (SFtCreateLanguageField)(c)
 }
 
 func (c FtCreateOnHash) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreateOnHash) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreateOnHash) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateOnHash) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateOnHash) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateOnHash) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateOnHash) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateOnHash) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateOnHash) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateOnHash) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateOnHash) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateOnHash) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateOnHash) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateOnHash) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateOnHash) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateOnHash) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateOnHash) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateOnHash) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateOnHash) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateOnHash) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateOnHash) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateOnHash) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11465,142 +12005,142 @@ type FtCreateOnJson Completed
 type SFtCreateOnJson SCompleted
 
 func (c FtCreateOnJson) Prefix(count int64) FtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (FtCreatePrefixCount)(c)
 }
 
 func (c SFtCreateOnJson) Prefix(count int64) SFtCreatePrefixCount {
-	c.cs = append(c.cs, "PREFIX", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "PREFIX", strconv.FormatInt(count, 10))
 	return (SFtCreatePrefixCount)(c)
 }
 
 func (c FtCreateOnJson) Language(defaultLang string) FtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (FtCreateLanguage)(c)
 }
 
 func (c SFtCreateOnJson) Language(defaultLang string) SFtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (SFtCreateLanguage)(c)
 }
 
 func (c FtCreateOnJson) LanguageField(langAttribute string) FtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (FtCreateLanguageField)(c)
 }
 
 func (c SFtCreateOnJson) LanguageField(langAttribute string) SFtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (SFtCreateLanguageField)(c)
 }
 
 func (c FtCreateOnJson) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreateOnJson) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreateOnJson) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateOnJson) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateOnJson) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateOnJson) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateOnJson) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateOnJson) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateOnJson) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateOnJson) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateOnJson) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateOnJson) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateOnJson) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateOnJson) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateOnJson) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateOnJson) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateOnJson) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateOnJson) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateOnJson) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateOnJson) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateOnJson) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateOnJson) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11609,82 +12149,82 @@ type FtCreatePayloadField Completed
 type SFtCreatePayloadField SCompleted
 
 func (c FtCreatePayloadField) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreatePayloadField) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreatePayloadField) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreatePayloadField) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreatePayloadField) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreatePayloadField) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreatePayloadField) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreatePayloadField) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreatePayloadField) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreatePayloadField) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreatePayloadField) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreatePayloadField) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreatePayloadField) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreatePayloadField) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreatePayloadField) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreatePayloadField) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11693,12 +12233,12 @@ type FtCreatePrefixCount Completed
 type SFtCreatePrefixCount SCompleted
 
 func (c FtCreatePrefixCount) Prefix(prefix ...string) FtCreatePrefixPrefix {
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, prefix...)
 	return (FtCreatePrefixPrefix)(c)
 }
 
 func (c SFtCreatePrefixCount) Prefix(prefix ...string) SFtCreatePrefixPrefix {
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, prefix...)
 	return (SFtCreatePrefixPrefix)(c)
 }
 
@@ -11707,142 +12247,142 @@ type FtCreatePrefixPrefix Completed
 type SFtCreatePrefixPrefix SCompleted
 
 func (c FtCreatePrefixPrefix) Prefix(prefix ...string) FtCreatePrefixPrefix {
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, prefix...)
 	return c
 }
 
 func (c SFtCreatePrefixPrefix) Prefix(prefix ...string) SFtCreatePrefixPrefix {
-	c.cs = append(c.cs, prefix...)
+	c.cs.s = append(c.cs.s, prefix...)
 	return c
 }
 
 func (c FtCreatePrefixPrefix) Language(defaultLang string) FtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (FtCreateLanguage)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Language(defaultLang string) SFtCreateLanguage {
-	c.cs = append(c.cs, "LANGUAGE", defaultLang)
+	c.cs.s = append(c.cs.s, "LANGUAGE", defaultLang)
 	return (SFtCreateLanguage)(c)
 }
 
 func (c FtCreatePrefixPrefix) LanguageField(langAttribute string) FtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (FtCreateLanguageField)(c)
 }
 
 func (c SFtCreatePrefixPrefix) LanguageField(langAttribute string) SFtCreateLanguageField {
-	c.cs = append(c.cs, "LANGUAGE_FIELD", langAttribute)
+	c.cs.s = append(c.cs.s, "LANGUAGE_FIELD", langAttribute)
 	return (SFtCreateLanguageField)(c)
 }
 
 func (c FtCreatePrefixPrefix) Score(defaultScore float64) FtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (FtCreateScore)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Score(defaultScore float64) SFtCreateScore {
-	c.cs = append(c.cs, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "SCORE", strconv.FormatFloat(defaultScore, 'f', -1, 64))
 	return (SFtCreateScore)(c)
 }
 
 func (c FtCreatePrefixPrefix) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreatePrefixPrefix) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreatePrefixPrefix) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreatePrefixPrefix) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreatePrefixPrefix) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreatePrefixPrefix) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreatePrefixPrefix) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreatePrefixPrefix) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreatePrefixPrefix) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreatePrefixPrefix) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreatePrefixPrefix) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreatePrefixPrefix) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreatePrefixPrefix) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11851,12 +12391,12 @@ type FtCreateSchema Completed
 type SFtCreateSchema SCompleted
 
 func (c FtCreateSchema) FieldName(fieldName string) FtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtCreateFieldFieldName)(c)
 }
 
 func (c SFtCreateSchema) FieldName(fieldName string) SFtCreateFieldFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtCreateFieldFieldName)(c)
 }
 
@@ -11865,102 +12405,102 @@ type FtCreateScore Completed
 type SFtCreateScore SCompleted
 
 func (c FtCreateScore) ScoreField(scoreAttribute string) FtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (FtCreateScoreField)(c)
 }
 
 func (c SFtCreateScore) ScoreField(scoreAttribute string) SFtCreateScoreField {
-	c.cs = append(c.cs, "SCORE_FIELD", scoreAttribute)
+	c.cs.s = append(c.cs.s, "SCORE_FIELD", scoreAttribute)
 	return (SFtCreateScoreField)(c)
 }
 
 func (c FtCreateScore) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateScore) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateScore) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateScore) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateScore) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateScore) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateScore) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateScore) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateScore) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateScore) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateScore) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateScore) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateScore) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateScore) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateScore) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateScore) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateScore) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateScore) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -11969,92 +12509,92 @@ type FtCreateScoreField Completed
 type SFtCreateScoreField SCompleted
 
 func (c FtCreateScoreField) PayloadField(payloadAttribute string) FtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (FtCreatePayloadField)(c)
 }
 
 func (c SFtCreateScoreField) PayloadField(payloadAttribute string) SFtCreatePayloadField {
-	c.cs = append(c.cs, "PAYLOAD_FIELD", payloadAttribute)
+	c.cs.s = append(c.cs.s, "PAYLOAD_FIELD", payloadAttribute)
 	return (SFtCreatePayloadField)(c)
 }
 
 func (c FtCreateScoreField) Maxtextfields() FtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (FtCreateMaxtextfields)(c)
 }
 
 func (c SFtCreateScoreField) Maxtextfields() SFtCreateMaxtextfields {
-	c.cs = append(c.cs, "MAXTEXTFIELDS")
+	c.cs.s = append(c.cs.s, "MAXTEXTFIELDS")
 	return (SFtCreateMaxtextfields)(c)
 }
 
 func (c FtCreateScoreField) Temporary(seconds float64) FtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (FtCreateTemporary)(c)
 }
 
 func (c SFtCreateScoreField) Temporary(seconds float64) SFtCreateTemporary {
-	c.cs = append(c.cs, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "TEMPORARY", strconv.FormatFloat(seconds, 'f', -1, 64))
 	return (SFtCreateTemporary)(c)
 }
 
 func (c FtCreateScoreField) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateScoreField) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateScoreField) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateScoreField) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateScoreField) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateScoreField) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateScoreField) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateScoreField) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateScoreField) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateScoreField) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateScoreField) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateScoreField) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -12063,22 +12603,22 @@ type FtCreateStopwordsStopword Completed
 type SFtCreateStopwordsStopword SCompleted
 
 func (c FtCreateStopwordsStopword) Stopword(stopword ...string) FtCreateStopwordsStopword {
-	c.cs = append(c.cs, stopword...)
+	c.cs.s = append(c.cs.s, stopword...)
 	return c
 }
 
 func (c SFtCreateStopwordsStopword) Stopword(stopword ...string) SFtCreateStopwordsStopword {
-	c.cs = append(c.cs, stopword...)
+	c.cs.s = append(c.cs.s, stopword...)
 	return c
 }
 
 func (c FtCreateStopwordsStopword) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateStopwordsStopword) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -12087,12 +12627,12 @@ type FtCreateStopwordsStopwords Completed
 type SFtCreateStopwordsStopwords SCompleted
 
 func (c FtCreateStopwordsStopwords) Stopword(stopword ...string) FtCreateStopwordsStopword {
-	c.cs = append(c.cs, stopword...)
+	c.cs.s = append(c.cs.s, stopword...)
 	return (FtCreateStopwordsStopword)(c)
 }
 
 func (c SFtCreateStopwordsStopwords) Stopword(stopword ...string) SFtCreateStopwordsStopword {
-	c.cs = append(c.cs, stopword...)
+	c.cs.s = append(c.cs.s, stopword...)
 	return (SFtCreateStopwordsStopword)(c)
 }
 
@@ -12101,62 +12641,62 @@ type FtCreateTemporary Completed
 type SFtCreateTemporary SCompleted
 
 func (c FtCreateTemporary) Nooffsets() FtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (FtCreateNooffsets)(c)
 }
 
 func (c SFtCreateTemporary) Nooffsets() SFtCreateNooffsets {
-	c.cs = append(c.cs, "NOOFFSETS")
+	c.cs.s = append(c.cs.s, "NOOFFSETS")
 	return (SFtCreateNooffsets)(c)
 }
 
 func (c FtCreateTemporary) Nohl() FtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (FtCreateNohl)(c)
 }
 
 func (c SFtCreateTemporary) Nohl() SFtCreateNohl {
-	c.cs = append(c.cs, "NOHL")
+	c.cs.s = append(c.cs.s, "NOHL")
 	return (SFtCreateNohl)(c)
 }
 
 func (c FtCreateTemporary) Nofields() FtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (FtCreateNofields)(c)
 }
 
 func (c SFtCreateTemporary) Nofields() SFtCreateNofields {
-	c.cs = append(c.cs, "NOFIELDS")
+	c.cs.s = append(c.cs.s, "NOFIELDS")
 	return (SFtCreateNofields)(c)
 }
 
 func (c FtCreateTemporary) Nofreqs() FtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (FtCreateNofreqs)(c)
 }
 
 func (c SFtCreateTemporary) Nofreqs() SFtCreateNofreqs {
-	c.cs = append(c.cs, "NOFREQS")
+	c.cs.s = append(c.cs.s, "NOFREQS")
 	return (SFtCreateNofreqs)(c)
 }
 
 func (c FtCreateTemporary) Stopwords(count int64) FtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (FtCreateStopwordsStopwords)(c)
 }
 
 func (c SFtCreateTemporary) Stopwords(count int64) SFtCreateStopwordsStopwords {
-	c.cs = append(c.cs, "STOPWORDS", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "STOPWORDS", strconv.FormatInt(count, 10))
 	return (SFtCreateStopwordsStopwords)(c)
 }
 
 func (c FtCreateTemporary) Schema() FtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (FtCreateSchema)(c)
 }
 
 func (c SFtCreateTemporary) Schema() SFtCreateSchema {
-	c.cs = append(c.cs, "SCHEMA")
+	c.cs.s = append(c.cs.s, "SCHEMA")
 	return (SFtCreateSchema)(c)
 }
 
@@ -12164,21 +12704,25 @@ type FtCursorDel Completed
 
 type SFtCursorDel SCompleted
 
-func (b *Builder) FtCursorDel() FtCursorDel {
-	return FtCursorDel{cs: append(b.get(), "FT.CURSOR", "DEL"), ks: InitSlot}
+func (b *Builder) FtCursorDel() (c FtCursorDel) {
+	c = FtCursorDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CURSOR", "DEL")
+	return c
 }
 
-func (b *SBuilder) FtCursorDel() SFtCursorDel {
-	return SFtCursorDel{cs: append(b.get(), "FT.CURSOR", "DEL"), ks: InitSlot}
+func (b *SBuilder) FtCursorDel() (c SFtCursorDel) {
+	c = SFtCursorDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CURSOR", "DEL")
+	return c
 }
 
 func (c FtCursorDel) Index(index string) FtCursorDelIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtCursorDelIndex)(c)
 }
 
 func (c SFtCursorDel) Index(index string) SFtCursorDelIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtCursorDelIndex)(c)
 }
 
@@ -12199,12 +12743,12 @@ type FtCursorDelIndex Completed
 type SFtCursorDelIndex SCompleted
 
 func (c FtCursorDelIndex) CursorId(cursorId int64) FtCursorDelCursorId {
-	c.cs = append(c.cs, strconv.FormatInt(cursorId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursorId, 10))
 	return (FtCursorDelCursorId)(c)
 }
 
 func (c SFtCursorDelIndex) CursorId(cursorId int64) SFtCursorDelCursorId {
-	c.cs = append(c.cs, strconv.FormatInt(cursorId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursorId, 10))
 	return (SFtCursorDelCursorId)(c)
 }
 
@@ -12212,21 +12756,25 @@ type FtCursorRead Completed
 
 type SFtCursorRead SCompleted
 
-func (b *Builder) FtCursorRead() FtCursorRead {
-	return FtCursorRead{cs: append(b.get(), "FT.CURSOR", "READ"), ks: InitSlot}
+func (b *Builder) FtCursorRead() (c FtCursorRead) {
+	c = FtCursorRead{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CURSOR", "READ")
+	return c
 }
 
-func (b *SBuilder) FtCursorRead() SFtCursorRead {
-	return SFtCursorRead{cs: append(b.get(), "FT.CURSOR", "READ"), ks: InitSlot}
+func (b *SBuilder) FtCursorRead() (c SFtCursorRead) {
+	c = SFtCursorRead{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.CURSOR", "READ")
+	return c
 }
 
 func (c FtCursorRead) Index(index string) FtCursorReadIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtCursorReadIndex)(c)
 }
 
 func (c SFtCursorRead) Index(index string) SFtCursorReadIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtCursorReadIndex)(c)
 }
 
@@ -12247,12 +12795,12 @@ type FtCursorReadCursorId Completed
 type SFtCursorReadCursorId SCompleted
 
 func (c FtCursorReadCursorId) Count(readSize int64) FtCursorReadCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(readSize, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(readSize, 10))
 	return (FtCursorReadCount)(c)
 }
 
 func (c SFtCursorReadCursorId) Count(readSize int64) SFtCursorReadCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(readSize, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(readSize, 10))
 	return (SFtCursorReadCount)(c)
 }
 
@@ -12269,12 +12817,12 @@ type FtCursorReadIndex Completed
 type SFtCursorReadIndex SCompleted
 
 func (c FtCursorReadIndex) CursorId(cursorId int64) FtCursorReadCursorId {
-	c.cs = append(c.cs, strconv.FormatInt(cursorId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursorId, 10))
 	return (FtCursorReadCursorId)(c)
 }
 
 func (c SFtCursorReadIndex) CursorId(cursorId int64) SFtCursorReadCursorId {
-	c.cs = append(c.cs, strconv.FormatInt(cursorId, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursorId, 10))
 	return (SFtCursorReadCursorId)(c)
 }
 
@@ -12282,21 +12830,25 @@ type FtDictadd Completed
 
 type SFtDictadd SCompleted
 
-func (b *Builder) FtDictadd() FtDictadd {
-	return FtDictadd{cs: append(b.get(), "FT.DICTADD"), ks: InitSlot}
+func (b *Builder) FtDictadd() (c FtDictadd) {
+	c = FtDictadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTADD")
+	return c
 }
 
-func (b *SBuilder) FtDictadd() SFtDictadd {
-	return SFtDictadd{cs: append(b.get(), "FT.DICTADD"), ks: InitSlot}
+func (b *SBuilder) FtDictadd() (c SFtDictadd) {
+	c = SFtDictadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTADD")
+	return c
 }
 
 func (c FtDictadd) Dict(dict string) FtDictaddDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (FtDictaddDict)(c)
 }
 
 func (c SFtDictadd) Dict(dict string) SFtDictaddDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (SFtDictaddDict)(c)
 }
 
@@ -12305,12 +12857,12 @@ type FtDictaddDict Completed
 type SFtDictaddDict SCompleted
 
 func (c FtDictaddDict) Term(term ...string) FtDictaddTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (FtDictaddTerm)(c)
 }
 
 func (c SFtDictaddDict) Term(term ...string) SFtDictaddTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (SFtDictaddTerm)(c)
 }
 
@@ -12319,12 +12871,12 @@ type FtDictaddTerm Completed
 type SFtDictaddTerm SCompleted
 
 func (c FtDictaddTerm) Term(term ...string) FtDictaddTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
 func (c SFtDictaddTerm) Term(term ...string) SFtDictaddTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
@@ -12340,21 +12892,25 @@ type FtDictdel Completed
 
 type SFtDictdel SCompleted
 
-func (b *Builder) FtDictdel() FtDictdel {
-	return FtDictdel{cs: append(b.get(), "FT.DICTDEL"), ks: InitSlot}
+func (b *Builder) FtDictdel() (c FtDictdel) {
+	c = FtDictdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTDEL")
+	return c
 }
 
-func (b *SBuilder) FtDictdel() SFtDictdel {
-	return SFtDictdel{cs: append(b.get(), "FT.DICTDEL"), ks: InitSlot}
+func (b *SBuilder) FtDictdel() (c SFtDictdel) {
+	c = SFtDictdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTDEL")
+	return c
 }
 
 func (c FtDictdel) Dict(dict string) FtDictdelDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (FtDictdelDict)(c)
 }
 
 func (c SFtDictdel) Dict(dict string) SFtDictdelDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (SFtDictdelDict)(c)
 }
 
@@ -12363,12 +12919,12 @@ type FtDictdelDict Completed
 type SFtDictdelDict SCompleted
 
 func (c FtDictdelDict) Term(term ...string) FtDictdelTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (FtDictdelTerm)(c)
 }
 
 func (c SFtDictdelDict) Term(term ...string) SFtDictdelTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (SFtDictdelTerm)(c)
 }
 
@@ -12377,12 +12933,12 @@ type FtDictdelTerm Completed
 type SFtDictdelTerm SCompleted
 
 func (c FtDictdelTerm) Term(term ...string) FtDictdelTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
 func (c SFtDictdelTerm) Term(term ...string) SFtDictdelTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
@@ -12398,21 +12954,25 @@ type FtDictdump Completed
 
 type SFtDictdump SCompleted
 
-func (b *Builder) FtDictdump() FtDictdump {
-	return FtDictdump{cs: append(b.get(), "FT.DICTDUMP"), ks: InitSlot}
+func (b *Builder) FtDictdump() (c FtDictdump) {
+	c = FtDictdump{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTDUMP")
+	return c
 }
 
-func (b *SBuilder) FtDictdump() SFtDictdump {
-	return SFtDictdump{cs: append(b.get(), "FT.DICTDUMP"), ks: InitSlot}
+func (b *SBuilder) FtDictdump() (c SFtDictdump) {
+	c = SFtDictdump{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DICTDUMP")
+	return c
 }
 
 func (c FtDictdump) Dict(dict string) FtDictdumpDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (FtDictdumpDict)(c)
 }
 
 func (c SFtDictdump) Dict(dict string) SFtDictdumpDict {
-	c.cs = append(c.cs, dict)
+	c.cs.s = append(c.cs.s, dict)
 	return (SFtDictdumpDict)(c)
 }
 
@@ -12432,21 +12992,25 @@ type FtDropindex Completed
 
 type SFtDropindex SCompleted
 
-func (b *Builder) FtDropindex() FtDropindex {
-	return FtDropindex{cs: append(b.get(), "FT.DROPINDEX"), ks: InitSlot}
+func (b *Builder) FtDropindex() (c FtDropindex) {
+	c = FtDropindex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DROPINDEX")
+	return c
 }
 
-func (b *SBuilder) FtDropindex() SFtDropindex {
-	return SFtDropindex{cs: append(b.get(), "FT.DROPINDEX"), ks: InitSlot}
+func (b *SBuilder) FtDropindex() (c SFtDropindex) {
+	c = SFtDropindex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.DROPINDEX")
+	return c
 }
 
 func (c FtDropindex) Index(index string) FtDropindexIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtDropindexIndex)(c)
 }
 
 func (c SFtDropindex) Index(index string) SFtDropindexIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtDropindexIndex)(c)
 }
 
@@ -12467,12 +13031,12 @@ type FtDropindexIndex Completed
 type SFtDropindexIndex SCompleted
 
 func (c FtDropindexIndex) Dd() FtDropindexDeleteDocsDd {
-	c.cs = append(c.cs, "DD")
+	c.cs.s = append(c.cs.s, "DD")
 	return (FtDropindexDeleteDocsDd)(c)
 }
 
 func (c SFtDropindexIndex) Dd() SFtDropindexDeleteDocsDd {
-	c.cs = append(c.cs, "DD")
+	c.cs.s = append(c.cs.s, "DD")
 	return (SFtDropindexDeleteDocsDd)(c)
 }
 
@@ -12488,21 +13052,25 @@ type FtExplain Completed
 
 type SFtExplain SCompleted
 
-func (b *Builder) FtExplain() FtExplain {
-	return FtExplain{cs: append(b.get(), "FT.EXPLAIN"), ks: InitSlot}
+func (b *Builder) FtExplain() (c FtExplain) {
+	c = FtExplain{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.EXPLAIN")
+	return c
 }
 
-func (b *SBuilder) FtExplain() SFtExplain {
-	return SFtExplain{cs: append(b.get(), "FT.EXPLAIN"), ks: InitSlot}
+func (b *SBuilder) FtExplain() (c SFtExplain) {
+	c = SFtExplain{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.EXPLAIN")
+	return c
 }
 
 func (c FtExplain) Index(index string) FtExplainIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtExplainIndex)(c)
 }
 
 func (c SFtExplain) Index(index string) SFtExplainIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtExplainIndex)(c)
 }
 
@@ -12511,12 +13079,12 @@ type FtExplainIndex Completed
 type SFtExplainIndex SCompleted
 
 func (c FtExplainIndex) Query(query string) FtExplainQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (FtExplainQuery)(c)
 }
 
 func (c SFtExplainIndex) Query(query string) SFtExplainQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SFtExplainQuery)(c)
 }
 
@@ -12536,21 +13104,25 @@ type FtExplaincli Completed
 
 type SFtExplaincli SCompleted
 
-func (b *Builder) FtExplaincli() FtExplaincli {
-	return FtExplaincli{cs: append(b.get(), "FT.EXPLAINCLI"), ks: InitSlot}
+func (b *Builder) FtExplaincli() (c FtExplaincli) {
+	c = FtExplaincli{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.EXPLAINCLI")
+	return c
 }
 
-func (b *SBuilder) FtExplaincli() SFtExplaincli {
-	return SFtExplaincli{cs: append(b.get(), "FT.EXPLAINCLI"), ks: InitSlot}
+func (b *SBuilder) FtExplaincli() (c SFtExplaincli) {
+	c = SFtExplaincli{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.EXPLAINCLI")
+	return c
 }
 
 func (c FtExplaincli) Index(index string) FtExplaincliIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtExplaincliIndex)(c)
 }
 
 func (c SFtExplaincli) Index(index string) SFtExplaincliIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtExplaincliIndex)(c)
 }
 
@@ -12559,12 +13131,12 @@ type FtExplaincliIndex Completed
 type SFtExplaincliIndex SCompleted
 
 func (c FtExplaincliIndex) Query(query string) FtExplaincliQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (FtExplaincliQuery)(c)
 }
 
 func (c SFtExplaincliIndex) Query(query string) SFtExplaincliQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SFtExplaincliQuery)(c)
 }
 
@@ -12584,21 +13156,25 @@ type FtInfo Completed
 
 type SFtInfo SCompleted
 
-func (b *Builder) FtInfo() FtInfo {
-	return FtInfo{cs: append(b.get(), "FT.INFO"), ks: InitSlot}
+func (b *Builder) FtInfo() (c FtInfo) {
+	c = FtInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.INFO")
+	return c
 }
 
-func (b *SBuilder) FtInfo() SFtInfo {
-	return SFtInfo{cs: append(b.get(), "FT.INFO"), ks: InitSlot}
+func (b *SBuilder) FtInfo() (c SFtInfo) {
+	c = SFtInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.INFO")
+	return c
 }
 
 func (c FtInfo) Index(index string) FtInfoIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtInfoIndex)(c)
 }
 
 func (c SFtInfo) Index(index string) SFtInfoIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtInfoIndex)(c)
 }
 
@@ -12618,12 +13194,16 @@ type FtList Completed
 
 type SFtList SCompleted
 
-func (b *Builder) FtList() FtList {
-	return FtList{cs: append(b.get(), "FT._LIST"), ks: InitSlot}
+func (b *Builder) FtList() (c FtList) {
+	c = FtList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT._LIST")
+	return c
 }
 
-func (b *SBuilder) FtList() SFtList {
-	return SFtList{cs: append(b.get(), "FT._LIST"), ks: InitSlot}
+func (b *SBuilder) FtList() (c SFtList) {
+	c = SFtList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT._LIST")
+	return c
 }
 
 func (c FtList) Build() Completed {
@@ -12638,21 +13218,25 @@ type FtSearch Completed
 
 type SFtSearch SCompleted
 
-func (b *Builder) FtSearch() FtSearch {
-	return FtSearch{cs: append(b.get(), "FT.SEARCH"), ks: InitSlot}
+func (b *Builder) FtSearch() (c FtSearch) {
+	c = FtSearch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SEARCH")
+	return c
 }
 
-func (b *SBuilder) FtSearch() SFtSearch {
-	return SFtSearch{cs: append(b.get(), "FT.SEARCH"), ks: InitSlot}
+func (b *SBuilder) FtSearch() (c SFtSearch) {
+	c = SFtSearch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SEARCH")
+	return c
 }
 
 func (c FtSearch) Index(index string) FtSearchIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtSearchIndex)(c)
 }
 
 func (c SFtSearch) Index(index string) SFtSearchIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtSearchIndex)(c)
 }
 
@@ -12661,52 +13245,52 @@ type FtSearchExpander Completed
 type SFtSearchExpander SCompleted
 
 func (c FtSearchExpander) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchExpander) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchExpander) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchExpander) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchExpander) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchExpander) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchExpander) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchExpander) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchExpander) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchExpander) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -12723,32 +13307,32 @@ type FtSearchExplainscore Completed
 type SFtSearchExplainscore SCompleted
 
 func (c FtSearchExplainscore) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchExplainscore) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchExplainscore) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchExplainscore) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchExplainscore) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchExplainscore) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -12765,12 +13349,12 @@ type FtSearchFilterFilter Completed
 type SFtSearchFilterFilter SCompleted
 
 func (c FtSearchFilterFilter) Min(min float64) FtSearchFilterMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (FtSearchFilterMin)(c)
 }
 
 func (c SFtSearchFilterFilter) Min(min float64) SFtSearchFilterMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (SFtSearchFilterMin)(c)
 }
 
@@ -12779,162 +13363,162 @@ type FtSearchFilterMax Completed
 type SFtSearchFilterMax SCompleted
 
 func (c FtSearchFilterMax) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchFilterMax) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchFilterMax) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchFilterMax) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchFilterMax) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchFilterMax) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchFilterMax) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchFilterMax) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchFilterMax) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchFilterMax) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchFilterMax) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchFilterMax) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchFilterMax) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchFilterMax) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchFilterMax) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchFilterMax) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchFilterMax) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchFilterMax) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchFilterMax) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchFilterMax) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchFilterMax) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchFilterMax) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchFilterMax) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchFilterMax) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchFilterMax) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchFilterMax) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchFilterMax) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchFilterMax) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchFilterMax) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchFilterMax) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchFilterMax) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchFilterMax) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -12951,12 +13535,12 @@ type FtSearchFilterMin Completed
 type SFtSearchFilterMin SCompleted
 
 func (c FtSearchFilterMin) Max(max float64) FtSearchFilterMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (FtSearchFilterMax)(c)
 }
 
 func (c SFtSearchFilterMin) Max(max float64) SFtSearchFilterMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (SFtSearchFilterMax)(c)
 }
 
@@ -12965,12 +13549,12 @@ type FtSearchGeoFilterGeofilter Completed
 type SFtSearchGeoFilterGeofilter SCompleted
 
 func (c FtSearchGeoFilterGeofilter) Lon(lon float64) FtSearchGeoFilterLon {
-	c.cs = append(c.cs, strconv.FormatFloat(lon, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(lon, 'f', -1, 64))
 	return (FtSearchGeoFilterLon)(c)
 }
 
 func (c SFtSearchGeoFilterGeofilter) Lon(lon float64) SFtSearchGeoFilterLon {
-	c.cs = append(c.cs, strconv.FormatFloat(lon, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(lon, 'f', -1, 64))
 	return (SFtSearchGeoFilterLon)(c)
 }
 
@@ -12979,12 +13563,12 @@ type FtSearchGeoFilterLat Completed
 type SFtSearchGeoFilterLat SCompleted
 
 func (c FtSearchGeoFilterLat) Radius(radius float64) FtSearchGeoFilterRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (FtSearchGeoFilterRadius)(c)
 }
 
 func (c SFtSearchGeoFilterLat) Radius(radius float64) SFtSearchGeoFilterRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SFtSearchGeoFilterRadius)(c)
 }
 
@@ -12993,12 +13577,12 @@ type FtSearchGeoFilterLon Completed
 type SFtSearchGeoFilterLon SCompleted
 
 func (c FtSearchGeoFilterLon) Lat(lat float64) FtSearchGeoFilterLat {
-	c.cs = append(c.cs, strconv.FormatFloat(lat, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(lat, 'f', -1, 64))
 	return (FtSearchGeoFilterLat)(c)
 }
 
 func (c SFtSearchGeoFilterLon) Lat(lat float64) SFtSearchGeoFilterLat {
-	c.cs = append(c.cs, strconv.FormatFloat(lat, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(lat, 'f', -1, 64))
 	return (SFtSearchGeoFilterLat)(c)
 }
 
@@ -13007,42 +13591,42 @@ type FtSearchGeoFilterRadius Completed
 type SFtSearchGeoFilterRadius SCompleted
 
 func (c FtSearchGeoFilterRadius) M() FtSearchGeoFilterRadiusTypeM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (FtSearchGeoFilterRadiusTypeM)(c)
 }
 
 func (c SFtSearchGeoFilterRadius) M() SFtSearchGeoFilterRadiusTypeM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SFtSearchGeoFilterRadiusTypeM)(c)
 }
 
 func (c FtSearchGeoFilterRadius) Km() FtSearchGeoFilterRadiusTypeKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (FtSearchGeoFilterRadiusTypeKm)(c)
 }
 
 func (c SFtSearchGeoFilterRadius) Km() SFtSearchGeoFilterRadiusTypeKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SFtSearchGeoFilterRadiusTypeKm)(c)
 }
 
 func (c FtSearchGeoFilterRadius) Mi() FtSearchGeoFilterRadiusTypeMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (FtSearchGeoFilterRadiusTypeMi)(c)
 }
 
 func (c SFtSearchGeoFilterRadius) Mi() SFtSearchGeoFilterRadiusTypeMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SFtSearchGeoFilterRadiusTypeMi)(c)
 }
 
 func (c FtSearchGeoFilterRadius) Ft() FtSearchGeoFilterRadiusTypeFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (FtSearchGeoFilterRadiusTypeFt)(c)
 }
 
 func (c SFtSearchGeoFilterRadius) Ft() SFtSearchGeoFilterRadiusTypeFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SFtSearchGeoFilterRadiusTypeFt)(c)
 }
 
@@ -13051,152 +13635,152 @@ type FtSearchGeoFilterRadiusTypeFt Completed
 type SFtSearchGeoFilterRadiusTypeFt SCompleted
 
 func (c FtSearchGeoFilterRadiusTypeFt) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeFt) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeFt) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13213,152 +13797,152 @@ type FtSearchGeoFilterRadiusTypeKm Completed
 type SFtSearchGeoFilterRadiusTypeKm SCompleted
 
 func (c FtSearchGeoFilterRadiusTypeKm) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeKm) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeKm) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13375,152 +13959,152 @@ type FtSearchGeoFilterRadiusTypeM Completed
 type SFtSearchGeoFilterRadiusTypeM SCompleted
 
 func (c FtSearchGeoFilterRadiusTypeM) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeM) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeM) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13537,152 +14121,152 @@ type FtSearchGeoFilterRadiusTypeMi Completed
 type SFtSearchGeoFilterRadiusTypeMi SCompleted
 
 func (c FtSearchGeoFilterRadiusTypeMi) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchGeoFilterRadiusTypeMi) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchGeoFilterRadiusTypeMi) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13699,112 +14283,112 @@ type FtSearchHighlightFieldsField Completed
 type SFtSearchHighlightFieldsField SCompleted
 
 func (c FtSearchHighlightFieldsField) Field(field ...string) FtSearchHighlightFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SFtSearchHighlightFieldsField) Field(field ...string) SFtSearchHighlightFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c FtSearchHighlightFieldsField) Tags() FtSearchHighlightTagsTags {
-	c.cs = append(c.cs, "TAGS")
+	c.cs.s = append(c.cs.s, "TAGS")
 	return (FtSearchHighlightTagsTags)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Tags() SFtSearchHighlightTagsTags {
-	c.cs = append(c.cs, "TAGS")
+	c.cs.s = append(c.cs.s, "TAGS")
 	return (SFtSearchHighlightTagsTags)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchHighlightFieldsField) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchHighlightFieldsField) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13821,12 +14405,12 @@ type FtSearchHighlightFieldsFields Completed
 type SFtSearchHighlightFieldsFields SCompleted
 
 func (c FtSearchHighlightFieldsFields) Field(field ...string) FtSearchHighlightFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (FtSearchHighlightFieldsField)(c)
 }
 
 func (c SFtSearchHighlightFieldsFields) Field(field ...string) SFtSearchHighlightFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SFtSearchHighlightFieldsField)(c)
 }
 
@@ -13835,112 +14419,112 @@ type FtSearchHighlightHighlight Completed
 type SFtSearchHighlightHighlight SCompleted
 
 func (c FtSearchHighlightHighlight) Fields(count string) FtSearchHighlightFieldsFields {
-	c.cs = append(c.cs, "FIELDS", count)
+	c.cs.s = append(c.cs.s, "FIELDS", count)
 	return (FtSearchHighlightFieldsFields)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Fields(count string) SFtSearchHighlightFieldsFields {
-	c.cs = append(c.cs, "FIELDS", count)
+	c.cs.s = append(c.cs.s, "FIELDS", count)
 	return (SFtSearchHighlightFieldsFields)(c)
 }
 
 func (c FtSearchHighlightHighlight) Tags() FtSearchHighlightTagsTags {
-	c.cs = append(c.cs, "TAGS")
+	c.cs.s = append(c.cs.s, "TAGS")
 	return (FtSearchHighlightTagsTags)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Tags() SFtSearchHighlightTagsTags {
-	c.cs = append(c.cs, "TAGS")
+	c.cs.s = append(c.cs.s, "TAGS")
 	return (SFtSearchHighlightTagsTags)(c)
 }
 
 func (c FtSearchHighlightHighlight) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchHighlightHighlight) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchHighlightHighlight) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchHighlightHighlight) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchHighlightHighlight) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchHighlightHighlight) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchHighlightHighlight) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchHighlightHighlight) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchHighlightHighlight) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchHighlightHighlight) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -13957,92 +14541,92 @@ type FtSearchHighlightTagsOpenClose Completed
 type SFtSearchHighlightTagsOpenClose SCompleted
 
 func (c FtSearchHighlightTagsOpenClose) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchHighlightTagsOpenClose) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchHighlightTagsOpenClose) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14059,12 +14643,12 @@ type FtSearchHighlightTagsTags Completed
 type SFtSearchHighlightTagsTags SCompleted
 
 func (c FtSearchHighlightTagsTags) OpenClose(open string, close string) FtSearchHighlightTagsOpenClose {
-	c.cs = append(c.cs, open, close)
+	c.cs.s = append(c.cs.s, open, close)
 	return (FtSearchHighlightTagsOpenClose)(c)
 }
 
 func (c SFtSearchHighlightTagsTags) OpenClose(open string, close string) SFtSearchHighlightTagsOpenClose {
-	c.cs = append(c.cs, open, close)
+	c.cs.s = append(c.cs.s, open, close)
 	return (SFtSearchHighlightTagsOpenClose)(c)
 }
 
@@ -14073,132 +14657,132 @@ type FtSearchInFieldsField Completed
 type SFtSearchInFieldsField SCompleted
 
 func (c FtSearchInFieldsField) Field(field ...string) FtSearchInFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SFtSearchInFieldsField) Field(field ...string) SFtSearchInFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c FtSearchInFieldsField) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchInFieldsField) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchInFieldsField) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchInFieldsField) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchInFieldsField) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchInFieldsField) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchInFieldsField) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchInFieldsField) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchInFieldsField) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchInFieldsField) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchInFieldsField) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchInFieldsField) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchInFieldsField) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchInFieldsField) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchInFieldsField) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchInFieldsField) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchInFieldsField) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchInFieldsField) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchInFieldsField) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchInFieldsField) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchInFieldsField) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchInFieldsField) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchInFieldsField) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchInFieldsField) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14215,12 +14799,12 @@ type FtSearchInFieldsInfields Completed
 type SFtSearchInFieldsInfields SCompleted
 
 func (c FtSearchInFieldsInfields) Field(field ...string) FtSearchInFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (FtSearchInFieldsField)(c)
 }
 
 func (c SFtSearchInFieldsInfields) Field(field ...string) SFtSearchInFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SFtSearchInFieldsField)(c)
 }
 
@@ -14229,12 +14813,12 @@ type FtSearchInKeysInkeys Completed
 type SFtSearchInKeysInkeys SCompleted
 
 func (c FtSearchInKeysInkeys) Key(key ...string) FtSearchInKeysKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (FtSearchInKeysKey)(c)
 }
 
 func (c SFtSearchInKeysInkeys) Key(key ...string) SFtSearchInKeysKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SFtSearchInKeysKey)(c)
 }
 
@@ -14243,142 +14827,142 @@ type FtSearchInKeysKey Completed
 type SFtSearchInKeysKey SCompleted
 
 func (c FtSearchInKeysKey) Key(key ...string) FtSearchInKeysKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c SFtSearchInKeysKey) Key(key ...string) SFtSearchInKeysKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c FtSearchInKeysKey) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchInKeysKey) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchInKeysKey) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchInKeysKey) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchInKeysKey) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchInKeysKey) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchInKeysKey) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchInKeysKey) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchInKeysKey) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchInKeysKey) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchInKeysKey) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchInKeysKey) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchInKeysKey) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchInKeysKey) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchInKeysKey) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchInKeysKey) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchInKeysKey) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchInKeysKey) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchInKeysKey) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchInKeysKey) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchInKeysKey) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchInKeysKey) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchInKeysKey) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchInKeysKey) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchInKeysKey) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchInKeysKey) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14395,12 +14979,12 @@ type FtSearchIndex Completed
 type SFtSearchIndex SCompleted
 
 func (c FtSearchIndex) Query(query string) FtSearchQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (FtSearchQuery)(c)
 }
 
 func (c SFtSearchIndex) Query(query string) SFtSearchQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SFtSearchQuery)(c)
 }
 
@@ -14409,62 +14993,62 @@ type FtSearchLanguage Completed
 type SFtSearchLanguage SCompleted
 
 func (c FtSearchLanguage) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchLanguage) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchLanguage) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchLanguage) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchLanguage) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchLanguage) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchLanguage) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchLanguage) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchLanguage) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchLanguage) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchLanguage) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchLanguage) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14481,12 +15065,12 @@ type FtSearchLimitLimit Completed
 type SFtSearchLimitLimit SCompleted
 
 func (c FtSearchLimitLimit) OffsetNum(offset int64, num int64) FtSearchLimitOffsetNum {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
 	return (FtSearchLimitOffsetNum)(c)
 }
 
 func (c SFtSearchLimitLimit) OffsetNum(offset int64, num int64) SFtSearchLimitOffsetNum {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10), strconv.FormatInt(num, 10))
 	return (SFtSearchLimitOffsetNum)(c)
 }
 
@@ -14507,212 +15091,212 @@ type FtSearchNocontent Completed
 type SFtSearchNocontent SCompleted
 
 func (c FtSearchNocontent) Verbatim() FtSearchVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (FtSearchVerbatim)(c)
 }
 
 func (c SFtSearchNocontent) Verbatim() SFtSearchVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (SFtSearchVerbatim)(c)
 }
 
 func (c FtSearchNocontent) Nostopwords() FtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (FtSearchNostopwords)(c)
 }
 
 func (c SFtSearchNocontent) Nostopwords() SFtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (SFtSearchNostopwords)(c)
 }
 
 func (c FtSearchNocontent) Withscores() FtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSearchWithscores)(c)
 }
 
 func (c SFtSearchNocontent) Withscores() SFtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSearchWithscores)(c)
 }
 
 func (c FtSearchNocontent) Withpayloads() FtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSearchWithpayloads)(c)
 }
 
 func (c SFtSearchNocontent) Withpayloads() SFtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSearchWithpayloads)(c)
 }
 
 func (c FtSearchNocontent) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchNocontent) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchNocontent) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchNocontent) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchNocontent) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchNocontent) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchNocontent) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchNocontent) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchNocontent) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchNocontent) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchNocontent) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchNocontent) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchNocontent) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchNocontent) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchNocontent) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchNocontent) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchNocontent) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchNocontent) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchNocontent) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchNocontent) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchNocontent) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchNocontent) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchNocontent) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchNocontent) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchNocontent) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchNocontent) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchNocontent) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchNocontent) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchNocontent) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchNocontent) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchNocontent) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchNocontent) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchNocontent) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchNocontent) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14729,192 +15313,192 @@ type FtSearchNostopwords Completed
 type SFtSearchNostopwords SCompleted
 
 func (c FtSearchNostopwords) Withscores() FtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSearchWithscores)(c)
 }
 
 func (c SFtSearchNostopwords) Withscores() SFtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSearchWithscores)(c)
 }
 
 func (c FtSearchNostopwords) Withpayloads() FtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSearchWithpayloads)(c)
 }
 
 func (c SFtSearchNostopwords) Withpayloads() SFtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSearchWithpayloads)(c)
 }
 
 func (c FtSearchNostopwords) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchNostopwords) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchNostopwords) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchNostopwords) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchNostopwords) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchNostopwords) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchNostopwords) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchNostopwords) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchNostopwords) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchNostopwords) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchNostopwords) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchNostopwords) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchNostopwords) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchNostopwords) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchNostopwords) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchNostopwords) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchNostopwords) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchNostopwords) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchNostopwords) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchNostopwords) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchNostopwords) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchNostopwords) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchNostopwords) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchNostopwords) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchNostopwords) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchNostopwords) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchNostopwords) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchNostopwords) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchNostopwords) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchNostopwords) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchNostopwords) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchNostopwords) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchNostopwords) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchNostopwords) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14931,22 +15515,22 @@ type FtSearchPayload Completed
 type SFtSearchPayload SCompleted
 
 func (c FtSearchPayload) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchPayload) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchPayload) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchPayload) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -14963,222 +15547,222 @@ type FtSearchQuery Completed
 type SFtSearchQuery SCompleted
 
 func (c FtSearchQuery) Nocontent() FtSearchNocontent {
-	c.cs = append(c.cs, "NOCONTENT")
+	c.cs.s = append(c.cs.s, "NOCONTENT")
 	return (FtSearchNocontent)(c)
 }
 
 func (c SFtSearchQuery) Nocontent() SFtSearchNocontent {
-	c.cs = append(c.cs, "NOCONTENT")
+	c.cs.s = append(c.cs.s, "NOCONTENT")
 	return (SFtSearchNocontent)(c)
 }
 
 func (c FtSearchQuery) Verbatim() FtSearchVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (FtSearchVerbatim)(c)
 }
 
 func (c SFtSearchQuery) Verbatim() SFtSearchVerbatim {
-	c.cs = append(c.cs, "VERBATIM")
+	c.cs.s = append(c.cs.s, "VERBATIM")
 	return (SFtSearchVerbatim)(c)
 }
 
 func (c FtSearchQuery) Nostopwords() FtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (FtSearchNostopwords)(c)
 }
 
 func (c SFtSearchQuery) Nostopwords() SFtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (SFtSearchNostopwords)(c)
 }
 
 func (c FtSearchQuery) Withscores() FtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSearchWithscores)(c)
 }
 
 func (c SFtSearchQuery) Withscores() SFtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSearchWithscores)(c)
 }
 
 func (c FtSearchQuery) Withpayloads() FtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSearchWithpayloads)(c)
 }
 
 func (c SFtSearchQuery) Withpayloads() SFtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSearchWithpayloads)(c)
 }
 
 func (c FtSearchQuery) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchQuery) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchQuery) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchQuery) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchQuery) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchQuery) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchQuery) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchQuery) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchQuery) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchQuery) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchQuery) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchQuery) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchQuery) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchQuery) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchQuery) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchQuery) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchQuery) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchQuery) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchQuery) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchQuery) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchQuery) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchQuery) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchQuery) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchQuery) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchQuery) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchQuery) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchQuery) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchQuery) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchQuery) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchQuery) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchQuery) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchQuery) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchQuery) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchQuery) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15195,122 +15779,122 @@ type FtSearchReturnField Completed
 type SFtSearchReturnField SCompleted
 
 func (c FtSearchReturnField) Field(field ...string) FtSearchReturnField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SFtSearchReturnField) Field(field ...string) SFtSearchReturnField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c FtSearchReturnField) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchReturnField) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchReturnField) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchReturnField) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchReturnField) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchReturnField) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchReturnField) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchReturnField) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchReturnField) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchReturnField) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchReturnField) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchReturnField) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchReturnField) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchReturnField) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchReturnField) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchReturnField) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchReturnField) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchReturnField) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchReturnField) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchReturnField) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchReturnField) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchReturnField) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15327,12 +15911,12 @@ type FtSearchReturnReturn Completed
 type SFtSearchReturnReturn SCompleted
 
 func (c FtSearchReturnReturn) Field(field ...string) FtSearchReturnField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (FtSearchReturnField)(c)
 }
 
 func (c SFtSearchReturnReturn) Field(field ...string) SFtSearchReturnField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SFtSearchReturnField)(c)
 }
 
@@ -15341,42 +15925,42 @@ type FtSearchScorer Completed
 type SFtSearchScorer SCompleted
 
 func (c FtSearchScorer) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchScorer) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchScorer) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchScorer) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchScorer) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchScorer) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchScorer) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchScorer) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15393,82 +15977,82 @@ type FtSearchSlop Completed
 type SFtSearchSlop SCompleted
 
 func (c FtSearchSlop) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSlop) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSlop) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSlop) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSlop) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSlop) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSlop) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSlop) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSlop) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSlop) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSlop) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSlop) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSlop) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSlop) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSlop) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSlop) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15485,12 +16069,12 @@ type FtSearchSortbyOrderAsc Completed
 type SFtSearchSortbyOrderAsc SCompleted
 
 func (c FtSearchSortbyOrderAsc) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSortbyOrderAsc) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15507,12 +16091,12 @@ type FtSearchSortbyOrderDesc Completed
 type SFtSearchSortbyOrderDesc SCompleted
 
 func (c FtSearchSortbyOrderDesc) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSortbyOrderDesc) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15529,32 +16113,32 @@ type FtSearchSortbySortby Completed
 type SFtSearchSortbySortby SCompleted
 
 func (c FtSearchSortbySortby) Asc() FtSearchSortbyOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (FtSearchSortbyOrderAsc)(c)
 }
 
 func (c SFtSearchSortbySortby) Asc() SFtSearchSortbyOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SFtSearchSortbyOrderAsc)(c)
 }
 
 func (c FtSearchSortbySortby) Desc() FtSearchSortbyOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (FtSearchSortbyOrderDesc)(c)
 }
 
 func (c SFtSearchSortbySortby) Desc() SFtSearchSortbyOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SFtSearchSortbyOrderDesc)(c)
 }
 
 func (c FtSearchSortbySortby) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSortbySortby) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15571,142 +16155,142 @@ type FtSearchSummarizeFieldsField Completed
 type SFtSearchSummarizeFieldsField SCompleted
 
 func (c FtSearchSummarizeFieldsField) Field(field ...string) FtSearchSummarizeFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SFtSearchSummarizeFieldsField) Field(field ...string) SFtSearchSummarizeFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c FtSearchSummarizeFieldsField) Frags(num int64) FtSearchSummarizeFrags {
-	c.cs = append(c.cs, "FRAGS", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "FRAGS", strconv.FormatInt(num, 10))
 	return (FtSearchSummarizeFrags)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Frags(num int64) SFtSearchSummarizeFrags {
-	c.cs = append(c.cs, "FRAGS", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "FRAGS", strconv.FormatInt(num, 10))
 	return (SFtSearchSummarizeFrags)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Len(fragsize int64) FtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (FtSearchSummarizeLen)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Len(fragsize int64) SFtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (SFtSearchSummarizeLen)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Separator(separator string) FtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (FtSearchSummarizeSeparator)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Separator(separator string) SFtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (SFtSearchSummarizeSeparator)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSummarizeFieldsField) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSummarizeFieldsField) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15723,12 +16307,12 @@ type FtSearchSummarizeFieldsFields Completed
 type SFtSearchSummarizeFieldsFields SCompleted
 
 func (c FtSearchSummarizeFieldsFields) Field(field ...string) FtSearchSummarizeFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (FtSearchSummarizeFieldsField)(c)
 }
 
 func (c SFtSearchSummarizeFieldsFields) Field(field ...string) SFtSearchSummarizeFieldsField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SFtSearchSummarizeFieldsField)(c)
 }
 
@@ -15737,122 +16321,122 @@ type FtSearchSummarizeFrags Completed
 type SFtSearchSummarizeFrags SCompleted
 
 func (c FtSearchSummarizeFrags) Len(fragsize int64) FtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (FtSearchSummarizeLen)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Len(fragsize int64) SFtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (SFtSearchSummarizeLen)(c)
 }
 
 func (c FtSearchSummarizeFrags) Separator(separator string) FtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (FtSearchSummarizeSeparator)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Separator(separator string) SFtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (SFtSearchSummarizeSeparator)(c)
 }
 
 func (c FtSearchSummarizeFrags) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchSummarizeFrags) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchSummarizeFrags) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSummarizeFrags) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSummarizeFrags) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSummarizeFrags) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSummarizeFrags) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSummarizeFrags) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSummarizeFrags) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSummarizeFrags) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSummarizeFrags) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15869,112 +16453,112 @@ type FtSearchSummarizeLen Completed
 type SFtSearchSummarizeLen SCompleted
 
 func (c FtSearchSummarizeLen) Separator(separator string) FtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (FtSearchSummarizeSeparator)(c)
 }
 
 func (c SFtSearchSummarizeLen) Separator(separator string) SFtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (SFtSearchSummarizeSeparator)(c)
 }
 
 func (c FtSearchSummarizeLen) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchSummarizeLen) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchSummarizeLen) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchSummarizeLen) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchSummarizeLen) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSummarizeLen) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSummarizeLen) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSummarizeLen) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSummarizeLen) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSummarizeLen) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSummarizeLen) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSummarizeLen) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSummarizeLen) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSummarizeLen) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSummarizeLen) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSummarizeLen) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSummarizeLen) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSummarizeLen) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSummarizeLen) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSummarizeLen) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -15991,102 +16575,102 @@ type FtSearchSummarizeSeparator Completed
 type SFtSearchSummarizeSeparator SCompleted
 
 func (c FtSearchSummarizeSeparator) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSummarizeSeparator) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSummarizeSeparator) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16103,142 +16687,142 @@ type FtSearchSummarizeSummarize Completed
 type SFtSearchSummarizeSummarize SCompleted
 
 func (c FtSearchSummarizeSummarize) Fields(count string) FtSearchSummarizeFieldsFields {
-	c.cs = append(c.cs, "FIELDS", count)
+	c.cs.s = append(c.cs.s, "FIELDS", count)
 	return (FtSearchSummarizeFieldsFields)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Fields(count string) SFtSearchSummarizeFieldsFields {
-	c.cs = append(c.cs, "FIELDS", count)
+	c.cs.s = append(c.cs.s, "FIELDS", count)
 	return (SFtSearchSummarizeFieldsFields)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Frags(num int64) FtSearchSummarizeFrags {
-	c.cs = append(c.cs, "FRAGS", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "FRAGS", strconv.FormatInt(num, 10))
 	return (FtSearchSummarizeFrags)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Frags(num int64) SFtSearchSummarizeFrags {
-	c.cs = append(c.cs, "FRAGS", strconv.FormatInt(num, 10))
+	c.cs.s = append(c.cs.s, "FRAGS", strconv.FormatInt(num, 10))
 	return (SFtSearchSummarizeFrags)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Len(fragsize int64) FtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (FtSearchSummarizeLen)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Len(fragsize int64) SFtSearchSummarizeLen {
-	c.cs = append(c.cs, "LEN", strconv.FormatInt(fragsize, 10))
+	c.cs.s = append(c.cs.s, "LEN", strconv.FormatInt(fragsize, 10))
 	return (SFtSearchSummarizeLen)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Separator(separator string) FtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (FtSearchSummarizeSeparator)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Separator(separator string) SFtSearchSummarizeSeparator {
-	c.cs = append(c.cs, "SEPARATOR", separator)
+	c.cs.s = append(c.cs.s, "SEPARATOR", separator)
 	return (SFtSearchSummarizeSeparator)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchSummarizeSummarize) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchSummarizeSummarize) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16255,72 +16839,72 @@ type FtSearchTagsInorder Completed
 type SFtSearchTagsInorder SCompleted
 
 func (c FtSearchTagsInorder) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchTagsInorder) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchTagsInorder) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchTagsInorder) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchTagsInorder) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchTagsInorder) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchTagsInorder) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchTagsInorder) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchTagsInorder) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchTagsInorder) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchTagsInorder) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchTagsInorder) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchTagsInorder) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchTagsInorder) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16337,202 +16921,202 @@ type FtSearchVerbatim Completed
 type SFtSearchVerbatim SCompleted
 
 func (c FtSearchVerbatim) Nostopwords() FtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (FtSearchNostopwords)(c)
 }
 
 func (c SFtSearchVerbatim) Nostopwords() SFtSearchNostopwords {
-	c.cs = append(c.cs, "NOSTOPWORDS")
+	c.cs.s = append(c.cs.s, "NOSTOPWORDS")
 	return (SFtSearchNostopwords)(c)
 }
 
 func (c FtSearchVerbatim) Withscores() FtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSearchWithscores)(c)
 }
 
 func (c SFtSearchVerbatim) Withscores() SFtSearchWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSearchWithscores)(c)
 }
 
 func (c FtSearchVerbatim) Withpayloads() FtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSearchWithpayloads)(c)
 }
 
 func (c SFtSearchVerbatim) Withpayloads() SFtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSearchWithpayloads)(c)
 }
 
 func (c FtSearchVerbatim) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchVerbatim) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchVerbatim) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchVerbatim) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchVerbatim) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchVerbatim) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchVerbatim) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchVerbatim) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchVerbatim) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchVerbatim) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchVerbatim) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchVerbatim) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchVerbatim) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchVerbatim) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchVerbatim) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchVerbatim) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchVerbatim) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchVerbatim) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchVerbatim) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchVerbatim) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchVerbatim) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchVerbatim) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchVerbatim) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchVerbatim) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchVerbatim) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchVerbatim) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchVerbatim) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchVerbatim) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchVerbatim) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchVerbatim) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchVerbatim) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchVerbatim) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchVerbatim) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchVerbatim) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16549,172 +17133,172 @@ type FtSearchWithpayloads Completed
 type SFtSearchWithpayloads SCompleted
 
 func (c FtSearchWithpayloads) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchWithpayloads) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchWithpayloads) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchWithpayloads) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchWithpayloads) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchWithpayloads) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchWithpayloads) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchWithpayloads) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchWithpayloads) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchWithpayloads) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchWithpayloads) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchWithpayloads) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchWithpayloads) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchWithpayloads) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchWithpayloads) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchWithpayloads) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchWithpayloads) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchWithpayloads) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchWithpayloads) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchWithpayloads) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchWithpayloads) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchWithpayloads) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchWithpayloads) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchWithpayloads) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchWithpayloads) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchWithpayloads) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchWithpayloads) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchWithpayloads) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchWithpayloads) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchWithpayloads) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchWithpayloads) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchWithpayloads) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchWithpayloads) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchWithpayloads) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16731,182 +17315,182 @@ type FtSearchWithscores Completed
 type SFtSearchWithscores SCompleted
 
 func (c FtSearchWithscores) Withpayloads() FtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSearchWithpayloads)(c)
 }
 
 func (c SFtSearchWithscores) Withpayloads() SFtSearchWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSearchWithpayloads)(c)
 }
 
 func (c FtSearchWithscores) Withsortkeys() FtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (FtSearchWithsortkeys)(c)
 }
 
 func (c SFtSearchWithscores) Withsortkeys() SFtSearchWithsortkeys {
-	c.cs = append(c.cs, "WITHSORTKEYS")
+	c.cs.s = append(c.cs.s, "WITHSORTKEYS")
 	return (SFtSearchWithsortkeys)(c)
 }
 
 func (c FtSearchWithscores) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchWithscores) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchWithscores) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchWithscores) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchWithscores) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchWithscores) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchWithscores) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchWithscores) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchWithscores) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchWithscores) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchWithscores) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchWithscores) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchWithscores) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchWithscores) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchWithscores) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchWithscores) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchWithscores) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchWithscores) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchWithscores) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchWithscores) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchWithscores) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchWithscores) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchWithscores) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchWithscores) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchWithscores) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchWithscores) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchWithscores) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchWithscores) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchWithscores) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchWithscores) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchWithscores) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchWithscores) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -16923,162 +17507,162 @@ type FtSearchWithsortkeys Completed
 type SFtSearchWithsortkeys SCompleted
 
 func (c FtSearchWithsortkeys) Filter(numericField string) FtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (FtSearchFilterFilter)(c)
 }
 
 func (c SFtSearchWithsortkeys) Filter(numericField string) SFtSearchFilterFilter {
-	c.cs = append(c.cs, "FILTER", numericField)
+	c.cs.s = append(c.cs.s, "FILTER", numericField)
 	return (SFtSearchFilterFilter)(c)
 }
 
 func (c FtSearchWithsortkeys) Geofilter(geoField string) FtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (FtSearchGeoFilterGeofilter)(c)
 }
 
 func (c SFtSearchWithsortkeys) Geofilter(geoField string) SFtSearchGeoFilterGeofilter {
-	c.cs = append(c.cs, "GEOFILTER", geoField)
+	c.cs.s = append(c.cs.s, "GEOFILTER", geoField)
 	return (SFtSearchGeoFilterGeofilter)(c)
 }
 
 func (c FtSearchWithsortkeys) Inkeys(count string) FtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (FtSearchInKeysInkeys)(c)
 }
 
 func (c SFtSearchWithsortkeys) Inkeys(count string) SFtSearchInKeysInkeys {
-	c.cs = append(c.cs, "INKEYS", count)
+	c.cs.s = append(c.cs.s, "INKEYS", count)
 	return (SFtSearchInKeysInkeys)(c)
 }
 
 func (c FtSearchWithsortkeys) Infields(count string) FtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (FtSearchInFieldsInfields)(c)
 }
 
 func (c SFtSearchWithsortkeys) Infields(count string) SFtSearchInFieldsInfields {
-	c.cs = append(c.cs, "INFIELDS", count)
+	c.cs.s = append(c.cs.s, "INFIELDS", count)
 	return (SFtSearchInFieldsInfields)(c)
 }
 
 func (c FtSearchWithsortkeys) Return(count string) FtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (FtSearchReturnReturn)(c)
 }
 
 func (c SFtSearchWithsortkeys) Return(count string) SFtSearchReturnReturn {
-	c.cs = append(c.cs, "RETURN", count)
+	c.cs.s = append(c.cs.s, "RETURN", count)
 	return (SFtSearchReturnReturn)(c)
 }
 
 func (c FtSearchWithsortkeys) Summarize() FtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (FtSearchSummarizeSummarize)(c)
 }
 
 func (c SFtSearchWithsortkeys) Summarize() SFtSearchSummarizeSummarize {
-	c.cs = append(c.cs, "SUMMARIZE")
+	c.cs.s = append(c.cs.s, "SUMMARIZE")
 	return (SFtSearchSummarizeSummarize)(c)
 }
 
 func (c FtSearchWithsortkeys) Highlight() FtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (FtSearchHighlightHighlight)(c)
 }
 
 func (c SFtSearchWithsortkeys) Highlight() SFtSearchHighlightHighlight {
-	c.cs = append(c.cs, "HIGHLIGHT")
+	c.cs.s = append(c.cs.s, "HIGHLIGHT")
 	return (SFtSearchHighlightHighlight)(c)
 }
 
 func (c FtSearchWithsortkeys) Slop(slop int64) FtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (FtSearchSlop)(c)
 }
 
 func (c SFtSearchWithsortkeys) Slop(slop int64) SFtSearchSlop {
-	c.cs = append(c.cs, "SLOP", strconv.FormatInt(slop, 10))
+	c.cs.s = append(c.cs.s, "SLOP", strconv.FormatInt(slop, 10))
 	return (SFtSearchSlop)(c)
 }
 
 func (c FtSearchWithsortkeys) Inorder() FtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (FtSearchTagsInorder)(c)
 }
 
 func (c SFtSearchWithsortkeys) Inorder() SFtSearchTagsInorder {
-	c.cs = append(c.cs, "INORDER")
+	c.cs.s = append(c.cs.s, "INORDER")
 	return (SFtSearchTagsInorder)(c)
 }
 
 func (c FtSearchWithsortkeys) Language(language string) FtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (FtSearchLanguage)(c)
 }
 
 func (c SFtSearchWithsortkeys) Language(language string) SFtSearchLanguage {
-	c.cs = append(c.cs, "LANGUAGE", language)
+	c.cs.s = append(c.cs.s, "LANGUAGE", language)
 	return (SFtSearchLanguage)(c)
 }
 
 func (c FtSearchWithsortkeys) Expander(expander string) FtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (FtSearchExpander)(c)
 }
 
 func (c SFtSearchWithsortkeys) Expander(expander string) SFtSearchExpander {
-	c.cs = append(c.cs, "EXPANDER", expander)
+	c.cs.s = append(c.cs.s, "EXPANDER", expander)
 	return (SFtSearchExpander)(c)
 }
 
 func (c FtSearchWithsortkeys) Scorer(scorer string) FtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (FtSearchScorer)(c)
 }
 
 func (c SFtSearchWithsortkeys) Scorer(scorer string) SFtSearchScorer {
-	c.cs = append(c.cs, "SCORER", scorer)
+	c.cs.s = append(c.cs.s, "SCORER", scorer)
 	return (SFtSearchScorer)(c)
 }
 
 func (c FtSearchWithsortkeys) Explainscore() FtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (FtSearchExplainscore)(c)
 }
 
 func (c SFtSearchWithsortkeys) Explainscore() SFtSearchExplainscore {
-	c.cs = append(c.cs, "EXPLAINSCORE")
+	c.cs.s = append(c.cs.s, "EXPLAINSCORE")
 	return (SFtSearchExplainscore)(c)
 }
 
 func (c FtSearchWithsortkeys) Payload(payload string) FtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSearchPayload)(c)
 }
 
 func (c SFtSearchWithsortkeys) Payload(payload string) SFtSearchPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSearchPayload)(c)
 }
 
 func (c FtSearchWithsortkeys) Sortby(sortby string) FtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (FtSearchSortbySortby)(c)
 }
 
 func (c SFtSearchWithsortkeys) Sortby(sortby string) SFtSearchSortbySortby {
-	c.cs = append(c.cs, "SORTBY", sortby)
+	c.cs.s = append(c.cs.s, "SORTBY", sortby)
 	return (SFtSearchSortbySortby)(c)
 }
 
 func (c FtSearchWithsortkeys) Limit() FtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (FtSearchLimitLimit)(c)
 }
 
 func (c SFtSearchWithsortkeys) Limit() SFtSearchLimitLimit {
-	c.cs = append(c.cs, "LIMIT")
+	c.cs.s = append(c.cs.s, "LIMIT")
 	return (SFtSearchLimitLimit)(c)
 }
 
@@ -17094,21 +17678,25 @@ type FtSpellcheck Completed
 
 type SFtSpellcheck SCompleted
 
-func (b *Builder) FtSpellcheck() FtSpellcheck {
-	return FtSpellcheck{cs: append(b.get(), "FT.SPELLCHECK"), ks: InitSlot}
+func (b *Builder) FtSpellcheck() (c FtSpellcheck) {
+	c = FtSpellcheck{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SPELLCHECK")
+	return c
 }
 
-func (b *SBuilder) FtSpellcheck() SFtSpellcheck {
-	return SFtSpellcheck{cs: append(b.get(), "FT.SPELLCHECK"), ks: InitSlot}
+func (b *SBuilder) FtSpellcheck() (c SFtSpellcheck) {
+	c = SFtSpellcheck{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SPELLCHECK")
+	return c
 }
 
 func (c FtSpellcheck) Index(index string) FtSpellcheckIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtSpellcheckIndex)(c)
 }
 
 func (c SFtSpellcheck) Index(index string) SFtSpellcheckIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtSpellcheckIndex)(c)
 }
 
@@ -17117,22 +17705,22 @@ type FtSpellcheckDistance Completed
 type SFtSpellcheckDistance SCompleted
 
 func (c FtSpellcheckDistance) TermsInclude() FtSpellcheckTermsTermsInclude {
-	c.cs = append(c.cs, "TERMS", "INCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "INCLUDE")
 	return (FtSpellcheckTermsTermsInclude)(c)
 }
 
 func (c SFtSpellcheckDistance) TermsInclude() SFtSpellcheckTermsTermsInclude {
-	c.cs = append(c.cs, "TERMS", "INCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "INCLUDE")
 	return (SFtSpellcheckTermsTermsInclude)(c)
 }
 
 func (c FtSpellcheckDistance) TermsExclude() FtSpellcheckTermsTermsExclude {
-	c.cs = append(c.cs, "TERMS", "EXCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "EXCLUDE")
 	return (FtSpellcheckTermsTermsExclude)(c)
 }
 
 func (c SFtSpellcheckDistance) TermsExclude() SFtSpellcheckTermsTermsExclude {
-	c.cs = append(c.cs, "TERMS", "EXCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "EXCLUDE")
 	return (SFtSpellcheckTermsTermsExclude)(c)
 }
 
@@ -17149,12 +17737,12 @@ type FtSpellcheckIndex Completed
 type SFtSpellcheckIndex SCompleted
 
 func (c FtSpellcheckIndex) Query(query string) FtSpellcheckQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (FtSpellcheckQuery)(c)
 }
 
 func (c SFtSpellcheckIndex) Query(query string) SFtSpellcheckQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SFtSpellcheckQuery)(c)
 }
 
@@ -17163,32 +17751,32 @@ type FtSpellcheckQuery Completed
 type SFtSpellcheckQuery SCompleted
 
 func (c FtSpellcheckQuery) Distance(distance int64) FtSpellcheckDistance {
-	c.cs = append(c.cs, "DISTANCE", strconv.FormatInt(distance, 10))
+	c.cs.s = append(c.cs.s, "DISTANCE", strconv.FormatInt(distance, 10))
 	return (FtSpellcheckDistance)(c)
 }
 
 func (c SFtSpellcheckQuery) Distance(distance int64) SFtSpellcheckDistance {
-	c.cs = append(c.cs, "DISTANCE", strconv.FormatInt(distance, 10))
+	c.cs.s = append(c.cs.s, "DISTANCE", strconv.FormatInt(distance, 10))
 	return (SFtSpellcheckDistance)(c)
 }
 
 func (c FtSpellcheckQuery) TermsInclude() FtSpellcheckTermsTermsInclude {
-	c.cs = append(c.cs, "TERMS", "INCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "INCLUDE")
 	return (FtSpellcheckTermsTermsInclude)(c)
 }
 
 func (c SFtSpellcheckQuery) TermsInclude() SFtSpellcheckTermsTermsInclude {
-	c.cs = append(c.cs, "TERMS", "INCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "INCLUDE")
 	return (SFtSpellcheckTermsTermsInclude)(c)
 }
 
 func (c FtSpellcheckQuery) TermsExclude() FtSpellcheckTermsTermsExclude {
-	c.cs = append(c.cs, "TERMS", "EXCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "EXCLUDE")
 	return (FtSpellcheckTermsTermsExclude)(c)
 }
 
 func (c SFtSpellcheckQuery) TermsExclude() SFtSpellcheckTermsTermsExclude {
-	c.cs = append(c.cs, "TERMS", "EXCLUDE")
+	c.cs.s = append(c.cs.s, "TERMS", "EXCLUDE")
 	return (SFtSpellcheckTermsTermsExclude)(c)
 }
 
@@ -17205,12 +17793,12 @@ type FtSpellcheckTermsDictionary Completed
 type SFtSpellcheckTermsDictionary SCompleted
 
 func (c FtSpellcheckTermsDictionary) Terms(terms ...string) FtSpellcheckTermsTerms {
-	c.cs = append(c.cs, terms...)
+	c.cs.s = append(c.cs.s, terms...)
 	return (FtSpellcheckTermsTerms)(c)
 }
 
 func (c SFtSpellcheckTermsDictionary) Terms(terms ...string) SFtSpellcheckTermsTerms {
-	c.cs = append(c.cs, terms...)
+	c.cs.s = append(c.cs.s, terms...)
 	return (SFtSpellcheckTermsTerms)(c)
 }
 
@@ -17227,12 +17815,12 @@ type FtSpellcheckTermsTerms Completed
 type SFtSpellcheckTermsTerms SCompleted
 
 func (c FtSpellcheckTermsTerms) Terms(terms ...string) FtSpellcheckTermsTerms {
-	c.cs = append(c.cs, terms...)
+	c.cs.s = append(c.cs.s, terms...)
 	return c
 }
 
 func (c SFtSpellcheckTermsTerms) Terms(terms ...string) SFtSpellcheckTermsTerms {
-	c.cs = append(c.cs, terms...)
+	c.cs.s = append(c.cs.s, terms...)
 	return c
 }
 
@@ -17249,12 +17837,12 @@ type FtSpellcheckTermsTermsExclude Completed
 type SFtSpellcheckTermsTermsExclude SCompleted
 
 func (c FtSpellcheckTermsTermsExclude) Dictionary(dictionary string) FtSpellcheckTermsDictionary {
-	c.cs = append(c.cs, dictionary)
+	c.cs.s = append(c.cs.s, dictionary)
 	return (FtSpellcheckTermsDictionary)(c)
 }
 
 func (c SFtSpellcheckTermsTermsExclude) Dictionary(dictionary string) SFtSpellcheckTermsDictionary {
-	c.cs = append(c.cs, dictionary)
+	c.cs.s = append(c.cs.s, dictionary)
 	return (SFtSpellcheckTermsDictionary)(c)
 }
 
@@ -17263,12 +17851,12 @@ type FtSpellcheckTermsTermsInclude Completed
 type SFtSpellcheckTermsTermsInclude SCompleted
 
 func (c FtSpellcheckTermsTermsInclude) Dictionary(dictionary string) FtSpellcheckTermsDictionary {
-	c.cs = append(c.cs, dictionary)
+	c.cs.s = append(c.cs.s, dictionary)
 	return (FtSpellcheckTermsDictionary)(c)
 }
 
 func (c SFtSpellcheckTermsTermsInclude) Dictionary(dictionary string) SFtSpellcheckTermsDictionary {
-	c.cs = append(c.cs, dictionary)
+	c.cs.s = append(c.cs.s, dictionary)
 	return (SFtSpellcheckTermsDictionary)(c)
 }
 
@@ -17276,21 +17864,25 @@ type FtSugadd Completed
 
 type SFtSugadd SCompleted
 
-func (b *Builder) FtSugadd() FtSugadd {
-	return FtSugadd{cs: append(b.get(), "FT.SUGADD"), ks: InitSlot}
+func (b *Builder) FtSugadd() (c FtSugadd) {
+	c = FtSugadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGADD")
+	return c
 }
 
-func (b *SBuilder) FtSugadd() SFtSugadd {
-	return SFtSugadd{cs: append(b.get(), "FT.SUGADD"), ks: InitSlot}
+func (b *SBuilder) FtSugadd() (c SFtSugadd) {
+	c = SFtSugadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGADD")
+	return c
 }
 
 func (c FtSugadd) Key(key string) FtSugaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (FtSugaddKey)(c)
 }
 
 func (c SFtSugadd) Key(key string) SFtSugaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SFtSugaddKey)(c)
 }
 
@@ -17299,12 +17891,12 @@ type FtSugaddIncrementScoreIncr Completed
 type SFtSugaddIncrementScoreIncr SCompleted
 
 func (c FtSugaddIncrementScoreIncr) Payload(payload string) FtSugaddPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSugaddPayload)(c)
 }
 
 func (c SFtSugaddIncrementScoreIncr) Payload(payload string) SFtSugaddPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSugaddPayload)(c)
 }
 
@@ -17321,12 +17913,12 @@ type FtSugaddKey Completed
 type SFtSugaddKey SCompleted
 
 func (c FtSugaddKey) String(string string) FtSugaddString {
-	c.cs = append(c.cs, string)
+	c.cs.s = append(c.cs.s, string)
 	return (FtSugaddString)(c)
 }
 
 func (c SFtSugaddKey) String(string string) SFtSugaddString {
-	c.cs = append(c.cs, string)
+	c.cs.s = append(c.cs.s, string)
 	return (SFtSugaddString)(c)
 }
 
@@ -17347,22 +17939,22 @@ type FtSugaddScore Completed
 type SFtSugaddScore SCompleted
 
 func (c FtSugaddScore) Incr() FtSugaddIncrementScoreIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (FtSugaddIncrementScoreIncr)(c)
 }
 
 func (c SFtSugaddScore) Incr() SFtSugaddIncrementScoreIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SFtSugaddIncrementScoreIncr)(c)
 }
 
 func (c FtSugaddScore) Payload(payload string) FtSugaddPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (FtSugaddPayload)(c)
 }
 
 func (c SFtSugaddScore) Payload(payload string) SFtSugaddPayload {
-	c.cs = append(c.cs, "PAYLOAD", payload)
+	c.cs.s = append(c.cs.s, "PAYLOAD", payload)
 	return (SFtSugaddPayload)(c)
 }
 
@@ -17379,12 +17971,12 @@ type FtSugaddString Completed
 type SFtSugaddString SCompleted
 
 func (c FtSugaddString) Score(score float64) FtSugaddScore {
-	c.cs = append(c.cs, strconv.FormatFloat(score, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(score, 'f', -1, 64))
 	return (FtSugaddScore)(c)
 }
 
 func (c SFtSugaddString) Score(score float64) SFtSugaddScore {
-	c.cs = append(c.cs, strconv.FormatFloat(score, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(score, 'f', -1, 64))
 	return (SFtSugaddScore)(c)
 }
 
@@ -17392,21 +17984,25 @@ type FtSugdel Completed
 
 type SFtSugdel SCompleted
 
-func (b *Builder) FtSugdel() FtSugdel {
-	return FtSugdel{cs: append(b.get(), "FT.SUGDEL"), ks: InitSlot}
+func (b *Builder) FtSugdel() (c FtSugdel) {
+	c = FtSugdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGDEL")
+	return c
 }
 
-func (b *SBuilder) FtSugdel() SFtSugdel {
-	return SFtSugdel{cs: append(b.get(), "FT.SUGDEL"), ks: InitSlot}
+func (b *SBuilder) FtSugdel() (c SFtSugdel) {
+	c = SFtSugdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGDEL")
+	return c
 }
 
 func (c FtSugdel) Key(key string) FtSugdelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (FtSugdelKey)(c)
 }
 
 func (c SFtSugdel) Key(key string) SFtSugdelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SFtSugdelKey)(c)
 }
 
@@ -17415,12 +18011,12 @@ type FtSugdelKey Completed
 type SFtSugdelKey SCompleted
 
 func (c FtSugdelKey) String(string string) FtSugdelString {
-	c.cs = append(c.cs, string)
+	c.cs.s = append(c.cs.s, string)
 	return (FtSugdelString)(c)
 }
 
 func (c SFtSugdelKey) String(string string) SFtSugdelString {
-	c.cs = append(c.cs, string)
+	c.cs.s = append(c.cs.s, string)
 	return (SFtSugdelString)(c)
 }
 
@@ -17440,21 +18036,25 @@ type FtSugget Completed
 
 type SFtSugget SCompleted
 
-func (b *Builder) FtSugget() FtSugget {
-	return FtSugget{cs: append(b.get(), "FT.SUGGET"), ks: InitSlot}
+func (b *Builder) FtSugget() (c FtSugget) {
+	c = FtSugget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGGET")
+	return c
 }
 
-func (b *SBuilder) FtSugget() SFtSugget {
-	return SFtSugget{cs: append(b.get(), "FT.SUGGET"), ks: InitSlot}
+func (b *SBuilder) FtSugget() (c SFtSugget) {
+	c = SFtSugget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGGET")
+	return c
 }
 
 func (c FtSugget) Key(key string) FtSuggetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (FtSuggetKey)(c)
 }
 
 func (c SFtSugget) Key(key string) SFtSuggetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SFtSuggetKey)(c)
 }
 
@@ -17463,32 +18063,32 @@ type FtSuggetFuzzy Completed
 type SFtSuggetFuzzy SCompleted
 
 func (c FtSuggetFuzzy) Withscores() FtSuggetWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSuggetWithscores)(c)
 }
 
 func (c SFtSuggetFuzzy) Withscores() SFtSuggetWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSuggetWithscores)(c)
 }
 
 func (c FtSuggetFuzzy) Withpayloads() FtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSuggetWithpayloads)(c)
 }
 
 func (c SFtSuggetFuzzy) Withpayloads() SFtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSuggetWithpayloads)(c)
 }
 
 func (c FtSuggetFuzzy) Max(max int64) FtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (FtSuggetMax)(c)
 }
 
 func (c SFtSuggetFuzzy) Max(max int64) SFtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (SFtSuggetMax)(c)
 }
 
@@ -17505,12 +18105,12 @@ type FtSuggetKey Completed
 type SFtSuggetKey SCompleted
 
 func (c FtSuggetKey) Prefix(prefix string) FtSuggetPrefix {
-	c.cs = append(c.cs, prefix)
+	c.cs.s = append(c.cs.s, prefix)
 	return (FtSuggetPrefix)(c)
 }
 
 func (c SFtSuggetKey) Prefix(prefix string) SFtSuggetPrefix {
-	c.cs = append(c.cs, prefix)
+	c.cs.s = append(c.cs.s, prefix)
 	return (SFtSuggetPrefix)(c)
 }
 
@@ -17531,42 +18131,42 @@ type FtSuggetPrefix Completed
 type SFtSuggetPrefix SCompleted
 
 func (c FtSuggetPrefix) Fuzzy() FtSuggetFuzzy {
-	c.cs = append(c.cs, "FUZZY")
+	c.cs.s = append(c.cs.s, "FUZZY")
 	return (FtSuggetFuzzy)(c)
 }
 
 func (c SFtSuggetPrefix) Fuzzy() SFtSuggetFuzzy {
-	c.cs = append(c.cs, "FUZZY")
+	c.cs.s = append(c.cs.s, "FUZZY")
 	return (SFtSuggetFuzzy)(c)
 }
 
 func (c FtSuggetPrefix) Withscores() FtSuggetWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (FtSuggetWithscores)(c)
 }
 
 func (c SFtSuggetPrefix) Withscores() SFtSuggetWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SFtSuggetWithscores)(c)
 }
 
 func (c FtSuggetPrefix) Withpayloads() FtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSuggetWithpayloads)(c)
 }
 
 func (c SFtSuggetPrefix) Withpayloads() SFtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSuggetWithpayloads)(c)
 }
 
 func (c FtSuggetPrefix) Max(max int64) FtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (FtSuggetMax)(c)
 }
 
 func (c SFtSuggetPrefix) Max(max int64) SFtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (SFtSuggetMax)(c)
 }
 
@@ -17583,12 +18183,12 @@ type FtSuggetWithpayloads Completed
 type SFtSuggetWithpayloads SCompleted
 
 func (c FtSuggetWithpayloads) Max(max int64) FtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (FtSuggetMax)(c)
 }
 
 func (c SFtSuggetWithpayloads) Max(max int64) SFtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (SFtSuggetMax)(c)
 }
 
@@ -17605,22 +18205,22 @@ type FtSuggetWithscores Completed
 type SFtSuggetWithscores SCompleted
 
 func (c FtSuggetWithscores) Withpayloads() FtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (FtSuggetWithpayloads)(c)
 }
 
 func (c SFtSuggetWithscores) Withpayloads() SFtSuggetWithpayloads {
-	c.cs = append(c.cs, "WITHPAYLOADS")
+	c.cs.s = append(c.cs.s, "WITHPAYLOADS")
 	return (SFtSuggetWithpayloads)(c)
 }
 
 func (c FtSuggetWithscores) Max(max int64) FtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (FtSuggetMax)(c)
 }
 
 func (c SFtSuggetWithscores) Max(max int64) SFtSuggetMax {
-	c.cs = append(c.cs, "MAX", strconv.FormatInt(max, 10))
+	c.cs.s = append(c.cs.s, "MAX", strconv.FormatInt(max, 10))
 	return (SFtSuggetMax)(c)
 }
 
@@ -17636,21 +18236,25 @@ type FtSuglen Completed
 
 type SFtSuglen SCompleted
 
-func (b *Builder) FtSuglen() FtSuglen {
-	return FtSuglen{cs: append(b.get(), "FT.SUGLEN"), ks: InitSlot}
+func (b *Builder) FtSuglen() (c FtSuglen) {
+	c = FtSuglen{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGLEN")
+	return c
 }
 
-func (b *SBuilder) FtSuglen() SFtSuglen {
-	return SFtSuglen{cs: append(b.get(), "FT.SUGLEN"), ks: InitSlot}
+func (b *SBuilder) FtSuglen() (c SFtSuglen) {
+	c = SFtSuglen{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SUGLEN")
+	return c
 }
 
 func (c FtSuglen) Key(key string) FtSuglenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (FtSuglenKey)(c)
 }
 
 func (c SFtSuglen) Key(key string) SFtSuglenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SFtSuglenKey)(c)
 }
 
@@ -17670,21 +18274,25 @@ type FtSyndump Completed
 
 type SFtSyndump SCompleted
 
-func (b *Builder) FtSyndump() FtSyndump {
-	return FtSyndump{cs: append(b.get(), "FT.SYNDUMP"), ks: InitSlot}
+func (b *Builder) FtSyndump() (c FtSyndump) {
+	c = FtSyndump{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SYNDUMP")
+	return c
 }
 
-func (b *SBuilder) FtSyndump() SFtSyndump {
-	return SFtSyndump{cs: append(b.get(), "FT.SYNDUMP"), ks: InitSlot}
+func (b *SBuilder) FtSyndump() (c SFtSyndump) {
+	c = SFtSyndump{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SYNDUMP")
+	return c
 }
 
 func (c FtSyndump) Index(index string) FtSyndumpIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtSyndumpIndex)(c)
 }
 
 func (c SFtSyndump) Index(index string) SFtSyndumpIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtSyndumpIndex)(c)
 }
 
@@ -17704,21 +18312,25 @@ type FtSynupdate Completed
 
 type SFtSynupdate SCompleted
 
-func (b *Builder) FtSynupdate() FtSynupdate {
-	return FtSynupdate{cs: append(b.get(), "FT.SYNUPDATE"), ks: InitSlot}
+func (b *Builder) FtSynupdate() (c FtSynupdate) {
+	c = FtSynupdate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SYNUPDATE")
+	return c
 }
 
-func (b *SBuilder) FtSynupdate() SFtSynupdate {
-	return SFtSynupdate{cs: append(b.get(), "FT.SYNUPDATE"), ks: InitSlot}
+func (b *SBuilder) FtSynupdate() (c SFtSynupdate) {
+	c = SFtSynupdate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.SYNUPDATE")
+	return c
 }
 
 func (c FtSynupdate) Index(index string) FtSynupdateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtSynupdateIndex)(c)
 }
 
 func (c SFtSynupdate) Index(index string) SFtSynupdateIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtSynupdateIndex)(c)
 }
 
@@ -17727,12 +18339,12 @@ type FtSynupdateIndex Completed
 type SFtSynupdateIndex SCompleted
 
 func (c FtSynupdateIndex) SynonymGroupId(synonymGroupId string) FtSynupdateSynonymGroupId {
-	c.cs = append(c.cs, synonymGroupId)
+	c.cs.s = append(c.cs.s, synonymGroupId)
 	return (FtSynupdateSynonymGroupId)(c)
 }
 
 func (c SFtSynupdateIndex) SynonymGroupId(synonymGroupId string) SFtSynupdateSynonymGroupId {
-	c.cs = append(c.cs, synonymGroupId)
+	c.cs.s = append(c.cs.s, synonymGroupId)
 	return (SFtSynupdateSynonymGroupId)(c)
 }
 
@@ -17741,12 +18353,12 @@ type FtSynupdateSkipinitialscan Completed
 type SFtSynupdateSkipinitialscan SCompleted
 
 func (c FtSynupdateSkipinitialscan) Term(term ...string) FtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (FtSynupdateTerm)(c)
 }
 
 func (c SFtSynupdateSkipinitialscan) Term(term ...string) SFtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (SFtSynupdateTerm)(c)
 }
 
@@ -17755,22 +18367,22 @@ type FtSynupdateSynonymGroupId Completed
 type SFtSynupdateSynonymGroupId SCompleted
 
 func (c FtSynupdateSynonymGroupId) Skipinitialscan() FtSynupdateSkipinitialscan {
-	c.cs = append(c.cs, "SKIPINITIALSCAN")
+	c.cs.s = append(c.cs.s, "SKIPINITIALSCAN")
 	return (FtSynupdateSkipinitialscan)(c)
 }
 
 func (c SFtSynupdateSynonymGroupId) Skipinitialscan() SFtSynupdateSkipinitialscan {
-	c.cs = append(c.cs, "SKIPINITIALSCAN")
+	c.cs.s = append(c.cs.s, "SKIPINITIALSCAN")
 	return (SFtSynupdateSkipinitialscan)(c)
 }
 
 func (c FtSynupdateSynonymGroupId) Term(term ...string) FtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (FtSynupdateTerm)(c)
 }
 
 func (c SFtSynupdateSynonymGroupId) Term(term ...string) SFtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return (SFtSynupdateTerm)(c)
 }
 
@@ -17779,12 +18391,12 @@ type FtSynupdateTerm Completed
 type SFtSynupdateTerm SCompleted
 
 func (c FtSynupdateTerm) Term(term ...string) FtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
 func (c SFtSynupdateTerm) Term(term ...string) SFtSynupdateTerm {
-	c.cs = append(c.cs, term...)
+	c.cs.s = append(c.cs.s, term...)
 	return c
 }
 
@@ -17800,21 +18412,25 @@ type FtTagvals Completed
 
 type SFtTagvals SCompleted
 
-func (b *Builder) FtTagvals() FtTagvals {
-	return FtTagvals{cs: append(b.get(), "FT.TAGVALS"), ks: InitSlot}
+func (b *Builder) FtTagvals() (c FtTagvals) {
+	c = FtTagvals{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.TAGVALS")
+	return c
 }
 
-func (b *SBuilder) FtTagvals() SFtTagvals {
-	return SFtTagvals{cs: append(b.get(), "FT.TAGVALS"), ks: InitSlot}
+func (b *SBuilder) FtTagvals() (c SFtTagvals) {
+	c = SFtTagvals{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "FT.TAGVALS")
+	return c
 }
 
 func (c FtTagvals) Index(index string) FtTagvalsIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (FtTagvalsIndex)(c)
 }
 
 func (c SFtTagvals) Index(index string) SFtTagvalsIndex {
-	c.cs = append(c.cs, index)
+	c.cs.s = append(c.cs.s, index)
 	return (SFtTagvalsIndex)(c)
 }
 
@@ -17835,12 +18451,12 @@ type FtTagvalsIndex Completed
 type SFtTagvalsIndex SCompleted
 
 func (c FtTagvalsIndex) FieldName(fieldName string) FtTagvalsFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (FtTagvalsFieldName)(c)
 }
 
 func (c SFtTagvalsIndex) FieldName(fieldName string) SFtTagvalsFieldName {
-	c.cs = append(c.cs, fieldName)
+	c.cs.s = append(c.cs.s, fieldName)
 	return (SFtTagvalsFieldName)(c)
 }
 
@@ -17848,22 +18464,26 @@ type Geoadd Completed
 
 type SGeoadd SCompleted
 
-func (b *Builder) Geoadd() Geoadd {
-	return Geoadd{cs: append(b.get(), "GEOADD"), ks: InitSlot}
+func (b *Builder) Geoadd() (c Geoadd) {
+	c = Geoadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEOADD")
+	return c
 }
 
-func (b *SBuilder) Geoadd() SGeoadd {
-	return SGeoadd{cs: append(b.get(), "GEOADD"), ks: InitSlot}
+func (b *SBuilder) Geoadd() (c SGeoadd) {
+	c = SGeoadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEOADD")
+	return c
 }
 
 func (c Geoadd) Key(key string) GeoaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoaddKey)(c)
 }
 
 func (c SGeoadd) Key(key string) SGeoaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoaddKey)(c)
 }
 
@@ -17884,12 +18504,12 @@ type GeoaddConditionNx Completed
 type SGeoaddConditionNx SCompleted
 
 func (c GeoaddConditionNx) Ch() GeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (GeoaddChangeCh)(c)
 }
 
 func (c SGeoaddConditionNx) Ch() SGeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SGeoaddChangeCh)(c)
 }
 
@@ -17906,12 +18526,12 @@ type GeoaddConditionXx Completed
 type SGeoaddConditionXx SCompleted
 
 func (c GeoaddConditionXx) Ch() GeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (GeoaddChangeCh)(c)
 }
 
 func (c SGeoaddConditionXx) Ch() SGeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SGeoaddChangeCh)(c)
 }
 
@@ -17928,32 +18548,32 @@ type GeoaddKey Completed
 type SGeoaddKey SCompleted
 
 func (c GeoaddKey) Nx() GeoaddConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (GeoaddConditionNx)(c)
 }
 
 func (c SGeoaddKey) Nx() SGeoaddConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SGeoaddConditionNx)(c)
 }
 
 func (c GeoaddKey) Xx() GeoaddConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (GeoaddConditionXx)(c)
 }
 
 func (c SGeoaddKey) Xx() SGeoaddConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SGeoaddConditionXx)(c)
 }
 
 func (c GeoaddKey) Ch() GeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (GeoaddChangeCh)(c)
 }
 
 func (c SGeoaddKey) Ch() SGeoaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SGeoaddChangeCh)(c)
 }
 
@@ -17970,12 +18590,12 @@ type GeoaddLongitudeLatitudeMember Completed
 type SGeoaddLongitudeLatitudeMember SCompleted
 
 func (c GeoaddLongitudeLatitudeMember) LongitudeLatitudeMember(longitude float64, latitude float64, member string) GeoaddLongitudeLatitudeMember {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64), member)
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64), member)
 	return c
 }
 
 func (c SGeoaddLongitudeLatitudeMember) LongitudeLatitudeMember(longitude float64, latitude float64, member string) SGeoaddLongitudeLatitudeMember {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64), member)
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64), member)
 	return c
 }
 
@@ -17991,22 +18611,26 @@ type Geodist Completed
 
 type SGeodist SCompleted
 
-func (b *Builder) Geodist() Geodist {
-	return Geodist{cs: append(b.get(), "GEODIST"), ks: InitSlot, cf: readonly}
+func (b *Builder) Geodist() (c Geodist) {
+	c = Geodist{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEODIST")
+	return c
 }
 
-func (b *SBuilder) Geodist() SGeodist {
-	return SGeodist{cs: append(b.get(), "GEODIST"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Geodist() (c SGeodist) {
+	c = SGeodist{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEODIST")
+	return c
 }
 
 func (c Geodist) Key(key string) GeodistKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeodistKey)(c)
 }
 
 func (c SGeodist) Key(key string) SGeodistKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeodistKey)(c)
 }
 
@@ -18015,12 +18639,12 @@ type GeodistKey Completed
 type SGeodistKey SCompleted
 
 func (c GeodistKey) Member1(member1 string) GeodistMember1 {
-	c.cs = append(c.cs, member1)
+	c.cs.s = append(c.cs.s, member1)
 	return (GeodistMember1)(c)
 }
 
 func (c SGeodistKey) Member1(member1 string) SGeodistMember1 {
-	c.cs = append(c.cs, member1)
+	c.cs.s = append(c.cs.s, member1)
 	return (SGeodistMember1)(c)
 }
 
@@ -18029,12 +18653,12 @@ type GeodistMember1 Completed
 type SGeodistMember1 SCompleted
 
 func (c GeodistMember1) Member2(member2 string) GeodistMember2 {
-	c.cs = append(c.cs, member2)
+	c.cs.s = append(c.cs.s, member2)
 	return (GeodistMember2)(c)
 }
 
 func (c SGeodistMember1) Member2(member2 string) SGeodistMember2 {
-	c.cs = append(c.cs, member2)
+	c.cs.s = append(c.cs.s, member2)
 	return (SGeodistMember2)(c)
 }
 
@@ -18043,42 +18667,42 @@ type GeodistMember2 Completed
 type SGeodistMember2 SCompleted
 
 func (c GeodistMember2) M() GeodistUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeodistUnitM)(c)
 }
 
 func (c SGeodistMember2) M() SGeodistUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeodistUnitM)(c)
 }
 
 func (c GeodistMember2) Km() GeodistUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeodistUnitKm)(c)
 }
 
 func (c SGeodistMember2) Km() SGeodistUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeodistUnitKm)(c)
 }
 
 func (c GeodistMember2) Ft() GeodistUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeodistUnitFt)(c)
 }
 
 func (c SGeodistMember2) Ft() SGeodistUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeodistUnitFt)(c)
 }
 
 func (c GeodistMember2) Mi() GeodistUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeodistUnitMi)(c)
 }
 
 func (c SGeodistMember2) Mi() SGeodistUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeodistUnitMi)(c)
 }
 
@@ -18182,22 +18806,26 @@ type Geohash Completed
 
 type SGeohash SCompleted
 
-func (b *Builder) Geohash() Geohash {
-	return Geohash{cs: append(b.get(), "GEOHASH"), ks: InitSlot, cf: readonly}
+func (b *Builder) Geohash() (c Geohash) {
+	c = Geohash{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOHASH")
+	return c
 }
 
-func (b *SBuilder) Geohash() SGeohash {
-	return SGeohash{cs: append(b.get(), "GEOHASH"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Geohash() (c SGeohash) {
+	c = SGeohash{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOHASH")
+	return c
 }
 
 func (c Geohash) Key(key string) GeohashKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeohashKey)(c)
 }
 
 func (c SGeohash) Key(key string) SGeohashKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeohashKey)(c)
 }
 
@@ -18206,12 +18834,12 @@ type GeohashKey Completed
 type SGeohashKey SCompleted
 
 func (c GeohashKey) Member(member ...string) GeohashMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (GeohashMember)(c)
 }
 
 func (c SGeohashKey) Member(member ...string) SGeohashMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SGeohashMember)(c)
 }
 
@@ -18220,12 +18848,12 @@ type GeohashMember Completed
 type SGeohashMember SCompleted
 
 func (c GeohashMember) Member(member ...string) GeohashMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SGeohashMember) Member(member ...string) SGeohashMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -18249,22 +18877,26 @@ type Geopos Completed
 
 type SGeopos SCompleted
 
-func (b *Builder) Geopos() Geopos {
-	return Geopos{cs: append(b.get(), "GEOPOS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Geopos() (c Geopos) {
+	c = Geopos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOPOS")
+	return c
 }
 
-func (b *SBuilder) Geopos() SGeopos {
-	return SGeopos{cs: append(b.get(), "GEOPOS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Geopos() (c SGeopos) {
+	c = SGeopos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOPOS")
+	return c
 }
 
 func (c Geopos) Key(key string) GeoposKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoposKey)(c)
 }
 
 func (c SGeopos) Key(key string) SGeoposKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoposKey)(c)
 }
 
@@ -18273,12 +18905,12 @@ type GeoposKey Completed
 type SGeoposKey SCompleted
 
 func (c GeoposKey) Member(member ...string) GeoposMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (GeoposMember)(c)
 }
 
 func (c SGeoposKey) Member(member ...string) SGeoposMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SGeoposMember)(c)
 }
 
@@ -18287,12 +18919,12 @@ type GeoposMember Completed
 type SGeoposMember SCompleted
 
 func (c GeoposMember) Member(member ...string) GeoposMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SGeoposMember) Member(member ...string) SGeoposMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -18316,22 +18948,26 @@ type Georadius Completed
 
 type SGeoradius SCompleted
 
-func (b *Builder) Georadius() Georadius {
-	return Georadius{cs: append(b.get(), "GEORADIUS"), ks: InitSlot}
+func (b *Builder) Georadius() (c Georadius) {
+	c = Georadius{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEORADIUS")
+	return c
 }
 
-func (b *SBuilder) Georadius() SGeoradius {
-	return SGeoradius{cs: append(b.get(), "GEORADIUS"), ks: InitSlot}
+func (b *SBuilder) Georadius() (c SGeoradius) {
+	c = SGeoradius{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEORADIUS")
+	return c
 }
 
 func (c Georadius) Key(key string) GeoradiusKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoradiusKey)(c)
 }
 
 func (c SGeoradius) Key(key string) SGeoradiusKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoradiusKey)(c)
 }
 
@@ -18340,44 +18976,44 @@ type GeoradiusCountAny Completed
 type SGeoradiusCountAny SCompleted
 
 func (c GeoradiusCountAny) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusCountAny) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusCountAny) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusCountAny) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusCountAny) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusCountAny) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusCountAny) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusCountAny) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -18394,54 +19030,54 @@ type GeoradiusCountCount Completed
 type SGeoradiusCountCount SCompleted
 
 func (c GeoradiusCountCount) Any() GeoradiusCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeoradiusCountAny)(c)
 }
 
 func (c SGeoradiusCountCount) Any() SGeoradiusCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeoradiusCountAny)(c)
 }
 
 func (c GeoradiusCountCount) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusCountCount) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusCountCount) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusCountCount) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusCountCount) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusCountCount) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusCountCount) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusCountCount) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -18458,12 +19094,12 @@ type GeoradiusKey Completed
 type SGeoradiusKey SCompleted
 
 func (c GeoradiusKey) Longitude(longitude float64) GeoradiusLongitude {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
 	return (GeoradiusLongitude)(c)
 }
 
 func (c SGeoradiusKey) Longitude(longitude float64) SGeoradiusLongitude {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
 	return (SGeoradiusLongitude)(c)
 }
 
@@ -18472,12 +19108,12 @@ type GeoradiusLatitude Completed
 type SGeoradiusLatitude SCompleted
 
 func (c GeoradiusLatitude) Radius(radius float64) GeoradiusRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeoradiusRadius)(c)
 }
 
 func (c SGeoradiusLatitude) Radius(radius float64) SGeoradiusRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeoradiusRadius)(c)
 }
 
@@ -18486,12 +19122,12 @@ type GeoradiusLongitude Completed
 type SGeoradiusLongitude SCompleted
 
 func (c GeoradiusLongitude) Latitude(latitude float64) GeoradiusLatitude {
-	c.cs = append(c.cs, strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeoradiusLatitude)(c)
 }
 
 func (c SGeoradiusLongitude) Latitude(latitude float64) SGeoradiusLatitude {
-	c.cs = append(c.cs, strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeoradiusLatitude)(c)
 }
 
@@ -18500,24 +19136,24 @@ type GeoradiusOrderAsc Completed
 type SGeoradiusOrderAsc SCompleted
 
 func (c GeoradiusOrderAsc) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusOrderAsc) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusOrderAsc) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusOrderAsc) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -18534,24 +19170,24 @@ type GeoradiusOrderDesc Completed
 type SGeoradiusOrderDesc SCompleted
 
 func (c GeoradiusOrderDesc) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusOrderDesc) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusOrderDesc) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusOrderDesc) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -18568,42 +19204,42 @@ type GeoradiusRadius Completed
 type SGeoradiusRadius SCompleted
 
 func (c GeoradiusRadius) M() GeoradiusUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeoradiusUnitM)(c)
 }
 
 func (c SGeoradiusRadius) M() SGeoradiusUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeoradiusUnitM)(c)
 }
 
 func (c GeoradiusRadius) Km() GeoradiusUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeoradiusUnitKm)(c)
 }
 
 func (c SGeoradiusRadius) Km() SGeoradiusUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeoradiusUnitKm)(c)
 }
 
 func (c GeoradiusRadius) Ft() GeoradiusUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeoradiusUnitFt)(c)
 }
 
 func (c SGeoradiusRadius) Ft() SGeoradiusUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeoradiusUnitFt)(c)
 }
 
 func (c GeoradiusRadius) Mi() GeoradiusUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeoradiusUnitMi)(c)
 }
 
 func (c SGeoradiusRadius) Mi() SGeoradiusUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeoradiusUnitMi)(c)
 }
 
@@ -18611,22 +19247,26 @@ type GeoradiusRo Completed
 
 type SGeoradiusRo SCompleted
 
-func (b *Builder) GeoradiusRo() GeoradiusRo {
-	return GeoradiusRo{cs: append(b.get(), "GEORADIUS_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) GeoradiusRo() (c GeoradiusRo) {
+	c = GeoradiusRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEORADIUS_RO")
+	return c
 }
 
-func (b *SBuilder) GeoradiusRo() SGeoradiusRo {
-	return SGeoradiusRo{cs: append(b.get(), "GEORADIUS_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GeoradiusRo() (c SGeoradiusRo) {
+	c = SGeoradiusRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEORADIUS_RO")
+	return c
 }
 
 func (c GeoradiusRo) Key(key string) GeoradiusRoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoradiusRoKey)(c)
 }
 
 func (c SGeoradiusRo) Key(key string) SGeoradiusRoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoradiusRoKey)(c)
 }
 
@@ -18635,33 +19275,33 @@ type GeoradiusRoCountAny Completed
 type SGeoradiusRoCountAny SCompleted
 
 func (c GeoradiusRoCountAny) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoCountAny) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoCountAny) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoCountAny) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoCountAny) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoCountAny) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -18686,43 +19326,43 @@ type GeoradiusRoCountCount Completed
 type SGeoradiusRoCountCount SCompleted
 
 func (c GeoradiusRoCountCount) Any() GeoradiusRoCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeoradiusRoCountAny)(c)
 }
 
 func (c SGeoradiusRoCountCount) Any() SGeoradiusRoCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeoradiusRoCountAny)(c)
 }
 
 func (c GeoradiusRoCountCount) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoCountCount) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoCountCount) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoCountCount) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoCountCount) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoCountCount) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -18747,12 +19387,12 @@ type GeoradiusRoKey Completed
 type SGeoradiusRoKey SCompleted
 
 func (c GeoradiusRoKey) Longitude(longitude float64) GeoradiusRoLongitude {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
 	return (GeoradiusRoLongitude)(c)
 }
 
 func (c SGeoradiusRoKey) Longitude(longitude float64) SGeoradiusRoLongitude {
-	c.cs = append(c.cs, strconv.FormatFloat(longitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
 	return (SGeoradiusRoLongitude)(c)
 }
 
@@ -18761,12 +19401,12 @@ type GeoradiusRoLatitude Completed
 type SGeoradiusRoLatitude SCompleted
 
 func (c GeoradiusRoLatitude) Radius(radius float64) GeoradiusRoRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeoradiusRoRadius)(c)
 }
 
 func (c SGeoradiusRoLatitude) Radius(radius float64) SGeoradiusRoRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeoradiusRoRadius)(c)
 }
 
@@ -18775,12 +19415,12 @@ type GeoradiusRoLongitude Completed
 type SGeoradiusRoLongitude SCompleted
 
 func (c GeoradiusRoLongitude) Latitude(latitude float64) GeoradiusRoLatitude {
-	c.cs = append(c.cs, strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeoradiusRoLatitude)(c)
 }
 
 func (c SGeoradiusRoLongitude) Latitude(latitude float64) SGeoradiusRoLatitude {
-	c.cs = append(c.cs, strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeoradiusRoLatitude)(c)
 }
 
@@ -18789,13 +19429,13 @@ type GeoradiusRoOrderAsc Completed
 type SGeoradiusRoOrderAsc SCompleted
 
 func (c GeoradiusRoOrderAsc) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoOrderAsc) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -18820,13 +19460,13 @@ type GeoradiusRoOrderDesc Completed
 type SGeoradiusRoOrderDesc SCompleted
 
 func (c GeoradiusRoOrderDesc) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoOrderDesc) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -18851,42 +19491,42 @@ type GeoradiusRoRadius Completed
 type SGeoradiusRoRadius SCompleted
 
 func (c GeoradiusRoRadius) M() GeoradiusRoUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeoradiusRoUnitM)(c)
 }
 
 func (c SGeoradiusRoRadius) M() SGeoradiusRoUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeoradiusRoUnitM)(c)
 }
 
 func (c GeoradiusRoRadius) Km() GeoradiusRoUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeoradiusRoUnitKm)(c)
 }
 
 func (c SGeoradiusRoRadius) Km() SGeoradiusRoUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeoradiusRoUnitKm)(c)
 }
 
 func (c GeoradiusRoRadius) Ft() GeoradiusRoUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeoradiusRoUnitFt)(c)
 }
 
 func (c SGeoradiusRoRadius) Ft() SGeoradiusRoUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeoradiusRoUnitFt)(c)
 }
 
 func (c GeoradiusRoRadius) Mi() GeoradiusRoUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeoradiusRoUnitMi)(c)
 }
 
 func (c SGeoradiusRoRadius) Mi() SGeoradiusRoUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeoradiusRoUnitMi)(c)
 }
 
@@ -18915,73 +19555,73 @@ type GeoradiusRoUnitFt Completed
 type SGeoradiusRoUnitFt SCompleted
 
 func (c GeoradiusRoUnitFt) Withcoord() GeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusRoWithcoord)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Withcoord() SGeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusRoWithcoord)(c)
 }
 
 func (c GeoradiusRoUnitFt) Withdist() GeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusRoWithdist)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Withdist() SGeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusRoWithdist)(c)
 }
 
 func (c GeoradiusRoUnitFt) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoUnitFt) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoUnitFt) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoUnitFt) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoUnitFt) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoUnitFt) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19006,73 +19646,73 @@ type GeoradiusRoUnitKm Completed
 type SGeoradiusRoUnitKm SCompleted
 
 func (c GeoradiusRoUnitKm) Withcoord() GeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusRoWithcoord)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Withcoord() SGeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusRoWithcoord)(c)
 }
 
 func (c GeoradiusRoUnitKm) Withdist() GeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusRoWithdist)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Withdist() SGeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusRoWithdist)(c)
 }
 
 func (c GeoradiusRoUnitKm) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoUnitKm) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoUnitKm) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoUnitKm) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoUnitKm) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoUnitKm) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19097,73 +19737,73 @@ type GeoradiusRoUnitM Completed
 type SGeoradiusRoUnitM SCompleted
 
 func (c GeoradiusRoUnitM) Withcoord() GeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusRoWithcoord)(c)
 }
 
 func (c SGeoradiusRoUnitM) Withcoord() SGeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusRoWithcoord)(c)
 }
 
 func (c GeoradiusRoUnitM) Withdist() GeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusRoWithdist)(c)
 }
 
 func (c SGeoradiusRoUnitM) Withdist() SGeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusRoWithdist)(c)
 }
 
 func (c GeoradiusRoUnitM) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoUnitM) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoUnitM) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoUnitM) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoUnitM) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoUnitM) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoUnitM) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoUnitM) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoUnitM) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoUnitM) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19188,73 +19828,73 @@ type GeoradiusRoUnitMi Completed
 type SGeoradiusRoUnitMi SCompleted
 
 func (c GeoradiusRoUnitMi) Withcoord() GeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusRoWithcoord)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Withcoord() SGeoradiusRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusRoWithcoord)(c)
 }
 
 func (c GeoradiusRoUnitMi) Withdist() GeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusRoWithdist)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Withdist() SGeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusRoWithdist)(c)
 }
 
 func (c GeoradiusRoUnitMi) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoUnitMi) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoUnitMi) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoUnitMi) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoUnitMi) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoUnitMi) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19279,63 +19919,63 @@ type GeoradiusRoWithcoord Completed
 type SGeoradiusRoWithcoord SCompleted
 
 func (c GeoradiusRoWithcoord) Withdist() GeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusRoWithdist)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Withdist() SGeoradiusRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusRoWithdist)(c)
 }
 
 func (c GeoradiusRoWithcoord) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoWithcoord) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoWithcoord) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoWithcoord) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoWithcoord) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoWithcoord) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19360,53 +20000,53 @@ type GeoradiusRoWithdist Completed
 type SGeoradiusRoWithdist SCompleted
 
 func (c GeoradiusRoWithdist) Withhash() GeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusRoWithhash)(c)
 }
 
 func (c SGeoradiusRoWithdist) Withhash() SGeoradiusRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusRoWithhash)(c)
 }
 
 func (c GeoradiusRoWithdist) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoWithdist) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoWithdist) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoWithdist) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoWithdist) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoWithdist) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoWithdist) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoWithdist) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19431,43 +20071,43 @@ type GeoradiusRoWithhash Completed
 type SGeoradiusRoWithhash SCompleted
 
 func (c GeoradiusRoWithhash) Count(count int64) GeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusRoCountCount)(c)
 }
 
 func (c SGeoradiusRoWithhash) Count(count int64) SGeoradiusRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusRoCountCount)(c)
 }
 
 func (c GeoradiusRoWithhash) Asc() GeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusRoOrderAsc)(c)
 }
 
 func (c SGeoradiusRoWithhash) Asc() SGeoradiusRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusRoOrderAsc)(c)
 }
 
 func (c GeoradiusRoWithhash) Desc() GeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusRoOrderDesc)(c)
 }
 
 func (c SGeoradiusRoWithhash) Desc() SGeoradiusRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusRoOrderDesc)(c)
 }
 
 func (c GeoradiusRoWithhash) Storedist(key string) GeoradiusRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusRoStoredist)(c)
 }
 
 func (c SGeoradiusRoWithhash) Storedist(key string) SGeoradiusRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusRoStoredist)(c)
 }
 
@@ -19492,13 +20132,13 @@ type GeoradiusStore Completed
 type SGeoradiusStore SCompleted
 
 func (c GeoradiusStore) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusStore) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19527,84 +20167,84 @@ type GeoradiusUnitFt Completed
 type SGeoradiusUnitFt SCompleted
 
 func (c GeoradiusUnitFt) Withcoord() GeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusWithcoord)(c)
 }
 
 func (c SGeoradiusUnitFt) Withcoord() SGeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusWithcoord)(c)
 }
 
 func (c GeoradiusUnitFt) Withdist() GeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusWithdist)(c)
 }
 
 func (c SGeoradiusUnitFt) Withdist() SGeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusWithdist)(c)
 }
 
 func (c GeoradiusUnitFt) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusUnitFt) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusUnitFt) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusUnitFt) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusUnitFt) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusUnitFt) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusUnitFt) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusUnitFt) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusUnitFt) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusUnitFt) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusUnitFt) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusUnitFt) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19621,84 +20261,84 @@ type GeoradiusUnitKm Completed
 type SGeoradiusUnitKm SCompleted
 
 func (c GeoradiusUnitKm) Withcoord() GeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusWithcoord)(c)
 }
 
 func (c SGeoradiusUnitKm) Withcoord() SGeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusWithcoord)(c)
 }
 
 func (c GeoradiusUnitKm) Withdist() GeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusWithdist)(c)
 }
 
 func (c SGeoradiusUnitKm) Withdist() SGeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusWithdist)(c)
 }
 
 func (c GeoradiusUnitKm) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusUnitKm) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusUnitKm) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusUnitKm) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusUnitKm) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusUnitKm) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusUnitKm) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusUnitKm) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusUnitKm) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusUnitKm) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusUnitKm) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusUnitKm) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19715,84 +20355,84 @@ type GeoradiusUnitM Completed
 type SGeoradiusUnitM SCompleted
 
 func (c GeoradiusUnitM) Withcoord() GeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusWithcoord)(c)
 }
 
 func (c SGeoradiusUnitM) Withcoord() SGeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusWithcoord)(c)
 }
 
 func (c GeoradiusUnitM) Withdist() GeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusWithdist)(c)
 }
 
 func (c SGeoradiusUnitM) Withdist() SGeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusWithdist)(c)
 }
 
 func (c GeoradiusUnitM) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusUnitM) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusUnitM) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusUnitM) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusUnitM) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusUnitM) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusUnitM) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusUnitM) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusUnitM) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusUnitM) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusUnitM) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusUnitM) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19809,84 +20449,84 @@ type GeoradiusUnitMi Completed
 type SGeoradiusUnitMi SCompleted
 
 func (c GeoradiusUnitMi) Withcoord() GeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusWithcoord)(c)
 }
 
 func (c SGeoradiusUnitMi) Withcoord() SGeoradiusWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusWithcoord)(c)
 }
 
 func (c GeoradiusUnitMi) Withdist() GeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusWithdist)(c)
 }
 
 func (c SGeoradiusUnitMi) Withdist() SGeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusWithdist)(c)
 }
 
 func (c GeoradiusUnitMi) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusUnitMi) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusUnitMi) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusUnitMi) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusUnitMi) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusUnitMi) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusUnitMi) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusUnitMi) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusUnitMi) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusUnitMi) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusUnitMi) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusUnitMi) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19903,74 +20543,74 @@ type GeoradiusWithcoord Completed
 type SGeoradiusWithcoord SCompleted
 
 func (c GeoradiusWithcoord) Withdist() GeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusWithdist)(c)
 }
 
 func (c SGeoradiusWithcoord) Withdist() SGeoradiusWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusWithdist)(c)
 }
 
 func (c GeoradiusWithcoord) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusWithcoord) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusWithcoord) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusWithcoord) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusWithcoord) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusWithcoord) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusWithcoord) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusWithcoord) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusWithcoord) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusWithcoord) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusWithcoord) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusWithcoord) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -19987,64 +20627,64 @@ type GeoradiusWithdist Completed
 type SGeoradiusWithdist SCompleted
 
 func (c GeoradiusWithdist) Withhash() GeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusWithhash)(c)
 }
 
 func (c SGeoradiusWithdist) Withhash() SGeoradiusWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusWithhash)(c)
 }
 
 func (c GeoradiusWithdist) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusWithdist) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusWithdist) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusWithdist) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusWithdist) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusWithdist) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusWithdist) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusWithdist) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusWithdist) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusWithdist) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -20061,54 +20701,54 @@ type GeoradiusWithhash Completed
 type SGeoradiusWithhash SCompleted
 
 func (c GeoradiusWithhash) Count(count int64) GeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusCountCount)(c)
 }
 
 func (c SGeoradiusWithhash) Count(count int64) SGeoradiusCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusCountCount)(c)
 }
 
 func (c GeoradiusWithhash) Asc() GeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusOrderAsc)(c)
 }
 
 func (c SGeoradiusWithhash) Asc() SGeoradiusOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusOrderAsc)(c)
 }
 
 func (c GeoradiusWithhash) Desc() GeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusOrderDesc)(c)
 }
 
 func (c SGeoradiusWithhash) Desc() SGeoradiusOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusOrderDesc)(c)
 }
 
 func (c GeoradiusWithhash) Store(key string) GeoradiusStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusStore)(c)
 }
 
 func (c SGeoradiusWithhash) Store(key string) SGeoradiusStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusStore)(c)
 }
 
 func (c GeoradiusWithhash) Storedist(key string) GeoradiusStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusStoredist)(c)
 }
 
 func (c SGeoradiusWithhash) Storedist(key string) SGeoradiusStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusStoredist)(c)
 }
 
@@ -20124,22 +20764,26 @@ type Georadiusbymember Completed
 
 type SGeoradiusbymember SCompleted
 
-func (b *Builder) Georadiusbymember() Georadiusbymember {
-	return Georadiusbymember{cs: append(b.get(), "GEORADIUSBYMEMBER"), ks: InitSlot}
+func (b *Builder) Georadiusbymember() (c Georadiusbymember) {
+	c = Georadiusbymember{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER")
+	return c
 }
 
-func (b *SBuilder) Georadiusbymember() SGeoradiusbymember {
-	return SGeoradiusbymember{cs: append(b.get(), "GEORADIUSBYMEMBER"), ks: InitSlot}
+func (b *SBuilder) Georadiusbymember() (c SGeoradiusbymember) {
+	c = SGeoradiusbymember{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER")
+	return c
 }
 
 func (c Georadiusbymember) Key(key string) GeoradiusbymemberKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoradiusbymemberKey)(c)
 }
 
 func (c SGeoradiusbymember) Key(key string) SGeoradiusbymemberKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoradiusbymemberKey)(c)
 }
 
@@ -20148,44 +20792,44 @@ type GeoradiusbymemberCountAny Completed
 type SGeoradiusbymemberCountAny SCompleted
 
 func (c GeoradiusbymemberCountAny) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberCountAny) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberCountAny) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberCountAny) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberCountAny) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberCountAny) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberCountAny) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberCountAny) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -20202,54 +20846,54 @@ type GeoradiusbymemberCountCount Completed
 type SGeoradiusbymemberCountCount SCompleted
 
 func (c GeoradiusbymemberCountCount) Any() GeoradiusbymemberCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeoradiusbymemberCountAny)(c)
 }
 
 func (c SGeoradiusbymemberCountCount) Any() SGeoradiusbymemberCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeoradiusbymemberCountAny)(c)
 }
 
 func (c GeoradiusbymemberCountCount) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberCountCount) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberCountCount) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberCountCount) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberCountCount) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberCountCount) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberCountCount) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberCountCount) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -20266,12 +20910,12 @@ type GeoradiusbymemberKey Completed
 type SGeoradiusbymemberKey SCompleted
 
 func (c GeoradiusbymemberKey) Member(member string) GeoradiusbymemberMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (GeoradiusbymemberMember)(c)
 }
 
 func (c SGeoradiusbymemberKey) Member(member string) SGeoradiusbymemberMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SGeoradiusbymemberMember)(c)
 }
 
@@ -20280,12 +20924,12 @@ type GeoradiusbymemberMember Completed
 type SGeoradiusbymemberMember SCompleted
 
 func (c GeoradiusbymemberMember) Radius(radius float64) GeoradiusbymemberRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeoradiusbymemberRadius)(c)
 }
 
 func (c SGeoradiusbymemberMember) Radius(radius float64) SGeoradiusbymemberRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeoradiusbymemberRadius)(c)
 }
 
@@ -20294,24 +20938,24 @@ type GeoradiusbymemberOrderAsc Completed
 type SGeoradiusbymemberOrderAsc SCompleted
 
 func (c GeoradiusbymemberOrderAsc) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberOrderAsc) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberOrderAsc) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberOrderAsc) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -20328,24 +20972,24 @@ type GeoradiusbymemberOrderDesc Completed
 type SGeoradiusbymemberOrderDesc SCompleted
 
 func (c GeoradiusbymemberOrderDesc) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberOrderDesc) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberOrderDesc) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberOrderDesc) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -20362,42 +21006,42 @@ type GeoradiusbymemberRadius Completed
 type SGeoradiusbymemberRadius SCompleted
 
 func (c GeoradiusbymemberRadius) M() GeoradiusbymemberUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeoradiusbymemberUnitM)(c)
 }
 
 func (c SGeoradiusbymemberRadius) M() SGeoradiusbymemberUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeoradiusbymemberUnitM)(c)
 }
 
 func (c GeoradiusbymemberRadius) Km() GeoradiusbymemberUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeoradiusbymemberUnitKm)(c)
 }
 
 func (c SGeoradiusbymemberRadius) Km() SGeoradiusbymemberUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeoradiusbymemberUnitKm)(c)
 }
 
 func (c GeoradiusbymemberRadius) Ft() GeoradiusbymemberUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeoradiusbymemberUnitFt)(c)
 }
 
 func (c SGeoradiusbymemberRadius) Ft() SGeoradiusbymemberUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeoradiusbymemberUnitFt)(c)
 }
 
 func (c GeoradiusbymemberRadius) Mi() GeoradiusbymemberUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeoradiusbymemberUnitMi)(c)
 }
 
 func (c SGeoradiusbymemberRadius) Mi() SGeoradiusbymemberUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeoradiusbymemberUnitMi)(c)
 }
 
@@ -20405,22 +21049,26 @@ type GeoradiusbymemberRo Completed
 
 type SGeoradiusbymemberRo SCompleted
 
-func (b *Builder) GeoradiusbymemberRo() GeoradiusbymemberRo {
-	return GeoradiusbymemberRo{cs: append(b.get(), "GEORADIUSBYMEMBER_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) GeoradiusbymemberRo() (c GeoradiusbymemberRo) {
+	c = GeoradiusbymemberRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER_RO")
+	return c
 }
 
-func (b *SBuilder) GeoradiusbymemberRo() SGeoradiusbymemberRo {
-	return SGeoradiusbymemberRo{cs: append(b.get(), "GEORADIUSBYMEMBER_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GeoradiusbymemberRo() (c SGeoradiusbymemberRo) {
+	c = SGeoradiusbymemberRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER_RO")
+	return c
 }
 
 func (c GeoradiusbymemberRo) Key(key string) GeoradiusbymemberRoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeoradiusbymemberRoKey)(c)
 }
 
 func (c SGeoradiusbymemberRo) Key(key string) SGeoradiusbymemberRoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeoradiusbymemberRoKey)(c)
 }
 
@@ -20429,33 +21077,33 @@ type GeoradiusbymemberRoCountAny Completed
 type SGeoradiusbymemberRoCountAny SCompleted
 
 func (c GeoradiusbymemberRoCountAny) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoCountAny) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoCountAny) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoCountAny) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoCountAny) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoCountAny) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20480,43 +21128,43 @@ type GeoradiusbymemberRoCountCount Completed
 type SGeoradiusbymemberRoCountCount SCompleted
 
 func (c GeoradiusbymemberRoCountCount) Any() GeoradiusbymemberRoCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeoradiusbymemberRoCountAny)(c)
 }
 
 func (c SGeoradiusbymemberRoCountCount) Any() SGeoradiusbymemberRoCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeoradiusbymemberRoCountAny)(c)
 }
 
 func (c GeoradiusbymemberRoCountCount) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoCountCount) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoCountCount) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoCountCount) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoCountCount) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoCountCount) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20541,12 +21189,12 @@ type GeoradiusbymemberRoKey Completed
 type SGeoradiusbymemberRoKey SCompleted
 
 func (c GeoradiusbymemberRoKey) Member(member string) GeoradiusbymemberRoMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (GeoradiusbymemberRoMember)(c)
 }
 
 func (c SGeoradiusbymemberRoKey) Member(member string) SGeoradiusbymemberRoMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SGeoradiusbymemberRoMember)(c)
 }
 
@@ -20555,12 +21203,12 @@ type GeoradiusbymemberRoMember Completed
 type SGeoradiusbymemberRoMember SCompleted
 
 func (c GeoradiusbymemberRoMember) Radius(radius float64) GeoradiusbymemberRoRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeoradiusbymemberRoRadius)(c)
 }
 
 func (c SGeoradiusbymemberRoMember) Radius(radius float64) SGeoradiusbymemberRoRadius {
-	c.cs = append(c.cs, strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeoradiusbymemberRoRadius)(c)
 }
 
@@ -20569,13 +21217,13 @@ type GeoradiusbymemberRoOrderAsc Completed
 type SGeoradiusbymemberRoOrderAsc SCompleted
 
 func (c GeoradiusbymemberRoOrderAsc) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoOrderAsc) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20600,13 +21248,13 @@ type GeoradiusbymemberRoOrderDesc Completed
 type SGeoradiusbymemberRoOrderDesc SCompleted
 
 func (c GeoradiusbymemberRoOrderDesc) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoOrderDesc) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20631,42 +21279,42 @@ type GeoradiusbymemberRoRadius Completed
 type SGeoradiusbymemberRoRadius SCompleted
 
 func (c GeoradiusbymemberRoRadius) M() GeoradiusbymemberRoUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeoradiusbymemberRoUnitM)(c)
 }
 
 func (c SGeoradiusbymemberRoRadius) M() SGeoradiusbymemberRoUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeoradiusbymemberRoUnitM)(c)
 }
 
 func (c GeoradiusbymemberRoRadius) Km() GeoradiusbymemberRoUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeoradiusbymemberRoUnitKm)(c)
 }
 
 func (c SGeoradiusbymemberRoRadius) Km() SGeoradiusbymemberRoUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeoradiusbymemberRoUnitKm)(c)
 }
 
 func (c GeoradiusbymemberRoRadius) Ft() GeoradiusbymemberRoUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeoradiusbymemberRoUnitFt)(c)
 }
 
 func (c SGeoradiusbymemberRoRadius) Ft() SGeoradiusbymemberRoUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeoradiusbymemberRoUnitFt)(c)
 }
 
 func (c GeoradiusbymemberRoRadius) Mi() GeoradiusbymemberRoUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeoradiusbymemberRoUnitMi)(c)
 }
 
 func (c SGeoradiusbymemberRoRadius) Mi() SGeoradiusbymemberRoUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeoradiusbymemberRoUnitMi)(c)
 }
 
@@ -20695,73 +21343,73 @@ type GeoradiusbymemberRoUnitFt Completed
 type SGeoradiusbymemberRoUnitFt SCompleted
 
 func (c GeoradiusbymemberRoUnitFt) Withcoord() GeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Withcoord() SGeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Withdist() GeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberRoWithdist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Withdist() SGeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberRoWithdist)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitFt) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitFt) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20786,73 +21434,73 @@ type GeoradiusbymemberRoUnitKm Completed
 type SGeoradiusbymemberRoUnitKm SCompleted
 
 func (c GeoradiusbymemberRoUnitKm) Withcoord() GeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Withcoord() SGeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Withdist() GeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberRoWithdist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Withdist() SGeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberRoWithdist)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitKm) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitKm) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20877,73 +21525,73 @@ type GeoradiusbymemberRoUnitM Completed
 type SGeoradiusbymemberRoUnitM SCompleted
 
 func (c GeoradiusbymemberRoUnitM) Withcoord() GeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Withcoord() SGeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Withdist() GeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberRoWithdist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Withdist() SGeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberRoWithdist)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitM) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitM) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -20968,73 +21616,73 @@ type GeoradiusbymemberRoUnitMi Completed
 type SGeoradiusbymemberRoUnitMi SCompleted
 
 func (c GeoradiusbymemberRoUnitMi) Withcoord() GeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Withcoord() SGeoradiusbymemberRoWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberRoWithcoord)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Withdist() GeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberRoWithdist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Withdist() SGeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberRoWithdist)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoUnitMi) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoUnitMi) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -21059,63 +21707,63 @@ type GeoradiusbymemberRoWithcoord Completed
 type SGeoradiusbymemberRoWithcoord SCompleted
 
 func (c GeoradiusbymemberRoWithcoord) Withdist() GeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberRoWithdist)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Withdist() SGeoradiusbymemberRoWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberRoWithdist)(c)
 }
 
 func (c GeoradiusbymemberRoWithcoord) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoWithcoord) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoWithcoord) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoWithcoord) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoWithcoord) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoWithcoord) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -21140,53 +21788,53 @@ type GeoradiusbymemberRoWithdist Completed
 type SGeoradiusbymemberRoWithdist SCompleted
 
 func (c GeoradiusbymemberRoWithdist) Withhash() GeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberRoWithhash)(c)
 }
 
 func (c SGeoradiusbymemberRoWithdist) Withhash() SGeoradiusbymemberRoWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberRoWithhash)(c)
 }
 
 func (c GeoradiusbymemberRoWithdist) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoWithdist) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoWithdist) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithdist) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoWithdist) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithdist) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoWithdist) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoWithdist) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -21211,43 +21859,43 @@ type GeoradiusbymemberRoWithhash Completed
 type SGeoradiusbymemberRoWithhash SCompleted
 
 func (c GeoradiusbymemberRoWithhash) Count(count int64) GeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberRoCountCount)(c)
 }
 
 func (c SGeoradiusbymemberRoWithhash) Count(count int64) SGeoradiusbymemberRoCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberRoCountCount)(c)
 }
 
 func (c GeoradiusbymemberRoWithhash) Asc() GeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithhash) Asc() SGeoradiusbymemberRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberRoOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberRoWithhash) Desc() GeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberRoWithhash) Desc() SGeoradiusbymemberRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberRoOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberRoWithhash) Storedist(key string) GeoradiusbymemberRoStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberRoStoredist)(c)
 }
 
 func (c SGeoradiusbymemberRoWithhash) Storedist(key string) SGeoradiusbymemberRoStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberRoStoredist)(c)
 }
 
@@ -21272,13 +21920,13 @@ type GeoradiusbymemberStore Completed
 type SGeoradiusbymemberStore SCompleted
 
 func (c GeoradiusbymemberStore) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberStore) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21307,84 +21955,84 @@ type GeoradiusbymemberUnitFt Completed
 type SGeoradiusbymemberUnitFt SCompleted
 
 func (c GeoradiusbymemberUnitFt) Withcoord() GeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Withcoord() SGeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberWithcoord)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Withdist() GeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberWithdist)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Withdist() SGeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberWithdist)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberUnitFt) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberUnitFt) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21401,84 +22049,84 @@ type GeoradiusbymemberUnitKm Completed
 type SGeoradiusbymemberUnitKm SCompleted
 
 func (c GeoradiusbymemberUnitKm) Withcoord() GeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Withcoord() SGeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberWithcoord)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Withdist() GeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberWithdist)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Withdist() SGeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberWithdist)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberUnitKm) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberUnitKm) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21495,84 +22143,84 @@ type GeoradiusbymemberUnitM Completed
 type SGeoradiusbymemberUnitM SCompleted
 
 func (c GeoradiusbymemberUnitM) Withcoord() GeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Withcoord() SGeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberWithcoord)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Withdist() GeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberWithdist)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Withdist() SGeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberWithdist)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberUnitM) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberUnitM) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21589,84 +22237,84 @@ type GeoradiusbymemberUnitMi Completed
 type SGeoradiusbymemberUnitMi SCompleted
 
 func (c GeoradiusbymemberUnitMi) Withcoord() GeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeoradiusbymemberWithcoord)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Withcoord() SGeoradiusbymemberWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeoradiusbymemberWithcoord)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Withdist() GeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberWithdist)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Withdist() SGeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberWithdist)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberUnitMi) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberUnitMi) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21683,74 +22331,74 @@ type GeoradiusbymemberWithcoord Completed
 type SGeoradiusbymemberWithcoord SCompleted
 
 func (c GeoradiusbymemberWithcoord) Withdist() GeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeoradiusbymemberWithdist)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Withdist() SGeoradiusbymemberWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeoradiusbymemberWithdist)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberWithcoord) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberWithcoord) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21767,64 +22415,64 @@ type GeoradiusbymemberWithdist Completed
 type SGeoradiusbymemberWithdist SCompleted
 
 func (c GeoradiusbymemberWithdist) Withhash() GeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeoradiusbymemberWithhash)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Withhash() SGeoradiusbymemberWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeoradiusbymemberWithhash)(c)
 }
 
 func (c GeoradiusbymemberWithdist) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberWithdist) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberWithdist) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberWithdist) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberWithdist) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberWithdist) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21841,54 +22489,54 @@ type GeoradiusbymemberWithhash Completed
 type SGeoradiusbymemberWithhash SCompleted
 
 func (c GeoradiusbymemberWithhash) Count(count int64) GeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeoradiusbymemberCountCount)(c)
 }
 
 func (c SGeoradiusbymemberWithhash) Count(count int64) SGeoradiusbymemberCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeoradiusbymemberCountCount)(c)
 }
 
 func (c GeoradiusbymemberWithhash) Asc() GeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeoradiusbymemberOrderAsc)(c)
 }
 
 func (c SGeoradiusbymemberWithhash) Asc() SGeoradiusbymemberOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeoradiusbymemberOrderAsc)(c)
 }
 
 func (c GeoradiusbymemberWithhash) Desc() GeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeoradiusbymemberOrderDesc)(c)
 }
 
 func (c SGeoradiusbymemberWithhash) Desc() SGeoradiusbymemberOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeoradiusbymemberOrderDesc)(c)
 }
 
 func (c GeoradiusbymemberWithhash) Store(key string) GeoradiusbymemberStore {
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (GeoradiusbymemberStore)(c)
 }
 
 func (c SGeoradiusbymemberWithhash) Store(key string) SGeoradiusbymemberStore {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STORE", key)
+	c.cs.s = append(c.cs.s, "STORE", key)
 	return (SGeoradiusbymemberStore)(c)
 }
 
 func (c GeoradiusbymemberWithhash) Storedist(key string) GeoradiusbymemberStoredist {
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (GeoradiusbymemberStoredist)(c)
 }
 
 func (c SGeoradiusbymemberWithhash) Storedist(key string) SGeoradiusbymemberStoredist {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, "STOREDIST", key)
+	c.cs.s = append(c.cs.s, "STOREDIST", key)
 	return (SGeoradiusbymemberStoredist)(c)
 }
 
@@ -21904,22 +22552,26 @@ type Geosearch Completed
 
 type SGeosearch SCompleted
 
-func (b *Builder) Geosearch() Geosearch {
-	return Geosearch{cs: append(b.get(), "GEOSEARCH"), ks: InitSlot, cf: readonly}
+func (b *Builder) Geosearch() (c Geosearch) {
+	c = Geosearch{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOSEARCH")
+	return c
 }
 
-func (b *SBuilder) Geosearch() SGeosearch {
-	return SGeosearch{cs: append(b.get(), "GEOSEARCH"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Geosearch() (c SGeosearch) {
+	c = SGeosearch{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GEOSEARCH")
+	return c
 }
 
 func (c Geosearch) Key(key string) GeosearchKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GeosearchKey)(c)
 }
 
 func (c SGeosearch) Key(key string) SGeosearchKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGeosearchKey)(c)
 }
 
@@ -21928,12 +22580,12 @@ type GeosearchBoxBybox Completed
 type SGeosearchBoxBybox SCompleted
 
 func (c GeosearchBoxBybox) Height(height float64) GeosearchBoxHeight {
-	c.cs = append(c.cs, strconv.FormatFloat(height, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
 	return (GeosearchBoxHeight)(c)
 }
 
 func (c SGeosearchBoxBybox) Height(height float64) SGeosearchBoxHeight {
-	c.cs = append(c.cs, strconv.FormatFloat(height, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
 	return (SGeosearchBoxHeight)(c)
 }
 
@@ -21942,42 +22594,42 @@ type GeosearchBoxHeight Completed
 type SGeosearchBoxHeight SCompleted
 
 func (c GeosearchBoxHeight) M() GeosearchBoxUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeosearchBoxUnitM)(c)
 }
 
 func (c SGeosearchBoxHeight) M() SGeosearchBoxUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeosearchBoxUnitM)(c)
 }
 
 func (c GeosearchBoxHeight) Km() GeosearchBoxUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeosearchBoxUnitKm)(c)
 }
 
 func (c SGeosearchBoxHeight) Km() SGeosearchBoxUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeosearchBoxUnitKm)(c)
 }
 
 func (c GeosearchBoxHeight) Ft() GeosearchBoxUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeosearchBoxUnitFt)(c)
 }
 
 func (c SGeosearchBoxHeight) Ft() SGeosearchBoxUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeosearchBoxUnitFt)(c)
 }
 
 func (c GeosearchBoxHeight) Mi() GeosearchBoxUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeosearchBoxUnitMi)(c)
 }
 
 func (c SGeosearchBoxHeight) Mi() SGeosearchBoxUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeosearchBoxUnitMi)(c)
 }
 
@@ -21986,62 +22638,62 @@ type GeosearchBoxUnitFt Completed
 type SGeosearchBoxUnitFt SCompleted
 
 func (c GeosearchBoxUnitFt) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchBoxUnitFt) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchBoxUnitFt) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchBoxUnitFt) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchBoxUnitFt) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchBoxUnitFt) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchBoxUnitFt) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22066,62 +22718,62 @@ type GeosearchBoxUnitKm Completed
 type SGeosearchBoxUnitKm SCompleted
 
 func (c GeosearchBoxUnitKm) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchBoxUnitKm) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchBoxUnitKm) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchBoxUnitKm) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchBoxUnitKm) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchBoxUnitKm) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchBoxUnitKm) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22146,62 +22798,62 @@ type GeosearchBoxUnitM Completed
 type SGeosearchBoxUnitM SCompleted
 
 func (c GeosearchBoxUnitM) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchBoxUnitM) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchBoxUnitM) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchBoxUnitM) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchBoxUnitM) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchBoxUnitM) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchBoxUnitM) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchBoxUnitM) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchBoxUnitM) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchBoxUnitM) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchBoxUnitM) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchBoxUnitM) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22226,62 +22878,62 @@ type GeosearchBoxUnitMi Completed
 type SGeosearchBoxUnitMi SCompleted
 
 func (c GeosearchBoxUnitMi) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchBoxUnitMi) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchBoxUnitMi) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchBoxUnitMi) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchBoxUnitMi) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchBoxUnitMi) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchBoxUnitMi) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22306,42 +22958,42 @@ type GeosearchCircleByradius Completed
 type SGeosearchCircleByradius SCompleted
 
 func (c GeosearchCircleByradius) M() GeosearchCircleUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeosearchCircleUnitM)(c)
 }
 
 func (c SGeosearchCircleByradius) M() SGeosearchCircleUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeosearchCircleUnitM)(c)
 }
 
 func (c GeosearchCircleByradius) Km() GeosearchCircleUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeosearchCircleUnitKm)(c)
 }
 
 func (c SGeosearchCircleByradius) Km() SGeosearchCircleUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeosearchCircleUnitKm)(c)
 }
 
 func (c GeosearchCircleByradius) Ft() GeosearchCircleUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeosearchCircleUnitFt)(c)
 }
 
 func (c SGeosearchCircleByradius) Ft() SGeosearchCircleUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeosearchCircleUnitFt)(c)
 }
 
 func (c GeosearchCircleByradius) Mi() GeosearchCircleUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeosearchCircleUnitMi)(c)
 }
 
 func (c SGeosearchCircleByradius) Mi() SGeosearchCircleUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeosearchCircleUnitMi)(c)
 }
 
@@ -22350,72 +23002,72 @@ type GeosearchCircleUnitFt Completed
 type SGeosearchCircleUnitFt SCompleted
 
 func (c GeosearchCircleUnitFt) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchCircleUnitFt) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchCircleUnitFt) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchCircleUnitFt) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchCircleUnitFt) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCircleUnitFt) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCircleUnitFt) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCircleUnitFt) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22440,72 +23092,72 @@ type GeosearchCircleUnitKm Completed
 type SGeosearchCircleUnitKm SCompleted
 
 func (c GeosearchCircleUnitKm) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchCircleUnitKm) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchCircleUnitKm) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchCircleUnitKm) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchCircleUnitKm) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCircleUnitKm) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCircleUnitKm) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCircleUnitKm) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22530,72 +23182,72 @@ type GeosearchCircleUnitM Completed
 type SGeosearchCircleUnitM SCompleted
 
 func (c GeosearchCircleUnitM) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchCircleUnitM) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchCircleUnitM) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchCircleUnitM) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchCircleUnitM) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchCircleUnitM) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchCircleUnitM) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchCircleUnitM) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchCircleUnitM) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCircleUnitM) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCircleUnitM) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCircleUnitM) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCircleUnitM) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCircleUnitM) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22620,72 +23272,72 @@ type GeosearchCircleUnitMi Completed
 type SGeosearchCircleUnitMi SCompleted
 
 func (c GeosearchCircleUnitMi) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchCircleUnitMi) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchCircleUnitMi) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchCircleUnitMi) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchCircleUnitMi) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCircleUnitMi) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCircleUnitMi) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCircleUnitMi) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22710,32 +23362,32 @@ type GeosearchCountAny Completed
 type SGeosearchCountAny SCompleted
 
 func (c GeosearchCountAny) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCountAny) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCountAny) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCountAny) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCountAny) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCountAny) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22760,42 +23412,42 @@ type GeosearchCountCount Completed
 type SGeosearchCountCount SCompleted
 
 func (c GeosearchCountCount) Any() GeosearchCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeosearchCountAny)(c)
 }
 
 func (c SGeosearchCountCount) Any() SGeosearchCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeosearchCountAny)(c)
 }
 
 func (c GeosearchCountCount) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchCountCount) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchCountCount) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchCountCount) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchCountCount) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchCountCount) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22820,82 +23472,82 @@ type GeosearchFromlonlat Completed
 type SGeosearchFromlonlat SCompleted
 
 func (c GeosearchFromlonlat) Byradius(radius float64) GeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchCircleByradius)(c)
 }
 
 func (c SGeosearchFromlonlat) Byradius(radius float64) SGeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchCircleByradius)(c)
 }
 
 func (c GeosearchFromlonlat) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchFromlonlat) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchFromlonlat) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchFromlonlat) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchFromlonlat) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchFromlonlat) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchFromlonlat) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchFromlonlat) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchFromlonlat) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchFromlonlat) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchFromlonlat) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchFromlonlat) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchFromlonlat) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchFromlonlat) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -22920,92 +23572,92 @@ type GeosearchFrommember Completed
 type SGeosearchFrommember SCompleted
 
 func (c GeosearchFrommember) Fromlonlat(longitude float64, latitude float64) GeosearchFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeosearchFromlonlat)(c)
 }
 
 func (c SGeosearchFrommember) Fromlonlat(longitude float64, latitude float64) SGeosearchFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeosearchFromlonlat)(c)
 }
 
 func (c GeosearchFrommember) Byradius(radius float64) GeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchCircleByradius)(c)
 }
 
 func (c SGeosearchFrommember) Byradius(radius float64) SGeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchCircleByradius)(c)
 }
 
 func (c GeosearchFrommember) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchFrommember) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchFrommember) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchFrommember) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchFrommember) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchFrommember) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchFrommember) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchFrommember) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchFrommember) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchFrommember) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchFrommember) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchFrommember) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchFrommember) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchFrommember) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23030,102 +23682,102 @@ type GeosearchKey Completed
 type SGeosearchKey SCompleted
 
 func (c GeosearchKey) Frommember(member string) GeosearchFrommember {
-	c.cs = append(c.cs, "FROMMEMBER", member)
+	c.cs.s = append(c.cs.s, "FROMMEMBER", member)
 	return (GeosearchFrommember)(c)
 }
 
 func (c SGeosearchKey) Frommember(member string) SGeosearchFrommember {
-	c.cs = append(c.cs, "FROMMEMBER", member)
+	c.cs.s = append(c.cs.s, "FROMMEMBER", member)
 	return (SGeosearchFrommember)(c)
 }
 
 func (c GeosearchKey) Fromlonlat(longitude float64, latitude float64) GeosearchFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeosearchFromlonlat)(c)
 }
 
 func (c SGeosearchKey) Fromlonlat(longitude float64, latitude float64) SGeosearchFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeosearchFromlonlat)(c)
 }
 
 func (c GeosearchKey) Byradius(radius float64) GeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchCircleByradius)(c)
 }
 
 func (c SGeosearchKey) Byradius(radius float64) SGeosearchCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchCircleByradius)(c)
 }
 
 func (c GeosearchKey) Bybox(width float64) GeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchBoxBybox)(c)
 }
 
 func (c SGeosearchKey) Bybox(width float64) SGeosearchBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchBoxBybox)(c)
 }
 
 func (c GeosearchKey) Asc() GeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchOrderAsc)(c)
 }
 
 func (c SGeosearchKey) Asc() SGeosearchOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchOrderAsc)(c)
 }
 
 func (c GeosearchKey) Desc() GeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchOrderDesc)(c)
 }
 
 func (c SGeosearchKey) Desc() SGeosearchOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchOrderDesc)(c)
 }
 
 func (c GeosearchKey) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchKey) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchKey) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchKey) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchKey) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchKey) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchKey) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchKey) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23150,42 +23802,42 @@ type GeosearchOrderAsc Completed
 type SGeosearchOrderAsc SCompleted
 
 func (c GeosearchOrderAsc) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchOrderAsc) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchOrderAsc) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchOrderAsc) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchOrderAsc) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchOrderAsc) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchOrderAsc) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchOrderAsc) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23210,42 +23862,42 @@ type GeosearchOrderDesc Completed
 type SGeosearchOrderDesc SCompleted
 
 func (c GeosearchOrderDesc) Count(count int64) GeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchCountCount)(c)
 }
 
 func (c SGeosearchOrderDesc) Count(count int64) SGeosearchCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchCountCount)(c)
 }
 
 func (c GeosearchOrderDesc) Withcoord() GeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (GeosearchWithcoord)(c)
 }
 
 func (c SGeosearchOrderDesc) Withcoord() SGeosearchWithcoord {
-	c.cs = append(c.cs, "WITHCOORD")
+	c.cs.s = append(c.cs.s, "WITHCOORD")
 	return (SGeosearchWithcoord)(c)
 }
 
 func (c GeosearchOrderDesc) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchOrderDesc) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchOrderDesc) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchOrderDesc) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23270,22 +23922,22 @@ type GeosearchWithcoord Completed
 type SGeosearchWithcoord SCompleted
 
 func (c GeosearchWithcoord) Withdist() GeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (GeosearchWithdist)(c)
 }
 
 func (c SGeosearchWithcoord) Withdist() SGeosearchWithdist {
-	c.cs = append(c.cs, "WITHDIST")
+	c.cs.s = append(c.cs.s, "WITHDIST")
 	return (SGeosearchWithdist)(c)
 }
 
 func (c GeosearchWithcoord) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchWithcoord) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23310,12 +23962,12 @@ type GeosearchWithdist Completed
 type SGeosearchWithdist SCompleted
 
 func (c GeosearchWithdist) Withhash() GeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (GeosearchWithhash)(c)
 }
 
 func (c SGeosearchWithdist) Withhash() SGeosearchWithhash {
-	c.cs = append(c.cs, "WITHHASH")
+	c.cs.s = append(c.cs.s, "WITHHASH")
 	return (SGeosearchWithhash)(c)
 }
 
@@ -23359,22 +24011,26 @@ type Geosearchstore Completed
 
 type SGeosearchstore SCompleted
 
-func (b *Builder) Geosearchstore() Geosearchstore {
-	return Geosearchstore{cs: append(b.get(), "GEOSEARCHSTORE"), ks: InitSlot}
+func (b *Builder) Geosearchstore() (c Geosearchstore) {
+	c = Geosearchstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEOSEARCHSTORE")
+	return c
 }
 
-func (b *SBuilder) Geosearchstore() SGeosearchstore {
-	return SGeosearchstore{cs: append(b.get(), "GEOSEARCHSTORE"), ks: InitSlot}
+func (b *SBuilder) Geosearchstore() (c SGeosearchstore) {
+	c = SGeosearchstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GEOSEARCHSTORE")
+	return c
 }
 
 func (c Geosearchstore) Destination(destination string) GeosearchstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (GeosearchstoreDestination)(c)
 }
 
 func (c SGeosearchstore) Destination(destination string) SGeosearchstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SGeosearchstoreDestination)(c)
 }
 
@@ -23383,12 +24039,12 @@ type GeosearchstoreBoxBybox Completed
 type SGeosearchstoreBoxBybox SCompleted
 
 func (c GeosearchstoreBoxBybox) Height(height float64) GeosearchstoreBoxHeight {
-	c.cs = append(c.cs, strconv.FormatFloat(height, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
 	return (GeosearchstoreBoxHeight)(c)
 }
 
 func (c SGeosearchstoreBoxBybox) Height(height float64) SGeosearchstoreBoxHeight {
-	c.cs = append(c.cs, strconv.FormatFloat(height, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
 	return (SGeosearchstoreBoxHeight)(c)
 }
 
@@ -23397,42 +24053,42 @@ type GeosearchstoreBoxHeight Completed
 type SGeosearchstoreBoxHeight SCompleted
 
 func (c GeosearchstoreBoxHeight) M() GeosearchstoreBoxUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeosearchstoreBoxUnitM)(c)
 }
 
 func (c SGeosearchstoreBoxHeight) M() SGeosearchstoreBoxUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeosearchstoreBoxUnitM)(c)
 }
 
 func (c GeosearchstoreBoxHeight) Km() GeosearchstoreBoxUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeosearchstoreBoxUnitKm)(c)
 }
 
 func (c SGeosearchstoreBoxHeight) Km() SGeosearchstoreBoxUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeosearchstoreBoxUnitKm)(c)
 }
 
 func (c GeosearchstoreBoxHeight) Ft() GeosearchstoreBoxUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeosearchstoreBoxUnitFt)(c)
 }
 
 func (c SGeosearchstoreBoxHeight) Ft() SGeosearchstoreBoxUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeosearchstoreBoxUnitFt)(c)
 }
 
 func (c GeosearchstoreBoxHeight) Mi() GeosearchstoreBoxUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeosearchstoreBoxUnitMi)(c)
 }
 
 func (c SGeosearchstoreBoxHeight) Mi() SGeosearchstoreBoxUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeosearchstoreBoxUnitMi)(c)
 }
 
@@ -23441,42 +24097,42 @@ type GeosearchstoreBoxUnitFt Completed
 type SGeosearchstoreBoxUnitFt SCompleted
 
 func (c GeosearchstoreBoxUnitFt) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitFt) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreBoxUnitFt) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitFt) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreBoxUnitFt) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreBoxUnitFt) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreBoxUnitFt) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreBoxUnitFt) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23493,42 +24149,42 @@ type GeosearchstoreBoxUnitKm Completed
 type SGeosearchstoreBoxUnitKm SCompleted
 
 func (c GeosearchstoreBoxUnitKm) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitKm) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreBoxUnitKm) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitKm) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreBoxUnitKm) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreBoxUnitKm) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreBoxUnitKm) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreBoxUnitKm) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23545,42 +24201,42 @@ type GeosearchstoreBoxUnitM Completed
 type SGeosearchstoreBoxUnitM SCompleted
 
 func (c GeosearchstoreBoxUnitM) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitM) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreBoxUnitM) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitM) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreBoxUnitM) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreBoxUnitM) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreBoxUnitM) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreBoxUnitM) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23597,42 +24253,42 @@ type GeosearchstoreBoxUnitMi Completed
 type SGeosearchstoreBoxUnitMi SCompleted
 
 func (c GeosearchstoreBoxUnitMi) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitMi) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreBoxUnitMi) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreBoxUnitMi) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreBoxUnitMi) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreBoxUnitMi) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreBoxUnitMi) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreBoxUnitMi) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23649,42 +24305,42 @@ type GeosearchstoreCircleByradius Completed
 type SGeosearchstoreCircleByradius SCompleted
 
 func (c GeosearchstoreCircleByradius) M() GeosearchstoreCircleUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (GeosearchstoreCircleUnitM)(c)
 }
 
 func (c SGeosearchstoreCircleByradius) M() SGeosearchstoreCircleUnitM {
-	c.cs = append(c.cs, "m")
+	c.cs.s = append(c.cs.s, "m")
 	return (SGeosearchstoreCircleUnitM)(c)
 }
 
 func (c GeosearchstoreCircleByradius) Km() GeosearchstoreCircleUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (GeosearchstoreCircleUnitKm)(c)
 }
 
 func (c SGeosearchstoreCircleByradius) Km() SGeosearchstoreCircleUnitKm {
-	c.cs = append(c.cs, "km")
+	c.cs.s = append(c.cs.s, "km")
 	return (SGeosearchstoreCircleUnitKm)(c)
 }
 
 func (c GeosearchstoreCircleByradius) Ft() GeosearchstoreCircleUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (GeosearchstoreCircleUnitFt)(c)
 }
 
 func (c SGeosearchstoreCircleByradius) Ft() SGeosearchstoreCircleUnitFt {
-	c.cs = append(c.cs, "ft")
+	c.cs.s = append(c.cs.s, "ft")
 	return (SGeosearchstoreCircleUnitFt)(c)
 }
 
 func (c GeosearchstoreCircleByradius) Mi() GeosearchstoreCircleUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (GeosearchstoreCircleUnitMi)(c)
 }
 
 func (c SGeosearchstoreCircleByradius) Mi() SGeosearchstoreCircleUnitMi {
-	c.cs = append(c.cs, "mi")
+	c.cs.s = append(c.cs.s, "mi")
 	return (SGeosearchstoreCircleUnitMi)(c)
 }
 
@@ -23693,52 +24349,52 @@ type GeosearchstoreCircleUnitFt Completed
 type SGeosearchstoreCircleUnitFt SCompleted
 
 func (c GeosearchstoreCircleUnitFt) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreCircleUnitFt) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreCircleUnitFt) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitFt) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreCircleUnitFt) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitFt) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreCircleUnitFt) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreCircleUnitFt) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreCircleUnitFt) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCircleUnitFt) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23755,52 +24411,52 @@ type GeosearchstoreCircleUnitKm Completed
 type SGeosearchstoreCircleUnitKm SCompleted
 
 func (c GeosearchstoreCircleUnitKm) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreCircleUnitKm) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreCircleUnitKm) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitKm) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreCircleUnitKm) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitKm) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreCircleUnitKm) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreCircleUnitKm) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreCircleUnitKm) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCircleUnitKm) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23817,52 +24473,52 @@ type GeosearchstoreCircleUnitM Completed
 type SGeosearchstoreCircleUnitM SCompleted
 
 func (c GeosearchstoreCircleUnitM) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreCircleUnitM) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreCircleUnitM) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitM) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreCircleUnitM) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitM) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreCircleUnitM) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreCircleUnitM) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreCircleUnitM) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCircleUnitM) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23879,52 +24535,52 @@ type GeosearchstoreCircleUnitMi Completed
 type SGeosearchstoreCircleUnitMi SCompleted
 
 func (c GeosearchstoreCircleUnitMi) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreCircleUnitMi) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreCircleUnitMi) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitMi) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreCircleUnitMi) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreCircleUnitMi) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreCircleUnitMi) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreCircleUnitMi) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreCircleUnitMi) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCircleUnitMi) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23941,12 +24597,12 @@ type GeosearchstoreCountAny Completed
 type SGeosearchstoreCountAny SCompleted
 
 func (c GeosearchstoreCountAny) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCountAny) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23963,22 +24619,22 @@ type GeosearchstoreCountCount Completed
 type SGeosearchstoreCountCount SCompleted
 
 func (c GeosearchstoreCountCount) Any() GeosearchstoreCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (GeosearchstoreCountAny)(c)
 }
 
 func (c SGeosearchstoreCountCount) Any() SGeosearchstoreCountAny {
-	c.cs = append(c.cs, "ANY")
+	c.cs.s = append(c.cs.s, "ANY")
 	return (SGeosearchstoreCountAny)(c)
 }
 
 func (c GeosearchstoreCountCount) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreCountCount) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -23995,13 +24651,13 @@ type GeosearchstoreDestination Completed
 type SGeosearchstoreDestination SCompleted
 
 func (c GeosearchstoreDestination) Source(source string) GeosearchstoreSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (GeosearchstoreSource)(c)
 }
 
 func (c SGeosearchstoreDestination) Source(source string) SGeosearchstoreSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SGeosearchstoreSource)(c)
 }
 
@@ -24010,62 +24666,62 @@ type GeosearchstoreFromlonlat Completed
 type SGeosearchstoreFromlonlat SCompleted
 
 func (c GeosearchstoreFromlonlat) Byradius(radius float64) GeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchstoreCircleByradius)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Byradius(radius float64) SGeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchstoreCircleByradius)(c)
 }
 
 func (c GeosearchstoreFromlonlat) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreFromlonlat) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreFromlonlat) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreFromlonlat) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreFromlonlat) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreFromlonlat) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -24082,72 +24738,72 @@ type GeosearchstoreFrommember Completed
 type SGeosearchstoreFrommember SCompleted
 
 func (c GeosearchstoreFrommember) Fromlonlat(longitude float64, latitude float64) GeosearchstoreFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeosearchstoreFromlonlat)(c)
 }
 
 func (c SGeosearchstoreFrommember) Fromlonlat(longitude float64, latitude float64) SGeosearchstoreFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeosearchstoreFromlonlat)(c)
 }
 
 func (c GeosearchstoreFrommember) Byradius(radius float64) GeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchstoreCircleByradius)(c)
 }
 
 func (c SGeosearchstoreFrommember) Byradius(radius float64) SGeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchstoreCircleByradius)(c)
 }
 
 func (c GeosearchstoreFrommember) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreFrommember) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreFrommember) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreFrommember) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreFrommember) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreFrommember) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreFrommember) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreFrommember) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreFrommember) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreFrommember) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -24164,22 +24820,22 @@ type GeosearchstoreOrderAsc Completed
 type SGeosearchstoreOrderAsc SCompleted
 
 func (c GeosearchstoreOrderAsc) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreOrderAsc) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreOrderAsc) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreOrderAsc) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -24196,22 +24852,22 @@ type GeosearchstoreOrderDesc Completed
 type SGeosearchstoreOrderDesc SCompleted
 
 func (c GeosearchstoreOrderDesc) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreOrderDesc) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreOrderDesc) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreOrderDesc) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -24228,82 +24884,82 @@ type GeosearchstoreSource Completed
 type SGeosearchstoreSource SCompleted
 
 func (c GeosearchstoreSource) Frommember(member string) GeosearchstoreFrommember {
-	c.cs = append(c.cs, "FROMMEMBER", member)
+	c.cs.s = append(c.cs.s, "FROMMEMBER", member)
 	return (GeosearchstoreFrommember)(c)
 }
 
 func (c SGeosearchstoreSource) Frommember(member string) SGeosearchstoreFrommember {
-	c.cs = append(c.cs, "FROMMEMBER", member)
+	c.cs.s = append(c.cs.s, "FROMMEMBER", member)
 	return (SGeosearchstoreFrommember)(c)
 }
 
 func (c GeosearchstoreSource) Fromlonlat(longitude float64, latitude float64) GeosearchstoreFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (GeosearchstoreFromlonlat)(c)
 }
 
 func (c SGeosearchstoreSource) Fromlonlat(longitude float64, latitude float64) SGeosearchstoreFromlonlat {
-	c.cs = append(c.cs, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
 	return (SGeosearchstoreFromlonlat)(c)
 }
 
 func (c GeosearchstoreSource) Byradius(radius float64) GeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (GeosearchstoreCircleByradius)(c)
 }
 
 func (c SGeosearchstoreSource) Byradius(radius float64) SGeosearchstoreCircleByradius {
-	c.cs = append(c.cs, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
 	return (SGeosearchstoreCircleByradius)(c)
 }
 
 func (c GeosearchstoreSource) Bybox(width float64) GeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (GeosearchstoreBoxBybox)(c)
 }
 
 func (c SGeosearchstoreSource) Bybox(width float64) SGeosearchstoreBoxBybox {
-	c.cs = append(c.cs, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
 	return (SGeosearchstoreBoxBybox)(c)
 }
 
 func (c GeosearchstoreSource) Asc() GeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (GeosearchstoreOrderAsc)(c)
 }
 
 func (c SGeosearchstoreSource) Asc() SGeosearchstoreOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SGeosearchstoreOrderAsc)(c)
 }
 
 func (c GeosearchstoreSource) Desc() GeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (GeosearchstoreOrderDesc)(c)
 }
 
 func (c SGeosearchstoreSource) Desc() SGeosearchstoreOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SGeosearchstoreOrderDesc)(c)
 }
 
 func (c GeosearchstoreSource) Count(count int64) GeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (GeosearchstoreCountCount)(c)
 }
 
 func (c SGeosearchstoreSource) Count(count int64) SGeosearchstoreCountCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SGeosearchstoreCountCount)(c)
 }
 
 func (c GeosearchstoreSource) Storedist() GeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (GeosearchstoreStoredist)(c)
 }
 
 func (c SGeosearchstoreSource) Storedist() SGeosearchstoreStoredist {
-	c.cs = append(c.cs, "STOREDIST")
+	c.cs.s = append(c.cs.s, "STOREDIST")
 	return (SGeosearchstoreStoredist)(c)
 }
 
@@ -24331,22 +24987,26 @@ type Get Completed
 
 type SGet SCompleted
 
-func (b *Builder) Get() Get {
-	return Get{cs: append(b.get(), "GET"), ks: InitSlot, cf: readonly}
+func (b *Builder) Get() (c Get) {
+	c = Get{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GET")
+	return c
 }
 
-func (b *SBuilder) Get() SGet {
-	return SGet{cs: append(b.get(), "GET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Get() (c SGet) {
+	c = SGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GET")
+	return c
 }
 
 func (c Get) Key(key string) GetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetKey)(c)
 }
 
 func (c SGet) Key(key string) SGetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetKey)(c)
 }
 
@@ -24374,22 +25034,26 @@ type Getbit Completed
 
 type SGetbit SCompleted
 
-func (b *Builder) Getbit() Getbit {
-	return Getbit{cs: append(b.get(), "GETBIT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Getbit() (c Getbit) {
+	c = Getbit{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GETBIT")
+	return c
 }
 
-func (b *SBuilder) Getbit() SGetbit {
-	return SGetbit{cs: append(b.get(), "GETBIT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Getbit() (c SGetbit) {
+	c = SGetbit{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GETBIT")
+	return c
 }
 
 func (c Getbit) Key(key string) GetbitKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetbitKey)(c)
 }
 
 func (c SGetbit) Key(key string) SGetbitKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetbitKey)(c)
 }
 
@@ -24398,12 +25062,12 @@ type GetbitKey Completed
 type SGetbitKey SCompleted
 
 func (c GetbitKey) Offset(offset int64) GetbitOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (GetbitOffset)(c)
 }
 
 func (c SGetbitKey) Offset(offset int64) SGetbitOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SGetbitOffset)(c)
 }
 
@@ -24431,22 +25095,26 @@ type Getdel Completed
 
 type SGetdel SCompleted
 
-func (b *Builder) Getdel() Getdel {
-	return Getdel{cs: append(b.get(), "GETDEL"), ks: InitSlot}
+func (b *Builder) Getdel() (c Getdel) {
+	c = Getdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETDEL")
+	return c
 }
 
-func (b *SBuilder) Getdel() SGetdel {
-	return SGetdel{cs: append(b.get(), "GETDEL"), ks: InitSlot}
+func (b *SBuilder) Getdel() (c SGetdel) {
+	c = SGetdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETDEL")
+	return c
 }
 
 func (c Getdel) Key(key string) GetdelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetdelKey)(c)
 }
 
 func (c SGetdel) Key(key string) SGetdelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetdelKey)(c)
 }
 
@@ -24466,22 +25134,26 @@ type Getex Completed
 
 type SGetex SCompleted
 
-func (b *Builder) Getex() Getex {
-	return Getex{cs: append(b.get(), "GETEX"), ks: InitSlot}
+func (b *Builder) Getex() (c Getex) {
+	c = Getex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETEX")
+	return c
 }
 
-func (b *SBuilder) Getex() SGetex {
-	return SGetex{cs: append(b.get(), "GETEX"), ks: InitSlot}
+func (b *SBuilder) Getex() (c SGetex) {
+	c = SGetex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETEX")
+	return c
 }
 
 func (c Getex) Key(key string) GetexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetexKey)(c)
 }
 
 func (c SGetex) Key(key string) SGetexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetexKey)(c)
 }
 
@@ -24550,52 +25222,52 @@ type GetexKey Completed
 type SGetexKey SCompleted
 
 func (c GetexKey) ExSeconds(seconds int64) GetexExpirationExSeconds {
-	c.cs = append(c.cs, "EX", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
 	return (GetexExpirationExSeconds)(c)
 }
 
 func (c SGetexKey) ExSeconds(seconds int64) SGetexExpirationExSeconds {
-	c.cs = append(c.cs, "EX", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
 	return (SGetexExpirationExSeconds)(c)
 }
 
 func (c GetexKey) PxMilliseconds(milliseconds int64) GetexExpirationPxMilliseconds {
-	c.cs = append(c.cs, "PX", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
 	return (GetexExpirationPxMilliseconds)(c)
 }
 
 func (c SGetexKey) PxMilliseconds(milliseconds int64) SGetexExpirationPxMilliseconds {
-	c.cs = append(c.cs, "PX", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
 	return (SGetexExpirationPxMilliseconds)(c)
 }
 
 func (c GetexKey) ExatTimestamp(timestamp int64) GetexExpirationExatTimestamp {
-	c.cs = append(c.cs, "EXAT", strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
 	return (GetexExpirationExatTimestamp)(c)
 }
 
 func (c SGetexKey) ExatTimestamp(timestamp int64) SGetexExpirationExatTimestamp {
-	c.cs = append(c.cs, "EXAT", strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
 	return (SGetexExpirationExatTimestamp)(c)
 }
 
 func (c GetexKey) PxatMillisecondsTimestamp(millisecondsTimestamp int64) GetexExpirationPxatMillisecondsTimestamp {
-	c.cs = append(c.cs, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
 	return (GetexExpirationPxatMillisecondsTimestamp)(c)
 }
 
 func (c SGetexKey) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SGetexExpirationPxatMillisecondsTimestamp {
-	c.cs = append(c.cs, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
 	return (SGetexExpirationPxatMillisecondsTimestamp)(c)
 }
 
 func (c GetexKey) Persist() GetexExpirationPersist {
-	c.cs = append(c.cs, "PERSIST")
+	c.cs.s = append(c.cs.s, "PERSIST")
 	return (GetexExpirationPersist)(c)
 }
 
 func (c SGetexKey) Persist() SGetexExpirationPersist {
-	c.cs = append(c.cs, "PERSIST")
+	c.cs.s = append(c.cs.s, "PERSIST")
 	return (SGetexExpirationPersist)(c)
 }
 
@@ -24611,22 +25283,26 @@ type Getrange Completed
 
 type SGetrange SCompleted
 
-func (b *Builder) Getrange() Getrange {
-	return Getrange{cs: append(b.get(), "GETRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Getrange() (c Getrange) {
+	c = Getrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GETRANGE")
+	return c
 }
 
-func (b *SBuilder) Getrange() SGetrange {
-	return SGetrange{cs: append(b.get(), "GETRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Getrange() (c SGetrange) {
+	c = SGetrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GETRANGE")
+	return c
 }
 
 func (c Getrange) Key(key string) GetrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetrangeKey)(c)
 }
 
 func (c SGetrange) Key(key string) SGetrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetrangeKey)(c)
 }
 
@@ -24655,12 +25331,12 @@ type GetrangeKey Completed
 type SGetrangeKey SCompleted
 
 func (c GetrangeKey) Start(start int64) GetrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (GetrangeStart)(c)
 }
 
 func (c SGetrangeKey) Start(start int64) SGetrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SGetrangeStart)(c)
 }
 
@@ -24669,12 +25345,12 @@ type GetrangeStart Completed
 type SGetrangeStart SCompleted
 
 func (c GetrangeStart) End(end int64) GetrangeEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (GetrangeEnd)(c)
 }
 
 func (c SGetrangeStart) End(end int64) SGetrangeEnd {
-	c.cs = append(c.cs, strconv.FormatInt(end, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
 	return (SGetrangeEnd)(c)
 }
 
@@ -24682,22 +25358,26 @@ type Getset Completed
 
 type SGetset SCompleted
 
-func (b *Builder) Getset() Getset {
-	return Getset{cs: append(b.get(), "GETSET"), ks: InitSlot}
+func (b *Builder) Getset() (c Getset) {
+	c = Getset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETSET")
+	return c
 }
 
-func (b *SBuilder) Getset() SGetset {
-	return SGetset{cs: append(b.get(), "GETSET"), ks: InitSlot}
+func (b *SBuilder) Getset() (c SGetset) {
+	c = SGetset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GETSET")
+	return c
 }
 
 func (c Getset) Key(key string) GetsetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (GetsetKey)(c)
 }
 
 func (c SGetset) Key(key string) SGetsetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SGetsetKey)(c)
 }
 
@@ -24706,12 +25386,12 @@ type GetsetKey Completed
 type SGetsetKey SCompleted
 
 func (c GetsetKey) Value(value string) GetsetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (GetsetValue)(c)
 }
 
 func (c SGetsetKey) Value(value string) SGetsetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SGetsetValue)(c)
 }
 
@@ -24731,21 +25411,25 @@ type GraphConfigGet Completed
 
 type SGraphConfigGet SCompleted
 
-func (b *Builder) GraphConfigGet() GraphConfigGet {
-	return GraphConfigGet{cs: append(b.get(), "GRAPH.CONFIG", "GET"), ks: InitSlot, cf: readonly}
+func (b *Builder) GraphConfigGet() (c GraphConfigGet) {
+	c = GraphConfigGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.CONFIG", "GET")
+	return c
 }
 
-func (b *SBuilder) GraphConfigGet() SGraphConfigGet {
-	return SGraphConfigGet{cs: append(b.get(), "GRAPH.CONFIG", "GET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GraphConfigGet() (c SGraphConfigGet) {
+	c = SGraphConfigGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.CONFIG", "GET")
+	return c
 }
 
 func (c GraphConfigGet) Name(name string) GraphConfigGetName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (GraphConfigGetName)(c)
 }
 
 func (c SGraphConfigGet) Name(name string) SGraphConfigGetName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (SGraphConfigGetName)(c)
 }
 
@@ -24765,21 +25449,25 @@ type GraphConfigSet Completed
 
 type SGraphConfigSet SCompleted
 
-func (b *Builder) GraphConfigSet() GraphConfigSet {
-	return GraphConfigSet{cs: append(b.get(), "GRAPH.CONFIG", "SET"), ks: InitSlot}
+func (b *Builder) GraphConfigSet() (c GraphConfigSet) {
+	c = GraphConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.CONFIG", "SET")
+	return c
 }
 
-func (b *SBuilder) GraphConfigSet() SGraphConfigSet {
-	return SGraphConfigSet{cs: append(b.get(), "GRAPH.CONFIG", "SET"), ks: InitSlot}
+func (b *SBuilder) GraphConfigSet() (c SGraphConfigSet) {
+	c = SGraphConfigSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.CONFIG", "SET")
+	return c
 }
 
 func (c GraphConfigSet) Name(name string) GraphConfigSetName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (GraphConfigSetName)(c)
 }
 
 func (c SGraphConfigSet) Name(name string) SGraphConfigSetName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (SGraphConfigSetName)(c)
 }
 
@@ -24788,12 +25476,12 @@ type GraphConfigSetName Completed
 type SGraphConfigSetName SCompleted
 
 func (c GraphConfigSetName) Value(value string) GraphConfigSetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (GraphConfigSetValue)(c)
 }
 
 func (c SGraphConfigSetName) Value(value string) SGraphConfigSetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SGraphConfigSetValue)(c)
 }
 
@@ -24813,22 +25501,26 @@ type GraphDelete Completed
 
 type SGraphDelete SCompleted
 
-func (b *Builder) GraphDelete() GraphDelete {
-	return GraphDelete{cs: append(b.get(), "GRAPH.DELETE"), ks: InitSlot}
+func (b *Builder) GraphDelete() (c GraphDelete) {
+	c = GraphDelete{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.DELETE")
+	return c
 }
 
-func (b *SBuilder) GraphDelete() SGraphDelete {
-	return SGraphDelete{cs: append(b.get(), "GRAPH.DELETE"), ks: InitSlot}
+func (b *SBuilder) GraphDelete() (c SGraphDelete) {
+	c = SGraphDelete{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.DELETE")
+	return c
 }
 
 func (c GraphDelete) Graph(graph string) GraphDeleteGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphDeleteGraph)(c)
 }
 
 func (c SGraphDelete) Graph(graph string) SGraphDeleteGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphDeleteGraph)(c)
 }
 
@@ -24848,22 +25540,26 @@ type GraphExplain Completed
 
 type SGraphExplain SCompleted
 
-func (b *Builder) GraphExplain() GraphExplain {
-	return GraphExplain{cs: append(b.get(), "GRAPH.EXPLAIN"), ks: InitSlot, cf: readonly}
+func (b *Builder) GraphExplain() (c GraphExplain) {
+	c = GraphExplain{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.EXPLAIN")
+	return c
 }
 
-func (b *SBuilder) GraphExplain() SGraphExplain {
-	return SGraphExplain{cs: append(b.get(), "GRAPH.EXPLAIN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GraphExplain() (c SGraphExplain) {
+	c = SGraphExplain{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.EXPLAIN")
+	return c
 }
 
 func (c GraphExplain) Graph(graph string) GraphExplainGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphExplainGraph)(c)
 }
 
 func (c SGraphExplain) Graph(graph string) SGraphExplainGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphExplainGraph)(c)
 }
 
@@ -24872,12 +25568,12 @@ type GraphExplainGraph Completed
 type SGraphExplainGraph SCompleted
 
 func (c GraphExplainGraph) Query(query string) GraphExplainQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (GraphExplainQuery)(c)
 }
 
 func (c SGraphExplainGraph) Query(query string) SGraphExplainQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SGraphExplainQuery)(c)
 }
 
@@ -24897,12 +25593,16 @@ type GraphList Completed
 
 type SGraphList SCompleted
 
-func (b *Builder) GraphList() GraphList {
-	return GraphList{cs: append(b.get(), "GRAPH.LIST"), ks: InitSlot, cf: readonly}
+func (b *Builder) GraphList() (c GraphList) {
+	c = GraphList{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.LIST")
+	return c
 }
 
-func (b *SBuilder) GraphList() SGraphList {
-	return SGraphList{cs: append(b.get(), "GRAPH.LIST"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GraphList() (c SGraphList) {
+	c = SGraphList{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.LIST")
+	return c
 }
 
 func (c GraphList) Build() Completed {
@@ -24917,22 +25617,26 @@ type GraphProfile Completed
 
 type SGraphProfile SCompleted
 
-func (b *Builder) GraphProfile() GraphProfile {
-	return GraphProfile{cs: append(b.get(), "GRAPH.PROFILE"), ks: InitSlot}
+func (b *Builder) GraphProfile() (c GraphProfile) {
+	c = GraphProfile{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.PROFILE")
+	return c
 }
 
-func (b *SBuilder) GraphProfile() SGraphProfile {
-	return SGraphProfile{cs: append(b.get(), "GRAPH.PROFILE"), ks: InitSlot}
+func (b *SBuilder) GraphProfile() (c SGraphProfile) {
+	c = SGraphProfile{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.PROFILE")
+	return c
 }
 
 func (c GraphProfile) Graph(graph string) GraphProfileGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphProfileGraph)(c)
 }
 
 func (c SGraphProfile) Graph(graph string) SGraphProfileGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphProfileGraph)(c)
 }
 
@@ -24941,12 +25645,12 @@ type GraphProfileGraph Completed
 type SGraphProfileGraph SCompleted
 
 func (c GraphProfileGraph) Query(query string) GraphProfileQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (GraphProfileQuery)(c)
 }
 
 func (c SGraphProfileGraph) Query(query string) SGraphProfileQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SGraphProfileQuery)(c)
 }
 
@@ -24966,22 +25670,26 @@ type GraphQuery Completed
 
 type SGraphQuery SCompleted
 
-func (b *Builder) GraphQuery() GraphQuery {
-	return GraphQuery{cs: append(b.get(), "GRAPH.QUERY"), ks: InitSlot}
+func (b *Builder) GraphQuery() (c GraphQuery) {
+	c = GraphQuery{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.QUERY")
+	return c
 }
 
-func (b *SBuilder) GraphQuery() SGraphQuery {
-	return SGraphQuery{cs: append(b.get(), "GRAPH.QUERY"), ks: InitSlot}
+func (b *SBuilder) GraphQuery() (c SGraphQuery) {
+	c = SGraphQuery{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "GRAPH.QUERY")
+	return c
 }
 
 func (c GraphQuery) Graph(graph string) GraphQueryGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphQueryGraph)(c)
 }
 
 func (c SGraphQuery) Graph(graph string) SGraphQueryGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphQueryGraph)(c)
 }
 
@@ -24990,12 +25698,12 @@ type GraphQueryGraph Completed
 type SGraphQueryGraph SCompleted
 
 func (c GraphQueryGraph) Query(query string) GraphQueryQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (GraphQueryQuery)(c)
 }
 
 func (c SGraphQueryGraph) Query(query string) SGraphQueryQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SGraphQueryQuery)(c)
 }
 
@@ -25015,22 +25723,26 @@ type GraphRoQuery Completed
 
 type SGraphRoQuery SCompleted
 
-func (b *Builder) GraphRoQuery() GraphRoQuery {
-	return GraphRoQuery{cs: append(b.get(), "GRAPH.RO_QUERY"), ks: InitSlot, cf: readonly}
+func (b *Builder) GraphRoQuery() (c GraphRoQuery) {
+	c = GraphRoQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.RO_QUERY")
+	return c
 }
 
-func (b *SBuilder) GraphRoQuery() SGraphRoQuery {
-	return SGraphRoQuery{cs: append(b.get(), "GRAPH.RO_QUERY"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GraphRoQuery() (c SGraphRoQuery) {
+	c = SGraphRoQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.RO_QUERY")
+	return c
 }
 
 func (c GraphRoQuery) Graph(graph string) GraphRoQueryGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphRoQueryGraph)(c)
 }
 
 func (c SGraphRoQuery) Graph(graph string) SGraphRoQueryGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphRoQueryGraph)(c)
 }
 
@@ -25039,12 +25751,12 @@ type GraphRoQueryGraph Completed
 type SGraphRoQueryGraph SCompleted
 
 func (c GraphRoQueryGraph) Query(query string) GraphRoQueryQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (GraphRoQueryQuery)(c)
 }
 
 func (c SGraphRoQueryGraph) Query(query string) SGraphRoQueryQuery {
-	c.cs = append(c.cs, query)
+	c.cs.s = append(c.cs.s, query)
 	return (SGraphRoQueryQuery)(c)
 }
 
@@ -25064,22 +25776,26 @@ type GraphSlowlog Completed
 
 type SGraphSlowlog SCompleted
 
-func (b *Builder) GraphSlowlog() GraphSlowlog {
-	return GraphSlowlog{cs: append(b.get(), "GRAPH.SLOWLOG"), ks: InitSlot, cf: readonly}
+func (b *Builder) GraphSlowlog() (c GraphSlowlog) {
+	c = GraphSlowlog{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.SLOWLOG")
+	return c
 }
 
-func (b *SBuilder) GraphSlowlog() SGraphSlowlog {
-	return SGraphSlowlog{cs: append(b.get(), "GRAPH.SLOWLOG"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) GraphSlowlog() (c SGraphSlowlog) {
+	c = SGraphSlowlog{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "GRAPH.SLOWLOG")
+	return c
 }
 
 func (c GraphSlowlog) Graph(graph string) GraphSlowlogGraph {
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (GraphSlowlogGraph)(c)
 }
 
 func (c SGraphSlowlog) Graph(graph string) SGraphSlowlogGraph {
 	c.ks = checkSlot(c.ks, slot(graph))
-	c.cs = append(c.cs, graph)
+	c.cs.s = append(c.cs.s, graph)
 	return (SGraphSlowlogGraph)(c)
 }
 
@@ -25099,22 +25815,26 @@ type Hdel Completed
 
 type SHdel SCompleted
 
-func (b *Builder) Hdel() Hdel {
-	return Hdel{cs: append(b.get(), "HDEL"), ks: InitSlot}
+func (b *Builder) Hdel() (c Hdel) {
+	c = Hdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HDEL")
+	return c
 }
 
-func (b *SBuilder) Hdel() SHdel {
-	return SHdel{cs: append(b.get(), "HDEL"), ks: InitSlot}
+func (b *SBuilder) Hdel() (c SHdel) {
+	c = SHdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HDEL")
+	return c
 }
 
 func (c Hdel) Key(key string) HdelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HdelKey)(c)
 }
 
 func (c SHdel) Key(key string) SHdelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHdelKey)(c)
 }
 
@@ -25123,12 +25843,12 @@ type HdelField Completed
 type SHdelField SCompleted
 
 func (c HdelField) Field(field ...string) HdelField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SHdelField) Field(field ...string) SHdelField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
@@ -25145,12 +25865,12 @@ type HdelKey Completed
 type SHdelKey SCompleted
 
 func (c HdelKey) Field(field ...string) HdelField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (HdelField)(c)
 }
 
 func (c SHdelKey) Field(field ...string) SHdelField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SHdelField)(c)
 }
 
@@ -25158,21 +25878,25 @@ type Hello Completed
 
 type SHello SCompleted
 
-func (b *Builder) Hello() Hello {
-	return Hello{cs: append(b.get(), "HELLO"), ks: InitSlot}
+func (b *Builder) Hello() (c Hello) {
+	c = Hello{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HELLO")
+	return c
 }
 
-func (b *SBuilder) Hello() SHello {
-	return SHello{cs: append(b.get(), "HELLO"), ks: InitSlot}
+func (b *SBuilder) Hello() (c SHello) {
+	c = SHello{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HELLO")
+	return c
 }
 
 func (c Hello) Protover(protover int64) HelloArgumentsProtover {
-	c.cs = append(c.cs, strconv.FormatInt(protover, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(protover, 10))
 	return (HelloArgumentsProtover)(c)
 }
 
 func (c SHello) Protover(protover int64) SHelloArgumentsProtover {
-	c.cs = append(c.cs, strconv.FormatInt(protover, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(protover, 10))
 	return (SHelloArgumentsProtover)(c)
 }
 
@@ -25189,12 +25913,12 @@ type HelloArgumentsAuth Completed
 type SHelloArgumentsAuth SCompleted
 
 func (c HelloArgumentsAuth) Setname(clientname string) HelloArgumentsSetname {
-	c.cs = append(c.cs, "SETNAME", clientname)
+	c.cs.s = append(c.cs.s, "SETNAME", clientname)
 	return (HelloArgumentsSetname)(c)
 }
 
 func (c SHelloArgumentsAuth) Setname(clientname string) SHelloArgumentsSetname {
-	c.cs = append(c.cs, "SETNAME", clientname)
+	c.cs.s = append(c.cs.s, "SETNAME", clientname)
 	return (SHelloArgumentsSetname)(c)
 }
 
@@ -25211,22 +25935,22 @@ type HelloArgumentsProtover Completed
 type SHelloArgumentsProtover SCompleted
 
 func (c HelloArgumentsProtover) Auth(username string, password string) HelloArgumentsAuth {
-	c.cs = append(c.cs, "AUTH", username, password)
+	c.cs.s = append(c.cs.s, "AUTH", username, password)
 	return (HelloArgumentsAuth)(c)
 }
 
 func (c SHelloArgumentsProtover) Auth(username string, password string) SHelloArgumentsAuth {
-	c.cs = append(c.cs, "AUTH", username, password)
+	c.cs.s = append(c.cs.s, "AUTH", username, password)
 	return (SHelloArgumentsAuth)(c)
 }
 
 func (c HelloArgumentsProtover) Setname(clientname string) HelloArgumentsSetname {
-	c.cs = append(c.cs, "SETNAME", clientname)
+	c.cs.s = append(c.cs.s, "SETNAME", clientname)
 	return (HelloArgumentsSetname)(c)
 }
 
 func (c SHelloArgumentsProtover) Setname(clientname string) SHelloArgumentsSetname {
-	c.cs = append(c.cs, "SETNAME", clientname)
+	c.cs.s = append(c.cs.s, "SETNAME", clientname)
 	return (SHelloArgumentsSetname)(c)
 }
 
@@ -25254,22 +25978,26 @@ type Hexists Completed
 
 type SHexists SCompleted
 
-func (b *Builder) Hexists() Hexists {
-	return Hexists{cs: append(b.get(), "HEXISTS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hexists() (c Hexists) {
+	c = Hexists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HEXISTS")
+	return c
 }
 
-func (b *SBuilder) Hexists() SHexists {
-	return SHexists{cs: append(b.get(), "HEXISTS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hexists() (c SHexists) {
+	c = SHexists{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HEXISTS")
+	return c
 }
 
 func (c Hexists) Key(key string) HexistsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HexistsKey)(c)
 }
 
 func (c SHexists) Key(key string) SHexistsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHexistsKey)(c)
 }
 
@@ -25298,12 +26026,12 @@ type HexistsKey Completed
 type SHexistsKey SCompleted
 
 func (c HexistsKey) Field(field string) HexistsField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HexistsField)(c)
 }
 
 func (c SHexistsKey) Field(field string) SHexistsField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHexistsField)(c)
 }
 
@@ -25311,22 +26039,26 @@ type Hget Completed
 
 type SHget SCompleted
 
-func (b *Builder) Hget() Hget {
-	return Hget{cs: append(b.get(), "HGET"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hget() (c Hget) {
+	c = Hget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HGET")
+	return c
 }
 
-func (b *SBuilder) Hget() SHget {
-	return SHget{cs: append(b.get(), "HGET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hget() (c SHget) {
+	c = SHget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HGET")
+	return c
 }
 
 func (c Hget) Key(key string) HgetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HgetKey)(c)
 }
 
 func (c SHget) Key(key string) SHgetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHgetKey)(c)
 }
 
@@ -25355,12 +26087,12 @@ type HgetKey Completed
 type SHgetKey SCompleted
 
 func (c HgetKey) Field(field string) HgetField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HgetField)(c)
 }
 
 func (c SHgetKey) Field(field string) SHgetField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHgetField)(c)
 }
 
@@ -25368,22 +26100,26 @@ type Hgetall Completed
 
 type SHgetall SCompleted
 
-func (b *Builder) Hgetall() Hgetall {
-	return Hgetall{cs: append(b.get(), "HGETALL"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hgetall() (c Hgetall) {
+	c = Hgetall{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HGETALL")
+	return c
 }
 
-func (b *SBuilder) Hgetall() SHgetall {
-	return SHgetall{cs: append(b.get(), "HGETALL"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hgetall() (c SHgetall) {
+	c = SHgetall{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HGETALL")
+	return c
 }
 
 func (c Hgetall) Key(key string) HgetallKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HgetallKey)(c)
 }
 
 func (c SHgetall) Key(key string) SHgetallKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHgetallKey)(c)
 }
 
@@ -25411,22 +26147,26 @@ type Hincrby Completed
 
 type SHincrby SCompleted
 
-func (b *Builder) Hincrby() Hincrby {
-	return Hincrby{cs: append(b.get(), "HINCRBY"), ks: InitSlot}
+func (b *Builder) Hincrby() (c Hincrby) {
+	c = Hincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HINCRBY")
+	return c
 }
 
-func (b *SBuilder) Hincrby() SHincrby {
-	return SHincrby{cs: append(b.get(), "HINCRBY"), ks: InitSlot}
+func (b *SBuilder) Hincrby() (c SHincrby) {
+	c = SHincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HINCRBY")
+	return c
 }
 
 func (c Hincrby) Key(key string) HincrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HincrbyKey)(c)
 }
 
 func (c SHincrby) Key(key string) SHincrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHincrbyKey)(c)
 }
 
@@ -25435,12 +26175,12 @@ type HincrbyField Completed
 type SHincrbyField SCompleted
 
 func (c HincrbyField) Increment(increment int64) HincrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (HincrbyIncrement)(c)
 }
 
 func (c SHincrbyField) Increment(increment int64) SHincrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (SHincrbyIncrement)(c)
 }
 
@@ -25461,12 +26201,12 @@ type HincrbyKey Completed
 type SHincrbyKey SCompleted
 
 func (c HincrbyKey) Field(field string) HincrbyField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HincrbyField)(c)
 }
 
 func (c SHincrbyKey) Field(field string) SHincrbyField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHincrbyField)(c)
 }
 
@@ -25474,22 +26214,26 @@ type Hincrbyfloat Completed
 
 type SHincrbyfloat SCompleted
 
-func (b *Builder) Hincrbyfloat() Hincrbyfloat {
-	return Hincrbyfloat{cs: append(b.get(), "HINCRBYFLOAT"), ks: InitSlot}
+func (b *Builder) Hincrbyfloat() (c Hincrbyfloat) {
+	c = Hincrbyfloat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HINCRBYFLOAT")
+	return c
 }
 
-func (b *SBuilder) Hincrbyfloat() SHincrbyfloat {
-	return SHincrbyfloat{cs: append(b.get(), "HINCRBYFLOAT"), ks: InitSlot}
+func (b *SBuilder) Hincrbyfloat() (c SHincrbyfloat) {
+	c = SHincrbyfloat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HINCRBYFLOAT")
+	return c
 }
 
 func (c Hincrbyfloat) Key(key string) HincrbyfloatKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HincrbyfloatKey)(c)
 }
 
 func (c SHincrbyfloat) Key(key string) SHincrbyfloatKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHincrbyfloatKey)(c)
 }
 
@@ -25498,12 +26242,12 @@ type HincrbyfloatField Completed
 type SHincrbyfloatField SCompleted
 
 func (c HincrbyfloatField) Increment(increment float64) HincrbyfloatIncrement {
-	c.cs = append(c.cs, strconv.FormatFloat(increment, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
 	return (HincrbyfloatIncrement)(c)
 }
 
 func (c SHincrbyfloatField) Increment(increment float64) SHincrbyfloatIncrement {
-	c.cs = append(c.cs, strconv.FormatFloat(increment, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
 	return (SHincrbyfloatIncrement)(c)
 }
 
@@ -25524,12 +26268,12 @@ type HincrbyfloatKey Completed
 type SHincrbyfloatKey SCompleted
 
 func (c HincrbyfloatKey) Field(field string) HincrbyfloatField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HincrbyfloatField)(c)
 }
 
 func (c SHincrbyfloatKey) Field(field string) SHincrbyfloatField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHincrbyfloatField)(c)
 }
 
@@ -25537,22 +26281,26 @@ type Hkeys Completed
 
 type SHkeys SCompleted
 
-func (b *Builder) Hkeys() Hkeys {
-	return Hkeys{cs: append(b.get(), "HKEYS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hkeys() (c Hkeys) {
+	c = Hkeys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HKEYS")
+	return c
 }
 
-func (b *SBuilder) Hkeys() SHkeys {
-	return SHkeys{cs: append(b.get(), "HKEYS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hkeys() (c SHkeys) {
+	c = SHkeys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HKEYS")
+	return c
 }
 
 func (c Hkeys) Key(key string) HkeysKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HkeysKey)(c)
 }
 
 func (c SHkeys) Key(key string) SHkeysKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHkeysKey)(c)
 }
 
@@ -25580,22 +26328,26 @@ type Hlen Completed
 
 type SHlen SCompleted
 
-func (b *Builder) Hlen() Hlen {
-	return Hlen{cs: append(b.get(), "HLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hlen() (c Hlen) {
+	c = Hlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HLEN")
+	return c
 }
 
-func (b *SBuilder) Hlen() SHlen {
-	return SHlen{cs: append(b.get(), "HLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hlen() (c SHlen) {
+	c = SHlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HLEN")
+	return c
 }
 
 func (c Hlen) Key(key string) HlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HlenKey)(c)
 }
 
 func (c SHlen) Key(key string) SHlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHlenKey)(c)
 }
 
@@ -25623,22 +26375,26 @@ type Hmget Completed
 
 type SHmget SCompleted
 
-func (b *Builder) Hmget() Hmget {
-	return Hmget{cs: append(b.get(), "HMGET"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hmget() (c Hmget) {
+	c = Hmget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HMGET")
+	return c
 }
 
-func (b *SBuilder) Hmget() SHmget {
-	return SHmget{cs: append(b.get(), "HMGET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hmget() (c SHmget) {
+	c = SHmget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HMGET")
+	return c
 }
 
 func (c Hmget) Key(key string) HmgetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HmgetKey)(c)
 }
 
 func (c SHmget) Key(key string) SHmgetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHmgetKey)(c)
 }
 
@@ -25647,12 +26403,12 @@ type HmgetField Completed
 type SHmgetField SCompleted
 
 func (c HmgetField) Field(field ...string) HmgetField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
 func (c SHmgetField) Field(field ...string) SHmgetField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return c
 }
 
@@ -25677,12 +26433,12 @@ type HmgetKey Completed
 type SHmgetKey SCompleted
 
 func (c HmgetKey) Field(field ...string) HmgetField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (HmgetField)(c)
 }
 
 func (c SHmgetKey) Field(field ...string) SHmgetField {
-	c.cs = append(c.cs, field...)
+	c.cs.s = append(c.cs.s, field...)
 	return (SHmgetField)(c)
 }
 
@@ -25690,22 +26446,26 @@ type Hmset Completed
 
 type SHmset SCompleted
 
-func (b *Builder) Hmset() Hmset {
-	return Hmset{cs: append(b.get(), "HMSET"), ks: InitSlot}
+func (b *Builder) Hmset() (c Hmset) {
+	c = Hmset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HMSET")
+	return c
 }
 
-func (b *SBuilder) Hmset() SHmset {
-	return SHmset{cs: append(b.get(), "HMSET"), ks: InitSlot}
+func (b *SBuilder) Hmset() (c SHmset) {
+	c = SHmset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HMSET")
+	return c
 }
 
 func (c Hmset) Key(key string) HmsetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HmsetKey)(c)
 }
 
 func (c SHmset) Key(key string) SHmsetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHmsetKey)(c)
 }
 
@@ -25714,12 +26474,12 @@ type HmsetFieldValue Completed
 type SHmsetFieldValue SCompleted
 
 func (c HmsetFieldValue) FieldValue(field string, value string) HmsetFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
 func (c SHmsetFieldValue) FieldValue(field string, value string) SHmsetFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
@@ -25747,22 +26507,26 @@ type Hrandfield Completed
 
 type SHrandfield SCompleted
 
-func (b *Builder) Hrandfield() Hrandfield {
-	return Hrandfield{cs: append(b.get(), "HRANDFIELD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hrandfield() (c Hrandfield) {
+	c = Hrandfield{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HRANDFIELD")
+	return c
 }
 
-func (b *SBuilder) Hrandfield() SHrandfield {
-	return SHrandfield{cs: append(b.get(), "HRANDFIELD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hrandfield() (c SHrandfield) {
+	c = SHrandfield{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HRANDFIELD")
+	return c
 }
 
 func (c Hrandfield) Key(key string) HrandfieldKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HrandfieldKey)(c)
 }
 
 func (c SHrandfield) Key(key string) SHrandfieldKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHrandfieldKey)(c)
 }
 
@@ -25771,12 +26535,12 @@ type HrandfieldKey Completed
 type SHrandfieldKey SCompleted
 
 func (c HrandfieldKey) Count(count int64) HrandfieldOptionsCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (HrandfieldOptionsCount)(c)
 }
 
 func (c SHrandfieldKey) Count(count int64) SHrandfieldOptionsCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SHrandfieldOptionsCount)(c)
 }
 
@@ -25793,12 +26557,12 @@ type HrandfieldOptionsCount Completed
 type SHrandfieldOptionsCount SCompleted
 
 func (c HrandfieldOptionsCount) Withvalues() HrandfieldOptionsWithvalues {
-	c.cs = append(c.cs, "WITHVALUES")
+	c.cs.s = append(c.cs.s, "WITHVALUES")
 	return (HrandfieldOptionsWithvalues)(c)
 }
 
 func (c SHrandfieldOptionsCount) Withvalues() SHrandfieldOptionsWithvalues {
-	c.cs = append(c.cs, "WITHVALUES")
+	c.cs.s = append(c.cs.s, "WITHVALUES")
 	return (SHrandfieldOptionsWithvalues)(c)
 }
 
@@ -25826,22 +26590,26 @@ type Hscan Completed
 
 type SHscan SCompleted
 
-func (b *Builder) Hscan() Hscan {
-	return Hscan{cs: append(b.get(), "HSCAN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hscan() (c Hscan) {
+	c = Hscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HSCAN")
+	return c
 }
 
-func (b *SBuilder) Hscan() SHscan {
-	return SHscan{cs: append(b.get(), "HSCAN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hscan() (c SHscan) {
+	c = SHscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HSCAN")
+	return c
 }
 
 func (c Hscan) Key(key string) HscanKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HscanKey)(c)
 }
 
 func (c SHscan) Key(key string) SHscanKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHscanKey)(c)
 }
 
@@ -25862,22 +26630,22 @@ type HscanCursor Completed
 type SHscanCursor SCompleted
 
 func (c HscanCursor) Match(pattern string) HscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (HscanMatch)(c)
 }
 
 func (c SHscanCursor) Match(pattern string) SHscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (SHscanMatch)(c)
 }
 
 func (c HscanCursor) Count(count int64) HscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (HscanCount)(c)
 }
 
 func (c SHscanCursor) Count(count int64) SHscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SHscanCount)(c)
 }
 
@@ -25894,12 +26662,12 @@ type HscanKey Completed
 type SHscanKey SCompleted
 
 func (c HscanKey) Cursor(cursor int64) HscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (HscanCursor)(c)
 }
 
 func (c SHscanKey) Cursor(cursor int64) SHscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (SHscanCursor)(c)
 }
 
@@ -25908,12 +26676,12 @@ type HscanMatch Completed
 type SHscanMatch SCompleted
 
 func (c HscanMatch) Count(count int64) HscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (HscanCount)(c)
 }
 
 func (c SHscanMatch) Count(count int64) SHscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SHscanCount)(c)
 }
 
@@ -25929,22 +26697,26 @@ type Hset Completed
 
 type SHset SCompleted
 
-func (b *Builder) Hset() Hset {
-	return Hset{cs: append(b.get(), "HSET"), ks: InitSlot}
+func (b *Builder) Hset() (c Hset) {
+	c = Hset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HSET")
+	return c
 }
 
-func (b *SBuilder) Hset() SHset {
-	return SHset{cs: append(b.get(), "HSET"), ks: InitSlot}
+func (b *SBuilder) Hset() (c SHset) {
+	c = SHset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HSET")
+	return c
 }
 
 func (c Hset) Key(key string) HsetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HsetKey)(c)
 }
 
 func (c SHset) Key(key string) SHsetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHsetKey)(c)
 }
 
@@ -25953,12 +26725,12 @@ type HsetFieldValue Completed
 type SHsetFieldValue SCompleted
 
 func (c HsetFieldValue) FieldValue(field string, value string) HsetFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
 func (c SHsetFieldValue) FieldValue(field string, value string) SHsetFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
@@ -25986,22 +26758,26 @@ type Hsetnx Completed
 
 type SHsetnx SCompleted
 
-func (b *Builder) Hsetnx() Hsetnx {
-	return Hsetnx{cs: append(b.get(), "HSETNX"), ks: InitSlot}
+func (b *Builder) Hsetnx() (c Hsetnx) {
+	c = Hsetnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HSETNX")
+	return c
 }
 
-func (b *SBuilder) Hsetnx() SHsetnx {
-	return SHsetnx{cs: append(b.get(), "HSETNX"), ks: InitSlot}
+func (b *SBuilder) Hsetnx() (c SHsetnx) {
+	c = SHsetnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "HSETNX")
+	return c
 }
 
 func (c Hsetnx) Key(key string) HsetnxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HsetnxKey)(c)
 }
 
 func (c SHsetnx) Key(key string) SHsetnxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHsetnxKey)(c)
 }
 
@@ -26010,12 +26786,12 @@ type HsetnxField Completed
 type SHsetnxField SCompleted
 
 func (c HsetnxField) Value(value string) HsetnxValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (HsetnxValue)(c)
 }
 
 func (c SHsetnxField) Value(value string) SHsetnxValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SHsetnxValue)(c)
 }
 
@@ -26024,12 +26800,12 @@ type HsetnxKey Completed
 type SHsetnxKey SCompleted
 
 func (c HsetnxKey) Field(field string) HsetnxField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HsetnxField)(c)
 }
 
 func (c SHsetnxKey) Field(field string) SHsetnxField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHsetnxField)(c)
 }
 
@@ -26049,22 +26825,26 @@ type Hstrlen Completed
 
 type SHstrlen SCompleted
 
-func (b *Builder) Hstrlen() Hstrlen {
-	return Hstrlen{cs: append(b.get(), "HSTRLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hstrlen() (c Hstrlen) {
+	c = Hstrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HSTRLEN")
+	return c
 }
 
-func (b *SBuilder) Hstrlen() SHstrlen {
-	return SHstrlen{cs: append(b.get(), "HSTRLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hstrlen() (c SHstrlen) {
+	c = SHstrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HSTRLEN")
+	return c
 }
 
 func (c Hstrlen) Key(key string) HstrlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HstrlenKey)(c)
 }
 
 func (c SHstrlen) Key(key string) SHstrlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHstrlenKey)(c)
 }
 
@@ -26093,12 +26873,12 @@ type HstrlenKey Completed
 type SHstrlenKey SCompleted
 
 func (c HstrlenKey) Field(field string) HstrlenField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (HstrlenField)(c)
 }
 
 func (c SHstrlenKey) Field(field string) SHstrlenField {
-	c.cs = append(c.cs, field)
+	c.cs.s = append(c.cs.s, field)
 	return (SHstrlenField)(c)
 }
 
@@ -26106,22 +26886,26 @@ type Hvals Completed
 
 type SHvals SCompleted
 
-func (b *Builder) Hvals() Hvals {
-	return Hvals{cs: append(b.get(), "HVALS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Hvals() (c Hvals) {
+	c = Hvals{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HVALS")
+	return c
 }
 
-func (b *SBuilder) Hvals() SHvals {
-	return SHvals{cs: append(b.get(), "HVALS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Hvals() (c SHvals) {
+	c = SHvals{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "HVALS")
+	return c
 }
 
 func (c Hvals) Key(key string) HvalsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (HvalsKey)(c)
 }
 
 func (c SHvals) Key(key string) SHvalsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SHvalsKey)(c)
 }
 
@@ -26149,22 +26933,26 @@ type Incr Completed
 
 type SIncr SCompleted
 
-func (b *Builder) Incr() Incr {
-	return Incr{cs: append(b.get(), "INCR"), ks: InitSlot}
+func (b *Builder) Incr() (c Incr) {
+	c = Incr{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCR")
+	return c
 }
 
-func (b *SBuilder) Incr() SIncr {
-	return SIncr{cs: append(b.get(), "INCR"), ks: InitSlot}
+func (b *SBuilder) Incr() (c SIncr) {
+	c = SIncr{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCR")
+	return c
 }
 
 func (c Incr) Key(key string) IncrKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (IncrKey)(c)
 }
 
 func (c SIncr) Key(key string) SIncrKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SIncrKey)(c)
 }
 
@@ -26184,22 +26972,26 @@ type Incrby Completed
 
 type SIncrby SCompleted
 
-func (b *Builder) Incrby() Incrby {
-	return Incrby{cs: append(b.get(), "INCRBY"), ks: InitSlot}
+func (b *Builder) Incrby() (c Incrby) {
+	c = Incrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCRBY")
+	return c
 }
 
-func (b *SBuilder) Incrby() SIncrby {
-	return SIncrby{cs: append(b.get(), "INCRBY"), ks: InitSlot}
+func (b *SBuilder) Incrby() (c SIncrby) {
+	c = SIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCRBY")
+	return c
 }
 
 func (c Incrby) Key(key string) IncrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (IncrbyKey)(c)
 }
 
 func (c SIncrby) Key(key string) SIncrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SIncrbyKey)(c)
 }
 
@@ -26220,12 +27012,12 @@ type IncrbyKey Completed
 type SIncrbyKey SCompleted
 
 func (c IncrbyKey) Increment(increment int64) IncrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (IncrbyIncrement)(c)
 }
 
 func (c SIncrbyKey) Increment(increment int64) SIncrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (SIncrbyIncrement)(c)
 }
 
@@ -26233,22 +27025,26 @@ type Incrbyfloat Completed
 
 type SIncrbyfloat SCompleted
 
-func (b *Builder) Incrbyfloat() Incrbyfloat {
-	return Incrbyfloat{cs: append(b.get(), "INCRBYFLOAT"), ks: InitSlot}
+func (b *Builder) Incrbyfloat() (c Incrbyfloat) {
+	c = Incrbyfloat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCRBYFLOAT")
+	return c
 }
 
-func (b *SBuilder) Incrbyfloat() SIncrbyfloat {
-	return SIncrbyfloat{cs: append(b.get(), "INCRBYFLOAT"), ks: InitSlot}
+func (b *SBuilder) Incrbyfloat() (c SIncrbyfloat) {
+	c = SIncrbyfloat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INCRBYFLOAT")
+	return c
 }
 
 func (c Incrbyfloat) Key(key string) IncrbyfloatKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (IncrbyfloatKey)(c)
 }
 
 func (c SIncrbyfloat) Key(key string) SIncrbyfloatKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SIncrbyfloatKey)(c)
 }
 
@@ -26269,12 +27065,12 @@ type IncrbyfloatKey Completed
 type SIncrbyfloatKey SCompleted
 
 func (c IncrbyfloatKey) Increment(increment float64) IncrbyfloatIncrement {
-	c.cs = append(c.cs, strconv.FormatFloat(increment, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
 	return (IncrbyfloatIncrement)(c)
 }
 
 func (c SIncrbyfloatKey) Increment(increment float64) SIncrbyfloatIncrement {
-	c.cs = append(c.cs, strconv.FormatFloat(increment, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
 	return (SIncrbyfloatIncrement)(c)
 }
 
@@ -26282,21 +27078,25 @@ type Info Completed
 
 type SInfo SCompleted
 
-func (b *Builder) Info() Info {
-	return Info{cs: append(b.get(), "INFO"), ks: InitSlot}
+func (b *Builder) Info() (c Info) {
+	c = Info{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INFO")
+	return c
 }
 
-func (b *SBuilder) Info() SInfo {
-	return SInfo{cs: append(b.get(), "INFO"), ks: InitSlot}
+func (b *SBuilder) Info() (c SInfo) {
+	c = SInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "INFO")
+	return c
 }
 
 func (c Info) Section(section string) InfoSection {
-	c.cs = append(c.cs, section)
+	c.cs.s = append(c.cs.s, section)
 	return (InfoSection)(c)
 }
 
 func (c SInfo) Section(section string) SInfoSection {
-	c.cs = append(c.cs, section)
+	c.cs.s = append(c.cs.s, section)
 	return (SInfoSection)(c)
 }
 
@@ -26324,22 +27124,26 @@ type JsonArrappend Completed
 
 type SJsonArrappend SCompleted
 
-func (b *Builder) JsonArrappend() JsonArrappend {
-	return JsonArrappend{cs: append(b.get(), "JSON.ARRAPPEND"), ks: InitSlot}
+func (b *Builder) JsonArrappend() (c JsonArrappend) {
+	c = JsonArrappend{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRAPPEND")
+	return c
 }
 
-func (b *SBuilder) JsonArrappend() SJsonArrappend {
-	return SJsonArrappend{cs: append(b.get(), "JSON.ARRAPPEND"), ks: InitSlot}
+func (b *SBuilder) JsonArrappend() (c SJsonArrappend) {
+	c = SJsonArrappend{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRAPPEND")
+	return c
 }
 
 func (c JsonArrappend) Key(key string) JsonArrappendKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrappendKey)(c)
 }
 
 func (c SJsonArrappend) Key(key string) SJsonArrappendKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrappendKey)(c)
 }
 
@@ -26348,22 +27152,22 @@ type JsonArrappendKey Completed
 type SJsonArrappendKey SCompleted
 
 func (c JsonArrappendKey) Path(path string) JsonArrappendPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonArrappendPath)(c)
 }
 
 func (c SJsonArrappendKey) Path(path string) SJsonArrappendPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonArrappendPath)(c)
 }
 
 func (c JsonArrappendKey) Value(value ...string) JsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (JsonArrappendValue)(c)
 }
 
 func (c SJsonArrappendKey) Value(value ...string) SJsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (SJsonArrappendValue)(c)
 }
 
@@ -26372,12 +27176,12 @@ type JsonArrappendPath Completed
 type SJsonArrappendPath SCompleted
 
 func (c JsonArrappendPath) Value(value ...string) JsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (JsonArrappendValue)(c)
 }
 
 func (c SJsonArrappendPath) Value(value ...string) SJsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (SJsonArrappendValue)(c)
 }
 
@@ -26386,12 +27190,12 @@ type JsonArrappendValue Completed
 type SJsonArrappendValue SCompleted
 
 func (c JsonArrappendValue) Value(value ...string) JsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return c
 }
 
 func (c SJsonArrappendValue) Value(value ...string) SJsonArrappendValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return c
 }
 
@@ -26407,22 +27211,26 @@ type JsonArrindex Completed
 
 type SJsonArrindex SCompleted
 
-func (b *Builder) JsonArrindex() JsonArrindex {
-	return JsonArrindex{cs: append(b.get(), "JSON.ARRINDEX"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonArrindex() (c JsonArrindex) {
+	c = JsonArrindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.ARRINDEX")
+	return c
 }
 
-func (b *SBuilder) JsonArrindex() SJsonArrindex {
-	return SJsonArrindex{cs: append(b.get(), "JSON.ARRINDEX"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonArrindex() (c SJsonArrindex) {
+	c = SJsonArrindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.ARRINDEX")
+	return c
 }
 
 func (c JsonArrindex) Key(key string) JsonArrindexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrindexKey)(c)
 }
 
 func (c SJsonArrindex) Key(key string) SJsonArrindexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrindexKey)(c)
 }
 
@@ -26431,12 +27239,12 @@ type JsonArrindexKey Completed
 type SJsonArrindexKey SCompleted
 
 func (c JsonArrindexKey) Path(path string) JsonArrindexPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonArrindexPath)(c)
 }
 
 func (c SJsonArrindexKey) Path(path string) SJsonArrindexPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonArrindexPath)(c)
 }
 
@@ -26445,12 +27253,12 @@ type JsonArrindexPath Completed
 type SJsonArrindexPath SCompleted
 
 func (c JsonArrindexPath) Value(value string) JsonArrindexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (JsonArrindexValue)(c)
 }
 
 func (c SJsonArrindexPath) Value(value string) SJsonArrindexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SJsonArrindexValue)(c)
 }
 
@@ -26459,12 +27267,12 @@ type JsonArrindexStartStart Completed
 type SJsonArrindexStartStart SCompleted
 
 func (c JsonArrindexStartStart) Stop(stop int64) JsonArrindexStartStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (JsonArrindexStartStop)(c)
 }
 
 func (c SJsonArrindexStartStart) Stop(stop int64) SJsonArrindexStartStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SJsonArrindexStartStop)(c)
 }
 
@@ -26509,12 +27317,12 @@ type JsonArrindexValue Completed
 type SJsonArrindexValue SCompleted
 
 func (c JsonArrindexValue) Start(start int64) JsonArrindexStartStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (JsonArrindexStartStart)(c)
 }
 
 func (c SJsonArrindexValue) Start(start int64) SJsonArrindexStartStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SJsonArrindexStartStart)(c)
 }
 
@@ -26538,22 +27346,26 @@ type JsonArrinsert Completed
 
 type SJsonArrinsert SCompleted
 
-func (b *Builder) JsonArrinsert() JsonArrinsert {
-	return JsonArrinsert{cs: append(b.get(), "JSON.ARRINSERT"), ks: InitSlot}
+func (b *Builder) JsonArrinsert() (c JsonArrinsert) {
+	c = JsonArrinsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRINSERT")
+	return c
 }
 
-func (b *SBuilder) JsonArrinsert() SJsonArrinsert {
-	return SJsonArrinsert{cs: append(b.get(), "JSON.ARRINSERT"), ks: InitSlot}
+func (b *SBuilder) JsonArrinsert() (c SJsonArrinsert) {
+	c = SJsonArrinsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRINSERT")
+	return c
 }
 
 func (c JsonArrinsert) Key(key string) JsonArrinsertKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrinsertKey)(c)
 }
 
 func (c SJsonArrinsert) Key(key string) SJsonArrinsertKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrinsertKey)(c)
 }
 
@@ -26562,12 +27374,12 @@ type JsonArrinsertIndex Completed
 type SJsonArrinsertIndex SCompleted
 
 func (c JsonArrinsertIndex) Value(value ...string) JsonArrinsertValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (JsonArrinsertValue)(c)
 }
 
 func (c SJsonArrinsertIndex) Value(value ...string) SJsonArrinsertValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return (SJsonArrinsertValue)(c)
 }
 
@@ -26576,12 +27388,12 @@ type JsonArrinsertKey Completed
 type SJsonArrinsertKey SCompleted
 
 func (c JsonArrinsertKey) Path(path string) JsonArrinsertPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonArrinsertPath)(c)
 }
 
 func (c SJsonArrinsertKey) Path(path string) SJsonArrinsertPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonArrinsertPath)(c)
 }
 
@@ -26590,12 +27402,12 @@ type JsonArrinsertPath Completed
 type SJsonArrinsertPath SCompleted
 
 func (c JsonArrinsertPath) Index(index int64) JsonArrinsertIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (JsonArrinsertIndex)(c)
 }
 
 func (c SJsonArrinsertPath) Index(index int64) SJsonArrinsertIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SJsonArrinsertIndex)(c)
 }
 
@@ -26604,12 +27416,12 @@ type JsonArrinsertValue Completed
 type SJsonArrinsertValue SCompleted
 
 func (c JsonArrinsertValue) Value(value ...string) JsonArrinsertValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return c
 }
 
 func (c SJsonArrinsertValue) Value(value ...string) SJsonArrinsertValue {
-	c.cs = append(c.cs, value...)
+	c.cs.s = append(c.cs.s, value...)
 	return c
 }
 
@@ -26625,22 +27437,26 @@ type JsonArrlen Completed
 
 type SJsonArrlen SCompleted
 
-func (b *Builder) JsonArrlen() JsonArrlen {
-	return JsonArrlen{cs: append(b.get(), "JSON.ARRLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonArrlen() (c JsonArrlen) {
+	c = JsonArrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.ARRLEN")
+	return c
 }
 
-func (b *SBuilder) JsonArrlen() SJsonArrlen {
-	return SJsonArrlen{cs: append(b.get(), "JSON.ARRLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonArrlen() (c SJsonArrlen) {
+	c = SJsonArrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.ARRLEN")
+	return c
 }
 
 func (c JsonArrlen) Key(key string) JsonArrlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrlenKey)(c)
 }
 
 func (c SJsonArrlen) Key(key string) SJsonArrlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrlenKey)(c)
 }
 
@@ -26649,12 +27465,12 @@ type JsonArrlenKey Completed
 type SJsonArrlenKey SCompleted
 
 func (c JsonArrlenKey) Path(path ...string) JsonArrlenPath {
-	c.cs = append(c.cs, path...)
+	c.cs.s = append(c.cs.s, path...)
 	return (JsonArrlenPath)(c)
 }
 
 func (c SJsonArrlenKey) Path(path ...string) SJsonArrlenPath {
-	c.cs = append(c.cs, path...)
+	c.cs.s = append(c.cs.s, path...)
 	return (SJsonArrlenPath)(c)
 }
 
@@ -26663,12 +27479,12 @@ type JsonArrlenPath Completed
 type SJsonArrlenPath SCompleted
 
 func (c JsonArrlenPath) Path(path ...string) JsonArrlenPath {
-	c.cs = append(c.cs, path...)
+	c.cs.s = append(c.cs.s, path...)
 	return c
 }
 
 func (c SJsonArrlenPath) Path(path ...string) SJsonArrlenPath {
-	c.cs = append(c.cs, path...)
+	c.cs.s = append(c.cs.s, path...)
 	return c
 }
 
@@ -26692,22 +27508,26 @@ type JsonArrpop Completed
 
 type SJsonArrpop SCompleted
 
-func (b *Builder) JsonArrpop() JsonArrpop {
-	return JsonArrpop{cs: append(b.get(), "JSON.ARRPOP"), ks: InitSlot}
+func (b *Builder) JsonArrpop() (c JsonArrpop) {
+	c = JsonArrpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRPOP")
+	return c
 }
 
-func (b *SBuilder) JsonArrpop() SJsonArrpop {
-	return SJsonArrpop{cs: append(b.get(), "JSON.ARRPOP"), ks: InitSlot}
+func (b *SBuilder) JsonArrpop() (c SJsonArrpop) {
+	c = SJsonArrpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRPOP")
+	return c
 }
 
 func (c JsonArrpop) Key(key string) JsonArrpopKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrpopKey)(c)
 }
 
 func (c SJsonArrpop) Key(key string) SJsonArrpopKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrpopKey)(c)
 }
 
@@ -26716,12 +27536,12 @@ type JsonArrpopKey Completed
 type SJsonArrpopKey SCompleted
 
 func (c JsonArrpopKey) Path(path string) JsonArrpopPathPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonArrpopPathPath)(c)
 }
 
 func (c SJsonArrpopKey) Path(path string) SJsonArrpopPathPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonArrpopPathPath)(c)
 }
 
@@ -26750,12 +27570,12 @@ type JsonArrpopPathPath Completed
 type SJsonArrpopPathPath SCompleted
 
 func (c JsonArrpopPathPath) Index(index int64) JsonArrpopPathIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (JsonArrpopPathIndex)(c)
 }
 
 func (c SJsonArrpopPathPath) Index(index int64) SJsonArrpopPathIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SJsonArrpopPathIndex)(c)
 }
 
@@ -26771,22 +27591,26 @@ type JsonArrtrim Completed
 
 type SJsonArrtrim SCompleted
 
-func (b *Builder) JsonArrtrim() JsonArrtrim {
-	return JsonArrtrim{cs: append(b.get(), "JSON.ARRTRIM"), ks: InitSlot}
+func (b *Builder) JsonArrtrim() (c JsonArrtrim) {
+	c = JsonArrtrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRTRIM")
+	return c
 }
 
-func (b *SBuilder) JsonArrtrim() SJsonArrtrim {
-	return SJsonArrtrim{cs: append(b.get(), "JSON.ARRTRIM"), ks: InitSlot}
+func (b *SBuilder) JsonArrtrim() (c SJsonArrtrim) {
+	c = SJsonArrtrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.ARRTRIM")
+	return c
 }
 
 func (c JsonArrtrim) Key(key string) JsonArrtrimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonArrtrimKey)(c)
 }
 
 func (c SJsonArrtrim) Key(key string) SJsonArrtrimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonArrtrimKey)(c)
 }
 
@@ -26795,12 +27619,12 @@ type JsonArrtrimKey Completed
 type SJsonArrtrimKey SCompleted
 
 func (c JsonArrtrimKey) Path(path string) JsonArrtrimPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonArrtrimPath)(c)
 }
 
 func (c SJsonArrtrimKey) Path(path string) SJsonArrtrimPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonArrtrimPath)(c)
 }
 
@@ -26809,12 +27633,12 @@ type JsonArrtrimPath Completed
 type SJsonArrtrimPath SCompleted
 
 func (c JsonArrtrimPath) Start(start int64) JsonArrtrimStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (JsonArrtrimStart)(c)
 }
 
 func (c SJsonArrtrimPath) Start(start int64) SJsonArrtrimStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SJsonArrtrimStart)(c)
 }
 
@@ -26823,12 +27647,12 @@ type JsonArrtrimStart Completed
 type SJsonArrtrimStart SCompleted
 
 func (c JsonArrtrimStart) Stop(stop int64) JsonArrtrimStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (JsonArrtrimStop)(c)
 }
 
 func (c SJsonArrtrimStart) Stop(stop int64) SJsonArrtrimStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SJsonArrtrimStop)(c)
 }
 
@@ -26848,22 +27672,26 @@ type JsonClear Completed
 
 type SJsonClear SCompleted
 
-func (b *Builder) JsonClear() JsonClear {
-	return JsonClear{cs: append(b.get(), "JSON.CLEAR"), ks: InitSlot}
+func (b *Builder) JsonClear() (c JsonClear) {
+	c = JsonClear{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.CLEAR")
+	return c
 }
 
-func (b *SBuilder) JsonClear() SJsonClear {
-	return SJsonClear{cs: append(b.get(), "JSON.CLEAR"), ks: InitSlot}
+func (b *SBuilder) JsonClear() (c SJsonClear) {
+	c = SJsonClear{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.CLEAR")
+	return c
 }
 
 func (c JsonClear) Key(key string) JsonClearKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonClearKey)(c)
 }
 
 func (c SJsonClear) Key(key string) SJsonClearKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonClearKey)(c)
 }
 
@@ -26872,12 +27700,12 @@ type JsonClearKey Completed
 type SJsonClearKey SCompleted
 
 func (c JsonClearKey) Path(path string) JsonClearPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonClearPath)(c)
 }
 
 func (c SJsonClearKey) Path(path string) SJsonClearPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonClearPath)(c)
 }
 
@@ -26905,22 +27733,26 @@ type JsonDel Completed
 
 type SJsonDel SCompleted
 
-func (b *Builder) JsonDel() JsonDel {
-	return JsonDel{cs: append(b.get(), "JSON.DEL"), ks: InitSlot}
+func (b *Builder) JsonDel() (c JsonDel) {
+	c = JsonDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.DEL")
+	return c
 }
 
-func (b *SBuilder) JsonDel() SJsonDel {
-	return SJsonDel{cs: append(b.get(), "JSON.DEL"), ks: InitSlot}
+func (b *SBuilder) JsonDel() (c SJsonDel) {
+	c = SJsonDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.DEL")
+	return c
 }
 
 func (c JsonDel) Key(key string) JsonDelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonDelKey)(c)
 }
 
 func (c SJsonDel) Key(key string) SJsonDelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonDelKey)(c)
 }
 
@@ -26929,12 +27761,12 @@ type JsonDelKey Completed
 type SJsonDelKey SCompleted
 
 func (c JsonDelKey) Path(path string) JsonDelPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonDelPath)(c)
 }
 
 func (c SJsonDelKey) Path(path string) SJsonDelPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonDelPath)(c)
 }
 
@@ -26962,22 +27794,26 @@ type JsonGet Completed
 
 type SJsonGet SCompleted
 
-func (b *Builder) JsonGet() JsonGet {
-	return JsonGet{cs: append(b.get(), "JSON.GET"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonGet() (c JsonGet) {
+	c = JsonGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.GET")
+	return c
 }
 
-func (b *SBuilder) JsonGet() SJsonGet {
-	return SJsonGet{cs: append(b.get(), "JSON.GET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonGet() (c SJsonGet) {
+	c = SJsonGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.GET")
+	return c
 }
 
 func (c JsonGet) Key(key string) JsonGetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonGetKey)(c)
 }
 
 func (c SJsonGet) Key(key string) SJsonGetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonGetKey)(c)
 }
 
@@ -26986,32 +27822,32 @@ type JsonGetIndent Completed
 type SJsonGetIndent SCompleted
 
 func (c JsonGetIndent) Newline(newline string) JsonGetNewline {
-	c.cs = append(c.cs, "NEWLINE", newline)
+	c.cs.s = append(c.cs.s, "NEWLINE", newline)
 	return (JsonGetNewline)(c)
 }
 
 func (c SJsonGetIndent) Newline(newline string) SJsonGetNewline {
-	c.cs = append(c.cs, "NEWLINE", newline)
+	c.cs.s = append(c.cs.s, "NEWLINE", newline)
 	return (SJsonGetNewline)(c)
 }
 
 func (c JsonGetIndent) Space(space string) JsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (JsonGetSpace)(c)
 }
 
 func (c SJsonGetIndent) Space(space string) SJsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (SJsonGetSpace)(c)
 }
 
 func (c JsonGetIndent) Paths(paths ...string) JsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (JsonGetPaths)(c)
 }
 
 func (c SJsonGetIndent) Paths(paths ...string) SJsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (SJsonGetPaths)(c)
 }
 
@@ -27036,42 +27872,42 @@ type JsonGetKey Completed
 type SJsonGetKey SCompleted
 
 func (c JsonGetKey) Indent(indent string) JsonGetIndent {
-	c.cs = append(c.cs, "INDENT", indent)
+	c.cs.s = append(c.cs.s, "INDENT", indent)
 	return (JsonGetIndent)(c)
 }
 
 func (c SJsonGetKey) Indent(indent string) SJsonGetIndent {
-	c.cs = append(c.cs, "INDENT", indent)
+	c.cs.s = append(c.cs.s, "INDENT", indent)
 	return (SJsonGetIndent)(c)
 }
 
 func (c JsonGetKey) Newline(newline string) JsonGetNewline {
-	c.cs = append(c.cs, "NEWLINE", newline)
+	c.cs.s = append(c.cs.s, "NEWLINE", newline)
 	return (JsonGetNewline)(c)
 }
 
 func (c SJsonGetKey) Newline(newline string) SJsonGetNewline {
-	c.cs = append(c.cs, "NEWLINE", newline)
+	c.cs.s = append(c.cs.s, "NEWLINE", newline)
 	return (SJsonGetNewline)(c)
 }
 
 func (c JsonGetKey) Space(space string) JsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (JsonGetSpace)(c)
 }
 
 func (c SJsonGetKey) Space(space string) SJsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (SJsonGetSpace)(c)
 }
 
 func (c JsonGetKey) Paths(paths ...string) JsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (JsonGetPaths)(c)
 }
 
 func (c SJsonGetKey) Paths(paths ...string) SJsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (SJsonGetPaths)(c)
 }
 
@@ -27096,22 +27932,22 @@ type JsonGetNewline Completed
 type SJsonGetNewline SCompleted
 
 func (c JsonGetNewline) Space(space string) JsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (JsonGetSpace)(c)
 }
 
 func (c SJsonGetNewline) Space(space string) SJsonGetSpace {
-	c.cs = append(c.cs, "SPACE", space)
+	c.cs.s = append(c.cs.s, "SPACE", space)
 	return (SJsonGetSpace)(c)
 }
 
 func (c JsonGetNewline) Paths(paths ...string) JsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (JsonGetPaths)(c)
 }
 
 func (c SJsonGetNewline) Paths(paths ...string) SJsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (SJsonGetPaths)(c)
 }
 
@@ -27136,12 +27972,12 @@ type JsonGetPaths Completed
 type SJsonGetPaths SCompleted
 
 func (c JsonGetPaths) Paths(paths ...string) JsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return c
 }
 
 func (c SJsonGetPaths) Paths(paths ...string) SJsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return c
 }
 
@@ -27166,12 +28002,12 @@ type JsonGetSpace Completed
 type SJsonGetSpace SCompleted
 
 func (c JsonGetSpace) Paths(paths ...string) JsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (JsonGetPaths)(c)
 }
 
 func (c SJsonGetSpace) Paths(paths ...string) SJsonGetPaths {
-	c.cs = append(c.cs, paths...)
+	c.cs.s = append(c.cs.s, paths...)
 	return (SJsonGetPaths)(c)
 }
 
@@ -27195,16 +28031,20 @@ type JsonMget Completed
 
 type SJsonMget SCompleted
 
-func (b *Builder) JsonMget() JsonMget {
-	return JsonMget{cs: append(b.get(), "JSON.MGET"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonMget() (c JsonMget) {
+	c = JsonMget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.MGET")
+	return c
 }
 
-func (b *SBuilder) JsonMget() SJsonMget {
-	return SJsonMget{cs: append(b.get(), "JSON.MGET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonMget() (c SJsonMget) {
+	c = SJsonMget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.MGET")
+	return c
 }
 
 func (c JsonMget) Key(key ...string) JsonMgetKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (JsonMgetKey)(c)
 }
 
@@ -27212,7 +28052,7 @@ func (c SJsonMget) Key(key ...string) SJsonMgetKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SJsonMgetKey)(c)
 }
 
@@ -27221,7 +28061,7 @@ type JsonMgetKey Completed
 type SJsonMgetKey SCompleted
 
 func (c JsonMgetKey) Key(key ...string) JsonMgetKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -27229,17 +28069,17 @@ func (c SJsonMgetKey) Key(key ...string) SJsonMgetKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c JsonMgetKey) Path(path string) JsonMgetPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonMgetPath)(c)
 }
 
 func (c SJsonMgetKey) Path(path string) SJsonMgetPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonMgetPath)(c)
 }
 
@@ -27259,22 +28099,26 @@ type JsonNumincrby Completed
 
 type SJsonNumincrby SCompleted
 
-func (b *Builder) JsonNumincrby() JsonNumincrby {
-	return JsonNumincrby{cs: append(b.get(), "JSON.NUMINCRBY"), ks: InitSlot}
+func (b *Builder) JsonNumincrby() (c JsonNumincrby) {
+	c = JsonNumincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.NUMINCRBY")
+	return c
 }
 
-func (b *SBuilder) JsonNumincrby() SJsonNumincrby {
-	return SJsonNumincrby{cs: append(b.get(), "JSON.NUMINCRBY"), ks: InitSlot}
+func (b *SBuilder) JsonNumincrby() (c SJsonNumincrby) {
+	c = SJsonNumincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.NUMINCRBY")
+	return c
 }
 
 func (c JsonNumincrby) Key(key string) JsonNumincrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonNumincrbyKey)(c)
 }
 
 func (c SJsonNumincrby) Key(key string) SJsonNumincrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonNumincrbyKey)(c)
 }
 
@@ -27283,12 +28127,12 @@ type JsonNumincrbyKey Completed
 type SJsonNumincrbyKey SCompleted
 
 func (c JsonNumincrbyKey) Path(path string) JsonNumincrbyPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonNumincrbyPath)(c)
 }
 
 func (c SJsonNumincrbyKey) Path(path string) SJsonNumincrbyPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonNumincrbyPath)(c)
 }
 
@@ -27297,12 +28141,12 @@ type JsonNumincrbyPath Completed
 type SJsonNumincrbyPath SCompleted
 
 func (c JsonNumincrbyPath) Value(value float64) JsonNumincrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (JsonNumincrbyValue)(c)
 }
 
 func (c SJsonNumincrbyPath) Value(value float64) SJsonNumincrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (SJsonNumincrbyValue)(c)
 }
 
@@ -27322,22 +28166,26 @@ type JsonObjkeys Completed
 
 type SJsonObjkeys SCompleted
 
-func (b *Builder) JsonObjkeys() JsonObjkeys {
-	return JsonObjkeys{cs: append(b.get(), "JSON.OBJKEYS"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonObjkeys() (c JsonObjkeys) {
+	c = JsonObjkeys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.OBJKEYS")
+	return c
 }
 
-func (b *SBuilder) JsonObjkeys() SJsonObjkeys {
-	return SJsonObjkeys{cs: append(b.get(), "JSON.OBJKEYS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonObjkeys() (c SJsonObjkeys) {
+	c = SJsonObjkeys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.OBJKEYS")
+	return c
 }
 
 func (c JsonObjkeys) Key(key string) JsonObjkeysKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonObjkeysKey)(c)
 }
 
 func (c SJsonObjkeys) Key(key string) SJsonObjkeysKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonObjkeysKey)(c)
 }
 
@@ -27346,12 +28194,12 @@ type JsonObjkeysKey Completed
 type SJsonObjkeysKey SCompleted
 
 func (c JsonObjkeysKey) Path(path string) JsonObjkeysPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonObjkeysPath)(c)
 }
 
 func (c SJsonObjkeysKey) Path(path string) SJsonObjkeysPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonObjkeysPath)(c)
 }
 
@@ -27395,22 +28243,26 @@ type JsonObjlen Completed
 
 type SJsonObjlen SCompleted
 
-func (b *Builder) JsonObjlen() JsonObjlen {
-	return JsonObjlen{cs: append(b.get(), "JSON.OBJLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonObjlen() (c JsonObjlen) {
+	c = JsonObjlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.OBJLEN")
+	return c
 }
 
-func (b *SBuilder) JsonObjlen() SJsonObjlen {
-	return SJsonObjlen{cs: append(b.get(), "JSON.OBJLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonObjlen() (c SJsonObjlen) {
+	c = SJsonObjlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.OBJLEN")
+	return c
 }
 
 func (c JsonObjlen) Key(key string) JsonObjlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonObjlenKey)(c)
 }
 
 func (c SJsonObjlen) Key(key string) SJsonObjlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonObjlenKey)(c)
 }
 
@@ -27419,12 +28271,12 @@ type JsonObjlenKey Completed
 type SJsonObjlenKey SCompleted
 
 func (c JsonObjlenKey) Path(path string) JsonObjlenPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonObjlenPath)(c)
 }
 
 func (c SJsonObjlenKey) Path(path string) SJsonObjlenPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonObjlenPath)(c)
 }
 
@@ -27468,22 +28320,26 @@ type JsonResp Completed
 
 type SJsonResp SCompleted
 
-func (b *Builder) JsonResp() JsonResp {
-	return JsonResp{cs: append(b.get(), "JSON.RESP"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonResp() (c JsonResp) {
+	c = JsonResp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.RESP")
+	return c
 }
 
-func (b *SBuilder) JsonResp() SJsonResp {
-	return SJsonResp{cs: append(b.get(), "JSON.RESP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonResp() (c SJsonResp) {
+	c = SJsonResp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.RESP")
+	return c
 }
 
 func (c JsonResp) Key(key string) JsonRespKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonRespKey)(c)
 }
 
 func (c SJsonResp) Key(key string) SJsonRespKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonRespKey)(c)
 }
 
@@ -27492,12 +28348,12 @@ type JsonRespKey Completed
 type SJsonRespKey SCompleted
 
 func (c JsonRespKey) Path(path string) JsonRespPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonRespPath)(c)
 }
 
 func (c SJsonRespKey) Path(path string) SJsonRespPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonRespPath)(c)
 }
 
@@ -27541,22 +28397,26 @@ type JsonSet Completed
 
 type SJsonSet SCompleted
 
-func (b *Builder) JsonSet() JsonSet {
-	return JsonSet{cs: append(b.get(), "JSON.SET"), ks: InitSlot}
+func (b *Builder) JsonSet() (c JsonSet) {
+	c = JsonSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.SET")
+	return c
 }
 
-func (b *SBuilder) JsonSet() SJsonSet {
-	return SJsonSet{cs: append(b.get(), "JSON.SET"), ks: InitSlot}
+func (b *SBuilder) JsonSet() (c SJsonSet) {
+	c = SJsonSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.SET")
+	return c
 }
 
 func (c JsonSet) Key(key string) JsonSetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonSetKey)(c)
 }
 
 func (c SJsonSet) Key(key string) SJsonSetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonSetKey)(c)
 }
 
@@ -27589,12 +28449,12 @@ type JsonSetKey Completed
 type SJsonSetKey SCompleted
 
 func (c JsonSetKey) Path(path string) JsonSetPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonSetPath)(c)
 }
 
 func (c SJsonSetKey) Path(path string) SJsonSetPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonSetPath)(c)
 }
 
@@ -27603,12 +28463,12 @@ type JsonSetPath Completed
 type SJsonSetPath SCompleted
 
 func (c JsonSetPath) Value(value string) JsonSetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (JsonSetValue)(c)
 }
 
 func (c SJsonSetPath) Value(value string) SJsonSetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SJsonSetValue)(c)
 }
 
@@ -27617,22 +28477,22 @@ type JsonSetValue Completed
 type SJsonSetValue SCompleted
 
 func (c JsonSetValue) Nx() JsonSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (JsonSetConditionNx)(c)
 }
 
 func (c SJsonSetValue) Nx() SJsonSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SJsonSetConditionNx)(c)
 }
 
 func (c JsonSetValue) Xx() JsonSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (JsonSetConditionXx)(c)
 }
 
 func (c SJsonSetValue) Xx() SJsonSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SJsonSetConditionXx)(c)
 }
 
@@ -27648,22 +28508,26 @@ type JsonStrappend Completed
 
 type SJsonStrappend SCompleted
 
-func (b *Builder) JsonStrappend() JsonStrappend {
-	return JsonStrappend{cs: append(b.get(), "JSON.STRAPPEND"), ks: InitSlot}
+func (b *Builder) JsonStrappend() (c JsonStrappend) {
+	c = JsonStrappend{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.STRAPPEND")
+	return c
 }
 
-func (b *SBuilder) JsonStrappend() SJsonStrappend {
-	return SJsonStrappend{cs: append(b.get(), "JSON.STRAPPEND"), ks: InitSlot}
+func (b *SBuilder) JsonStrappend() (c SJsonStrappend) {
+	c = SJsonStrappend{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.STRAPPEND")
+	return c
 }
 
 func (c JsonStrappend) Key(key string) JsonStrappendKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonStrappendKey)(c)
 }
 
 func (c SJsonStrappend) Key(key string) SJsonStrappendKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonStrappendKey)(c)
 }
 
@@ -27672,22 +28536,22 @@ type JsonStrappendKey Completed
 type SJsonStrappendKey SCompleted
 
 func (c JsonStrappendKey) Path(path string) JsonStrappendPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonStrappendPath)(c)
 }
 
 func (c SJsonStrappendKey) Path(path string) SJsonStrappendPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonStrappendPath)(c)
 }
 
 func (c JsonStrappendKey) Value(value string) JsonStrappendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (JsonStrappendValue)(c)
 }
 
 func (c SJsonStrappendKey) Value(value string) SJsonStrappendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SJsonStrappendValue)(c)
 }
 
@@ -27696,12 +28560,12 @@ type JsonStrappendPath Completed
 type SJsonStrappendPath SCompleted
 
 func (c JsonStrappendPath) Value(value string) JsonStrappendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (JsonStrappendValue)(c)
 }
 
 func (c SJsonStrappendPath) Value(value string) SJsonStrappendValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SJsonStrappendValue)(c)
 }
 
@@ -27721,22 +28585,26 @@ type JsonStrlen Completed
 
 type SJsonStrlen SCompleted
 
-func (b *Builder) JsonStrlen() JsonStrlen {
-	return JsonStrlen{cs: append(b.get(), "JSON.STRLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonStrlen() (c JsonStrlen) {
+	c = JsonStrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.STRLEN")
+	return c
 }
 
-func (b *SBuilder) JsonStrlen() SJsonStrlen {
-	return SJsonStrlen{cs: append(b.get(), "JSON.STRLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonStrlen() (c SJsonStrlen) {
+	c = SJsonStrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.STRLEN")
+	return c
 }
 
 func (c JsonStrlen) Key(key string) JsonStrlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonStrlenKey)(c)
 }
 
 func (c SJsonStrlen) Key(key string) SJsonStrlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonStrlenKey)(c)
 }
 
@@ -27745,12 +28613,12 @@ type JsonStrlenKey Completed
 type SJsonStrlenKey SCompleted
 
 func (c JsonStrlenKey) Path(path string) JsonStrlenPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonStrlenPath)(c)
 }
 
 func (c SJsonStrlenKey) Path(path string) SJsonStrlenPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonStrlenPath)(c)
 }
 
@@ -27794,22 +28662,26 @@ type JsonToggle Completed
 
 type SJsonToggle SCompleted
 
-func (b *Builder) JsonToggle() JsonToggle {
-	return JsonToggle{cs: append(b.get(), "JSON.TOGGLE"), ks: InitSlot}
+func (b *Builder) JsonToggle() (c JsonToggle) {
+	c = JsonToggle{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.TOGGLE")
+	return c
 }
 
-func (b *SBuilder) JsonToggle() SJsonToggle {
-	return SJsonToggle{cs: append(b.get(), "JSON.TOGGLE"), ks: InitSlot}
+func (b *SBuilder) JsonToggle() (c SJsonToggle) {
+	c = SJsonToggle{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "JSON.TOGGLE")
+	return c
 }
 
 func (c JsonToggle) Key(key string) JsonToggleKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonToggleKey)(c)
 }
 
 func (c SJsonToggle) Key(key string) SJsonToggleKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonToggleKey)(c)
 }
 
@@ -27818,12 +28690,12 @@ type JsonToggleKey Completed
 type SJsonToggleKey SCompleted
 
 func (c JsonToggleKey) Path(path string) JsonTogglePath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonTogglePath)(c)
 }
 
 func (c SJsonToggleKey) Path(path string) SJsonTogglePath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonTogglePath)(c)
 }
 
@@ -27851,22 +28723,26 @@ type JsonType Completed
 
 type SJsonType SCompleted
 
-func (b *Builder) JsonType() JsonType {
-	return JsonType{cs: append(b.get(), "JSON.TYPE"), ks: InitSlot, cf: readonly}
+func (b *Builder) JsonType() (c JsonType) {
+	c = JsonType{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.TYPE")
+	return c
 }
 
-func (b *SBuilder) JsonType() SJsonType {
-	return SJsonType{cs: append(b.get(), "JSON.TYPE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) JsonType() (c SJsonType) {
+	c = SJsonType{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "JSON.TYPE")
+	return c
 }
 
 func (c JsonType) Key(key string) JsonTypeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (JsonTypeKey)(c)
 }
 
 func (c SJsonType) Key(key string) SJsonTypeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SJsonTypeKey)(c)
 }
 
@@ -27875,12 +28751,12 @@ type JsonTypeKey Completed
 type SJsonTypeKey SCompleted
 
 func (c JsonTypeKey) Path(path string) JsonTypePath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (JsonTypePath)(c)
 }
 
 func (c SJsonTypeKey) Path(path string) SJsonTypePath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SJsonTypePath)(c)
 }
 
@@ -27924,21 +28800,25 @@ type Keys Completed
 
 type SKeys SCompleted
 
-func (b *Builder) Keys() Keys {
-	return Keys{cs: append(b.get(), "KEYS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Keys() (c Keys) {
+	c = Keys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "KEYS")
+	return c
 }
 
-func (b *SBuilder) Keys() SKeys {
-	return SKeys{cs: append(b.get(), "KEYS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Keys() (c SKeys) {
+	c = SKeys{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "KEYS")
+	return c
 }
 
 func (c Keys) Pattern(pattern string) KeysPattern {
-	c.cs = append(c.cs, pattern)
+	c.cs.s = append(c.cs.s, pattern)
 	return (KeysPattern)(c)
 }
 
 func (c SKeys) Pattern(pattern string) SKeysPattern {
-	c.cs = append(c.cs, pattern)
+	c.cs.s = append(c.cs.s, pattern)
 	return (SKeysPattern)(c)
 }
 
@@ -27958,12 +28838,16 @@ type Lastsave Completed
 
 type SLastsave SCompleted
 
-func (b *Builder) Lastsave() Lastsave {
-	return Lastsave{cs: append(b.get(), "LASTSAVE"), ks: InitSlot}
+func (b *Builder) Lastsave() (c Lastsave) {
+	c = Lastsave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LASTSAVE")
+	return c
 }
 
-func (b *SBuilder) Lastsave() SLastsave {
-	return SLastsave{cs: append(b.get(), "LASTSAVE"), ks: InitSlot}
+func (b *SBuilder) Lastsave() (c SLastsave) {
+	c = SLastsave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LASTSAVE")
+	return c
 }
 
 func (c Lastsave) Build() Completed {
@@ -27978,12 +28862,16 @@ type LatencyDoctor Completed
 
 type SLatencyDoctor SCompleted
 
-func (b *Builder) LatencyDoctor() LatencyDoctor {
-	return LatencyDoctor{cs: append(b.get(), "LATENCY", "DOCTOR"), ks: InitSlot}
+func (b *Builder) LatencyDoctor() (c LatencyDoctor) {
+	c = LatencyDoctor{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "DOCTOR")
+	return c
 }
 
-func (b *SBuilder) LatencyDoctor() SLatencyDoctor {
-	return SLatencyDoctor{cs: append(b.get(), "LATENCY", "DOCTOR"), ks: InitSlot}
+func (b *SBuilder) LatencyDoctor() (c SLatencyDoctor) {
+	c = SLatencyDoctor{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "DOCTOR")
+	return c
 }
 
 func (c LatencyDoctor) Build() Completed {
@@ -27998,21 +28886,25 @@ type LatencyGraph Completed
 
 type SLatencyGraph SCompleted
 
-func (b *Builder) LatencyGraph() LatencyGraph {
-	return LatencyGraph{cs: append(b.get(), "LATENCY", "GRAPH"), ks: InitSlot}
+func (b *Builder) LatencyGraph() (c LatencyGraph) {
+	c = LatencyGraph{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "GRAPH")
+	return c
 }
 
-func (b *SBuilder) LatencyGraph() SLatencyGraph {
-	return SLatencyGraph{cs: append(b.get(), "LATENCY", "GRAPH"), ks: InitSlot}
+func (b *SBuilder) LatencyGraph() (c SLatencyGraph) {
+	c = SLatencyGraph{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "GRAPH")
+	return c
 }
 
 func (c LatencyGraph) Event(event string) LatencyGraphEvent {
-	c.cs = append(c.cs, event)
+	c.cs.s = append(c.cs.s, event)
 	return (LatencyGraphEvent)(c)
 }
 
 func (c SLatencyGraph) Event(event string) SLatencyGraphEvent {
-	c.cs = append(c.cs, event)
+	c.cs.s = append(c.cs.s, event)
 	return (SLatencyGraphEvent)(c)
 }
 
@@ -28032,12 +28924,16 @@ type LatencyHelp Completed
 
 type SLatencyHelp SCompleted
 
-func (b *Builder) LatencyHelp() LatencyHelp {
-	return LatencyHelp{cs: append(b.get(), "LATENCY", "HELP"), ks: InitSlot}
+func (b *Builder) LatencyHelp() (c LatencyHelp) {
+	c = LatencyHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "HELP")
+	return c
 }
 
-func (b *SBuilder) LatencyHelp() SLatencyHelp {
-	return SLatencyHelp{cs: append(b.get(), "LATENCY", "HELP"), ks: InitSlot}
+func (b *SBuilder) LatencyHelp() (c SLatencyHelp) {
+	c = SLatencyHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "HELP")
+	return c
 }
 
 func (c LatencyHelp) Build() Completed {
@@ -28052,21 +28948,25 @@ type LatencyHistory Completed
 
 type SLatencyHistory SCompleted
 
-func (b *Builder) LatencyHistory() LatencyHistory {
-	return LatencyHistory{cs: append(b.get(), "LATENCY", "HISTORY"), ks: InitSlot}
+func (b *Builder) LatencyHistory() (c LatencyHistory) {
+	c = LatencyHistory{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "HISTORY")
+	return c
 }
 
-func (b *SBuilder) LatencyHistory() SLatencyHistory {
-	return SLatencyHistory{cs: append(b.get(), "LATENCY", "HISTORY"), ks: InitSlot}
+func (b *SBuilder) LatencyHistory() (c SLatencyHistory) {
+	c = SLatencyHistory{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "HISTORY")
+	return c
 }
 
 func (c LatencyHistory) Event(event string) LatencyHistoryEvent {
-	c.cs = append(c.cs, event)
+	c.cs.s = append(c.cs.s, event)
 	return (LatencyHistoryEvent)(c)
 }
 
 func (c SLatencyHistory) Event(event string) SLatencyHistoryEvent {
-	c.cs = append(c.cs, event)
+	c.cs.s = append(c.cs.s, event)
 	return (SLatencyHistoryEvent)(c)
 }
 
@@ -28086,12 +28986,16 @@ type LatencyLatest Completed
 
 type SLatencyLatest SCompleted
 
-func (b *Builder) LatencyLatest() LatencyLatest {
-	return LatencyLatest{cs: append(b.get(), "LATENCY", "LATEST"), ks: InitSlot}
+func (b *Builder) LatencyLatest() (c LatencyLatest) {
+	c = LatencyLatest{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "LATEST")
+	return c
 }
 
-func (b *SBuilder) LatencyLatest() SLatencyLatest {
-	return SLatencyLatest{cs: append(b.get(), "LATENCY", "LATEST"), ks: InitSlot}
+func (b *SBuilder) LatencyLatest() (c SLatencyLatest) {
+	c = SLatencyLatest{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "LATEST")
+	return c
 }
 
 func (c LatencyLatest) Build() Completed {
@@ -28106,21 +29010,25 @@ type LatencyReset Completed
 
 type SLatencyReset SCompleted
 
-func (b *Builder) LatencyReset() LatencyReset {
-	return LatencyReset{cs: append(b.get(), "LATENCY", "RESET"), ks: InitSlot}
+func (b *Builder) LatencyReset() (c LatencyReset) {
+	c = LatencyReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "RESET")
+	return c
 }
 
-func (b *SBuilder) LatencyReset() SLatencyReset {
-	return SLatencyReset{cs: append(b.get(), "LATENCY", "RESET"), ks: InitSlot}
+func (b *SBuilder) LatencyReset() (c SLatencyReset) {
+	c = SLatencyReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LATENCY", "RESET")
+	return c
 }
 
 func (c LatencyReset) Event(event ...string) LatencyResetEvent {
-	c.cs = append(c.cs, event...)
+	c.cs.s = append(c.cs.s, event...)
 	return (LatencyResetEvent)(c)
 }
 
 func (c SLatencyReset) Event(event ...string) SLatencyResetEvent {
-	c.cs = append(c.cs, event...)
+	c.cs.s = append(c.cs.s, event...)
 	return (SLatencyResetEvent)(c)
 }
 
@@ -28137,12 +29045,12 @@ type LatencyResetEvent Completed
 type SLatencyResetEvent SCompleted
 
 func (c LatencyResetEvent) Event(event ...string) LatencyResetEvent {
-	c.cs = append(c.cs, event...)
+	c.cs.s = append(c.cs.s, event...)
 	return c
 }
 
 func (c SLatencyResetEvent) Event(event ...string) SLatencyResetEvent {
-	c.cs = append(c.cs, event...)
+	c.cs.s = append(c.cs.s, event...)
 	return c
 }
 
@@ -28158,22 +29066,26 @@ type Lcs Completed
 
 type SLcs SCompleted
 
-func (b *Builder) Lcs() Lcs {
-	return Lcs{cs: append(b.get(), "LCS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Lcs() (c Lcs) {
+	c = Lcs{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LCS")
+	return c
 }
 
-func (b *SBuilder) Lcs() SLcs {
-	return SLcs{cs: append(b.get(), "LCS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Lcs() (c SLcs) {
+	c = SLcs{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LCS")
+	return c
 }
 
 func (c Lcs) Key1(key1 string) LcsKey1 {
-	c.cs = append(c.cs, key1)
+	c.cs.s = append(c.cs.s, key1)
 	return (LcsKey1)(c)
 }
 
 func (c SLcs) Key1(key1 string) SLcsKey1 {
 	c.ks = checkSlot(c.ks, slot(key1))
-	c.cs = append(c.cs, key1)
+	c.cs.s = append(c.cs.s, key1)
 	return (SLcsKey1)(c)
 }
 
@@ -28182,22 +29094,22 @@ type LcsIdx Completed
 type SLcsIdx SCompleted
 
 func (c LcsIdx) Minmatchlen(len int64) LcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (LcsMinmatchlen)(c)
 }
 
 func (c SLcsIdx) Minmatchlen(len int64) SLcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (SLcsMinmatchlen)(c)
 }
 
 func (c LcsIdx) Withmatchlen() LcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (LcsWithmatchlen)(c)
 }
 
 func (c SLcsIdx) Withmatchlen() SLcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (SLcsWithmatchlen)(c)
 }
 
@@ -28214,13 +29126,13 @@ type LcsKey1 Completed
 type SLcsKey1 SCompleted
 
 func (c LcsKey1) Key2(key2 string) LcsKey2 {
-	c.cs = append(c.cs, key2)
+	c.cs.s = append(c.cs.s, key2)
 	return (LcsKey2)(c)
 }
 
 func (c SLcsKey1) Key2(key2 string) SLcsKey2 {
 	c.ks = checkSlot(c.ks, slot(key2))
-	c.cs = append(c.cs, key2)
+	c.cs.s = append(c.cs.s, key2)
 	return (SLcsKey2)(c)
 }
 
@@ -28229,42 +29141,42 @@ type LcsKey2 Completed
 type SLcsKey2 SCompleted
 
 func (c LcsKey2) Len() LcsLen {
-	c.cs = append(c.cs, "LEN")
+	c.cs.s = append(c.cs.s, "LEN")
 	return (LcsLen)(c)
 }
 
 func (c SLcsKey2) Len() SLcsLen {
-	c.cs = append(c.cs, "LEN")
+	c.cs.s = append(c.cs.s, "LEN")
 	return (SLcsLen)(c)
 }
 
 func (c LcsKey2) Idx() LcsIdx {
-	c.cs = append(c.cs, "IDX")
+	c.cs.s = append(c.cs.s, "IDX")
 	return (LcsIdx)(c)
 }
 
 func (c SLcsKey2) Idx() SLcsIdx {
-	c.cs = append(c.cs, "IDX")
+	c.cs.s = append(c.cs.s, "IDX")
 	return (SLcsIdx)(c)
 }
 
 func (c LcsKey2) Minmatchlen(len int64) LcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (LcsMinmatchlen)(c)
 }
 
 func (c SLcsKey2) Minmatchlen(len int64) SLcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (SLcsMinmatchlen)(c)
 }
 
 func (c LcsKey2) Withmatchlen() LcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (LcsWithmatchlen)(c)
 }
 
 func (c SLcsKey2) Withmatchlen() SLcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (SLcsWithmatchlen)(c)
 }
 
@@ -28281,32 +29193,32 @@ type LcsLen Completed
 type SLcsLen SCompleted
 
 func (c LcsLen) Idx() LcsIdx {
-	c.cs = append(c.cs, "IDX")
+	c.cs.s = append(c.cs.s, "IDX")
 	return (LcsIdx)(c)
 }
 
 func (c SLcsLen) Idx() SLcsIdx {
-	c.cs = append(c.cs, "IDX")
+	c.cs.s = append(c.cs.s, "IDX")
 	return (SLcsIdx)(c)
 }
 
 func (c LcsLen) Minmatchlen(len int64) LcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (LcsMinmatchlen)(c)
 }
 
 func (c SLcsLen) Minmatchlen(len int64) SLcsMinmatchlen {
-	c.cs = append(c.cs, "MINMATCHLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
 	return (SLcsMinmatchlen)(c)
 }
 
 func (c LcsLen) Withmatchlen() LcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (LcsWithmatchlen)(c)
 }
 
 func (c SLcsLen) Withmatchlen() SLcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (SLcsWithmatchlen)(c)
 }
 
@@ -28323,12 +29235,12 @@ type LcsMinmatchlen Completed
 type SLcsMinmatchlen SCompleted
 
 func (c LcsMinmatchlen) Withmatchlen() LcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (LcsWithmatchlen)(c)
 }
 
 func (c SLcsMinmatchlen) Withmatchlen() SLcsWithmatchlen {
-	c.cs = append(c.cs, "WITHMATCHLEN")
+	c.cs.s = append(c.cs.s, "WITHMATCHLEN")
 	return (SLcsWithmatchlen)(c)
 }
 
@@ -28356,22 +29268,26 @@ type Lindex Completed
 
 type SLindex SCompleted
 
-func (b *Builder) Lindex() Lindex {
-	return Lindex{cs: append(b.get(), "LINDEX"), ks: InitSlot, cf: readonly}
+func (b *Builder) Lindex() (c Lindex) {
+	c = Lindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LINDEX")
+	return c
 }
 
-func (b *SBuilder) Lindex() SLindex {
-	return SLindex{cs: append(b.get(), "LINDEX"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Lindex() (c SLindex) {
+	c = SLindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LINDEX")
+	return c
 }
 
 func (c Lindex) Key(key string) LindexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LindexKey)(c)
 }
 
 func (c SLindex) Key(key string) SLindexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLindexKey)(c)
 }
 
@@ -28400,12 +29316,12 @@ type LindexKey Completed
 type SLindexKey SCompleted
 
 func (c LindexKey) Index(index int64) LindexIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (LindexIndex)(c)
 }
 
 func (c SLindexKey) Index(index int64) SLindexIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SLindexIndex)(c)
 }
 
@@ -28413,22 +29329,26 @@ type Linsert Completed
 
 type SLinsert SCompleted
 
-func (b *Builder) Linsert() Linsert {
-	return Linsert{cs: append(b.get(), "LINSERT"), ks: InitSlot}
+func (b *Builder) Linsert() (c Linsert) {
+	c = Linsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LINSERT")
+	return c
 }
 
-func (b *SBuilder) Linsert() SLinsert {
-	return SLinsert{cs: append(b.get(), "LINSERT"), ks: InitSlot}
+func (b *SBuilder) Linsert() (c SLinsert) {
+	c = SLinsert{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LINSERT")
+	return c
 }
 
 func (c Linsert) Key(key string) LinsertKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LinsertKey)(c)
 }
 
 func (c SLinsert) Key(key string) SLinsertKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLinsertKey)(c)
 }
 
@@ -28449,22 +29369,22 @@ type LinsertKey Completed
 type SLinsertKey SCompleted
 
 func (c LinsertKey) Before() LinsertWhereBefore {
-	c.cs = append(c.cs, "BEFORE")
+	c.cs.s = append(c.cs.s, "BEFORE")
 	return (LinsertWhereBefore)(c)
 }
 
 func (c SLinsertKey) Before() SLinsertWhereBefore {
-	c.cs = append(c.cs, "BEFORE")
+	c.cs.s = append(c.cs.s, "BEFORE")
 	return (SLinsertWhereBefore)(c)
 }
 
 func (c LinsertKey) After() LinsertWhereAfter {
-	c.cs = append(c.cs, "AFTER")
+	c.cs.s = append(c.cs.s, "AFTER")
 	return (LinsertWhereAfter)(c)
 }
 
 func (c SLinsertKey) After() SLinsertWhereAfter {
-	c.cs = append(c.cs, "AFTER")
+	c.cs.s = append(c.cs.s, "AFTER")
 	return (SLinsertWhereAfter)(c)
 }
 
@@ -28473,12 +29393,12 @@ type LinsertPivot Completed
 type SLinsertPivot SCompleted
 
 func (c LinsertPivot) Element(element string) LinsertElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (LinsertElement)(c)
 }
 
 func (c SLinsertPivot) Element(element string) SLinsertElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (SLinsertElement)(c)
 }
 
@@ -28487,12 +29407,12 @@ type LinsertWhereAfter Completed
 type SLinsertWhereAfter SCompleted
 
 func (c LinsertWhereAfter) Pivot(pivot string) LinsertPivot {
-	c.cs = append(c.cs, pivot)
+	c.cs.s = append(c.cs.s, pivot)
 	return (LinsertPivot)(c)
 }
 
 func (c SLinsertWhereAfter) Pivot(pivot string) SLinsertPivot {
-	c.cs = append(c.cs, pivot)
+	c.cs.s = append(c.cs.s, pivot)
 	return (SLinsertPivot)(c)
 }
 
@@ -28501,12 +29421,12 @@ type LinsertWhereBefore Completed
 type SLinsertWhereBefore SCompleted
 
 func (c LinsertWhereBefore) Pivot(pivot string) LinsertPivot {
-	c.cs = append(c.cs, pivot)
+	c.cs.s = append(c.cs.s, pivot)
 	return (LinsertPivot)(c)
 }
 
 func (c SLinsertWhereBefore) Pivot(pivot string) SLinsertPivot {
-	c.cs = append(c.cs, pivot)
+	c.cs.s = append(c.cs.s, pivot)
 	return (SLinsertPivot)(c)
 }
 
@@ -28514,22 +29434,26 @@ type Llen Completed
 
 type SLlen SCompleted
 
-func (b *Builder) Llen() Llen {
-	return Llen{cs: append(b.get(), "LLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Llen() (c Llen) {
+	c = Llen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LLEN")
+	return c
 }
 
-func (b *SBuilder) Llen() SLlen {
-	return SLlen{cs: append(b.get(), "LLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Llen() (c SLlen) {
+	c = SLlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LLEN")
+	return c
 }
 
 func (c Llen) Key(key string) LlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LlenKey)(c)
 }
 
 func (c SLlen) Key(key string) SLlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLlenKey)(c)
 }
 
@@ -28557,22 +29481,26 @@ type Lmove Completed
 
 type SLmove SCompleted
 
-func (b *Builder) Lmove() Lmove {
-	return Lmove{cs: append(b.get(), "LMOVE"), ks: InitSlot}
+func (b *Builder) Lmove() (c Lmove) {
+	c = Lmove{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LMOVE")
+	return c
 }
 
-func (b *SBuilder) Lmove() SLmove {
-	return SLmove{cs: append(b.get(), "LMOVE"), ks: InitSlot}
+func (b *SBuilder) Lmove() (c SLmove) {
+	c = SLmove{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LMOVE")
+	return c
 }
 
 func (c Lmove) Source(source string) LmoveSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (LmoveSource)(c)
 }
 
 func (c SLmove) Source(source string) SLmoveSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SLmoveSource)(c)
 }
 
@@ -28581,22 +29509,22 @@ type LmoveDestination Completed
 type SLmoveDestination SCompleted
 
 func (c LmoveDestination) Left() LmoveWherefromLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (LmoveWherefromLeft)(c)
 }
 
 func (c SLmoveDestination) Left() SLmoveWherefromLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SLmoveWherefromLeft)(c)
 }
 
 func (c LmoveDestination) Right() LmoveWherefromRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (LmoveWherefromRight)(c)
 }
 
 func (c SLmoveDestination) Right() SLmoveWherefromRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SLmoveWherefromRight)(c)
 }
 
@@ -28605,13 +29533,13 @@ type LmoveSource Completed
 type SLmoveSource SCompleted
 
 func (c LmoveSource) Destination(destination string) LmoveDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (LmoveDestination)(c)
 }
 
 func (c SLmoveSource) Destination(destination string) SLmoveDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SLmoveDestination)(c)
 }
 
@@ -28620,22 +29548,22 @@ type LmoveWherefromLeft Completed
 type SLmoveWherefromLeft SCompleted
 
 func (c LmoveWherefromLeft) Left() LmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (LmoveWheretoLeft)(c)
 }
 
 func (c SLmoveWherefromLeft) Left() SLmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SLmoveWheretoLeft)(c)
 }
 
 func (c LmoveWherefromLeft) Right() LmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (LmoveWheretoRight)(c)
 }
 
 func (c SLmoveWherefromLeft) Right() SLmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SLmoveWheretoRight)(c)
 }
 
@@ -28644,22 +29572,22 @@ type LmoveWherefromRight Completed
 type SLmoveWherefromRight SCompleted
 
 func (c LmoveWherefromRight) Left() LmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (LmoveWheretoLeft)(c)
 }
 
 func (c SLmoveWherefromRight) Left() SLmoveWheretoLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SLmoveWheretoLeft)(c)
 }
 
 func (c LmoveWherefromRight) Right() LmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (LmoveWheretoRight)(c)
 }
 
 func (c SLmoveWherefromRight) Right() SLmoveWheretoRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SLmoveWheretoRight)(c)
 }
 
@@ -28691,21 +29619,25 @@ type Lmpop Completed
 
 type SLmpop SCompleted
 
-func (b *Builder) Lmpop() Lmpop {
-	return Lmpop{cs: append(b.get(), "LMPOP"), ks: InitSlot}
+func (b *Builder) Lmpop() (c Lmpop) {
+	c = Lmpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LMPOP")
+	return c
 }
 
-func (b *SBuilder) Lmpop() SLmpop {
-	return SLmpop{cs: append(b.get(), "LMPOP"), ks: InitSlot}
+func (b *SBuilder) Lmpop() (c SLmpop) {
+	c = SLmpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LMPOP")
+	return c
 }
 
 func (c Lmpop) Numkeys(numkeys int64) LmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (LmpopNumkeys)(c)
 }
 
 func (c SLmpop) Numkeys(numkeys int64) SLmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SLmpopNumkeys)(c)
 }
 
@@ -28726,7 +29658,7 @@ type LmpopKey Completed
 type SLmpopKey SCompleted
 
 func (c LmpopKey) Key(key ...string) LmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -28734,27 +29666,27 @@ func (c SLmpopKey) Key(key ...string) SLmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c LmpopKey) Left() LmpopWhereLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (LmpopWhereLeft)(c)
 }
 
 func (c SLmpopKey) Left() SLmpopWhereLeft {
-	c.cs = append(c.cs, "LEFT")
+	c.cs.s = append(c.cs.s, "LEFT")
 	return (SLmpopWhereLeft)(c)
 }
 
 func (c LmpopKey) Right() LmpopWhereRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (LmpopWhereRight)(c)
 }
 
 func (c SLmpopKey) Right() SLmpopWhereRight {
-	c.cs = append(c.cs, "RIGHT")
+	c.cs.s = append(c.cs.s, "RIGHT")
 	return (SLmpopWhereRight)(c)
 }
 
@@ -28763,7 +29695,7 @@ type LmpopNumkeys Completed
 type SLmpopNumkeys SCompleted
 
 func (c LmpopNumkeys) Key(key ...string) LmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (LmpopKey)(c)
 }
 
@@ -28771,7 +29703,7 @@ func (c SLmpopNumkeys) Key(key ...string) SLmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SLmpopKey)(c)
 }
 
@@ -28780,12 +29712,12 @@ type LmpopWhereLeft Completed
 type SLmpopWhereLeft SCompleted
 
 func (c LmpopWhereLeft) Count(count int64) LmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (LmpopCount)(c)
 }
 
 func (c SLmpopWhereLeft) Count(count int64) SLmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SLmpopCount)(c)
 }
 
@@ -28802,12 +29734,12 @@ type LmpopWhereRight Completed
 type SLmpopWhereRight SCompleted
 
 func (c LmpopWhereRight) Count(count int64) LmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (LmpopCount)(c)
 }
 
 func (c SLmpopWhereRight) Count(count int64) SLmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SLmpopCount)(c)
 }
 
@@ -28823,21 +29755,25 @@ type Lolwut Completed
 
 type SLolwut SCompleted
 
-func (b *Builder) Lolwut() Lolwut {
-	return Lolwut{cs: append(b.get(), "LOLWUT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Lolwut() (c Lolwut) {
+	c = Lolwut{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LOLWUT")
+	return c
 }
 
-func (b *SBuilder) Lolwut() SLolwut {
-	return SLolwut{cs: append(b.get(), "LOLWUT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Lolwut() (c SLolwut) {
+	c = SLolwut{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LOLWUT")
+	return c
 }
 
 func (c Lolwut) Version(version int64) LolwutVersion {
-	c.cs = append(c.cs, "VERSION", strconv.FormatInt(version, 10))
+	c.cs.s = append(c.cs.s, "VERSION", strconv.FormatInt(version, 10))
 	return (LolwutVersion)(c)
 }
 
 func (c SLolwut) Version(version int64) SLolwutVersion {
-	c.cs = append(c.cs, "VERSION", strconv.FormatInt(version, 10))
+	c.cs.s = append(c.cs.s, "VERSION", strconv.FormatInt(version, 10))
 	return (SLolwutVersion)(c)
 }
 
@@ -28865,22 +29801,26 @@ type Lpop Completed
 
 type SLpop SCompleted
 
-func (b *Builder) Lpop() Lpop {
-	return Lpop{cs: append(b.get(), "LPOP"), ks: InitSlot}
+func (b *Builder) Lpop() (c Lpop) {
+	c = Lpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPOP")
+	return c
 }
 
-func (b *SBuilder) Lpop() SLpop {
-	return SLpop{cs: append(b.get(), "LPOP"), ks: InitSlot}
+func (b *SBuilder) Lpop() (c SLpop) {
+	c = SLpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPOP")
+	return c
 }
 
 func (c Lpop) Key(key string) LpopKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LpopKey)(c)
 }
 
 func (c SLpop) Key(key string) SLpopKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLpopKey)(c)
 }
 
@@ -28901,12 +29841,12 @@ type LpopKey Completed
 type SLpopKey SCompleted
 
 func (c LpopKey) Count(count int64) LpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (LpopCount)(c)
 }
 
 func (c SLpopKey) Count(count int64) SLpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SLpopCount)(c)
 }
 
@@ -28922,22 +29862,26 @@ type Lpos Completed
 
 type SLpos SCompleted
 
-func (b *Builder) Lpos() Lpos {
-	return Lpos{cs: append(b.get(), "LPOS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Lpos() (c Lpos) {
+	c = Lpos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LPOS")
+	return c
 }
 
-func (b *SBuilder) Lpos() SLpos {
-	return SLpos{cs: append(b.get(), "LPOS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Lpos() (c SLpos) {
+	c = SLpos{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LPOS")
+	return c
 }
 
 func (c Lpos) Key(key string) LposKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LposKey)(c)
 }
 
 func (c SLpos) Key(key string) SLposKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLposKey)(c)
 }
 
@@ -28946,12 +29890,12 @@ type LposCount Completed
 type SLposCount SCompleted
 
 func (c LposCount) Maxlen(len int64) LposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (LposMaxlen)(c)
 }
 
 func (c SLposCount) Maxlen(len int64) SLposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (SLposMaxlen)(c)
 }
 
@@ -28976,32 +29920,32 @@ type LposElement Completed
 type SLposElement SCompleted
 
 func (c LposElement) Rank(rank int64) LposRank {
-	c.cs = append(c.cs, "RANK", strconv.FormatInt(rank, 10))
+	c.cs.s = append(c.cs.s, "RANK", strconv.FormatInt(rank, 10))
 	return (LposRank)(c)
 }
 
 func (c SLposElement) Rank(rank int64) SLposRank {
-	c.cs = append(c.cs, "RANK", strconv.FormatInt(rank, 10))
+	c.cs.s = append(c.cs.s, "RANK", strconv.FormatInt(rank, 10))
 	return (SLposRank)(c)
 }
 
 func (c LposElement) Count(numMatches int64) LposCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(numMatches, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(numMatches, 10))
 	return (LposCount)(c)
 }
 
 func (c SLposElement) Count(numMatches int64) SLposCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(numMatches, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(numMatches, 10))
 	return (SLposCount)(c)
 }
 
 func (c LposElement) Maxlen(len int64) LposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (LposMaxlen)(c)
 }
 
 func (c SLposElement) Maxlen(len int64) SLposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (SLposMaxlen)(c)
 }
 
@@ -29026,12 +29970,12 @@ type LposKey Completed
 type SLposKey SCompleted
 
 func (c LposKey) Element(element string) LposElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (LposElement)(c)
 }
 
 func (c SLposKey) Element(element string) SLposElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (SLposElement)(c)
 }
 
@@ -29060,22 +30004,22 @@ type LposRank Completed
 type SLposRank SCompleted
 
 func (c LposRank) Count(numMatches int64) LposCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(numMatches, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(numMatches, 10))
 	return (LposCount)(c)
 }
 
 func (c SLposRank) Count(numMatches int64) SLposCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(numMatches, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(numMatches, 10))
 	return (SLposCount)(c)
 }
 
 func (c LposRank) Maxlen(len int64) LposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (LposMaxlen)(c)
 }
 
 func (c SLposRank) Maxlen(len int64) SLposMaxlen {
-	c.cs = append(c.cs, "MAXLEN", strconv.FormatInt(len, 10))
+	c.cs.s = append(c.cs.s, "MAXLEN", strconv.FormatInt(len, 10))
 	return (SLposMaxlen)(c)
 }
 
@@ -29099,22 +30043,26 @@ type Lpush Completed
 
 type SLpush SCompleted
 
-func (b *Builder) Lpush() Lpush {
-	return Lpush{cs: append(b.get(), "LPUSH"), ks: InitSlot}
+func (b *Builder) Lpush() (c Lpush) {
+	c = Lpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPUSH")
+	return c
 }
 
-func (b *SBuilder) Lpush() SLpush {
-	return SLpush{cs: append(b.get(), "LPUSH"), ks: InitSlot}
+func (b *SBuilder) Lpush() (c SLpush) {
+	c = SLpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPUSH")
+	return c
 }
 
 func (c Lpush) Key(key string) LpushKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LpushKey)(c)
 }
 
 func (c SLpush) Key(key string) SLpushKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLpushKey)(c)
 }
 
@@ -29123,12 +30071,12 @@ type LpushElement Completed
 type SLpushElement SCompleted
 
 func (c LpushElement) Element(element ...string) LpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
 func (c SLpushElement) Element(element ...string) SLpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
@@ -29145,12 +30093,12 @@ type LpushKey Completed
 type SLpushKey SCompleted
 
 func (c LpushKey) Element(element ...string) LpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (LpushElement)(c)
 }
 
 func (c SLpushKey) Element(element ...string) SLpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (SLpushElement)(c)
 }
 
@@ -29158,22 +30106,26 @@ type Lpushx Completed
 
 type SLpushx SCompleted
 
-func (b *Builder) Lpushx() Lpushx {
-	return Lpushx{cs: append(b.get(), "LPUSHX"), ks: InitSlot}
+func (b *Builder) Lpushx() (c Lpushx) {
+	c = Lpushx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPUSHX")
+	return c
 }
 
-func (b *SBuilder) Lpushx() SLpushx {
-	return SLpushx{cs: append(b.get(), "LPUSHX"), ks: InitSlot}
+func (b *SBuilder) Lpushx() (c SLpushx) {
+	c = SLpushx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LPUSHX")
+	return c
 }
 
 func (c Lpushx) Key(key string) LpushxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LpushxKey)(c)
 }
 
 func (c SLpushx) Key(key string) SLpushxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLpushxKey)(c)
 }
 
@@ -29182,12 +30134,12 @@ type LpushxElement Completed
 type SLpushxElement SCompleted
 
 func (c LpushxElement) Element(element ...string) LpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
 func (c SLpushxElement) Element(element ...string) SLpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
@@ -29204,12 +30156,12 @@ type LpushxKey Completed
 type SLpushxKey SCompleted
 
 func (c LpushxKey) Element(element ...string) LpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (LpushxElement)(c)
 }
 
 func (c SLpushxKey) Element(element ...string) SLpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (SLpushxElement)(c)
 }
 
@@ -29217,22 +30169,26 @@ type Lrange Completed
 
 type SLrange SCompleted
 
-func (b *Builder) Lrange() Lrange {
-	return Lrange{cs: append(b.get(), "LRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Lrange() (c Lrange) {
+	c = Lrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LRANGE")
+	return c
 }
 
-func (b *SBuilder) Lrange() SLrange {
-	return SLrange{cs: append(b.get(), "LRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Lrange() (c SLrange) {
+	c = SLrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "LRANGE")
+	return c
 }
 
 func (c Lrange) Key(key string) LrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LrangeKey)(c)
 }
 
 func (c SLrange) Key(key string) SLrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLrangeKey)(c)
 }
 
@@ -29241,12 +30197,12 @@ type LrangeKey Completed
 type SLrangeKey SCompleted
 
 func (c LrangeKey) Start(start int64) LrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (LrangeStart)(c)
 }
 
 func (c SLrangeKey) Start(start int64) SLrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SLrangeStart)(c)
 }
 
@@ -29255,12 +30211,12 @@ type LrangeStart Completed
 type SLrangeStart SCompleted
 
 func (c LrangeStart) Stop(stop int64) LrangeStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (LrangeStop)(c)
 }
 
 func (c SLrangeStart) Stop(stop int64) SLrangeStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SLrangeStop)(c)
 }
 
@@ -29288,22 +30244,26 @@ type Lrem Completed
 
 type SLrem SCompleted
 
-func (b *Builder) Lrem() Lrem {
-	return Lrem{cs: append(b.get(), "LREM"), ks: InitSlot}
+func (b *Builder) Lrem() (c Lrem) {
+	c = Lrem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LREM")
+	return c
 }
 
-func (b *SBuilder) Lrem() SLrem {
-	return SLrem{cs: append(b.get(), "LREM"), ks: InitSlot}
+func (b *SBuilder) Lrem() (c SLrem) {
+	c = SLrem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LREM")
+	return c
 }
 
 func (c Lrem) Key(key string) LremKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LremKey)(c)
 }
 
 func (c SLrem) Key(key string) SLremKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLremKey)(c)
 }
 
@@ -29312,12 +30272,12 @@ type LremCount Completed
 type SLremCount SCompleted
 
 func (c LremCount) Element(element string) LremElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (LremElement)(c)
 }
 
 func (c SLremCount) Element(element string) SLremElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (SLremElement)(c)
 }
 
@@ -29338,12 +30298,12 @@ type LremKey Completed
 type SLremKey SCompleted
 
 func (c LremKey) Count(count int64) LremCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (LremCount)(c)
 }
 
 func (c SLremKey) Count(count int64) SLremCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SLremCount)(c)
 }
 
@@ -29351,22 +30311,26 @@ type Lset Completed
 
 type SLset SCompleted
 
-func (b *Builder) Lset() Lset {
-	return Lset{cs: append(b.get(), "LSET"), ks: InitSlot}
+func (b *Builder) Lset() (c Lset) {
+	c = Lset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LSET")
+	return c
 }
 
-func (b *SBuilder) Lset() SLset {
-	return SLset{cs: append(b.get(), "LSET"), ks: InitSlot}
+func (b *SBuilder) Lset() (c SLset) {
+	c = SLset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LSET")
+	return c
 }
 
 func (c Lset) Key(key string) LsetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LsetKey)(c)
 }
 
 func (c SLset) Key(key string) SLsetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLsetKey)(c)
 }
 
@@ -29387,12 +30351,12 @@ type LsetIndex Completed
 type SLsetIndex SCompleted
 
 func (c LsetIndex) Element(element string) LsetElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (LsetElement)(c)
 }
 
 func (c SLsetIndex) Element(element string) SLsetElement {
-	c.cs = append(c.cs, element)
+	c.cs.s = append(c.cs.s, element)
 	return (SLsetElement)(c)
 }
 
@@ -29401,12 +30365,12 @@ type LsetKey Completed
 type SLsetKey SCompleted
 
 func (c LsetKey) Index(index int64) LsetIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (LsetIndex)(c)
 }
 
 func (c SLsetKey) Index(index int64) SLsetIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SLsetIndex)(c)
 }
 
@@ -29414,22 +30378,26 @@ type Ltrim Completed
 
 type SLtrim SCompleted
 
-func (b *Builder) Ltrim() Ltrim {
-	return Ltrim{cs: append(b.get(), "LTRIM"), ks: InitSlot}
+func (b *Builder) Ltrim() (c Ltrim) {
+	c = Ltrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LTRIM")
+	return c
 }
 
-func (b *SBuilder) Ltrim() SLtrim {
-	return SLtrim{cs: append(b.get(), "LTRIM"), ks: InitSlot}
+func (b *SBuilder) Ltrim() (c SLtrim) {
+	c = SLtrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "LTRIM")
+	return c
 }
 
 func (c Ltrim) Key(key string) LtrimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (LtrimKey)(c)
 }
 
 func (c SLtrim) Key(key string) SLtrimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SLtrimKey)(c)
 }
 
@@ -29438,12 +30406,12 @@ type LtrimKey Completed
 type SLtrimKey SCompleted
 
 func (c LtrimKey) Start(start int64) LtrimStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (LtrimStart)(c)
 }
 
 func (c SLtrimKey) Start(start int64) SLtrimStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SLtrimStart)(c)
 }
 
@@ -29452,12 +30420,12 @@ type LtrimStart Completed
 type SLtrimStart SCompleted
 
 func (c LtrimStart) Stop(stop int64) LtrimStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (LtrimStop)(c)
 }
 
 func (c SLtrimStart) Stop(stop int64) SLtrimStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SLtrimStop)(c)
 }
 
@@ -29477,12 +30445,16 @@ type MemoryDoctor Completed
 
 type SMemoryDoctor SCompleted
 
-func (b *Builder) MemoryDoctor() MemoryDoctor {
-	return MemoryDoctor{cs: append(b.get(), "MEMORY", "DOCTOR"), ks: InitSlot, cf: readonly}
+func (b *Builder) MemoryDoctor() (c MemoryDoctor) {
+	c = MemoryDoctor{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "DOCTOR")
+	return c
 }
 
-func (b *SBuilder) MemoryDoctor() SMemoryDoctor {
-	return SMemoryDoctor{cs: append(b.get(), "MEMORY", "DOCTOR"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) MemoryDoctor() (c SMemoryDoctor) {
+	c = SMemoryDoctor{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "DOCTOR")
+	return c
 }
 
 func (c MemoryDoctor) Build() Completed {
@@ -29497,12 +30469,16 @@ type MemoryHelp Completed
 
 type SMemoryHelp SCompleted
 
-func (b *Builder) MemoryHelp() MemoryHelp {
-	return MemoryHelp{cs: append(b.get(), "MEMORY", "HELP"), ks: InitSlot}
+func (b *Builder) MemoryHelp() (c MemoryHelp) {
+	c = MemoryHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MEMORY", "HELP")
+	return c
 }
 
-func (b *SBuilder) MemoryHelp() SMemoryHelp {
-	return SMemoryHelp{cs: append(b.get(), "MEMORY", "HELP"), ks: InitSlot}
+func (b *SBuilder) MemoryHelp() (c SMemoryHelp) {
+	c = SMemoryHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MEMORY", "HELP")
+	return c
 }
 
 func (c MemoryHelp) Build() Completed {
@@ -29517,12 +30493,16 @@ type MemoryMallocStats Completed
 
 type SMemoryMallocStats SCompleted
 
-func (b *Builder) MemoryMallocStats() MemoryMallocStats {
-	return MemoryMallocStats{cs: append(b.get(), "MEMORY", "MALLOC-STATS"), ks: InitSlot, cf: readonly}
+func (b *Builder) MemoryMallocStats() (c MemoryMallocStats) {
+	c = MemoryMallocStats{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "MALLOC-STATS")
+	return c
 }
 
-func (b *SBuilder) MemoryMallocStats() SMemoryMallocStats {
-	return SMemoryMallocStats{cs: append(b.get(), "MEMORY", "MALLOC-STATS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) MemoryMallocStats() (c SMemoryMallocStats) {
+	c = SMemoryMallocStats{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "MALLOC-STATS")
+	return c
 }
 
 func (c MemoryMallocStats) Build() Completed {
@@ -29537,12 +30517,16 @@ type MemoryPurge Completed
 
 type SMemoryPurge SCompleted
 
-func (b *Builder) MemoryPurge() MemoryPurge {
-	return MemoryPurge{cs: append(b.get(), "MEMORY", "PURGE"), ks: InitSlot}
+func (b *Builder) MemoryPurge() (c MemoryPurge) {
+	c = MemoryPurge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MEMORY", "PURGE")
+	return c
 }
 
-func (b *SBuilder) MemoryPurge() SMemoryPurge {
-	return SMemoryPurge{cs: append(b.get(), "MEMORY", "PURGE"), ks: InitSlot}
+func (b *SBuilder) MemoryPurge() (c SMemoryPurge) {
+	c = SMemoryPurge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MEMORY", "PURGE")
+	return c
 }
 
 func (c MemoryPurge) Build() Completed {
@@ -29557,12 +30541,16 @@ type MemoryStats Completed
 
 type SMemoryStats SCompleted
 
-func (b *Builder) MemoryStats() MemoryStats {
-	return MemoryStats{cs: append(b.get(), "MEMORY", "STATS"), ks: InitSlot, cf: readonly}
+func (b *Builder) MemoryStats() (c MemoryStats) {
+	c = MemoryStats{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "STATS")
+	return c
 }
 
-func (b *SBuilder) MemoryStats() SMemoryStats {
-	return SMemoryStats{cs: append(b.get(), "MEMORY", "STATS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) MemoryStats() (c SMemoryStats) {
+	c = SMemoryStats{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "STATS")
+	return c
 }
 
 func (c MemoryStats) Build() Completed {
@@ -29577,22 +30565,26 @@ type MemoryUsage Completed
 
 type SMemoryUsage SCompleted
 
-func (b *Builder) MemoryUsage() MemoryUsage {
-	return MemoryUsage{cs: append(b.get(), "MEMORY", "USAGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) MemoryUsage() (c MemoryUsage) {
+	c = MemoryUsage{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "USAGE")
+	return c
 }
 
-func (b *SBuilder) MemoryUsage() SMemoryUsage {
-	return SMemoryUsage{cs: append(b.get(), "MEMORY", "USAGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) MemoryUsage() (c SMemoryUsage) {
+	c = SMemoryUsage{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MEMORY", "USAGE")
+	return c
 }
 
 func (c MemoryUsage) Key(key string) MemoryUsageKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (MemoryUsageKey)(c)
 }
 
 func (c SMemoryUsage) Key(key string) SMemoryUsageKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SMemoryUsageKey)(c)
 }
 
@@ -29601,12 +30593,12 @@ type MemoryUsageKey Completed
 type SMemoryUsageKey SCompleted
 
 func (c MemoryUsageKey) Samples(count int64) MemoryUsageSamples {
-	c.cs = append(c.cs, "SAMPLES", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "SAMPLES", strconv.FormatInt(count, 10))
 	return (MemoryUsageSamples)(c)
 }
 
 func (c SMemoryUsageKey) Samples(count int64) SMemoryUsageSamples {
-	c.cs = append(c.cs, "SAMPLES", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "SAMPLES", strconv.FormatInt(count, 10))
 	return (SMemoryUsageSamples)(c)
 }
 
@@ -29634,16 +30626,20 @@ type Mget Completed
 
 type SMget SCompleted
 
-func (b *Builder) Mget() Mget {
-	return Mget{cs: append(b.get(), "MGET"), ks: InitSlot, cf: readonly}
+func (b *Builder) Mget() (c Mget) {
+	c = Mget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MGET")
+	return c
 }
 
-func (b *SBuilder) Mget() SMget {
-	return SMget{cs: append(b.get(), "MGET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Mget() (c SMget) {
+	c = SMget{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "MGET")
+	return c
 }
 
 func (c Mget) Key(key ...string) MgetKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (MgetKey)(c)
 }
 
@@ -29651,7 +30647,7 @@ func (c SMget) Key(key ...string) SMgetKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SMgetKey)(c)
 }
 
@@ -29660,7 +30656,7 @@ type MgetKey Completed
 type SMgetKey SCompleted
 
 func (c MgetKey) Key(key ...string) MgetKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -29668,7 +30664,7 @@ func (c SMgetKey) Key(key ...string) SMgetKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -29684,21 +30680,25 @@ type Migrate Completed
 
 type SMigrate SCompleted
 
-func (b *Builder) Migrate() Migrate {
-	return Migrate{cs: append(b.get(), "MIGRATE"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Migrate() (c Migrate) {
+	c = Migrate{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "MIGRATE")
+	return c
 }
 
-func (b *SBuilder) Migrate() SMigrate {
-	return SMigrate{cs: append(b.get(), "MIGRATE"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Migrate() (c SMigrate) {
+	c = SMigrate{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "MIGRATE")
+	return c
 }
 
 func (c Migrate) Host(host string) MigrateHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (MigrateHost)(c)
 }
 
 func (c SMigrate) Host(host string) SMigrateHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (SMigrateHost)(c)
 }
 
@@ -29707,18 +30707,18 @@ type MigrateAuth Completed
 type SMigrateAuth SCompleted
 
 func (c MigrateAuth) Auth2(usernamePassword string) MigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (MigrateAuth2)(c)
 }
 
 func (c SMigrateAuth) Auth2(usernamePassword string) SMigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (SMigrateAuth2)(c)
 }
 
 func (c MigrateAuth) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (MigrateKeys)(c)
 }
 
@@ -29726,8 +30726,8 @@ func (c SMigrateAuth) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (SMigrateKeys)(c)
 }
 
@@ -29744,8 +30744,8 @@ type MigrateAuth2 Completed
 type SMigrateAuth2 SCompleted
 
 func (c MigrateAuth2) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (MigrateKeys)(c)
 }
 
@@ -29753,8 +30753,8 @@ func (c SMigrateAuth2) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (SMigrateKeys)(c)
 }
 
@@ -29771,38 +30771,38 @@ type MigrateCopy Completed
 type SMigrateCopy SCompleted
 
 func (c MigrateCopy) Replace() MigrateReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (MigrateReplace)(c)
 }
 
 func (c SMigrateCopy) Replace() SMigrateReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (SMigrateReplace)(c)
 }
 
 func (c MigrateCopy) Auth(password string) MigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (MigrateAuth)(c)
 }
 
 func (c SMigrateCopy) Auth(password string) SMigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (SMigrateAuth)(c)
 }
 
 func (c MigrateCopy) Auth2(usernamePassword string) MigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (MigrateAuth2)(c)
 }
 
 func (c SMigrateCopy) Auth2(usernamePassword string) SMigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (SMigrateAuth2)(c)
 }
 
 func (c MigrateCopy) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (MigrateKeys)(c)
 }
 
@@ -29810,8 +30810,8 @@ func (c SMigrateCopy) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (SMigrateKeys)(c)
 }
 
@@ -29828,12 +30828,12 @@ type MigrateDestinationDb Completed
 type SMigrateDestinationDb SCompleted
 
 func (c MigrateDestinationDb) Timeout(timeout int64) MigrateTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (MigrateTimeout)(c)
 }
 
 func (c SMigrateDestinationDb) Timeout(timeout int64) SMigrateTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (SMigrateTimeout)(c)
 }
 
@@ -29842,12 +30842,12 @@ type MigrateHost Completed
 type SMigrateHost SCompleted
 
 func (c MigrateHost) Port(port string) MigratePort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (MigratePort)(c)
 }
 
 func (c SMigrateHost) Port(port string) SMigratePort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (SMigratePort)(c)
 }
 
@@ -29856,12 +30856,12 @@ type MigrateKey Completed
 type SMigrateKey SCompleted
 
 func (c MigrateKey) DestinationDb(destinationDb int64) MigrateDestinationDb {
-	c.cs = append(c.cs, strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(destinationDb, 10))
 	return (MigrateDestinationDb)(c)
 }
 
 func (c SMigrateKey) DestinationDb(destinationDb int64) SMigrateDestinationDb {
-	c.cs = append(c.cs, strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(destinationDb, 10))
 	return (SMigrateDestinationDb)(c)
 }
 
@@ -29870,12 +30870,12 @@ type MigrateKeyEmpty Completed
 type SMigrateKeyEmpty SCompleted
 
 func (c MigrateKeyEmpty) DestinationDb(destinationDb int64) MigrateDestinationDb {
-	c.cs = append(c.cs, strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(destinationDb, 10))
 	return (MigrateDestinationDb)(c)
 }
 
 func (c SMigrateKeyEmpty) DestinationDb(destinationDb int64) SMigrateDestinationDb {
-	c.cs = append(c.cs, strconv.FormatInt(destinationDb, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(destinationDb, 10))
 	return (SMigrateDestinationDb)(c)
 }
 
@@ -29884,8 +30884,8 @@ type MigrateKeys Completed
 type SMigrateKeys SCompleted
 
 func (c MigrateKeys) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -29893,8 +30893,8 @@ func (c SMigrateKeys) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -29911,22 +30911,22 @@ type MigratePort Completed
 type SMigratePort SCompleted
 
 func (c MigratePort) Key() MigrateKey {
-	c.cs = append(c.cs, "key")
+	c.cs.s = append(c.cs.s, "key")
 	return (MigrateKey)(c)
 }
 
 func (c SMigratePort) Key() SMigrateKey {
-	c.cs = append(c.cs, "key")
+	c.cs.s = append(c.cs.s, "key")
 	return (SMigrateKey)(c)
 }
 
 func (c MigratePort) Empty() MigrateKeyEmpty {
-	c.cs = append(c.cs, "")
+	c.cs.s = append(c.cs.s, "")
 	return (MigrateKeyEmpty)(c)
 }
 
 func (c SMigratePort) Empty() SMigrateKeyEmpty {
-	c.cs = append(c.cs, "")
+	c.cs.s = append(c.cs.s, "")
 	return (SMigrateKeyEmpty)(c)
 }
 
@@ -29935,28 +30935,28 @@ type MigrateReplace Completed
 type SMigrateReplace SCompleted
 
 func (c MigrateReplace) Auth(password string) MigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (MigrateAuth)(c)
 }
 
 func (c SMigrateReplace) Auth(password string) SMigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (SMigrateAuth)(c)
 }
 
 func (c MigrateReplace) Auth2(usernamePassword string) MigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (MigrateAuth2)(c)
 }
 
 func (c SMigrateReplace) Auth2(usernamePassword string) SMigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (SMigrateAuth2)(c)
 }
 
 func (c MigrateReplace) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (MigrateKeys)(c)
 }
 
@@ -29964,8 +30964,8 @@ func (c SMigrateReplace) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (SMigrateKeys)(c)
 }
 
@@ -29982,48 +30982,48 @@ type MigrateTimeout Completed
 type SMigrateTimeout SCompleted
 
 func (c MigrateTimeout) Copy() MigrateCopy {
-	c.cs = append(c.cs, "COPY")
+	c.cs.s = append(c.cs.s, "COPY")
 	return (MigrateCopy)(c)
 }
 
 func (c SMigrateTimeout) Copy() SMigrateCopy {
-	c.cs = append(c.cs, "COPY")
+	c.cs.s = append(c.cs.s, "COPY")
 	return (SMigrateCopy)(c)
 }
 
 func (c MigrateTimeout) Replace() MigrateReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (MigrateReplace)(c)
 }
 
 func (c SMigrateTimeout) Replace() SMigrateReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (SMigrateReplace)(c)
 }
 
 func (c MigrateTimeout) Auth(password string) MigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (MigrateAuth)(c)
 }
 
 func (c SMigrateTimeout) Auth(password string) SMigrateAuth {
-	c.cs = append(c.cs, "AUTH", password)
+	c.cs.s = append(c.cs.s, "AUTH", password)
 	return (SMigrateAuth)(c)
 }
 
 func (c MigrateTimeout) Auth2(usernamePassword string) MigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (MigrateAuth2)(c)
 }
 
 func (c SMigrateTimeout) Auth2(usernamePassword string) SMigrateAuth2 {
-	c.cs = append(c.cs, "AUTH2", usernamePassword)
+	c.cs.s = append(c.cs.s, "AUTH2", usernamePassword)
 	return (SMigrateAuth2)(c)
 }
 
 func (c MigrateTimeout) Keys(key ...string) MigrateKeys {
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (MigrateKeys)(c)
 }
 
@@ -30031,8 +31031,8 @@ func (c SMigrateTimeout) Keys(key ...string) SMigrateKeys {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, "KEYS")
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, "KEYS")
+	c.cs.s = append(c.cs.s, key...)
 	return (SMigrateKeys)(c)
 }
 
@@ -30048,12 +31048,16 @@ type ModuleList Completed
 
 type SModuleList SCompleted
 
-func (b *Builder) ModuleList() ModuleList {
-	return ModuleList{cs: append(b.get(), "MODULE", "LIST"), ks: InitSlot}
+func (b *Builder) ModuleList() (c ModuleList) {
+	c = ModuleList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "LIST")
+	return c
 }
 
-func (b *SBuilder) ModuleList() SModuleList {
-	return SModuleList{cs: append(b.get(), "MODULE", "LIST"), ks: InitSlot}
+func (b *SBuilder) ModuleList() (c SModuleList) {
+	c = SModuleList{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "LIST")
+	return c
 }
 
 func (c ModuleList) Build() Completed {
@@ -30068,21 +31072,25 @@ type ModuleLoad Completed
 
 type SModuleLoad SCompleted
 
-func (b *Builder) ModuleLoad() ModuleLoad {
-	return ModuleLoad{cs: append(b.get(), "MODULE", "LOAD"), ks: InitSlot}
+func (b *Builder) ModuleLoad() (c ModuleLoad) {
+	c = ModuleLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "LOAD")
+	return c
 }
 
-func (b *SBuilder) ModuleLoad() SModuleLoad {
-	return SModuleLoad{cs: append(b.get(), "MODULE", "LOAD"), ks: InitSlot}
+func (b *SBuilder) ModuleLoad() (c SModuleLoad) {
+	c = SModuleLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "LOAD")
+	return c
 }
 
 func (c ModuleLoad) Path(path string) ModuleLoadPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (ModuleLoadPath)(c)
 }
 
 func (c SModuleLoad) Path(path string) SModuleLoadPath {
-	c.cs = append(c.cs, path)
+	c.cs.s = append(c.cs.s, path)
 	return (SModuleLoadPath)(c)
 }
 
@@ -30091,12 +31099,12 @@ type ModuleLoadArg Completed
 type SModuleLoadArg SCompleted
 
 func (c ModuleLoadArg) Arg(arg ...string) ModuleLoadArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
 func (c SModuleLoadArg) Arg(arg ...string) SModuleLoadArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return c
 }
 
@@ -30113,12 +31121,12 @@ type ModuleLoadPath Completed
 type SModuleLoadPath SCompleted
 
 func (c ModuleLoadPath) Arg(arg ...string) ModuleLoadArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (ModuleLoadArg)(c)
 }
 
 func (c SModuleLoadPath) Arg(arg ...string) SModuleLoadArg {
-	c.cs = append(c.cs, arg...)
+	c.cs.s = append(c.cs.s, arg...)
 	return (SModuleLoadArg)(c)
 }
 
@@ -30134,21 +31142,25 @@ type ModuleUnload Completed
 
 type SModuleUnload SCompleted
 
-func (b *Builder) ModuleUnload() ModuleUnload {
-	return ModuleUnload{cs: append(b.get(), "MODULE", "UNLOAD"), ks: InitSlot}
+func (b *Builder) ModuleUnload() (c ModuleUnload) {
+	c = ModuleUnload{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "UNLOAD")
+	return c
 }
 
-func (b *SBuilder) ModuleUnload() SModuleUnload {
-	return SModuleUnload{cs: append(b.get(), "MODULE", "UNLOAD"), ks: InitSlot}
+func (b *SBuilder) ModuleUnload() (c SModuleUnload) {
+	c = SModuleUnload{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MODULE", "UNLOAD")
+	return c
 }
 
 func (c ModuleUnload) Name(name string) ModuleUnloadName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (ModuleUnloadName)(c)
 }
 
 func (c SModuleUnload) Name(name string) SModuleUnloadName {
-	c.cs = append(c.cs, name)
+	c.cs.s = append(c.cs.s, name)
 	return (SModuleUnloadName)(c)
 }
 
@@ -30168,12 +31180,16 @@ type Monitor Completed
 
 type SMonitor SCompleted
 
-func (b *Builder) Monitor() Monitor {
-	return Monitor{cs: append(b.get(), "MONITOR"), ks: InitSlot}
+func (b *Builder) Monitor() (c Monitor) {
+	c = Monitor{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MONITOR")
+	return c
 }
 
-func (b *SBuilder) Monitor() SMonitor {
-	return SMonitor{cs: append(b.get(), "MONITOR"), ks: InitSlot}
+func (b *SBuilder) Monitor() (c SMonitor) {
+	c = SMonitor{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MONITOR")
+	return c
 }
 
 func (c Monitor) Build() Completed {
@@ -30188,22 +31204,26 @@ type Move Completed
 
 type SMove SCompleted
 
-func (b *Builder) Move() Move {
-	return Move{cs: append(b.get(), "MOVE"), ks: InitSlot}
+func (b *Builder) Move() (c Move) {
+	c = Move{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MOVE")
+	return c
 }
 
-func (b *SBuilder) Move() SMove {
-	return SMove{cs: append(b.get(), "MOVE"), ks: InitSlot}
+func (b *SBuilder) Move() (c SMove) {
+	c = SMove{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MOVE")
+	return c
 }
 
 func (c Move) Key(key string) MoveKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (MoveKey)(c)
 }
 
 func (c SMove) Key(key string) SMoveKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SMoveKey)(c)
 }
 
@@ -30224,12 +31244,12 @@ type MoveKey Completed
 type SMoveKey SCompleted
 
 func (c MoveKey) Db(db int64) MoveDb {
-	c.cs = append(c.cs, strconv.FormatInt(db, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(db, 10))
 	return (MoveDb)(c)
 }
 
 func (c SMoveKey) Db(db int64) SMoveDb {
-	c.cs = append(c.cs, strconv.FormatInt(db, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(db, 10))
 	return (SMoveDb)(c)
 }
 
@@ -30237,12 +31257,16 @@ type Mset Completed
 
 type SMset SCompleted
 
-func (b *Builder) Mset() Mset {
-	return Mset{cs: append(b.get(), "MSET"), ks: InitSlot}
+func (b *Builder) Mset() (c Mset) {
+	c = Mset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MSET")
+	return c
 }
 
-func (b *SBuilder) Mset() SMset {
-	return SMset{cs: append(b.get(), "MSET"), ks: InitSlot}
+func (b *SBuilder) Mset() (c SMset) {
+	c = SMset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MSET")
+	return c
 }
 
 func (c Mset) KeyValue() MsetKeyValue {
@@ -30258,13 +31282,13 @@ type MsetKeyValue Completed
 type SMsetKeyValue SCompleted
 
 func (c MsetKeyValue) KeyValue(key string, value string) MsetKeyValue {
-	c.cs = append(c.cs, key, value)
+	c.cs.s = append(c.cs.s, key, value)
 	return c
 }
 
 func (c SMsetKeyValue) KeyValue(key string, value string) SMsetKeyValue {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key, value)
+	c.cs.s = append(c.cs.s, key, value)
 	return c
 }
 
@@ -30280,12 +31304,16 @@ type Msetnx Completed
 
 type SMsetnx SCompleted
 
-func (b *Builder) Msetnx() Msetnx {
-	return Msetnx{cs: append(b.get(), "MSETNX"), ks: InitSlot}
+func (b *Builder) Msetnx() (c Msetnx) {
+	c = Msetnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MSETNX")
+	return c
 }
 
-func (b *SBuilder) Msetnx() SMsetnx {
-	return SMsetnx{cs: append(b.get(), "MSETNX"), ks: InitSlot}
+func (b *SBuilder) Msetnx() (c SMsetnx) {
+	c = SMsetnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MSETNX")
+	return c
 }
 
 func (c Msetnx) KeyValue() MsetnxKeyValue {
@@ -30301,13 +31329,13 @@ type MsetnxKeyValue Completed
 type SMsetnxKeyValue SCompleted
 
 func (c MsetnxKeyValue) KeyValue(key string, value string) MsetnxKeyValue {
-	c.cs = append(c.cs, key, value)
+	c.cs.s = append(c.cs.s, key, value)
 	return c
 }
 
 func (c SMsetnxKeyValue) KeyValue(key string, value string) SMsetnxKeyValue {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key, value)
+	c.cs.s = append(c.cs.s, key, value)
 	return c
 }
 
@@ -30323,12 +31351,16 @@ type Multi Completed
 
 type SMulti SCompleted
 
-func (b *Builder) Multi() Multi {
-	return Multi{cs: append(b.get(), "MULTI"), ks: InitSlot}
+func (b *Builder) Multi() (c Multi) {
+	c = Multi{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MULTI")
+	return c
 }
 
-func (b *SBuilder) Multi() SMulti {
-	return SMulti{cs: append(b.get(), "MULTI"), ks: InitSlot}
+func (b *SBuilder) Multi() (c SMulti) {
+	c = SMulti{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "MULTI")
+	return c
 }
 
 func (c Multi) Build() Completed {
@@ -30343,22 +31375,26 @@ type ObjectEncoding Completed
 
 type SObjectEncoding SCompleted
 
-func (b *Builder) ObjectEncoding() ObjectEncoding {
-	return ObjectEncoding{cs: append(b.get(), "OBJECT", "ENCODING"), ks: InitSlot, cf: readonly}
+func (b *Builder) ObjectEncoding() (c ObjectEncoding) {
+	c = ObjectEncoding{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "ENCODING")
+	return c
 }
 
-func (b *SBuilder) ObjectEncoding() SObjectEncoding {
-	return SObjectEncoding{cs: append(b.get(), "OBJECT", "ENCODING"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) ObjectEncoding() (c SObjectEncoding) {
+	c = SObjectEncoding{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "ENCODING")
+	return c
 }
 
 func (c ObjectEncoding) Key(key string) ObjectEncodingKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ObjectEncodingKey)(c)
 }
 
 func (c SObjectEncoding) Key(key string) SObjectEncodingKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SObjectEncodingKey)(c)
 }
 
@@ -30378,22 +31414,26 @@ type ObjectFreq Completed
 
 type SObjectFreq SCompleted
 
-func (b *Builder) ObjectFreq() ObjectFreq {
-	return ObjectFreq{cs: append(b.get(), "OBJECT", "FREQ"), ks: InitSlot, cf: readonly}
+func (b *Builder) ObjectFreq() (c ObjectFreq) {
+	c = ObjectFreq{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "FREQ")
+	return c
 }
 
-func (b *SBuilder) ObjectFreq() SObjectFreq {
-	return SObjectFreq{cs: append(b.get(), "OBJECT", "FREQ"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) ObjectFreq() (c SObjectFreq) {
+	c = SObjectFreq{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "FREQ")
+	return c
 }
 
 func (c ObjectFreq) Key(key string) ObjectFreqKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ObjectFreqKey)(c)
 }
 
 func (c SObjectFreq) Key(key string) SObjectFreqKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SObjectFreqKey)(c)
 }
 
@@ -30413,12 +31453,16 @@ type ObjectHelp Completed
 
 type SObjectHelp SCompleted
 
-func (b *Builder) ObjectHelp() ObjectHelp {
-	return ObjectHelp{cs: append(b.get(), "OBJECT", "HELP"), ks: InitSlot, cf: readonly}
+func (b *Builder) ObjectHelp() (c ObjectHelp) {
+	c = ObjectHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "HELP")
+	return c
 }
 
-func (b *SBuilder) ObjectHelp() SObjectHelp {
-	return SObjectHelp{cs: append(b.get(), "OBJECT", "HELP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) ObjectHelp() (c SObjectHelp) {
+	c = SObjectHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "HELP")
+	return c
 }
 
 func (c ObjectHelp) Build() Completed {
@@ -30433,22 +31477,26 @@ type ObjectIdletime Completed
 
 type SObjectIdletime SCompleted
 
-func (b *Builder) ObjectIdletime() ObjectIdletime {
-	return ObjectIdletime{cs: append(b.get(), "OBJECT", "IDLETIME"), ks: InitSlot, cf: readonly}
+func (b *Builder) ObjectIdletime() (c ObjectIdletime) {
+	c = ObjectIdletime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "IDLETIME")
+	return c
 }
 
-func (b *SBuilder) ObjectIdletime() SObjectIdletime {
-	return SObjectIdletime{cs: append(b.get(), "OBJECT", "IDLETIME"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) ObjectIdletime() (c SObjectIdletime) {
+	c = SObjectIdletime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "IDLETIME")
+	return c
 }
 
 func (c ObjectIdletime) Key(key string) ObjectIdletimeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ObjectIdletimeKey)(c)
 }
 
 func (c SObjectIdletime) Key(key string) SObjectIdletimeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SObjectIdletimeKey)(c)
 }
 
@@ -30468,22 +31516,26 @@ type ObjectRefcount Completed
 
 type SObjectRefcount SCompleted
 
-func (b *Builder) ObjectRefcount() ObjectRefcount {
-	return ObjectRefcount{cs: append(b.get(), "OBJECT", "REFCOUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) ObjectRefcount() (c ObjectRefcount) {
+	c = ObjectRefcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "REFCOUNT")
+	return c
 }
 
-func (b *SBuilder) ObjectRefcount() SObjectRefcount {
-	return SObjectRefcount{cs: append(b.get(), "OBJECT", "REFCOUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) ObjectRefcount() (c SObjectRefcount) {
+	c = SObjectRefcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "OBJECT", "REFCOUNT")
+	return c
 }
 
 func (c ObjectRefcount) Key(key string) ObjectRefcountKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ObjectRefcountKey)(c)
 }
 
 func (c SObjectRefcount) Key(key string) SObjectRefcountKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SObjectRefcountKey)(c)
 }
 
@@ -30503,22 +31555,26 @@ type Persist Completed
 
 type SPersist SCompleted
 
-func (b *Builder) Persist() Persist {
-	return Persist{cs: append(b.get(), "PERSIST"), ks: InitSlot}
+func (b *Builder) Persist() (c Persist) {
+	c = Persist{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PERSIST")
+	return c
 }
 
-func (b *SBuilder) Persist() SPersist {
-	return SPersist{cs: append(b.get(), "PERSIST"), ks: InitSlot}
+func (b *SBuilder) Persist() (c SPersist) {
+	c = SPersist{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PERSIST")
+	return c
 }
 
 func (c Persist) Key(key string) PersistKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PersistKey)(c)
 }
 
 func (c SPersist) Key(key string) SPersistKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPersistKey)(c)
 }
 
@@ -30538,22 +31594,26 @@ type Pexpire Completed
 
 type SPexpire SCompleted
 
-func (b *Builder) Pexpire() Pexpire {
-	return Pexpire{cs: append(b.get(), "PEXPIRE"), ks: InitSlot}
+func (b *Builder) Pexpire() (c Pexpire) {
+	c = Pexpire{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PEXPIRE")
+	return c
 }
 
-func (b *SBuilder) Pexpire() SPexpire {
-	return SPexpire{cs: append(b.get(), "PEXPIRE"), ks: InitSlot}
+func (b *SBuilder) Pexpire() (c SPexpire) {
+	c = SPexpire{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PEXPIRE")
+	return c
 }
 
 func (c Pexpire) Key(key string) PexpireKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PexpireKey)(c)
 }
 
 func (c SPexpire) Key(key string) SPexpireKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPexpireKey)(c)
 }
 
@@ -30610,12 +31670,12 @@ type PexpireKey Completed
 type SPexpireKey SCompleted
 
 func (c PexpireKey) Milliseconds(milliseconds int64) PexpireMilliseconds {
-	c.cs = append(c.cs, strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
 	return (PexpireMilliseconds)(c)
 }
 
 func (c SPexpireKey) Milliseconds(milliseconds int64) SPexpireMilliseconds {
-	c.cs = append(c.cs, strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
 	return (SPexpireMilliseconds)(c)
 }
 
@@ -30624,42 +31684,42 @@ type PexpireMilliseconds Completed
 type SPexpireMilliseconds SCompleted
 
 func (c PexpireMilliseconds) Nx() PexpireConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (PexpireConditionNx)(c)
 }
 
 func (c SPexpireMilliseconds) Nx() SPexpireConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SPexpireConditionNx)(c)
 }
 
 func (c PexpireMilliseconds) Xx() PexpireConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (PexpireConditionXx)(c)
 }
 
 func (c SPexpireMilliseconds) Xx() SPexpireConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SPexpireConditionXx)(c)
 }
 
 func (c PexpireMilliseconds) Gt() PexpireConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (PexpireConditionGt)(c)
 }
 
 func (c SPexpireMilliseconds) Gt() SPexpireConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SPexpireConditionGt)(c)
 }
 
 func (c PexpireMilliseconds) Lt() PexpireConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (PexpireConditionLt)(c)
 }
 
 func (c SPexpireMilliseconds) Lt() SPexpireConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SPexpireConditionLt)(c)
 }
 
@@ -30675,22 +31735,26 @@ type Pexpireat Completed
 
 type SPexpireat SCompleted
 
-func (b *Builder) Pexpireat() Pexpireat {
-	return Pexpireat{cs: append(b.get(), "PEXPIREAT"), ks: InitSlot}
+func (b *Builder) Pexpireat() (c Pexpireat) {
+	c = Pexpireat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PEXPIREAT")
+	return c
 }
 
-func (b *SBuilder) Pexpireat() SPexpireat {
-	return SPexpireat{cs: append(b.get(), "PEXPIREAT"), ks: InitSlot}
+func (b *SBuilder) Pexpireat() (c SPexpireat) {
+	c = SPexpireat{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PEXPIREAT")
+	return c
 }
 
 func (c Pexpireat) Key(key string) PexpireatKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PexpireatKey)(c)
 }
 
 func (c SPexpireat) Key(key string) SPexpireatKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPexpireatKey)(c)
 }
 
@@ -30747,12 +31811,12 @@ type PexpireatKey Completed
 type SPexpireatKey SCompleted
 
 func (c PexpireatKey) MillisecondsTimestamp(millisecondsTimestamp int64) PexpireatMillisecondsTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(millisecondsTimestamp, 10))
 	return (PexpireatMillisecondsTimestamp)(c)
 }
 
 func (c SPexpireatKey) MillisecondsTimestamp(millisecondsTimestamp int64) SPexpireatMillisecondsTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(millisecondsTimestamp, 10))
 	return (SPexpireatMillisecondsTimestamp)(c)
 }
 
@@ -30761,42 +31825,42 @@ type PexpireatMillisecondsTimestamp Completed
 type SPexpireatMillisecondsTimestamp SCompleted
 
 func (c PexpireatMillisecondsTimestamp) Nx() PexpireatConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (PexpireatConditionNx)(c)
 }
 
 func (c SPexpireatMillisecondsTimestamp) Nx() SPexpireatConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SPexpireatConditionNx)(c)
 }
 
 func (c PexpireatMillisecondsTimestamp) Xx() PexpireatConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (PexpireatConditionXx)(c)
 }
 
 func (c SPexpireatMillisecondsTimestamp) Xx() SPexpireatConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SPexpireatConditionXx)(c)
 }
 
 func (c PexpireatMillisecondsTimestamp) Gt() PexpireatConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (PexpireatConditionGt)(c)
 }
 
 func (c SPexpireatMillisecondsTimestamp) Gt() SPexpireatConditionGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SPexpireatConditionGt)(c)
 }
 
 func (c PexpireatMillisecondsTimestamp) Lt() PexpireatConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (PexpireatConditionLt)(c)
 }
 
 func (c SPexpireatMillisecondsTimestamp) Lt() SPexpireatConditionLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SPexpireatConditionLt)(c)
 }
 
@@ -30812,22 +31876,26 @@ type Pexpiretime Completed
 
 type SPexpiretime SCompleted
 
-func (b *Builder) Pexpiretime() Pexpiretime {
-	return Pexpiretime{cs: append(b.get(), "PEXPIRETIME"), ks: InitSlot, cf: readonly}
+func (b *Builder) Pexpiretime() (c Pexpiretime) {
+	c = Pexpiretime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PEXPIRETIME")
+	return c
 }
 
-func (b *SBuilder) Pexpiretime() SPexpiretime {
-	return SPexpiretime{cs: append(b.get(), "PEXPIRETIME"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Pexpiretime() (c SPexpiretime) {
+	c = SPexpiretime{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PEXPIRETIME")
+	return c
 }
 
 func (c Pexpiretime) Key(key string) PexpiretimeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PexpiretimeKey)(c)
 }
 
 func (c SPexpiretime) Key(key string) SPexpiretimeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPexpiretimeKey)(c)
 }
 
@@ -30855,22 +31923,26 @@ type Pfadd Completed
 
 type SPfadd SCompleted
 
-func (b *Builder) Pfadd() Pfadd {
-	return Pfadd{cs: append(b.get(), "PFADD"), ks: InitSlot}
+func (b *Builder) Pfadd() (c Pfadd) {
+	c = Pfadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PFADD")
+	return c
 }
 
-func (b *SBuilder) Pfadd() SPfadd {
-	return SPfadd{cs: append(b.get(), "PFADD"), ks: InitSlot}
+func (b *SBuilder) Pfadd() (c SPfadd) {
+	c = SPfadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PFADD")
+	return c
 }
 
 func (c Pfadd) Key(key string) PfaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PfaddKey)(c)
 }
 
 func (c SPfadd) Key(key string) SPfaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPfaddKey)(c)
 }
 
@@ -30879,12 +31951,12 @@ type PfaddElement Completed
 type SPfaddElement SCompleted
 
 func (c PfaddElement) Element(element ...string) PfaddElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
 func (c SPfaddElement) Element(element ...string) SPfaddElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
@@ -30901,12 +31973,12 @@ type PfaddKey Completed
 type SPfaddKey SCompleted
 
 func (c PfaddKey) Element(element ...string) PfaddElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (PfaddElement)(c)
 }
 
 func (c SPfaddKey) Element(element ...string) SPfaddElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (SPfaddElement)(c)
 }
 
@@ -30922,16 +31994,20 @@ type Pfcount Completed
 
 type SPfcount SCompleted
 
-func (b *Builder) Pfcount() Pfcount {
-	return Pfcount{cs: append(b.get(), "PFCOUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Pfcount() (c Pfcount) {
+	c = Pfcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PFCOUNT")
+	return c
 }
 
-func (b *SBuilder) Pfcount() SPfcount {
-	return SPfcount{cs: append(b.get(), "PFCOUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Pfcount() (c SPfcount) {
+	c = SPfcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PFCOUNT")
+	return c
 }
 
 func (c Pfcount) Key(key ...string) PfcountKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (PfcountKey)(c)
 }
 
@@ -30939,7 +32015,7 @@ func (c SPfcount) Key(key ...string) SPfcountKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SPfcountKey)(c)
 }
 
@@ -30948,7 +32024,7 @@ type PfcountKey Completed
 type SPfcountKey SCompleted
 
 func (c PfcountKey) Key(key ...string) PfcountKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -30956,7 +32032,7 @@ func (c SPfcountKey) Key(key ...string) SPfcountKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -30972,22 +32048,26 @@ type Pfmerge Completed
 
 type SPfmerge SCompleted
 
-func (b *Builder) Pfmerge() Pfmerge {
-	return Pfmerge{cs: append(b.get(), "PFMERGE"), ks: InitSlot}
+func (b *Builder) Pfmerge() (c Pfmerge) {
+	c = Pfmerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PFMERGE")
+	return c
 }
 
-func (b *SBuilder) Pfmerge() SPfmerge {
-	return SPfmerge{cs: append(b.get(), "PFMERGE"), ks: InitSlot}
+func (b *SBuilder) Pfmerge() (c SPfmerge) {
+	c = SPfmerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PFMERGE")
+	return c
 }
 
 func (c Pfmerge) Destkey(destkey string) PfmergeDestkey {
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (PfmergeDestkey)(c)
 }
 
 func (c SPfmerge) Destkey(destkey string) SPfmergeDestkey {
 	c.ks = checkSlot(c.ks, slot(destkey))
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (SPfmergeDestkey)(c)
 }
 
@@ -30996,7 +32076,7 @@ type PfmergeDestkey Completed
 type SPfmergeDestkey SCompleted
 
 func (c PfmergeDestkey) Sourcekey(sourcekey ...string) PfmergeSourcekey {
-	c.cs = append(c.cs, sourcekey...)
+	c.cs.s = append(c.cs.s, sourcekey...)
 	return (PfmergeSourcekey)(c)
 }
 
@@ -31004,7 +32084,7 @@ func (c SPfmergeDestkey) Sourcekey(sourcekey ...string) SPfmergeSourcekey {
 	for _, k := range sourcekey {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, sourcekey...)
+	c.cs.s = append(c.cs.s, sourcekey...)
 	return (SPfmergeSourcekey)(c)
 }
 
@@ -31013,7 +32093,7 @@ type PfmergeSourcekey Completed
 type SPfmergeSourcekey SCompleted
 
 func (c PfmergeSourcekey) Sourcekey(sourcekey ...string) PfmergeSourcekey {
-	c.cs = append(c.cs, sourcekey...)
+	c.cs.s = append(c.cs.s, sourcekey...)
 	return c
 }
 
@@ -31021,7 +32101,7 @@ func (c SPfmergeSourcekey) Sourcekey(sourcekey ...string) SPfmergeSourcekey {
 	for _, k := range sourcekey {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, sourcekey...)
+	c.cs.s = append(c.cs.s, sourcekey...)
 	return c
 }
 
@@ -31037,21 +32117,25 @@ type Ping Completed
 
 type SPing SCompleted
 
-func (b *Builder) Ping() Ping {
-	return Ping{cs: append(b.get(), "PING"), ks: InitSlot}
+func (b *Builder) Ping() (c Ping) {
+	c = Ping{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PING")
+	return c
 }
 
-func (b *SBuilder) Ping() SPing {
-	return SPing{cs: append(b.get(), "PING"), ks: InitSlot}
+func (b *SBuilder) Ping() (c SPing) {
+	c = SPing{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PING")
+	return c
 }
 
 func (c Ping) Message(message string) PingMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (PingMessage)(c)
 }
 
 func (c SPing) Message(message string) SPingMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (SPingMessage)(c)
 }
 
@@ -31079,22 +32163,26 @@ type Psetex Completed
 
 type SPsetex SCompleted
 
-func (b *Builder) Psetex() Psetex {
-	return Psetex{cs: append(b.get(), "PSETEX"), ks: InitSlot}
+func (b *Builder) Psetex() (c Psetex) {
+	c = Psetex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PSETEX")
+	return c
 }
 
-func (b *SBuilder) Psetex() SPsetex {
-	return SPsetex{cs: append(b.get(), "PSETEX"), ks: InitSlot}
+func (b *SBuilder) Psetex() (c SPsetex) {
+	c = SPsetex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PSETEX")
+	return c
 }
 
 func (c Psetex) Key(key string) PsetexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PsetexKey)(c)
 }
 
 func (c SPsetex) Key(key string) SPsetexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPsetexKey)(c)
 }
 
@@ -31103,12 +32191,12 @@ type PsetexKey Completed
 type SPsetexKey SCompleted
 
 func (c PsetexKey) Milliseconds(milliseconds int64) PsetexMilliseconds {
-	c.cs = append(c.cs, strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
 	return (PsetexMilliseconds)(c)
 }
 
 func (c SPsetexKey) Milliseconds(milliseconds int64) SPsetexMilliseconds {
-	c.cs = append(c.cs, strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
 	return (SPsetexMilliseconds)(c)
 }
 
@@ -31117,12 +32205,12 @@ type PsetexMilliseconds Completed
 type SPsetexMilliseconds SCompleted
 
 func (c PsetexMilliseconds) Value(value string) PsetexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (PsetexValue)(c)
 }
 
 func (c SPsetexMilliseconds) Value(value string) SPsetexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SPsetexValue)(c)
 }
 
@@ -31142,21 +32230,25 @@ type Psubscribe Completed
 
 type SPsubscribe SCompleted
 
-func (b *Builder) Psubscribe() Psubscribe {
-	return Psubscribe{cs: append(b.get(), "PSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *Builder) Psubscribe() (c Psubscribe) {
+	c = Psubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "PSUBSCRIBE")
+	return c
 }
 
-func (b *SBuilder) Psubscribe() SPsubscribe {
-	return SPsubscribe{cs: append(b.get(), "PSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *SBuilder) Psubscribe() (c SPsubscribe) {
+	c = SPsubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "PSUBSCRIBE")
+	return c
 }
 
 func (c Psubscribe) Pattern(pattern ...string) PsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return (PsubscribePattern)(c)
 }
 
 func (c SPsubscribe) Pattern(pattern ...string) SPsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SPsubscribePattern)(c)
 }
 
@@ -31165,12 +32257,12 @@ type PsubscribePattern Completed
 type SPsubscribePattern SCompleted
 
 func (c PsubscribePattern) Pattern(pattern ...string) PsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SPsubscribePattern) Pattern(pattern ...string) SPsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
@@ -31186,21 +32278,25 @@ type Psync Completed
 
 type SPsync SCompleted
 
-func (b *Builder) Psync() Psync {
-	return Psync{cs: append(b.get(), "PSYNC"), ks: InitSlot}
+func (b *Builder) Psync() (c Psync) {
+	c = Psync{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PSYNC")
+	return c
 }
 
-func (b *SBuilder) Psync() SPsync {
-	return SPsync{cs: append(b.get(), "PSYNC"), ks: InitSlot}
+func (b *SBuilder) Psync() (c SPsync) {
+	c = SPsync{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PSYNC")
+	return c
 }
 
 func (c Psync) Replicationid(replicationid int64) PsyncReplicationid {
-	c.cs = append(c.cs, strconv.FormatInt(replicationid, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(replicationid, 10))
 	return (PsyncReplicationid)(c)
 }
 
 func (c SPsync) Replicationid(replicationid int64) SPsyncReplicationid {
-	c.cs = append(c.cs, strconv.FormatInt(replicationid, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(replicationid, 10))
 	return (SPsyncReplicationid)(c)
 }
 
@@ -31221,12 +32317,12 @@ type PsyncReplicationid Completed
 type SPsyncReplicationid SCompleted
 
 func (c PsyncReplicationid) Offset(offset int64) PsyncOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (PsyncOffset)(c)
 }
 
 func (c SPsyncReplicationid) Offset(offset int64) SPsyncOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SPsyncOffset)(c)
 }
 
@@ -31234,22 +32330,26 @@ type Pttl Completed
 
 type SPttl SCompleted
 
-func (b *Builder) Pttl() Pttl {
-	return Pttl{cs: append(b.get(), "PTTL"), ks: InitSlot, cf: readonly}
+func (b *Builder) Pttl() (c Pttl) {
+	c = Pttl{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PTTL")
+	return c
 }
 
-func (b *SBuilder) Pttl() SPttl {
-	return SPttl{cs: append(b.get(), "PTTL"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Pttl() (c SPttl) {
+	c = SPttl{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PTTL")
+	return c
 }
 
 func (c Pttl) Key(key string) PttlKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (PttlKey)(c)
 }
 
 func (c SPttl) Key(key string) SPttlKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SPttlKey)(c)
 }
 
@@ -31277,21 +32377,25 @@ type Publish Completed
 
 type SPublish SCompleted
 
-func (b *Builder) Publish() Publish {
-	return Publish{cs: append(b.get(), "PUBLISH"), ks: InitSlot}
+func (b *Builder) Publish() (c Publish) {
+	c = Publish{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PUBLISH")
+	return c
 }
 
-func (b *SBuilder) Publish() SPublish {
-	return SPublish{cs: append(b.get(), "PUBLISH"), ks: InitSlot}
+func (b *SBuilder) Publish() (c SPublish) {
+	c = SPublish{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "PUBLISH")
+	return c
 }
 
 func (c Publish) Channel(channel string) PublishChannel {
-	c.cs = append(c.cs, channel)
+	c.cs.s = append(c.cs.s, channel)
 	return (PublishChannel)(c)
 }
 
 func (c SPublish) Channel(channel string) SPublishChannel {
-	c.cs = append(c.cs, channel)
+	c.cs.s = append(c.cs.s, channel)
 	return (SPublishChannel)(c)
 }
 
@@ -31300,12 +32404,12 @@ type PublishChannel Completed
 type SPublishChannel SCompleted
 
 func (c PublishChannel) Message(message string) PublishMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (PublishMessage)(c)
 }
 
 func (c SPublishChannel) Message(message string) SPublishMessage {
-	c.cs = append(c.cs, message)
+	c.cs.s = append(c.cs.s, message)
 	return (SPublishMessage)(c)
 }
 
@@ -31325,21 +32429,25 @@ type PubsubChannels Completed
 
 type SPubsubChannels SCompleted
 
-func (b *Builder) PubsubChannels() PubsubChannels {
-	return PubsubChannels{cs: append(b.get(), "PUBSUB", "CHANNELS"), ks: InitSlot, cf: readonly}
+func (b *Builder) PubsubChannels() (c PubsubChannels) {
+	c = PubsubChannels{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "CHANNELS")
+	return c
 }
 
-func (b *SBuilder) PubsubChannels() SPubsubChannels {
-	return SPubsubChannels{cs: append(b.get(), "PUBSUB", "CHANNELS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) PubsubChannels() (c SPubsubChannels) {
+	c = SPubsubChannels{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "CHANNELS")
+	return c
 }
 
 func (c PubsubChannels) Pattern(pattern string) PubsubChannelsPattern {
-	c.cs = append(c.cs, pattern)
+	c.cs.s = append(c.cs.s, pattern)
 	return (PubsubChannelsPattern)(c)
 }
 
 func (c SPubsubChannels) Pattern(pattern string) SPubsubChannelsPattern {
-	c.cs = append(c.cs, pattern)
+	c.cs.s = append(c.cs.s, pattern)
 	return (SPubsubChannelsPattern)(c)
 }
 
@@ -31367,12 +32475,16 @@ type PubsubHelp Completed
 
 type SPubsubHelp SCompleted
 
-func (b *Builder) PubsubHelp() PubsubHelp {
-	return PubsubHelp{cs: append(b.get(), "PUBSUB", "HELP"), ks: InitSlot, cf: readonly}
+func (b *Builder) PubsubHelp() (c PubsubHelp) {
+	c = PubsubHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "HELP")
+	return c
 }
 
-func (b *SBuilder) PubsubHelp() SPubsubHelp {
-	return SPubsubHelp{cs: append(b.get(), "PUBSUB", "HELP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) PubsubHelp() (c SPubsubHelp) {
+	c = SPubsubHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "HELP")
+	return c
 }
 
 func (c PubsubHelp) Build() Completed {
@@ -31387,12 +32499,16 @@ type PubsubNumpat Completed
 
 type SPubsubNumpat SCompleted
 
-func (b *Builder) PubsubNumpat() PubsubNumpat {
-	return PubsubNumpat{cs: append(b.get(), "PUBSUB", "NUMPAT"), ks: InitSlot, cf: readonly}
+func (b *Builder) PubsubNumpat() (c PubsubNumpat) {
+	c = PubsubNumpat{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "NUMPAT")
+	return c
 }
 
-func (b *SBuilder) PubsubNumpat() SPubsubNumpat {
-	return SPubsubNumpat{cs: append(b.get(), "PUBSUB", "NUMPAT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) PubsubNumpat() (c SPubsubNumpat) {
+	c = SPubsubNumpat{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "NUMPAT")
+	return c
 }
 
 func (c PubsubNumpat) Build() Completed {
@@ -31407,21 +32523,25 @@ type PubsubNumsub Completed
 
 type SPubsubNumsub SCompleted
 
-func (b *Builder) PubsubNumsub() PubsubNumsub {
-	return PubsubNumsub{cs: append(b.get(), "PUBSUB", "NUMSUB"), ks: InitSlot, cf: readonly}
+func (b *Builder) PubsubNumsub() (c PubsubNumsub) {
+	c = PubsubNumsub{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "NUMSUB")
+	return c
 }
 
-func (b *SBuilder) PubsubNumsub() SPubsubNumsub {
-	return SPubsubNumsub{cs: append(b.get(), "PUBSUB", "NUMSUB"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) PubsubNumsub() (c SPubsubNumsub) {
+	c = SPubsubNumsub{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "PUBSUB", "NUMSUB")
+	return c
 }
 
 func (c PubsubNumsub) Channel(channel ...string) PubsubNumsubChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (PubsubNumsubChannel)(c)
 }
 
 func (c SPubsubNumsub) Channel(channel ...string) SPubsubNumsubChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (SPubsubNumsubChannel)(c)
 }
 
@@ -31438,12 +32558,12 @@ type PubsubNumsubChannel Completed
 type SPubsubNumsubChannel SCompleted
 
 func (c PubsubNumsubChannel) Channel(channel ...string) PubsubNumsubChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
 func (c SPubsubNumsubChannel) Channel(channel ...string) SPubsubNumsubChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
@@ -31459,21 +32579,25 @@ type Punsubscribe Completed
 
 type SPunsubscribe SCompleted
 
-func (b *Builder) Punsubscribe() Punsubscribe {
-	return Punsubscribe{cs: append(b.get(), "PUNSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *Builder) Punsubscribe() (c Punsubscribe) {
+	c = Punsubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "PUNSUBSCRIBE")
+	return c
 }
 
-func (b *SBuilder) Punsubscribe() SPunsubscribe {
-	return SPunsubscribe{cs: append(b.get(), "PUNSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *SBuilder) Punsubscribe() (c SPunsubscribe) {
+	c = SPunsubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "PUNSUBSCRIBE")
+	return c
 }
 
 func (c Punsubscribe) Pattern(pattern ...string) PunsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return (PunsubscribePattern)(c)
 }
 
 func (c SPunsubscribe) Pattern(pattern ...string) SPunsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SPunsubscribePattern)(c)
 }
 
@@ -31490,12 +32614,12 @@ type PunsubscribePattern Completed
 type SPunsubscribePattern SCompleted
 
 func (c PunsubscribePattern) Pattern(pattern ...string) PunsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SPunsubscribePattern) Pattern(pattern ...string) SPunsubscribePattern {
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
@@ -31511,12 +32635,16 @@ type Quit Completed
 
 type SQuit SCompleted
 
-func (b *Builder) Quit() Quit {
-	return Quit{cs: append(b.get(), "QUIT"), ks: InitSlot}
+func (b *Builder) Quit() (c Quit) {
+	c = Quit{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "QUIT")
+	return c
 }
 
-func (b *SBuilder) Quit() SQuit {
-	return SQuit{cs: append(b.get(), "QUIT"), ks: InitSlot}
+func (b *SBuilder) Quit() (c SQuit) {
+	c = SQuit{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "QUIT")
+	return c
 }
 
 func (c Quit) Build() Completed {
@@ -31531,12 +32659,16 @@ type Randomkey Completed
 
 type SRandomkey SCompleted
 
-func (b *Builder) Randomkey() Randomkey {
-	return Randomkey{cs: append(b.get(), "RANDOMKEY"), ks: InitSlot, cf: readonly}
+func (b *Builder) Randomkey() (c Randomkey) {
+	c = Randomkey{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "RANDOMKEY")
+	return c
 }
 
-func (b *SBuilder) Randomkey() SRandomkey {
-	return SRandomkey{cs: append(b.get(), "RANDOMKEY"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Randomkey() (c SRandomkey) {
+	c = SRandomkey{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "RANDOMKEY")
+	return c
 }
 
 func (c Randomkey) Build() Completed {
@@ -31551,12 +32683,16 @@ type Readonly Completed
 
 type SReadonly SCompleted
 
-func (b *Builder) Readonly() Readonly {
-	return Readonly{cs: append(b.get(), "READONLY"), ks: InitSlot}
+func (b *Builder) Readonly() (c Readonly) {
+	c = Readonly{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "READONLY")
+	return c
 }
 
-func (b *SBuilder) Readonly() SReadonly {
-	return SReadonly{cs: append(b.get(), "READONLY"), ks: InitSlot}
+func (b *SBuilder) Readonly() (c SReadonly) {
+	c = SReadonly{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "READONLY")
+	return c
 }
 
 func (c Readonly) Build() Completed {
@@ -31571,12 +32707,16 @@ type Readwrite Completed
 
 type SReadwrite SCompleted
 
-func (b *Builder) Readwrite() Readwrite {
-	return Readwrite{cs: append(b.get(), "READWRITE"), ks: InitSlot}
+func (b *Builder) Readwrite() (c Readwrite) {
+	c = Readwrite{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "READWRITE")
+	return c
 }
 
-func (b *SBuilder) Readwrite() SReadwrite {
-	return SReadwrite{cs: append(b.get(), "READWRITE"), ks: InitSlot}
+func (b *SBuilder) Readwrite() (c SReadwrite) {
+	c = SReadwrite{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "READWRITE")
+	return c
 }
 
 func (c Readwrite) Build() Completed {
@@ -31591,22 +32731,26 @@ type Rename Completed
 
 type SRename SCompleted
 
-func (b *Builder) Rename() Rename {
-	return Rename{cs: append(b.get(), "RENAME"), ks: InitSlot}
+func (b *Builder) Rename() (c Rename) {
+	c = Rename{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RENAME")
+	return c
 }
 
-func (b *SBuilder) Rename() SRename {
-	return SRename{cs: append(b.get(), "RENAME"), ks: InitSlot}
+func (b *SBuilder) Rename() (c SRename) {
+	c = SRename{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RENAME")
+	return c
 }
 
 func (c Rename) Key(key string) RenameKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RenameKey)(c)
 }
 
 func (c SRename) Key(key string) SRenameKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRenameKey)(c)
 }
 
@@ -31615,13 +32759,13 @@ type RenameKey Completed
 type SRenameKey SCompleted
 
 func (c RenameKey) Newkey(newkey string) RenameNewkey {
-	c.cs = append(c.cs, newkey)
+	c.cs.s = append(c.cs.s, newkey)
 	return (RenameNewkey)(c)
 }
 
 func (c SRenameKey) Newkey(newkey string) SRenameNewkey {
 	c.ks = checkSlot(c.ks, slot(newkey))
-	c.cs = append(c.cs, newkey)
+	c.cs.s = append(c.cs.s, newkey)
 	return (SRenameNewkey)(c)
 }
 
@@ -31641,22 +32785,26 @@ type Renamenx Completed
 
 type SRenamenx SCompleted
 
-func (b *Builder) Renamenx() Renamenx {
-	return Renamenx{cs: append(b.get(), "RENAMENX"), ks: InitSlot}
+func (b *Builder) Renamenx() (c Renamenx) {
+	c = Renamenx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RENAMENX")
+	return c
 }
 
-func (b *SBuilder) Renamenx() SRenamenx {
-	return SRenamenx{cs: append(b.get(), "RENAMENX"), ks: InitSlot}
+func (b *SBuilder) Renamenx() (c SRenamenx) {
+	c = SRenamenx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RENAMENX")
+	return c
 }
 
 func (c Renamenx) Key(key string) RenamenxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RenamenxKey)(c)
 }
 
 func (c SRenamenx) Key(key string) SRenamenxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRenamenxKey)(c)
 }
 
@@ -31665,13 +32813,13 @@ type RenamenxKey Completed
 type SRenamenxKey SCompleted
 
 func (c RenamenxKey) Newkey(newkey string) RenamenxNewkey {
-	c.cs = append(c.cs, newkey)
+	c.cs.s = append(c.cs.s, newkey)
 	return (RenamenxNewkey)(c)
 }
 
 func (c SRenamenxKey) Newkey(newkey string) SRenamenxNewkey {
 	c.ks = checkSlot(c.ks, slot(newkey))
-	c.cs = append(c.cs, newkey)
+	c.cs.s = append(c.cs.s, newkey)
 	return (SRenamenxNewkey)(c)
 }
 
@@ -31691,21 +32839,25 @@ type Replicaof Completed
 
 type SReplicaof SCompleted
 
-func (b *Builder) Replicaof() Replicaof {
-	return Replicaof{cs: append(b.get(), "REPLICAOF"), ks: InitSlot}
+func (b *Builder) Replicaof() (c Replicaof) {
+	c = Replicaof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "REPLICAOF")
+	return c
 }
 
-func (b *SBuilder) Replicaof() SReplicaof {
-	return SReplicaof{cs: append(b.get(), "REPLICAOF"), ks: InitSlot}
+func (b *SBuilder) Replicaof() (c SReplicaof) {
+	c = SReplicaof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "REPLICAOF")
+	return c
 }
 
 func (c Replicaof) Host(host string) ReplicaofHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (ReplicaofHost)(c)
 }
 
 func (c SReplicaof) Host(host string) SReplicaofHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (SReplicaofHost)(c)
 }
 
@@ -31714,12 +32866,12 @@ type ReplicaofHost Completed
 type SReplicaofHost SCompleted
 
 func (c ReplicaofHost) Port(port string) ReplicaofPort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (ReplicaofPort)(c)
 }
 
 func (c SReplicaofHost) Port(port string) SReplicaofPort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (SReplicaofPort)(c)
 }
 
@@ -31739,12 +32891,16 @@ type Reset Completed
 
 type SReset SCompleted
 
-func (b *Builder) Reset() Reset {
-	return Reset{cs: append(b.get(), "RESET"), ks: InitSlot}
+func (b *Builder) Reset() (c Reset) {
+	c = Reset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RESET")
+	return c
 }
 
-func (b *SBuilder) Reset() SReset {
-	return SReset{cs: append(b.get(), "RESET"), ks: InitSlot}
+func (b *SBuilder) Reset() (c SReset) {
+	c = SReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RESET")
+	return c
 }
 
 func (c Reset) Build() Completed {
@@ -31759,22 +32915,26 @@ type Restore Completed
 
 type SRestore SCompleted
 
-func (b *Builder) Restore() Restore {
-	return Restore{cs: append(b.get(), "RESTORE"), ks: InitSlot}
+func (b *Builder) Restore() (c Restore) {
+	c = Restore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RESTORE")
+	return c
 }
 
-func (b *SBuilder) Restore() SRestore {
-	return SRestore{cs: append(b.get(), "RESTORE"), ks: InitSlot}
+func (b *SBuilder) Restore() (c SRestore) {
+	c = SRestore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RESTORE")
+	return c
 }
 
 func (c Restore) Key(key string) RestoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RestoreKey)(c)
 }
 
 func (c SRestore) Key(key string) SRestoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRestoreKey)(c)
 }
 
@@ -31783,22 +32943,22 @@ type RestoreAbsttl Completed
 type SRestoreAbsttl SCompleted
 
 func (c RestoreAbsttl) Idletime(seconds int64) RestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (RestoreIdletime)(c)
 }
 
 func (c SRestoreAbsttl) Idletime(seconds int64) SRestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (SRestoreIdletime)(c)
 }
 
 func (c RestoreAbsttl) Freq(frequency int64) RestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (RestoreFreq)(c)
 }
 
 func (c SRestoreAbsttl) Freq(frequency int64) SRestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (SRestoreFreq)(c)
 }
 
@@ -31827,12 +32987,12 @@ type RestoreIdletime Completed
 type SRestoreIdletime SCompleted
 
 func (c RestoreIdletime) Freq(frequency int64) RestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (RestoreFreq)(c)
 }
 
 func (c SRestoreIdletime) Freq(frequency int64) SRestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (SRestoreFreq)(c)
 }
 
@@ -31849,12 +33009,12 @@ type RestoreKey Completed
 type SRestoreKey SCompleted
 
 func (c RestoreKey) Ttl(ttl int64) RestoreTtl {
-	c.cs = append(c.cs, strconv.FormatInt(ttl, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(ttl, 10))
 	return (RestoreTtl)(c)
 }
 
 func (c SRestoreKey) Ttl(ttl int64) SRestoreTtl {
-	c.cs = append(c.cs, strconv.FormatInt(ttl, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(ttl, 10))
 	return (SRestoreTtl)(c)
 }
 
@@ -31863,32 +33023,32 @@ type RestoreReplace Completed
 type SRestoreReplace SCompleted
 
 func (c RestoreReplace) Absttl() RestoreAbsttl {
-	c.cs = append(c.cs, "ABSTTL")
+	c.cs.s = append(c.cs.s, "ABSTTL")
 	return (RestoreAbsttl)(c)
 }
 
 func (c SRestoreReplace) Absttl() SRestoreAbsttl {
-	c.cs = append(c.cs, "ABSTTL")
+	c.cs.s = append(c.cs.s, "ABSTTL")
 	return (SRestoreAbsttl)(c)
 }
 
 func (c RestoreReplace) Idletime(seconds int64) RestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (RestoreIdletime)(c)
 }
 
 func (c SRestoreReplace) Idletime(seconds int64) SRestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (SRestoreIdletime)(c)
 }
 
 func (c RestoreReplace) Freq(frequency int64) RestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (RestoreFreq)(c)
 }
 
 func (c SRestoreReplace) Freq(frequency int64) SRestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (SRestoreFreq)(c)
 }
 
@@ -31905,42 +33065,42 @@ type RestoreSerializedValue Completed
 type SRestoreSerializedValue SCompleted
 
 func (c RestoreSerializedValue) Replace() RestoreReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (RestoreReplace)(c)
 }
 
 func (c SRestoreSerializedValue) Replace() SRestoreReplace {
-	c.cs = append(c.cs, "REPLACE")
+	c.cs.s = append(c.cs.s, "REPLACE")
 	return (SRestoreReplace)(c)
 }
 
 func (c RestoreSerializedValue) Absttl() RestoreAbsttl {
-	c.cs = append(c.cs, "ABSTTL")
+	c.cs.s = append(c.cs.s, "ABSTTL")
 	return (RestoreAbsttl)(c)
 }
 
 func (c SRestoreSerializedValue) Absttl() SRestoreAbsttl {
-	c.cs = append(c.cs, "ABSTTL")
+	c.cs.s = append(c.cs.s, "ABSTTL")
 	return (SRestoreAbsttl)(c)
 }
 
 func (c RestoreSerializedValue) Idletime(seconds int64) RestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (RestoreIdletime)(c)
 }
 
 func (c SRestoreSerializedValue) Idletime(seconds int64) SRestoreIdletime {
-	c.cs = append(c.cs, "IDLETIME", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "IDLETIME", strconv.FormatInt(seconds, 10))
 	return (SRestoreIdletime)(c)
 }
 
 func (c RestoreSerializedValue) Freq(frequency int64) RestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (RestoreFreq)(c)
 }
 
 func (c SRestoreSerializedValue) Freq(frequency int64) SRestoreFreq {
-	c.cs = append(c.cs, "FREQ", strconv.FormatInt(frequency, 10))
+	c.cs.s = append(c.cs.s, "FREQ", strconv.FormatInt(frequency, 10))
 	return (SRestoreFreq)(c)
 }
 
@@ -31957,12 +33117,12 @@ type RestoreTtl Completed
 type SRestoreTtl SCompleted
 
 func (c RestoreTtl) SerializedValue(serializedValue string) RestoreSerializedValue {
-	c.cs = append(c.cs, serializedValue)
+	c.cs.s = append(c.cs.s, serializedValue)
 	return (RestoreSerializedValue)(c)
 }
 
 func (c SRestoreTtl) SerializedValue(serializedValue string) SRestoreSerializedValue {
-	c.cs = append(c.cs, serializedValue)
+	c.cs.s = append(c.cs.s, serializedValue)
 	return (SRestoreSerializedValue)(c)
 }
 
@@ -31970,12 +33130,16 @@ type Role Completed
 
 type SRole SCompleted
 
-func (b *Builder) Role() Role {
-	return Role{cs: append(b.get(), "ROLE"), ks: InitSlot}
+func (b *Builder) Role() (c Role) {
+	c = Role{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ROLE")
+	return c
 }
 
-func (b *SBuilder) Role() SRole {
-	return SRole{cs: append(b.get(), "ROLE"), ks: InitSlot}
+func (b *SBuilder) Role() (c SRole) {
+	c = SRole{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ROLE")
+	return c
 }
 
 func (c Role) Build() Completed {
@@ -31990,22 +33154,26 @@ type Rpop Completed
 
 type SRpop SCompleted
 
-func (b *Builder) Rpop() Rpop {
-	return Rpop{cs: append(b.get(), "RPOP"), ks: InitSlot}
+func (b *Builder) Rpop() (c Rpop) {
+	c = Rpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPOP")
+	return c
 }
 
-func (b *SBuilder) Rpop() SRpop {
-	return SRpop{cs: append(b.get(), "RPOP"), ks: InitSlot}
+func (b *SBuilder) Rpop() (c SRpop) {
+	c = SRpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPOP")
+	return c
 }
 
 func (c Rpop) Key(key string) RpopKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RpopKey)(c)
 }
 
 func (c SRpop) Key(key string) SRpopKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRpopKey)(c)
 }
 
@@ -32026,12 +33194,12 @@ type RpopKey Completed
 type SRpopKey SCompleted
 
 func (c RpopKey) Count(count int64) RpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (RpopCount)(c)
 }
 
 func (c SRpopKey) Count(count int64) SRpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SRpopCount)(c)
 }
 
@@ -32047,22 +33215,26 @@ type Rpoplpush Completed
 
 type SRpoplpush SCompleted
 
-func (b *Builder) Rpoplpush() Rpoplpush {
-	return Rpoplpush{cs: append(b.get(), "RPOPLPUSH"), ks: InitSlot}
+func (b *Builder) Rpoplpush() (c Rpoplpush) {
+	c = Rpoplpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPOPLPUSH")
+	return c
 }
 
-func (b *SBuilder) Rpoplpush() SRpoplpush {
-	return SRpoplpush{cs: append(b.get(), "RPOPLPUSH"), ks: InitSlot}
+func (b *SBuilder) Rpoplpush() (c SRpoplpush) {
+	c = SRpoplpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPOPLPUSH")
+	return c
 }
 
 func (c Rpoplpush) Source(source string) RpoplpushSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (RpoplpushSource)(c)
 }
 
 func (c SRpoplpush) Source(source string) SRpoplpushSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SRpoplpushSource)(c)
 }
 
@@ -32083,13 +33255,13 @@ type RpoplpushSource Completed
 type SRpoplpushSource SCompleted
 
 func (c RpoplpushSource) Destination(destination string) RpoplpushDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (RpoplpushDestination)(c)
 }
 
 func (c SRpoplpushSource) Destination(destination string) SRpoplpushDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SRpoplpushDestination)(c)
 }
 
@@ -32097,22 +33269,26 @@ type Rpush Completed
 
 type SRpush SCompleted
 
-func (b *Builder) Rpush() Rpush {
-	return Rpush{cs: append(b.get(), "RPUSH"), ks: InitSlot}
+func (b *Builder) Rpush() (c Rpush) {
+	c = Rpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPUSH")
+	return c
 }
 
-func (b *SBuilder) Rpush() SRpush {
-	return SRpush{cs: append(b.get(), "RPUSH"), ks: InitSlot}
+func (b *SBuilder) Rpush() (c SRpush) {
+	c = SRpush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPUSH")
+	return c
 }
 
 func (c Rpush) Key(key string) RpushKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RpushKey)(c)
 }
 
 func (c SRpush) Key(key string) SRpushKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRpushKey)(c)
 }
 
@@ -32121,12 +33297,12 @@ type RpushElement Completed
 type SRpushElement SCompleted
 
 func (c RpushElement) Element(element ...string) RpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
 func (c SRpushElement) Element(element ...string) SRpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
@@ -32143,12 +33319,12 @@ type RpushKey Completed
 type SRpushKey SCompleted
 
 func (c RpushKey) Element(element ...string) RpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (RpushElement)(c)
 }
 
 func (c SRpushKey) Element(element ...string) SRpushElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (SRpushElement)(c)
 }
 
@@ -32156,22 +33332,26 @@ type Rpushx Completed
 
 type SRpushx SCompleted
 
-func (b *Builder) Rpushx() Rpushx {
-	return Rpushx{cs: append(b.get(), "RPUSHX"), ks: InitSlot}
+func (b *Builder) Rpushx() (c Rpushx) {
+	c = Rpushx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPUSHX")
+	return c
 }
 
-func (b *SBuilder) Rpushx() SRpushx {
-	return SRpushx{cs: append(b.get(), "RPUSHX"), ks: InitSlot}
+func (b *SBuilder) Rpushx() (c SRpushx) {
+	c = SRpushx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "RPUSHX")
+	return c
 }
 
 func (c Rpushx) Key(key string) RpushxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (RpushxKey)(c)
 }
 
 func (c SRpushx) Key(key string) SRpushxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SRpushxKey)(c)
 }
 
@@ -32180,12 +33360,12 @@ type RpushxElement Completed
 type SRpushxElement SCompleted
 
 func (c RpushxElement) Element(element ...string) RpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
 func (c SRpushxElement) Element(element ...string) SRpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return c
 }
 
@@ -32202,12 +33382,12 @@ type RpushxKey Completed
 type SRpushxKey SCompleted
 
 func (c RpushxKey) Element(element ...string) RpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (RpushxElement)(c)
 }
 
 func (c SRpushxKey) Element(element ...string) SRpushxElement {
-	c.cs = append(c.cs, element...)
+	c.cs.s = append(c.cs.s, element...)
 	return (SRpushxElement)(c)
 }
 
@@ -32215,22 +33395,26 @@ type Sadd Completed
 
 type SSadd SCompleted
 
-func (b *Builder) Sadd() Sadd {
-	return Sadd{cs: append(b.get(), "SADD"), ks: InitSlot}
+func (b *Builder) Sadd() (c Sadd) {
+	c = Sadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SADD")
+	return c
 }
 
-func (b *SBuilder) Sadd() SSadd {
-	return SSadd{cs: append(b.get(), "SADD"), ks: InitSlot}
+func (b *SBuilder) Sadd() (c SSadd) {
+	c = SSadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SADD")
+	return c
 }
 
 func (c Sadd) Key(key string) SaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SaddKey)(c)
 }
 
 func (c SSadd) Key(key string) SSaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSaddKey)(c)
 }
 
@@ -32239,12 +33423,12 @@ type SaddKey Completed
 type SSaddKey SCompleted
 
 func (c SaddKey) Member(member ...string) SaddMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SaddMember)(c)
 }
 
 func (c SSaddKey) Member(member ...string) SSaddMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SSaddMember)(c)
 }
 
@@ -32253,12 +33437,12 @@ type SaddMember Completed
 type SSaddMember SCompleted
 
 func (c SaddMember) Member(member ...string) SaddMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SSaddMember) Member(member ...string) SSaddMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -32274,12 +33458,16 @@ type Save Completed
 
 type SSave SCompleted
 
-func (b *Builder) Save() Save {
-	return Save{cs: append(b.get(), "SAVE"), ks: InitSlot}
+func (b *Builder) Save() (c Save) {
+	c = Save{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SAVE")
+	return c
 }
 
-func (b *SBuilder) Save() SSave {
-	return SSave{cs: append(b.get(), "SAVE"), ks: InitSlot}
+func (b *SBuilder) Save() (c SSave) {
+	c = SSave{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SAVE")
+	return c
 }
 
 func (c Save) Build() Completed {
@@ -32294,21 +33482,25 @@ type Scan Completed
 
 type SScan SCompleted
 
-func (b *Builder) Scan() Scan {
-	return Scan{cs: append(b.get(), "SCAN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Scan() (c Scan) {
+	c = Scan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SCAN")
+	return c
 }
 
-func (b *SBuilder) Scan() SScan {
-	return SScan{cs: append(b.get(), "SCAN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Scan() (c SScan) {
+	c = SScan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SCAN")
+	return c
 }
 
 func (c Scan) Cursor(cursor int64) ScanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (ScanCursor)(c)
 }
 
 func (c SScan) Cursor(cursor int64) SScanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (SScanCursor)(c)
 }
 
@@ -32317,12 +33509,12 @@ type ScanCount Completed
 type SScanCount SCompleted
 
 func (c ScanCount) Type(typ string) ScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (ScanType)(c)
 }
 
 func (c SScanCount) Type(typ string) SScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (SScanType)(c)
 }
 
@@ -32339,32 +33531,32 @@ type ScanCursor Completed
 type SScanCursor SCompleted
 
 func (c ScanCursor) Match(pattern string) ScanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (ScanMatch)(c)
 }
 
 func (c SScanCursor) Match(pattern string) SScanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (SScanMatch)(c)
 }
 
 func (c ScanCursor) Count(count int64) ScanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ScanCount)(c)
 }
 
 func (c SScanCursor) Count(count int64) SScanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SScanCount)(c)
 }
 
 func (c ScanCursor) Type(typ string) ScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (ScanType)(c)
 }
 
 func (c SScanCursor) Type(typ string) SScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (SScanType)(c)
 }
 
@@ -32381,22 +33573,22 @@ type ScanMatch Completed
 type SScanMatch SCompleted
 
 func (c ScanMatch) Count(count int64) ScanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ScanCount)(c)
 }
 
 func (c SScanMatch) Count(count int64) SScanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SScanCount)(c)
 }
 
 func (c ScanMatch) Type(typ string) ScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (ScanType)(c)
 }
 
 func (c SScanMatch) Type(typ string) SScanType {
-	c.cs = append(c.cs, "TYPE", typ)
+	c.cs.s = append(c.cs.s, "TYPE", typ)
 	return (SScanType)(c)
 }
 
@@ -32424,22 +33616,26 @@ type Scard Completed
 
 type SScard SCompleted
 
-func (b *Builder) Scard() Scard {
-	return Scard{cs: append(b.get(), "SCARD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Scard() (c Scard) {
+	c = Scard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SCARD")
+	return c
 }
 
-func (b *SBuilder) Scard() SScard {
-	return SScard{cs: append(b.get(), "SCARD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Scard() (c SScard) {
+	c = SScard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SCARD")
+	return c
 }
 
 func (c Scard) Key(key string) ScardKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ScardKey)(c)
 }
 
 func (c SScard) Key(key string) SScardKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SScardKey)(c)
 }
 
@@ -32467,41 +33663,45 @@ type ScriptDebug Completed
 
 type SScriptDebug SCompleted
 
-func (b *Builder) ScriptDebug() ScriptDebug {
-	return ScriptDebug{cs: append(b.get(), "SCRIPT", "DEBUG"), ks: InitSlot}
+func (b *Builder) ScriptDebug() (c ScriptDebug) {
+	c = ScriptDebug{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "DEBUG")
+	return c
 }
 
-func (b *SBuilder) ScriptDebug() SScriptDebug {
-	return SScriptDebug{cs: append(b.get(), "SCRIPT", "DEBUG"), ks: InitSlot}
+func (b *SBuilder) ScriptDebug() (c SScriptDebug) {
+	c = SScriptDebug{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "DEBUG")
+	return c
 }
 
 func (c ScriptDebug) Yes() ScriptDebugModeYes {
-	c.cs = append(c.cs, "YES")
+	c.cs.s = append(c.cs.s, "YES")
 	return (ScriptDebugModeYes)(c)
 }
 
 func (c SScriptDebug) Yes() SScriptDebugModeYes {
-	c.cs = append(c.cs, "YES")
+	c.cs.s = append(c.cs.s, "YES")
 	return (SScriptDebugModeYes)(c)
 }
 
 func (c ScriptDebug) Sync() ScriptDebugModeSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (ScriptDebugModeSync)(c)
 }
 
 func (c SScriptDebug) Sync() SScriptDebugModeSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (SScriptDebugModeSync)(c)
 }
 
 func (c ScriptDebug) No() ScriptDebugModeNo {
-	c.cs = append(c.cs, "NO")
+	c.cs.s = append(c.cs.s, "NO")
 	return (ScriptDebugModeNo)(c)
 }
 
 func (c SScriptDebug) No() SScriptDebugModeNo {
-	c.cs = append(c.cs, "NO")
+	c.cs.s = append(c.cs.s, "NO")
 	return (SScriptDebugModeNo)(c)
 }
 
@@ -32545,21 +33745,25 @@ type ScriptExists Completed
 
 type SScriptExists SCompleted
 
-func (b *Builder) ScriptExists() ScriptExists {
-	return ScriptExists{cs: append(b.get(), "SCRIPT", "EXISTS"), ks: InitSlot}
+func (b *Builder) ScriptExists() (c ScriptExists) {
+	c = ScriptExists{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "EXISTS")
+	return c
 }
 
-func (b *SBuilder) ScriptExists() SScriptExists {
-	return SScriptExists{cs: append(b.get(), "SCRIPT", "EXISTS"), ks: InitSlot}
+func (b *SBuilder) ScriptExists() (c SScriptExists) {
+	c = SScriptExists{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "EXISTS")
+	return c
 }
 
 func (c ScriptExists) Sha1(sha1 ...string) ScriptExistsSha1 {
-	c.cs = append(c.cs, sha1...)
+	c.cs.s = append(c.cs.s, sha1...)
 	return (ScriptExistsSha1)(c)
 }
 
 func (c SScriptExists) Sha1(sha1 ...string) SScriptExistsSha1 {
-	c.cs = append(c.cs, sha1...)
+	c.cs.s = append(c.cs.s, sha1...)
 	return (SScriptExistsSha1)(c)
 }
 
@@ -32568,12 +33772,12 @@ type ScriptExistsSha1 Completed
 type SScriptExistsSha1 SCompleted
 
 func (c ScriptExistsSha1) Sha1(sha1 ...string) ScriptExistsSha1 {
-	c.cs = append(c.cs, sha1...)
+	c.cs.s = append(c.cs.s, sha1...)
 	return c
 }
 
 func (c SScriptExistsSha1) Sha1(sha1 ...string) SScriptExistsSha1 {
-	c.cs = append(c.cs, sha1...)
+	c.cs.s = append(c.cs.s, sha1...)
 	return c
 }
 
@@ -32589,31 +33793,35 @@ type ScriptFlush Completed
 
 type SScriptFlush SCompleted
 
-func (b *Builder) ScriptFlush() ScriptFlush {
-	return ScriptFlush{cs: append(b.get(), "SCRIPT", "FLUSH"), ks: InitSlot}
+func (b *Builder) ScriptFlush() (c ScriptFlush) {
+	c = ScriptFlush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "FLUSH")
+	return c
 }
 
-func (b *SBuilder) ScriptFlush() SScriptFlush {
-	return SScriptFlush{cs: append(b.get(), "SCRIPT", "FLUSH"), ks: InitSlot}
+func (b *SBuilder) ScriptFlush() (c SScriptFlush) {
+	c = SScriptFlush{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "FLUSH")
+	return c
 }
 
 func (c ScriptFlush) Async() ScriptFlushAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (ScriptFlushAsync)(c)
 }
 
 func (c SScriptFlush) Async() SScriptFlushAsync {
-	c.cs = append(c.cs, "ASYNC")
+	c.cs.s = append(c.cs.s, "ASYNC")
 	return (SScriptFlushAsync)(c)
 }
 
 func (c ScriptFlush) Sync() ScriptFlushAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (ScriptFlushAsyncSync)(c)
 }
 
 func (c SScriptFlush) Sync() SScriptFlushAsyncSync {
-	c.cs = append(c.cs, "SYNC")
+	c.cs.s = append(c.cs.s, "SYNC")
 	return (SScriptFlushAsyncSync)(c)
 }
 
@@ -32653,12 +33861,16 @@ type ScriptKill Completed
 
 type SScriptKill SCompleted
 
-func (b *Builder) ScriptKill() ScriptKill {
-	return ScriptKill{cs: append(b.get(), "SCRIPT", "KILL"), ks: InitSlot}
+func (b *Builder) ScriptKill() (c ScriptKill) {
+	c = ScriptKill{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "KILL")
+	return c
 }
 
-func (b *SBuilder) ScriptKill() SScriptKill {
-	return SScriptKill{cs: append(b.get(), "SCRIPT", "KILL"), ks: InitSlot}
+func (b *SBuilder) ScriptKill() (c SScriptKill) {
+	c = SScriptKill{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "KILL")
+	return c
 }
 
 func (c ScriptKill) Build() Completed {
@@ -32673,21 +33885,25 @@ type ScriptLoad Completed
 
 type SScriptLoad SCompleted
 
-func (b *Builder) ScriptLoad() ScriptLoad {
-	return ScriptLoad{cs: append(b.get(), "SCRIPT", "LOAD"), ks: InitSlot}
+func (b *Builder) ScriptLoad() (c ScriptLoad) {
+	c = ScriptLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "LOAD")
+	return c
 }
 
-func (b *SBuilder) ScriptLoad() SScriptLoad {
-	return SScriptLoad{cs: append(b.get(), "SCRIPT", "LOAD"), ks: InitSlot}
+func (b *SBuilder) ScriptLoad() (c SScriptLoad) {
+	c = SScriptLoad{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SCRIPT", "LOAD")
+	return c
 }
 
 func (c ScriptLoad) Script(script string) ScriptLoadScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (ScriptLoadScript)(c)
 }
 
 func (c SScriptLoad) Script(script string) SScriptLoadScript {
-	c.cs = append(c.cs, script)
+	c.cs.s = append(c.cs.s, script)
 	return (SScriptLoadScript)(c)
 }
 
@@ -32707,16 +33923,20 @@ type Sdiff Completed
 
 type SSdiff SCompleted
 
-func (b *Builder) Sdiff() Sdiff {
-	return Sdiff{cs: append(b.get(), "SDIFF"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sdiff() (c Sdiff) {
+	c = Sdiff{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SDIFF")
+	return c
 }
 
-func (b *SBuilder) Sdiff() SSdiff {
-	return SSdiff{cs: append(b.get(), "SDIFF"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sdiff() (c SSdiff) {
+	c = SSdiff{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SDIFF")
+	return c
 }
 
 func (c Sdiff) Key(key ...string) SdiffKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SdiffKey)(c)
 }
 
@@ -32724,7 +33944,7 @@ func (c SSdiff) Key(key ...string) SSdiffKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSdiffKey)(c)
 }
 
@@ -32733,7 +33953,7 @@ type SdiffKey Completed
 type SSdiffKey SCompleted
 
 func (c SdiffKey) Key(key ...string) SdiffKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -32741,7 +33961,7 @@ func (c SSdiffKey) Key(key ...string) SSdiffKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -32757,22 +33977,26 @@ type Sdiffstore Completed
 
 type SSdiffstore SCompleted
 
-func (b *Builder) Sdiffstore() Sdiffstore {
-	return Sdiffstore{cs: append(b.get(), "SDIFFSTORE"), ks: InitSlot}
+func (b *Builder) Sdiffstore() (c Sdiffstore) {
+	c = Sdiffstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SDIFFSTORE")
+	return c
 }
 
-func (b *SBuilder) Sdiffstore() SSdiffstore {
-	return SSdiffstore{cs: append(b.get(), "SDIFFSTORE"), ks: InitSlot}
+func (b *SBuilder) Sdiffstore() (c SSdiffstore) {
+	c = SSdiffstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SDIFFSTORE")
+	return c
 }
 
 func (c Sdiffstore) Destination(destination string) SdiffstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SdiffstoreDestination)(c)
 }
 
 func (c SSdiffstore) Destination(destination string) SSdiffstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SSdiffstoreDestination)(c)
 }
 
@@ -32781,7 +34005,7 @@ type SdiffstoreDestination Completed
 type SSdiffstoreDestination SCompleted
 
 func (c SdiffstoreDestination) Key(key ...string) SdiffstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SdiffstoreKey)(c)
 }
 
@@ -32789,7 +34013,7 @@ func (c SSdiffstoreDestination) Key(key ...string) SSdiffstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSdiffstoreKey)(c)
 }
 
@@ -32798,7 +34022,7 @@ type SdiffstoreKey Completed
 type SSdiffstoreKey SCompleted
 
 func (c SdiffstoreKey) Key(key ...string) SdiffstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -32806,7 +34030,7 @@ func (c SSdiffstoreKey) Key(key ...string) SSdiffstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -32822,21 +34046,25 @@ type Select Completed
 
 type SSelect SCompleted
 
-func (b *Builder) Select() Select {
-	return Select{cs: append(b.get(), "SELECT"), ks: InitSlot}
+func (b *Builder) Select() (c Select) {
+	c = Select{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SELECT")
+	return c
 }
 
-func (b *SBuilder) Select() SSelect {
-	return SSelect{cs: append(b.get(), "SELECT"), ks: InitSlot}
+func (b *SBuilder) Select() (c SSelect) {
+	c = SSelect{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SELECT")
+	return c
 }
 
 func (c Select) Index(index int64) SelectIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SelectIndex)(c)
 }
 
 func (c SSelect) Index(index int64) SSelectIndex {
-	c.cs = append(c.cs, strconv.FormatInt(index, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index, 10))
 	return (SSelectIndex)(c)
 }
 
@@ -32856,22 +34084,26 @@ type Set Completed
 
 type SSet SCompleted
 
-func (b *Builder) Set() Set {
-	return Set{cs: append(b.get(), "SET"), ks: InitSlot}
+func (b *Builder) Set() (c Set) {
+	c = Set{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SET")
+	return c
 }
 
-func (b *SBuilder) Set() SSet {
-	return SSet{cs: append(b.get(), "SET"), ks: InitSlot}
+func (b *SBuilder) Set() (c SSet) {
+	c = SSet{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SET")
+	return c
 }
 
 func (c Set) Key(key string) SetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SetKey)(c)
 }
 
 func (c SSet) Key(key string) SSetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSetKey)(c)
 }
 
@@ -32880,12 +34112,12 @@ type SetConditionNx Completed
 type SSetConditionNx SCompleted
 
 func (c SetConditionNx) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetConditionNx) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -32902,12 +34134,12 @@ type SetConditionXx Completed
 type SSetConditionXx SCompleted
 
 func (c SetConditionXx) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetConditionXx) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -32924,32 +34156,32 @@ type SetExpirationExSeconds Completed
 type SSetExpirationExSeconds SCompleted
 
 func (c SetExpirationExSeconds) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetExpirationExSeconds) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetExpirationExSeconds) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetExpirationExSeconds) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetExpirationExSeconds) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetExpirationExSeconds) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -32966,32 +34198,32 @@ type SetExpirationExatTimestamp Completed
 type SSetExpirationExatTimestamp SCompleted
 
 func (c SetExpirationExatTimestamp) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetExpirationExatTimestamp) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetExpirationExatTimestamp) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetExpirationExatTimestamp) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetExpirationExatTimestamp) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetExpirationExatTimestamp) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -33008,32 +34240,32 @@ type SetExpirationKeepttl Completed
 type SSetExpirationKeepttl SCompleted
 
 func (c SetExpirationKeepttl) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetExpirationKeepttl) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetExpirationKeepttl) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetExpirationKeepttl) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetExpirationKeepttl) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetExpirationKeepttl) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -33050,32 +34282,32 @@ type SetExpirationPxMilliseconds Completed
 type SSetExpirationPxMilliseconds SCompleted
 
 func (c SetExpirationPxMilliseconds) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetExpirationPxMilliseconds) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetExpirationPxMilliseconds) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetExpirationPxMilliseconds) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetExpirationPxMilliseconds) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetExpirationPxMilliseconds) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -33092,32 +34324,32 @@ type SetExpirationPxatMillisecondsTimestamp Completed
 type SSetExpirationPxatMillisecondsTimestamp SCompleted
 
 func (c SetExpirationPxatMillisecondsTimestamp) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetExpirationPxatMillisecondsTimestamp) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetExpirationPxatMillisecondsTimestamp) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetExpirationPxatMillisecondsTimestamp) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetExpirationPxatMillisecondsTimestamp) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetExpirationPxatMillisecondsTimestamp) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -33146,12 +34378,12 @@ type SetKey Completed
 type SSetKey SCompleted
 
 func (c SetKey) Value(value string) SetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SetValue)(c)
 }
 
 func (c SSetKey) Value(value string) SSetValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SSetValue)(c)
 }
 
@@ -33160,82 +34392,82 @@ type SetValue Completed
 type SSetValue SCompleted
 
 func (c SetValue) ExSeconds(seconds int64) SetExpirationExSeconds {
-	c.cs = append(c.cs, "EX", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
 	return (SetExpirationExSeconds)(c)
 }
 
 func (c SSetValue) ExSeconds(seconds int64) SSetExpirationExSeconds {
-	c.cs = append(c.cs, "EX", strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
 	return (SSetExpirationExSeconds)(c)
 }
 
 func (c SetValue) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
-	c.cs = append(c.cs, "PX", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
 	return (SetExpirationPxMilliseconds)(c)
 }
 
 func (c SSetValue) PxMilliseconds(milliseconds int64) SSetExpirationPxMilliseconds {
-	c.cs = append(c.cs, "PX", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
 	return (SSetExpirationPxMilliseconds)(c)
 }
 
 func (c SetValue) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
-	c.cs = append(c.cs, "EXAT", strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
 	return (SetExpirationExatTimestamp)(c)
 }
 
 func (c SSetValue) ExatTimestamp(timestamp int64) SSetExpirationExatTimestamp {
-	c.cs = append(c.cs, "EXAT", strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
 	return (SSetExpirationExatTimestamp)(c)
 }
 
 func (c SetValue) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
-	c.cs = append(c.cs, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
 	return (SetExpirationPxatMillisecondsTimestamp)(c)
 }
 
 func (c SSetValue) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SSetExpirationPxatMillisecondsTimestamp {
-	c.cs = append(c.cs, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
+	c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
 	return (SSetExpirationPxatMillisecondsTimestamp)(c)
 }
 
 func (c SetValue) Keepttl() SetExpirationKeepttl {
-	c.cs = append(c.cs, "KEEPTTL")
+	c.cs.s = append(c.cs.s, "KEEPTTL")
 	return (SetExpirationKeepttl)(c)
 }
 
 func (c SSetValue) Keepttl() SSetExpirationKeepttl {
-	c.cs = append(c.cs, "KEEPTTL")
+	c.cs.s = append(c.cs.s, "KEEPTTL")
 	return (SSetExpirationKeepttl)(c)
 }
 
 func (c SetValue) Nx() SetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SetConditionNx)(c)
 }
 
 func (c SSetValue) Nx() SSetConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SSetConditionNx)(c)
 }
 
 func (c SetValue) Xx() SetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SetConditionXx)(c)
 }
 
 func (c SSetValue) Xx() SSetConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SSetConditionXx)(c)
 }
 
 func (c SetValue) Get() SetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SetGet)(c)
 }
 
 func (c SSetValue) Get() SSetGet {
-	c.cs = append(c.cs, "GET")
+	c.cs.s = append(c.cs.s, "GET")
 	return (SSetGet)(c)
 }
 
@@ -33251,22 +34483,26 @@ type Setbit Completed
 
 type SSetbit SCompleted
 
-func (b *Builder) Setbit() Setbit {
-	return Setbit{cs: append(b.get(), "SETBIT"), ks: InitSlot}
+func (b *Builder) Setbit() (c Setbit) {
+	c = Setbit{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETBIT")
+	return c
 }
 
-func (b *SBuilder) Setbit() SSetbit {
-	return SSetbit{cs: append(b.get(), "SETBIT"), ks: InitSlot}
+func (b *SBuilder) Setbit() (c SSetbit) {
+	c = SSetbit{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETBIT")
+	return c
 }
 
 func (c Setbit) Key(key string) SetbitKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SetbitKey)(c)
 }
 
 func (c SSetbit) Key(key string) SSetbitKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSetbitKey)(c)
 }
 
@@ -33275,12 +34511,12 @@ type SetbitKey Completed
 type SSetbitKey SCompleted
 
 func (c SetbitKey) Offset(offset int64) SetbitOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SetbitOffset)(c)
 }
 
 func (c SSetbitKey) Offset(offset int64) SSetbitOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SSetbitOffset)(c)
 }
 
@@ -33289,12 +34525,12 @@ type SetbitOffset Completed
 type SSetbitOffset SCompleted
 
 func (c SetbitOffset) Value(value int64) SetbitValue {
-	c.cs = append(c.cs, strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(value, 10))
 	return (SetbitValue)(c)
 }
 
 func (c SSetbitOffset) Value(value int64) SSetbitValue {
-	c.cs = append(c.cs, strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(value, 10))
 	return (SSetbitValue)(c)
 }
 
@@ -33314,22 +34550,26 @@ type Setex Completed
 
 type SSetex SCompleted
 
-func (b *Builder) Setex() Setex {
-	return Setex{cs: append(b.get(), "SETEX"), ks: InitSlot}
+func (b *Builder) Setex() (c Setex) {
+	c = Setex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETEX")
+	return c
 }
 
-func (b *SBuilder) Setex() SSetex {
-	return SSetex{cs: append(b.get(), "SETEX"), ks: InitSlot}
+func (b *SBuilder) Setex() (c SSetex) {
+	c = SSetex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETEX")
+	return c
 }
 
 func (c Setex) Key(key string) SetexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SetexKey)(c)
 }
 
 func (c SSetex) Key(key string) SSetexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSetexKey)(c)
 }
 
@@ -33338,12 +34578,12 @@ type SetexKey Completed
 type SSetexKey SCompleted
 
 func (c SetexKey) Seconds(seconds int64) SetexSeconds {
-	c.cs = append(c.cs, strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
 	return (SetexSeconds)(c)
 }
 
 func (c SSetexKey) Seconds(seconds int64) SSetexSeconds {
-	c.cs = append(c.cs, strconv.FormatInt(seconds, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
 	return (SSetexSeconds)(c)
 }
 
@@ -33352,12 +34592,12 @@ type SetexSeconds Completed
 type SSetexSeconds SCompleted
 
 func (c SetexSeconds) Value(value string) SetexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SetexValue)(c)
 }
 
 func (c SSetexSeconds) Value(value string) SSetexValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SSetexValue)(c)
 }
 
@@ -33377,22 +34617,26 @@ type Setnx Completed
 
 type SSetnx SCompleted
 
-func (b *Builder) Setnx() Setnx {
-	return Setnx{cs: append(b.get(), "SETNX"), ks: InitSlot}
+func (b *Builder) Setnx() (c Setnx) {
+	c = Setnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETNX")
+	return c
 }
 
-func (b *SBuilder) Setnx() SSetnx {
-	return SSetnx{cs: append(b.get(), "SETNX"), ks: InitSlot}
+func (b *SBuilder) Setnx() (c SSetnx) {
+	c = SSetnx{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETNX")
+	return c
 }
 
 func (c Setnx) Key(key string) SetnxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SetnxKey)(c)
 }
 
 func (c SSetnx) Key(key string) SSetnxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSetnxKey)(c)
 }
 
@@ -33401,12 +34645,12 @@ type SetnxKey Completed
 type SSetnxKey SCompleted
 
 func (c SetnxKey) Value(value string) SetnxValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SetnxValue)(c)
 }
 
 func (c SSetnxKey) Value(value string) SSetnxValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SSetnxValue)(c)
 }
 
@@ -33426,22 +34670,26 @@ type Setrange Completed
 
 type SSetrange SCompleted
 
-func (b *Builder) Setrange() Setrange {
-	return Setrange{cs: append(b.get(), "SETRANGE"), ks: InitSlot}
+func (b *Builder) Setrange() (c Setrange) {
+	c = Setrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETRANGE")
+	return c
 }
 
-func (b *SBuilder) Setrange() SSetrange {
-	return SSetrange{cs: append(b.get(), "SETRANGE"), ks: InitSlot}
+func (b *SBuilder) Setrange() (c SSetrange) {
+	c = SSetrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SETRANGE")
+	return c
 }
 
 func (c Setrange) Key(key string) SetrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SetrangeKey)(c)
 }
 
 func (c SSetrange) Key(key string) SSetrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSetrangeKey)(c)
 }
 
@@ -33450,12 +34698,12 @@ type SetrangeKey Completed
 type SSetrangeKey SCompleted
 
 func (c SetrangeKey) Offset(offset int64) SetrangeOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SetrangeOffset)(c)
 }
 
 func (c SSetrangeKey) Offset(offset int64) SSetrangeOffset {
-	c.cs = append(c.cs, strconv.FormatInt(offset, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
 	return (SSetrangeOffset)(c)
 }
 
@@ -33464,12 +34712,12 @@ type SetrangeOffset Completed
 type SSetrangeOffset SCompleted
 
 func (c SetrangeOffset) Value(value string) SetrangeValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SetrangeValue)(c)
 }
 
 func (c SSetrangeOffset) Value(value string) SSetrangeValue {
-	c.cs = append(c.cs, value)
+	c.cs.s = append(c.cs.s, value)
 	return (SSetrangeValue)(c)
 }
 
@@ -33489,31 +34737,35 @@ type Shutdown Completed
 
 type SShutdown SCompleted
 
-func (b *Builder) Shutdown() Shutdown {
-	return Shutdown{cs: append(b.get(), "SHUTDOWN"), ks: InitSlot}
+func (b *Builder) Shutdown() (c Shutdown) {
+	c = Shutdown{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SHUTDOWN")
+	return c
 }
 
-func (b *SBuilder) Shutdown() SShutdown {
-	return SShutdown{cs: append(b.get(), "SHUTDOWN"), ks: InitSlot}
+func (b *SBuilder) Shutdown() (c SShutdown) {
+	c = SShutdown{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SHUTDOWN")
+	return c
 }
 
 func (c Shutdown) Nosave() ShutdownSaveModeNosave {
-	c.cs = append(c.cs, "NOSAVE")
+	c.cs.s = append(c.cs.s, "NOSAVE")
 	return (ShutdownSaveModeNosave)(c)
 }
 
 func (c SShutdown) Nosave() SShutdownSaveModeNosave {
-	c.cs = append(c.cs, "NOSAVE")
+	c.cs.s = append(c.cs.s, "NOSAVE")
 	return (SShutdownSaveModeNosave)(c)
 }
 
 func (c Shutdown) Save() ShutdownSaveModeSave {
-	c.cs = append(c.cs, "SAVE")
+	c.cs.s = append(c.cs.s, "SAVE")
 	return (ShutdownSaveModeSave)(c)
 }
 
 func (c SShutdown) Save() SShutdownSaveModeSave {
-	c.cs = append(c.cs, "SAVE")
+	c.cs.s = append(c.cs.s, "SAVE")
 	return (SShutdownSaveModeSave)(c)
 }
 
@@ -33553,16 +34805,20 @@ type Sinter Completed
 
 type SSinter SCompleted
 
-func (b *Builder) Sinter() Sinter {
-	return Sinter{cs: append(b.get(), "SINTER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sinter() (c Sinter) {
+	c = Sinter{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SINTER")
+	return c
 }
 
-func (b *SBuilder) Sinter() SSinter {
-	return SSinter{cs: append(b.get(), "SINTER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sinter() (c SSinter) {
+	c = SSinter{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SINTER")
+	return c
 }
 
 func (c Sinter) Key(key ...string) SinterKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SinterKey)(c)
 }
 
@@ -33570,7 +34826,7 @@ func (c SSinter) Key(key ...string) SSinterKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSinterKey)(c)
 }
 
@@ -33579,7 +34835,7 @@ type SinterKey Completed
 type SSinterKey SCompleted
 
 func (c SinterKey) Key(key ...string) SinterKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -33587,7 +34843,7 @@ func (c SSinterKey) Key(key ...string) SSinterKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -33603,21 +34859,25 @@ type Sintercard Completed
 
 type SSintercard SCompleted
 
-func (b *Builder) Sintercard() Sintercard {
-	return Sintercard{cs: append(b.get(), "SINTERCARD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sintercard() (c Sintercard) {
+	c = Sintercard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SINTERCARD")
+	return c
 }
 
-func (b *SBuilder) Sintercard() SSintercard {
-	return SSintercard{cs: append(b.get(), "SINTERCARD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sintercard() (c SSintercard) {
+	c = SSintercard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SINTERCARD")
+	return c
 }
 
 func (c Sintercard) Numkeys(numkeys int64) SintercardNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SintercardNumkeys)(c)
 }
 
 func (c SSintercard) Numkeys(numkeys int64) SSintercardNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SSintercardNumkeys)(c)
 }
 
@@ -33626,7 +34886,7 @@ type SintercardKey Completed
 type SSintercardKey SCompleted
 
 func (c SintercardKey) Key(key ...string) SintercardKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -33634,17 +34894,17 @@ func (c SSintercardKey) Key(key ...string) SSintercardKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c SintercardKey) Limit(limit int64) SintercardLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(limit, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(limit, 10))
 	return (SintercardLimit)(c)
 }
 
 func (c SSintercardKey) Limit(limit int64) SSintercardLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(limit, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(limit, 10))
 	return (SSintercardLimit)(c)
 }
 
@@ -33673,7 +34933,7 @@ type SintercardNumkeys Completed
 type SSintercardNumkeys SCompleted
 
 func (c SintercardNumkeys) Key(key ...string) SintercardKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SintercardKey)(c)
 }
 
@@ -33681,7 +34941,7 @@ func (c SSintercardNumkeys) Key(key ...string) SSintercardKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSintercardKey)(c)
 }
 
@@ -33689,22 +34949,26 @@ type Sinterstore Completed
 
 type SSinterstore SCompleted
 
-func (b *Builder) Sinterstore() Sinterstore {
-	return Sinterstore{cs: append(b.get(), "SINTERSTORE"), ks: InitSlot}
+func (b *Builder) Sinterstore() (c Sinterstore) {
+	c = Sinterstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SINTERSTORE")
+	return c
 }
 
-func (b *SBuilder) Sinterstore() SSinterstore {
-	return SSinterstore{cs: append(b.get(), "SINTERSTORE"), ks: InitSlot}
+func (b *SBuilder) Sinterstore() (c SSinterstore) {
+	c = SSinterstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SINTERSTORE")
+	return c
 }
 
 func (c Sinterstore) Destination(destination string) SinterstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SinterstoreDestination)(c)
 }
 
 func (c SSinterstore) Destination(destination string) SSinterstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SSinterstoreDestination)(c)
 }
 
@@ -33713,7 +34977,7 @@ type SinterstoreDestination Completed
 type SSinterstoreDestination SCompleted
 
 func (c SinterstoreDestination) Key(key ...string) SinterstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SinterstoreKey)(c)
 }
 
@@ -33721,7 +34985,7 @@ func (c SSinterstoreDestination) Key(key ...string) SSinterstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSinterstoreKey)(c)
 }
 
@@ -33730,7 +34994,7 @@ type SinterstoreKey Completed
 type SSinterstoreKey SCompleted
 
 func (c SinterstoreKey) Key(key ...string) SinterstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -33738,7 +35002,7 @@ func (c SSinterstoreKey) Key(key ...string) SSinterstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -33754,22 +35018,26 @@ type Sismember Completed
 
 type SSismember SCompleted
 
-func (b *Builder) Sismember() Sismember {
-	return Sismember{cs: append(b.get(), "SISMEMBER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sismember() (c Sismember) {
+	c = Sismember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SISMEMBER")
+	return c
 }
 
-func (b *SBuilder) Sismember() SSismember {
-	return SSismember{cs: append(b.get(), "SISMEMBER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sismember() (c SSismember) {
+	c = SSismember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SISMEMBER")
+	return c
 }
 
 func (c Sismember) Key(key string) SismemberKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SismemberKey)(c)
 }
 
 func (c SSismember) Key(key string) SSismemberKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSismemberKey)(c)
 }
 
@@ -33778,12 +35046,12 @@ type SismemberKey Completed
 type SSismemberKey SCompleted
 
 func (c SismemberKey) Member(member string) SismemberMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SismemberMember)(c)
 }
 
 func (c SSismemberKey) Member(member string) SSismemberMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SSismemberMember)(c)
 }
 
@@ -33811,21 +35079,25 @@ type Slaveof Completed
 
 type SSlaveof SCompleted
 
-func (b *Builder) Slaveof() Slaveof {
-	return Slaveof{cs: append(b.get(), "SLAVEOF"), ks: InitSlot}
+func (b *Builder) Slaveof() (c Slaveof) {
+	c = Slaveof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SLAVEOF")
+	return c
 }
 
-func (b *SBuilder) Slaveof() SSlaveof {
-	return SSlaveof{cs: append(b.get(), "SLAVEOF"), ks: InitSlot}
+func (b *SBuilder) Slaveof() (c SSlaveof) {
+	c = SSlaveof{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SLAVEOF")
+	return c
 }
 
 func (c Slaveof) Host(host string) SlaveofHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (SlaveofHost)(c)
 }
 
 func (c SSlaveof) Host(host string) SSlaveofHost {
-	c.cs = append(c.cs, host)
+	c.cs.s = append(c.cs.s, host)
 	return (SSlaveofHost)(c)
 }
 
@@ -33834,12 +35106,12 @@ type SlaveofHost Completed
 type SSlaveofHost SCompleted
 
 func (c SlaveofHost) Port(port string) SlaveofPort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (SlaveofPort)(c)
 }
 
 func (c SSlaveofHost) Port(port string) SSlaveofPort {
-	c.cs = append(c.cs, port)
+	c.cs.s = append(c.cs.s, port)
 	return (SSlaveofPort)(c)
 }
 
@@ -33859,21 +35131,25 @@ type SlowlogGet Completed
 
 type SSlowlogGet SCompleted
 
-func (b *Builder) SlowlogGet() SlowlogGet {
-	return SlowlogGet{cs: append(b.get(), "SLOWLOG", "GET"), ks: InitSlot, cf: readonly}
+func (b *Builder) SlowlogGet() (c SlowlogGet) {
+	c = SlowlogGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "GET")
+	return c
 }
 
-func (b *SBuilder) SlowlogGet() SSlowlogGet {
-	return SSlowlogGet{cs: append(b.get(), "SLOWLOG", "GET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) SlowlogGet() (c SSlowlogGet) {
+	c = SSlowlogGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "GET")
+	return c
 }
 
 func (c SlowlogGet) Count(count int64) SlowlogGetCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SlowlogGetCount)(c)
 }
 
 func (c SSlowlogGet) Count(count int64) SSlowlogGetCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SSlowlogGetCount)(c)
 }
 
@@ -33901,12 +35177,16 @@ type SlowlogHelp Completed
 
 type SSlowlogHelp SCompleted
 
-func (b *Builder) SlowlogHelp() SlowlogHelp {
-	return SlowlogHelp{cs: append(b.get(), "SLOWLOG", "HELP"), ks: InitSlot, cf: readonly}
+func (b *Builder) SlowlogHelp() (c SlowlogHelp) {
+	c = SlowlogHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "HELP")
+	return c
 }
 
-func (b *SBuilder) SlowlogHelp() SSlowlogHelp {
-	return SSlowlogHelp{cs: append(b.get(), "SLOWLOG", "HELP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) SlowlogHelp() (c SSlowlogHelp) {
+	c = SSlowlogHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "HELP")
+	return c
 }
 
 func (c SlowlogHelp) Build() Completed {
@@ -33921,12 +35201,16 @@ type SlowlogLen Completed
 
 type SSlowlogLen SCompleted
 
-func (b *Builder) SlowlogLen() SlowlogLen {
-	return SlowlogLen{cs: append(b.get(), "SLOWLOG", "LEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) SlowlogLen() (c SlowlogLen) {
+	c = SlowlogLen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "LEN")
+	return c
 }
 
-func (b *SBuilder) SlowlogLen() SSlowlogLen {
-	return SSlowlogLen{cs: append(b.get(), "SLOWLOG", "LEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) SlowlogLen() (c SSlowlogLen) {
+	c = SSlowlogLen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "LEN")
+	return c
 }
 
 func (c SlowlogLen) Build() Completed {
@@ -33941,12 +35225,16 @@ type SlowlogReset Completed
 
 type SSlowlogReset SCompleted
 
-func (b *Builder) SlowlogReset() SlowlogReset {
-	return SlowlogReset{cs: append(b.get(), "SLOWLOG", "RESET"), ks: InitSlot}
+func (b *Builder) SlowlogReset() (c SlowlogReset) {
+	c = SlowlogReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "RESET")
+	return c
 }
 
-func (b *SBuilder) SlowlogReset() SSlowlogReset {
-	return SSlowlogReset{cs: append(b.get(), "SLOWLOG", "RESET"), ks: InitSlot}
+func (b *SBuilder) SlowlogReset() (c SSlowlogReset) {
+	c = SSlowlogReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SLOWLOG", "RESET")
+	return c
 }
 
 func (c SlowlogReset) Build() Completed {
@@ -33961,22 +35249,26 @@ type Smembers Completed
 
 type SSmembers SCompleted
 
-func (b *Builder) Smembers() Smembers {
-	return Smembers{cs: append(b.get(), "SMEMBERS"), ks: InitSlot, cf: readonly}
+func (b *Builder) Smembers() (c Smembers) {
+	c = Smembers{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SMEMBERS")
+	return c
 }
 
-func (b *SBuilder) Smembers() SSmembers {
-	return SSmembers{cs: append(b.get(), "SMEMBERS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Smembers() (c SSmembers) {
+	c = SSmembers{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SMEMBERS")
+	return c
 }
 
 func (c Smembers) Key(key string) SmembersKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SmembersKey)(c)
 }
 
 func (c SSmembers) Key(key string) SSmembersKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSmembersKey)(c)
 }
 
@@ -34004,22 +35296,26 @@ type Smismember Completed
 
 type SSmismember SCompleted
 
-func (b *Builder) Smismember() Smismember {
-	return Smismember{cs: append(b.get(), "SMISMEMBER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Smismember() (c Smismember) {
+	c = Smismember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SMISMEMBER")
+	return c
 }
 
-func (b *SBuilder) Smismember() SSmismember {
-	return SSmismember{cs: append(b.get(), "SMISMEMBER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Smismember() (c SSmismember) {
+	c = SSmismember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SMISMEMBER")
+	return c
 }
 
 func (c Smismember) Key(key string) SmismemberKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SmismemberKey)(c)
 }
 
 func (c SSmismember) Key(key string) SSmismemberKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSmismemberKey)(c)
 }
 
@@ -34028,12 +35324,12 @@ type SmismemberKey Completed
 type SSmismemberKey SCompleted
 
 func (c SmismemberKey) Member(member ...string) SmismemberMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SmismemberMember)(c)
 }
 
 func (c SSmismemberKey) Member(member ...string) SSmismemberMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SSmismemberMember)(c)
 }
 
@@ -34042,12 +35338,12 @@ type SmismemberMember Completed
 type SSmismemberMember SCompleted
 
 func (c SmismemberMember) Member(member ...string) SmismemberMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SSmismemberMember) Member(member ...string) SSmismemberMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -34071,22 +35367,26 @@ type Smove Completed
 
 type SSmove SCompleted
 
-func (b *Builder) Smove() Smove {
-	return Smove{cs: append(b.get(), "SMOVE"), ks: InitSlot}
+func (b *Builder) Smove() (c Smove) {
+	c = Smove{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SMOVE")
+	return c
 }
 
-func (b *SBuilder) Smove() SSmove {
-	return SSmove{cs: append(b.get(), "SMOVE"), ks: InitSlot}
+func (b *SBuilder) Smove() (c SSmove) {
+	c = SSmove{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SMOVE")
+	return c
 }
 
 func (c Smove) Source(source string) SmoveSource {
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SmoveSource)(c)
 }
 
 func (c SSmove) Source(source string) SSmoveSource {
 	c.ks = checkSlot(c.ks, slot(source))
-	c.cs = append(c.cs, source)
+	c.cs.s = append(c.cs.s, source)
 	return (SSmoveSource)(c)
 }
 
@@ -34095,12 +35395,12 @@ type SmoveDestination Completed
 type SSmoveDestination SCompleted
 
 func (c SmoveDestination) Member(member string) SmoveMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SmoveMember)(c)
 }
 
 func (c SSmoveDestination) Member(member string) SSmoveMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SSmoveMember)(c)
 }
 
@@ -34121,13 +35421,13 @@ type SmoveSource Completed
 type SSmoveSource SCompleted
 
 func (c SmoveSource) Destination(destination string) SmoveDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SmoveDestination)(c)
 }
 
 func (c SSmoveSource) Destination(destination string) SSmoveDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SSmoveDestination)(c)
 }
 
@@ -34135,22 +35435,26 @@ type Sort Completed
 
 type SSort SCompleted
 
-func (b *Builder) Sort() Sort {
-	return Sort{cs: append(b.get(), "SORT"), ks: InitSlot}
+func (b *Builder) Sort() (c Sort) {
+	c = Sort{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SORT")
+	return c
 }
 
-func (b *SBuilder) Sort() SSort {
-	return SSort{cs: append(b.get(), "SORT"), ks: InitSlot}
+func (b *SBuilder) Sort() (c SSort) {
+	c = SSort{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SORT")
+	return c
 }
 
 func (c Sort) Key(key string) SortKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SortKey)(c)
 }
 
 func (c SSort) Key(key string) SSortKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSortKey)(c)
 }
 
@@ -34159,65 +35463,65 @@ type SortBy Completed
 type SSortBy SCompleted
 
 func (c SortBy) Limit(offset int64, count int64) SortLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SortLimit)(c)
 }
 
 func (c SSortBy) Limit(offset int64, count int64) SSortLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SSortLimit)(c)
 }
 
 func (c SortBy) Get(pattern ...string) SortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortGet)(c)
 }
 
 func (c SSortBy) Get(pattern ...string) SSortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortGet)(c)
 }
 
 func (c SortBy) Asc() SortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortOrderAsc)(c)
 }
 
 func (c SSortBy) Asc() SSortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortOrderAsc)(c)
 }
 
 func (c SortBy) Desc() SortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortOrderDesc)(c)
 }
 
 func (c SSortBy) Desc() SSortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortOrderDesc)(c)
 }
 
 func (c SortBy) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortBy) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortBy) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortBy) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34234,55 +35538,55 @@ type SortGet Completed
 type SSortGet SCompleted
 
 func (c SortGet) Get(pattern ...string) SortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SSortGet) Get(pattern ...string) SSortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SortGet) Asc() SortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortOrderAsc)(c)
 }
 
 func (c SSortGet) Asc() SSortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortOrderAsc)(c)
 }
 
 func (c SortGet) Desc() SortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortOrderDesc)(c)
 }
 
 func (c SSortGet) Desc() SSortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortOrderDesc)(c)
 }
 
 func (c SortGet) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortGet) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortGet) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortGet) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34299,75 +35603,75 @@ type SortKey Completed
 type SSortKey SCompleted
 
 func (c SortKey) By(pattern string) SortBy {
-	c.cs = append(c.cs, "BY", pattern)
+	c.cs.s = append(c.cs.s, "BY", pattern)
 	return (SortBy)(c)
 }
 
 func (c SSortKey) By(pattern string) SSortBy {
-	c.cs = append(c.cs, "BY", pattern)
+	c.cs.s = append(c.cs.s, "BY", pattern)
 	return (SSortBy)(c)
 }
 
 func (c SortKey) Limit(offset int64, count int64) SortLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SortLimit)(c)
 }
 
 func (c SSortKey) Limit(offset int64, count int64) SSortLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SSortLimit)(c)
 }
 
 func (c SortKey) Get(pattern ...string) SortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortGet)(c)
 }
 
 func (c SSortKey) Get(pattern ...string) SSortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortGet)(c)
 }
 
 func (c SortKey) Asc() SortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortOrderAsc)(c)
 }
 
 func (c SSortKey) Asc() SSortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortOrderAsc)(c)
 }
 
 func (c SortKey) Desc() SortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortOrderDesc)(c)
 }
 
 func (c SSortKey) Desc() SSortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortOrderDesc)(c)
 }
 
 func (c SortKey) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortKey) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortKey) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortKey) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34384,55 +35688,55 @@ type SortLimit Completed
 type SSortLimit SCompleted
 
 func (c SortLimit) Get(pattern ...string) SortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortGet)(c)
 }
 
 func (c SSortLimit) Get(pattern ...string) SSortGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortGet)(c)
 }
 
 func (c SortLimit) Asc() SortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortOrderAsc)(c)
 }
 
 func (c SSortLimit) Asc() SSortOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortOrderAsc)(c)
 }
 
 func (c SortLimit) Desc() SortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortOrderDesc)(c)
 }
 
 func (c SSortLimit) Desc() SSortOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortOrderDesc)(c)
 }
 
 func (c SortLimit) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortLimit) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortLimit) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortLimit) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34449,23 +35753,23 @@ type SortOrderAsc Completed
 type SSortOrderAsc SCompleted
 
 func (c SortOrderAsc) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortOrderAsc) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortOrderAsc) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortOrderAsc) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34482,23 +35786,23 @@ type SortOrderDesc Completed
 type SSortOrderDesc SCompleted
 
 func (c SortOrderDesc) Alpha() SortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortSortingAlpha)(c)
 }
 
 func (c SSortOrderDesc) Alpha() SSortSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortSortingAlpha)(c)
 }
 
 func (c SortOrderDesc) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortOrderDesc) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34514,22 +35818,26 @@ type SortRo Completed
 
 type SSortRo SCompleted
 
-func (b *Builder) SortRo() SortRo {
-	return SortRo{cs: append(b.get(), "SORT_RO"), ks: InitSlot, cf: readonly}
+func (b *Builder) SortRo() (c SortRo) {
+	c = SortRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SORT_RO")
+	return c
 }
 
-func (b *SBuilder) SortRo() SSortRo {
-	return SSortRo{cs: append(b.get(), "SORT_RO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) SortRo() (c SSortRo) {
+	c = SSortRo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SORT_RO")
+	return c
 }
 
 func (c SortRo) Key(key string) SortRoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SortRoKey)(c)
 }
 
 func (c SSortRo) Key(key string) SSortRoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSortRoKey)(c)
 }
 
@@ -34538,54 +35846,54 @@ type SortRoBy Completed
 type SSortRoBy SCompleted
 
 func (c SortRoBy) Limit(offset int64, count int64) SortRoLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SortRoLimit)(c)
 }
 
 func (c SSortRoBy) Limit(offset int64, count int64) SSortRoLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SSortRoLimit)(c)
 }
 
 func (c SortRoBy) Get(pattern ...string) SortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortRoGet)(c)
 }
 
 func (c SSortRoBy) Get(pattern ...string) SSortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortRoGet)(c)
 }
 
 func (c SortRoBy) Asc() SortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortRoOrderAsc)(c)
 }
 
 func (c SSortRoBy) Asc() SSortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortRoOrderAsc)(c)
 }
 
 func (c SortRoBy) Desc() SortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortRoOrderDesc)(c)
 }
 
 func (c SSortRoBy) Desc() SSortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortRoOrderDesc)(c)
 }
 
 func (c SortRoBy) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoBy) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34610,44 +35918,44 @@ type SortRoGet Completed
 type SSortRoGet SCompleted
 
 func (c SortRoGet) Get(pattern ...string) SortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SSortRoGet) Get(pattern ...string) SSortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return c
 }
 
 func (c SortRoGet) Asc() SortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortRoOrderAsc)(c)
 }
 
 func (c SSortRoGet) Asc() SSortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortRoOrderAsc)(c)
 }
 
 func (c SortRoGet) Desc() SortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortRoOrderDesc)(c)
 }
 
 func (c SSortRoGet) Desc() SSortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortRoOrderDesc)(c)
 }
 
 func (c SortRoGet) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoGet) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34672,64 +35980,64 @@ type SortRoKey Completed
 type SSortRoKey SCompleted
 
 func (c SortRoKey) By(pattern string) SortRoBy {
-	c.cs = append(c.cs, "BY", pattern)
+	c.cs.s = append(c.cs.s, "BY", pattern)
 	return (SortRoBy)(c)
 }
 
 func (c SSortRoKey) By(pattern string) SSortRoBy {
-	c.cs = append(c.cs, "BY", pattern)
+	c.cs.s = append(c.cs.s, "BY", pattern)
 	return (SSortRoBy)(c)
 }
 
 func (c SortRoKey) Limit(offset int64, count int64) SortRoLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SortRoLimit)(c)
 }
 
 func (c SSortRoKey) Limit(offset int64, count int64) SSortRoLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SSortRoLimit)(c)
 }
 
 func (c SortRoKey) Get(pattern ...string) SortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortRoGet)(c)
 }
 
 func (c SSortRoKey) Get(pattern ...string) SSortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortRoGet)(c)
 }
 
 func (c SortRoKey) Asc() SortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortRoOrderAsc)(c)
 }
 
 func (c SSortRoKey) Asc() SSortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortRoOrderAsc)(c)
 }
 
 func (c SortRoKey) Desc() SortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortRoOrderDesc)(c)
 }
 
 func (c SSortRoKey) Desc() SSortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortRoOrderDesc)(c)
 }
 
 func (c SortRoKey) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoKey) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34754,44 +36062,44 @@ type SortRoLimit Completed
 type SSortRoLimit SCompleted
 
 func (c SortRoLimit) Get(pattern ...string) SortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SortRoGet)(c)
 }
 
 func (c SSortRoLimit) Get(pattern ...string) SSortRoGet {
-	c.cs = append(c.cs, "GET")
-	c.cs = append(c.cs, pattern...)
+	c.cs.s = append(c.cs.s, "GET")
+	c.cs.s = append(c.cs.s, pattern...)
 	return (SSortRoGet)(c)
 }
 
 func (c SortRoLimit) Asc() SortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SortRoOrderAsc)(c)
 }
 
 func (c SSortRoLimit) Asc() SSortRoOrderAsc {
-	c.cs = append(c.cs, "ASC")
+	c.cs.s = append(c.cs.s, "ASC")
 	return (SSortRoOrderAsc)(c)
 }
 
 func (c SortRoLimit) Desc() SortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SortRoOrderDesc)(c)
 }
 
 func (c SSortRoLimit) Desc() SSortRoOrderDesc {
-	c.cs = append(c.cs, "DESC")
+	c.cs.s = append(c.cs.s, "DESC")
 	return (SSortRoOrderDesc)(c)
 }
 
 func (c SortRoLimit) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoLimit) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34816,12 +36124,12 @@ type SortRoOrderAsc Completed
 type SSortRoOrderAsc SCompleted
 
 func (c SortRoOrderAsc) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoOrderAsc) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34846,12 +36154,12 @@ type SortRoOrderDesc Completed
 type SSortRoOrderDesc SCompleted
 
 func (c SortRoOrderDesc) Alpha() SortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SortRoSortingAlpha)(c)
 }
 
 func (c SSortRoOrderDesc) Alpha() SSortRoSortingAlpha {
-	c.cs = append(c.cs, "ALPHA")
+	c.cs.s = append(c.cs.s, "ALPHA")
 	return (SSortRoSortingAlpha)(c)
 }
 
@@ -34896,13 +36204,13 @@ type SortSortingAlpha Completed
 type SSortSortingAlpha SCompleted
 
 func (c SortSortingAlpha) Store(destination string) SortStore {
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SortStore)(c)
 }
 
 func (c SSortSortingAlpha) Store(destination string) SSortStore {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, "STORE", destination)
+	c.cs.s = append(c.cs.s, "STORE", destination)
 	return (SSortStore)(c)
 }
 
@@ -34930,22 +36238,26 @@ type Spop Completed
 
 type SSpop SCompleted
 
-func (b *Builder) Spop() Spop {
-	return Spop{cs: append(b.get(), "SPOP"), ks: InitSlot}
+func (b *Builder) Spop() (c Spop) {
+	c = Spop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SPOP")
+	return c
 }
 
-func (b *SBuilder) Spop() SSpop {
-	return SSpop{cs: append(b.get(), "SPOP"), ks: InitSlot}
+func (b *SBuilder) Spop() (c SSpop) {
+	c = SSpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SPOP")
+	return c
 }
 
 func (c Spop) Key(key string) SpopKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SpopKey)(c)
 }
 
 func (c SSpop) Key(key string) SSpopKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSpopKey)(c)
 }
 
@@ -34966,12 +36278,12 @@ type SpopKey Completed
 type SSpopKey SCompleted
 
 func (c SpopKey) Count(count int64) SpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SpopCount)(c)
 }
 
 func (c SSpopKey) Count(count int64) SSpopCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SSpopCount)(c)
 }
 
@@ -34987,22 +36299,26 @@ type Srandmember Completed
 
 type SSrandmember SCompleted
 
-func (b *Builder) Srandmember() Srandmember {
-	return Srandmember{cs: append(b.get(), "SRANDMEMBER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Srandmember() (c Srandmember) {
+	c = Srandmember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SRANDMEMBER")
+	return c
 }
 
-func (b *SBuilder) Srandmember() SSrandmember {
-	return SSrandmember{cs: append(b.get(), "SRANDMEMBER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Srandmember() (c SSrandmember) {
+	c = SSrandmember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SRANDMEMBER")
+	return c
 }
 
 func (c Srandmember) Key(key string) SrandmemberKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SrandmemberKey)(c)
 }
 
 func (c SSrandmember) Key(key string) SSrandmemberKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSrandmemberKey)(c)
 }
 
@@ -35023,12 +36339,12 @@ type SrandmemberKey Completed
 type SSrandmemberKey SCompleted
 
 func (c SrandmemberKey) Count(count int64) SrandmemberCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SrandmemberCount)(c)
 }
 
 func (c SSrandmemberKey) Count(count int64) SSrandmemberCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SSrandmemberCount)(c)
 }
 
@@ -35044,22 +36360,26 @@ type Srem Completed
 
 type SSrem SCompleted
 
-func (b *Builder) Srem() Srem {
-	return Srem{cs: append(b.get(), "SREM"), ks: InitSlot}
+func (b *Builder) Srem() (c Srem) {
+	c = Srem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SREM")
+	return c
 }
 
-func (b *SBuilder) Srem() SSrem {
-	return SSrem{cs: append(b.get(), "SREM"), ks: InitSlot}
+func (b *SBuilder) Srem() (c SSrem) {
+	c = SSrem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SREM")
+	return c
 }
 
 func (c Srem) Key(key string) SremKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SremKey)(c)
 }
 
 func (c SSrem) Key(key string) SSremKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSremKey)(c)
 }
 
@@ -35068,12 +36388,12 @@ type SremKey Completed
 type SSremKey SCompleted
 
 func (c SremKey) Member(member ...string) SremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SremMember)(c)
 }
 
 func (c SSremKey) Member(member ...string) SSremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SSremMember)(c)
 }
 
@@ -35082,12 +36402,12 @@ type SremMember Completed
 type SSremMember SCompleted
 
 func (c SremMember) Member(member ...string) SremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SSremMember) Member(member ...string) SSremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -35103,22 +36423,26 @@ type Sscan Completed
 
 type SSscan SCompleted
 
-func (b *Builder) Sscan() Sscan {
-	return Sscan{cs: append(b.get(), "SSCAN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sscan() (c Sscan) {
+	c = Sscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SSCAN")
+	return c
 }
 
-func (b *SBuilder) Sscan() SSscan {
-	return SSscan{cs: append(b.get(), "SSCAN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sscan() (c SSscan) {
+	c = SSscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SSCAN")
+	return c
 }
 
 func (c Sscan) Key(key string) SscanKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SscanKey)(c)
 }
 
 func (c SSscan) Key(key string) SSscanKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SSscanKey)(c)
 }
 
@@ -35139,22 +36463,22 @@ type SscanCursor Completed
 type SSscanCursor SCompleted
 
 func (c SscanCursor) Match(pattern string) SscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (SscanMatch)(c)
 }
 
 func (c SSscanCursor) Match(pattern string) SSscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (SSscanMatch)(c)
 }
 
 func (c SscanCursor) Count(count int64) SscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SscanCount)(c)
 }
 
 func (c SSscanCursor) Count(count int64) SSscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SSscanCount)(c)
 }
 
@@ -35171,12 +36495,12 @@ type SscanKey Completed
 type SSscanKey SCompleted
 
 func (c SscanKey) Cursor(cursor int64) SscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (SscanCursor)(c)
 }
 
 func (c SSscanKey) Cursor(cursor int64) SSscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (SSscanCursor)(c)
 }
 
@@ -35185,12 +36509,12 @@ type SscanMatch Completed
 type SSscanMatch SCompleted
 
 func (c SscanMatch) Count(count int64) SscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SscanCount)(c)
 }
 
 func (c SSscanMatch) Count(count int64) SSscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SSscanCount)(c)
 }
 
@@ -35206,22 +36530,26 @@ type Strlen Completed
 
 type SStrlen SCompleted
 
-func (b *Builder) Strlen() Strlen {
-	return Strlen{cs: append(b.get(), "STRLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Strlen() (c Strlen) {
+	c = Strlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "STRLEN")
+	return c
 }
 
-func (b *SBuilder) Strlen() SStrlen {
-	return SStrlen{cs: append(b.get(), "STRLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Strlen() (c SStrlen) {
+	c = SStrlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "STRLEN")
+	return c
 }
 
 func (c Strlen) Key(key string) StrlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (StrlenKey)(c)
 }
 
 func (c SStrlen) Key(key string) SStrlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SStrlenKey)(c)
 }
 
@@ -35249,21 +36577,25 @@ type Subscribe Completed
 
 type SSubscribe SCompleted
 
-func (b *Builder) Subscribe() Subscribe {
-	return Subscribe{cs: append(b.get(), "SUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *Builder) Subscribe() (c Subscribe) {
+	c = Subscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "SUBSCRIBE")
+	return c
 }
 
-func (b *SBuilder) Subscribe() SSubscribe {
-	return SSubscribe{cs: append(b.get(), "SUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *SBuilder) Subscribe() (c SSubscribe) {
+	c = SSubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "SUBSCRIBE")
+	return c
 }
 
 func (c Subscribe) Channel(channel ...string) SubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (SubscribeChannel)(c)
 }
 
 func (c SSubscribe) Channel(channel ...string) SSubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (SSubscribeChannel)(c)
 }
 
@@ -35272,12 +36604,12 @@ type SubscribeChannel Completed
 type SSubscribeChannel SCompleted
 
 func (c SubscribeChannel) Channel(channel ...string) SubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
 func (c SSubscribeChannel) Channel(channel ...string) SSubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
@@ -35293,16 +36625,20 @@ type Sunion Completed
 
 type SSunion SCompleted
 
-func (b *Builder) Sunion() Sunion {
-	return Sunion{cs: append(b.get(), "SUNION"), ks: InitSlot, cf: readonly}
+func (b *Builder) Sunion() (c Sunion) {
+	c = Sunion{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SUNION")
+	return c
 }
 
-func (b *SBuilder) Sunion() SSunion {
-	return SSunion{cs: append(b.get(), "SUNION"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Sunion() (c SSunion) {
+	c = SSunion{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "SUNION")
+	return c
 }
 
 func (c Sunion) Key(key ...string) SunionKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SunionKey)(c)
 }
 
@@ -35310,7 +36646,7 @@ func (c SSunion) Key(key ...string) SSunionKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSunionKey)(c)
 }
 
@@ -35319,7 +36655,7 @@ type SunionKey Completed
 type SSunionKey SCompleted
 
 func (c SunionKey) Key(key ...string) SunionKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -35327,7 +36663,7 @@ func (c SSunionKey) Key(key ...string) SSunionKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -35343,22 +36679,26 @@ type Sunionstore Completed
 
 type SSunionstore SCompleted
 
-func (b *Builder) Sunionstore() Sunionstore {
-	return Sunionstore{cs: append(b.get(), "SUNIONSTORE"), ks: InitSlot}
+func (b *Builder) Sunionstore() (c Sunionstore) {
+	c = Sunionstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SUNIONSTORE")
+	return c
 }
 
-func (b *SBuilder) Sunionstore() SSunionstore {
-	return SSunionstore{cs: append(b.get(), "SUNIONSTORE"), ks: InitSlot}
+func (b *SBuilder) Sunionstore() (c SSunionstore) {
+	c = SSunionstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SUNIONSTORE")
+	return c
 }
 
 func (c Sunionstore) Destination(destination string) SunionstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SunionstoreDestination)(c)
 }
 
 func (c SSunionstore) Destination(destination string) SSunionstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SSunionstoreDestination)(c)
 }
 
@@ -35367,7 +36707,7 @@ type SunionstoreDestination Completed
 type SSunionstoreDestination SCompleted
 
 func (c SunionstoreDestination) Key(key ...string) SunionstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SunionstoreKey)(c)
 }
 
@@ -35375,7 +36715,7 @@ func (c SSunionstoreDestination) Key(key ...string) SSunionstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SSunionstoreKey)(c)
 }
 
@@ -35384,7 +36724,7 @@ type SunionstoreKey Completed
 type SSunionstoreKey SCompleted
 
 func (c SunionstoreKey) Key(key ...string) SunionstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -35392,7 +36732,7 @@ func (c SSunionstoreKey) Key(key ...string) SSunionstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -35408,21 +36748,25 @@ type Swapdb Completed
 
 type SSwapdb SCompleted
 
-func (b *Builder) Swapdb() Swapdb {
-	return Swapdb{cs: append(b.get(), "SWAPDB"), ks: InitSlot}
+func (b *Builder) Swapdb() (c Swapdb) {
+	c = Swapdb{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SWAPDB")
+	return c
 }
 
-func (b *SBuilder) Swapdb() SSwapdb {
-	return SSwapdb{cs: append(b.get(), "SWAPDB"), ks: InitSlot}
+func (b *SBuilder) Swapdb() (c SSwapdb) {
+	c = SSwapdb{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SWAPDB")
+	return c
 }
 
 func (c Swapdb) Index1(index1 int64) SwapdbIndex1 {
-	c.cs = append(c.cs, strconv.FormatInt(index1, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index1, 10))
 	return (SwapdbIndex1)(c)
 }
 
 func (c SSwapdb) Index1(index1 int64) SSwapdbIndex1 {
-	c.cs = append(c.cs, strconv.FormatInt(index1, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index1, 10))
 	return (SSwapdbIndex1)(c)
 }
 
@@ -35431,12 +36775,12 @@ type SwapdbIndex1 Completed
 type SSwapdbIndex1 SCompleted
 
 func (c SwapdbIndex1) Index2(index2 int64) SwapdbIndex2 {
-	c.cs = append(c.cs, strconv.FormatInt(index2, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index2, 10))
 	return (SwapdbIndex2)(c)
 }
 
 func (c SSwapdbIndex1) Index2(index2 int64) SSwapdbIndex2 {
-	c.cs = append(c.cs, strconv.FormatInt(index2, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(index2, 10))
 	return (SSwapdbIndex2)(c)
 }
 
@@ -35456,12 +36800,16 @@ type Sync Completed
 
 type SSync SCompleted
 
-func (b *Builder) Sync() Sync {
-	return Sync{cs: append(b.get(), "SYNC"), ks: InitSlot}
+func (b *Builder) Sync() (c Sync) {
+	c = Sync{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SYNC")
+	return c
 }
 
-func (b *SBuilder) Sync() SSync {
-	return SSync{cs: append(b.get(), "SYNC"), ks: InitSlot}
+func (b *SBuilder) Sync() (c SSync) {
+	c = SSync{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "SYNC")
+	return c
 }
 
 func (c Sync) Build() Completed {
@@ -35476,22 +36824,26 @@ type TdigestAdd Completed
 
 type STdigestAdd SCompleted
 
-func (b *Builder) TdigestAdd() TdigestAdd {
-	return TdigestAdd{cs: append(b.get(), "TDIGEST.ADD"), ks: InitSlot}
+func (b *Builder) TdigestAdd() (c TdigestAdd) {
+	c = TdigestAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.ADD")
+	return c
 }
 
-func (b *SBuilder) TdigestAdd() STdigestAdd {
-	return STdigestAdd{cs: append(b.get(), "TDIGEST.ADD"), ks: InitSlot}
+func (b *SBuilder) TdigestAdd() (c STdigestAdd) {
+	c = STdigestAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.ADD")
+	return c
 }
 
 func (c TdigestAdd) Key(key string) TdigestAddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestAddKey)(c)
 }
 
 func (c STdigestAdd) Key(key string) STdigestAddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestAddKey)(c)
 }
 
@@ -35500,12 +36852,12 @@ type TdigestAddKey Completed
 type STdigestAddKey SCompleted
 
 func (c TdigestAddKey) Value(value float64) TdigestAddValuesValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TdigestAddValuesValue)(c)
 }
 
 func (c STdigestAddKey) Value(value float64) STdigestAddValuesValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STdigestAddValuesValue)(c)
 }
 
@@ -35514,12 +36866,12 @@ type TdigestAddValuesValue Completed
 type STdigestAddValuesValue SCompleted
 
 func (c TdigestAddValuesValue) Weight(weight float64) TdigestAddValuesWeight {
-	c.cs = append(c.cs, strconv.FormatFloat(weight, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(weight, 'f', -1, 64))
 	return (TdigestAddValuesWeight)(c)
 }
 
 func (c STdigestAddValuesValue) Weight(weight float64) STdigestAddValuesWeight {
-	c.cs = append(c.cs, strconv.FormatFloat(weight, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(weight, 'f', -1, 64))
 	return (STdigestAddValuesWeight)(c)
 }
 
@@ -35528,12 +36880,12 @@ type TdigestAddValuesWeight Completed
 type STdigestAddValuesWeight SCompleted
 
 func (c TdigestAddValuesWeight) Value(value float64) TdigestAddValuesValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TdigestAddValuesValue)(c)
 }
 
 func (c STdigestAddValuesWeight) Value(value float64) STdigestAddValuesValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STdigestAddValuesValue)(c)
 }
 
@@ -35549,22 +36901,26 @@ type TdigestCdf Completed
 
 type STdigestCdf SCompleted
 
-func (b *Builder) TdigestCdf() TdigestCdf {
-	return TdigestCdf{cs: append(b.get(), "TDIGEST.CDF"), ks: InitSlot}
+func (b *Builder) TdigestCdf() (c TdigestCdf) {
+	c = TdigestCdf{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.CDF")
+	return c
 }
 
-func (b *SBuilder) TdigestCdf() STdigestCdf {
-	return STdigestCdf{cs: append(b.get(), "TDIGEST.CDF"), ks: InitSlot}
+func (b *SBuilder) TdigestCdf() (c STdigestCdf) {
+	c = STdigestCdf{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.CDF")
+	return c
 }
 
 func (c TdigestCdf) Key(key string) TdigestCdfKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestCdfKey)(c)
 }
 
 func (c STdigestCdf) Key(key string) STdigestCdfKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestCdfKey)(c)
 }
 
@@ -35573,12 +36929,12 @@ type TdigestCdfKey Completed
 type STdigestCdfKey SCompleted
 
 func (c TdigestCdfKey) Value(value float64) TdigestCdfValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TdigestCdfValue)(c)
 }
 
 func (c STdigestCdfKey) Value(value float64) STdigestCdfValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STdigestCdfValue)(c)
 }
 
@@ -35598,22 +36954,26 @@ type TdigestCreate Completed
 
 type STdigestCreate SCompleted
 
-func (b *Builder) TdigestCreate() TdigestCreate {
-	return TdigestCreate{cs: append(b.get(), "TDIGEST.CREATE"), ks: InitSlot}
+func (b *Builder) TdigestCreate() (c TdigestCreate) {
+	c = TdigestCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.CREATE")
+	return c
 }
 
-func (b *SBuilder) TdigestCreate() STdigestCreate {
-	return STdigestCreate{cs: append(b.get(), "TDIGEST.CREATE"), ks: InitSlot}
+func (b *SBuilder) TdigestCreate() (c STdigestCreate) {
+	c = STdigestCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.CREATE")
+	return c
 }
 
 func (c TdigestCreate) Key(key string) TdigestCreateKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestCreateKey)(c)
 }
 
 func (c STdigestCreate) Key(key string) STdigestCreateKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestCreateKey)(c)
 }
 
@@ -35634,12 +36994,12 @@ type TdigestCreateKey Completed
 type STdigestCreateKey SCompleted
 
 func (c TdigestCreateKey) Compression(compression int64) TdigestCreateCompression {
-	c.cs = append(c.cs, strconv.FormatInt(compression, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(compression, 10))
 	return (TdigestCreateCompression)(c)
 }
 
 func (c STdigestCreateKey) Compression(compression int64) STdigestCreateCompression {
-	c.cs = append(c.cs, strconv.FormatInt(compression, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(compression, 10))
 	return (STdigestCreateCompression)(c)
 }
 
@@ -35647,22 +37007,26 @@ type TdigestInfo Completed
 
 type STdigestInfo SCompleted
 
-func (b *Builder) TdigestInfo() TdigestInfo {
-	return TdigestInfo{cs: append(b.get(), "TDIGEST.INFO"), ks: InitSlot}
+func (b *Builder) TdigestInfo() (c TdigestInfo) {
+	c = TdigestInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.INFO")
+	return c
 }
 
-func (b *SBuilder) TdigestInfo() STdigestInfo {
-	return STdigestInfo{cs: append(b.get(), "TDIGEST.INFO"), ks: InitSlot}
+func (b *SBuilder) TdigestInfo() (c STdigestInfo) {
+	c = STdigestInfo{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.INFO")
+	return c
 }
 
 func (c TdigestInfo) Key(key string) TdigestInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestInfoKey)(c)
 }
 
 func (c STdigestInfo) Key(key string) STdigestInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestInfoKey)(c)
 }
 
@@ -35682,22 +37046,26 @@ type TdigestMax Completed
 
 type STdigestMax SCompleted
 
-func (b *Builder) TdigestMax() TdigestMax {
-	return TdigestMax{cs: append(b.get(), "TDIGEST.MAX"), ks: InitSlot}
+func (b *Builder) TdigestMax() (c TdigestMax) {
+	c = TdigestMax{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MAX")
+	return c
 }
 
-func (b *SBuilder) TdigestMax() STdigestMax {
-	return STdigestMax{cs: append(b.get(), "TDIGEST.MAX"), ks: InitSlot}
+func (b *SBuilder) TdigestMax() (c STdigestMax) {
+	c = STdigestMax{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MAX")
+	return c
 }
 
 func (c TdigestMax) Key(key string) TdigestMaxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestMaxKey)(c)
 }
 
 func (c STdigestMax) Key(key string) STdigestMaxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestMaxKey)(c)
 }
 
@@ -35717,22 +37085,26 @@ type TdigestMerge Completed
 
 type STdigestMerge SCompleted
 
-func (b *Builder) TdigestMerge() TdigestMerge {
-	return TdigestMerge{cs: append(b.get(), "TDIGEST.MERGE"), ks: InitSlot}
+func (b *Builder) TdigestMerge() (c TdigestMerge) {
+	c = TdigestMerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MERGE")
+	return c
 }
 
-func (b *SBuilder) TdigestMerge() STdigestMerge {
-	return STdigestMerge{cs: append(b.get(), "TDIGEST.MERGE"), ks: InitSlot}
+func (b *SBuilder) TdigestMerge() (c STdigestMerge) {
+	c = STdigestMerge{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MERGE")
+	return c
 }
 
 func (c TdigestMerge) ToKey(toKey string) TdigestMergeToKey {
-	c.cs = append(c.cs, toKey)
+	c.cs.s = append(c.cs.s, toKey)
 	return (TdigestMergeToKey)(c)
 }
 
 func (c STdigestMerge) ToKey(toKey string) STdigestMergeToKey {
 	c.ks = checkSlot(c.ks, slot(toKey))
-	c.cs = append(c.cs, toKey)
+	c.cs.s = append(c.cs.s, toKey)
 	return (STdigestMergeToKey)(c)
 }
 
@@ -35753,13 +37125,13 @@ type TdigestMergeToKey Completed
 type STdigestMergeToKey SCompleted
 
 func (c TdigestMergeToKey) FromKey(fromKey string) TdigestMergeFromKey {
-	c.cs = append(c.cs, fromKey)
+	c.cs.s = append(c.cs.s, fromKey)
 	return (TdigestMergeFromKey)(c)
 }
 
 func (c STdigestMergeToKey) FromKey(fromKey string) STdigestMergeFromKey {
 	c.ks = checkSlot(c.ks, slot(fromKey))
-	c.cs = append(c.cs, fromKey)
+	c.cs.s = append(c.cs.s, fromKey)
 	return (STdigestMergeFromKey)(c)
 }
 
@@ -35767,22 +37139,26 @@ type TdigestMin Completed
 
 type STdigestMin SCompleted
 
-func (b *Builder) TdigestMin() TdigestMin {
-	return TdigestMin{cs: append(b.get(), "TDIGEST.MIN"), ks: InitSlot}
+func (b *Builder) TdigestMin() (c TdigestMin) {
+	c = TdigestMin{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MIN")
+	return c
 }
 
-func (b *SBuilder) TdigestMin() STdigestMin {
-	return STdigestMin{cs: append(b.get(), "TDIGEST.MIN"), ks: InitSlot}
+func (b *SBuilder) TdigestMin() (c STdigestMin) {
+	c = STdigestMin{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.MIN")
+	return c
 }
 
 func (c TdigestMin) Key(key string) TdigestMinKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestMinKey)(c)
 }
 
 func (c STdigestMin) Key(key string) STdigestMinKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestMinKey)(c)
 }
 
@@ -35802,22 +37178,26 @@ type TdigestQuantile Completed
 
 type STdigestQuantile SCompleted
 
-func (b *Builder) TdigestQuantile() TdigestQuantile {
-	return TdigestQuantile{cs: append(b.get(), "TDIGEST.QUANTILE"), ks: InitSlot}
+func (b *Builder) TdigestQuantile() (c TdigestQuantile) {
+	c = TdigestQuantile{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.QUANTILE")
+	return c
 }
 
-func (b *SBuilder) TdigestQuantile() STdigestQuantile {
-	return STdigestQuantile{cs: append(b.get(), "TDIGEST.QUANTILE"), ks: InitSlot}
+func (b *SBuilder) TdigestQuantile() (c STdigestQuantile) {
+	c = STdigestQuantile{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.QUANTILE")
+	return c
 }
 
 func (c TdigestQuantile) Key(key string) TdigestQuantileKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestQuantileKey)(c)
 }
 
 func (c STdigestQuantile) Key(key string) STdigestQuantileKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestQuantileKey)(c)
 }
 
@@ -35826,12 +37206,12 @@ type TdigestQuantileKey Completed
 type STdigestQuantileKey SCompleted
 
 func (c TdigestQuantileKey) Quantile(quantile float64) TdigestQuantileQuantile {
-	c.cs = append(c.cs, strconv.FormatFloat(quantile, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(quantile, 'f', -1, 64))
 	return (TdigestQuantileQuantile)(c)
 }
 
 func (c STdigestQuantileKey) Quantile(quantile float64) STdigestQuantileQuantile {
-	c.cs = append(c.cs, strconv.FormatFloat(quantile, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(quantile, 'f', -1, 64))
 	return (STdigestQuantileQuantile)(c)
 }
 
@@ -35851,22 +37231,26 @@ type TdigestReset Completed
 
 type STdigestReset SCompleted
 
-func (b *Builder) TdigestReset() TdigestReset {
-	return TdigestReset{cs: append(b.get(), "TDIGEST.RESET"), ks: InitSlot}
+func (b *Builder) TdigestReset() (c TdigestReset) {
+	c = TdigestReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.RESET")
+	return c
 }
 
-func (b *SBuilder) TdigestReset() STdigestReset {
-	return STdigestReset{cs: append(b.get(), "TDIGEST.RESET"), ks: InitSlot}
+func (b *SBuilder) TdigestReset() (c STdigestReset) {
+	c = STdigestReset{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TDIGEST.RESET")
+	return c
 }
 
 func (c TdigestReset) Key(key string) TdigestResetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TdigestResetKey)(c)
 }
 
 func (c STdigestReset) Key(key string) STdigestResetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STdigestResetKey)(c)
 }
 
@@ -35886,12 +37270,16 @@ type Time Completed
 
 type STime SCompleted
 
-func (b *Builder) Time() Time {
-	return Time{cs: append(b.get(), "TIME"), ks: InitSlot}
+func (b *Builder) Time() (c Time) {
+	c = Time{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TIME")
+	return c
 }
 
-func (b *SBuilder) Time() STime {
-	return STime{cs: append(b.get(), "TIME"), ks: InitSlot}
+func (b *SBuilder) Time() (c STime) {
+	c = STime{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TIME")
+	return c
 }
 
 func (c Time) Build() Completed {
@@ -35906,22 +37294,26 @@ type TopkAdd Completed
 
 type STopkAdd SCompleted
 
-func (b *Builder) TopkAdd() TopkAdd {
-	return TopkAdd{cs: append(b.get(), "TOPK.ADD"), ks: InitSlot}
+func (b *Builder) TopkAdd() (c TopkAdd) {
+	c = TopkAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.ADD")
+	return c
 }
 
-func (b *SBuilder) TopkAdd() STopkAdd {
-	return STopkAdd{cs: append(b.get(), "TOPK.ADD"), ks: InitSlot}
+func (b *SBuilder) TopkAdd() (c STopkAdd) {
+	c = STopkAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.ADD")
+	return c
 }
 
 func (c TopkAdd) Key(key string) TopkAddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkAddKey)(c)
 }
 
 func (c STopkAdd) Key(key string) STopkAddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkAddKey)(c)
 }
 
@@ -35930,12 +37322,12 @@ type TopkAddItems Completed
 type STopkAddItems SCompleted
 
 func (c TopkAddItems) Items(items ...string) TopkAddItems {
-	c.cs = append(c.cs, items...)
+	c.cs.s = append(c.cs.s, items...)
 	return c
 }
 
 func (c STopkAddItems) Items(items ...string) STopkAddItems {
-	c.cs = append(c.cs, items...)
+	c.cs.s = append(c.cs.s, items...)
 	return c
 }
 
@@ -35952,12 +37344,12 @@ type TopkAddKey Completed
 type STopkAddKey SCompleted
 
 func (c TopkAddKey) Items(items ...string) TopkAddItems {
-	c.cs = append(c.cs, items...)
+	c.cs.s = append(c.cs.s, items...)
 	return (TopkAddItems)(c)
 }
 
 func (c STopkAddKey) Items(items ...string) STopkAddItems {
-	c.cs = append(c.cs, items...)
+	c.cs.s = append(c.cs.s, items...)
 	return (STopkAddItems)(c)
 }
 
@@ -35965,22 +37357,26 @@ type TopkIncrby Completed
 
 type STopkIncrby SCompleted
 
-func (b *Builder) TopkIncrby() TopkIncrby {
-	return TopkIncrby{cs: append(b.get(), "TOPK.INCRBY"), ks: InitSlot}
+func (b *Builder) TopkIncrby() (c TopkIncrby) {
+	c = TopkIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.INCRBY")
+	return c
 }
 
-func (b *SBuilder) TopkIncrby() STopkIncrby {
-	return STopkIncrby{cs: append(b.get(), "TOPK.INCRBY"), ks: InitSlot}
+func (b *SBuilder) TopkIncrby() (c STopkIncrby) {
+	c = STopkIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.INCRBY")
+	return c
 }
 
 func (c TopkIncrby) Key(key string) TopkIncrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkIncrbyKey)(c)
 }
 
 func (c STopkIncrby) Key(key string) STopkIncrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkIncrbyKey)(c)
 }
 
@@ -35989,12 +37385,12 @@ type TopkIncrbyItemsIncrement Completed
 type STopkIncrbyItemsIncrement SCompleted
 
 func (c TopkIncrbyItemsIncrement) Item(item string) TopkIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (TopkIncrbyItemsItem)(c)
 }
 
 func (c STopkIncrbyItemsIncrement) Item(item string) STopkIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (STopkIncrbyItemsItem)(c)
 }
 
@@ -36011,12 +37407,12 @@ type TopkIncrbyItemsItem Completed
 type STopkIncrbyItemsItem SCompleted
 
 func (c TopkIncrbyItemsItem) Increment(increment int64) TopkIncrbyItemsIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (TopkIncrbyItemsIncrement)(c)
 }
 
 func (c STopkIncrbyItemsItem) Increment(increment int64) STopkIncrbyItemsIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (STopkIncrbyItemsIncrement)(c)
 }
 
@@ -36025,12 +37421,12 @@ type TopkIncrbyKey Completed
 type STopkIncrbyKey SCompleted
 
 func (c TopkIncrbyKey) Item(item string) TopkIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (TopkIncrbyItemsItem)(c)
 }
 
 func (c STopkIncrbyKey) Item(item string) STopkIncrbyItemsItem {
-	c.cs = append(c.cs, item)
+	c.cs.s = append(c.cs.s, item)
 	return (STopkIncrbyItemsItem)(c)
 }
 
@@ -36038,22 +37434,26 @@ type TopkInfo Completed
 
 type STopkInfo SCompleted
 
-func (b *Builder) TopkInfo() TopkInfo {
-	return TopkInfo{cs: append(b.get(), "TOPK.INFO"), ks: InitSlot, cf: readonly}
+func (b *Builder) TopkInfo() (c TopkInfo) {
+	c = TopkInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.INFO")
+	return c
 }
 
-func (b *SBuilder) TopkInfo() STopkInfo {
-	return STopkInfo{cs: append(b.get(), "TOPK.INFO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TopkInfo() (c STopkInfo) {
+	c = STopkInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.INFO")
+	return c
 }
 
 func (c TopkInfo) Key(key string) TopkInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkInfoKey)(c)
 }
 
 func (c STopkInfo) Key(key string) STopkInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkInfoKey)(c)
 }
 
@@ -36081,22 +37481,26 @@ type TopkList Completed
 
 type STopkList SCompleted
 
-func (b *Builder) TopkList() TopkList {
-	return TopkList{cs: append(b.get(), "TOPK.LIST"), ks: InitSlot, cf: readonly}
+func (b *Builder) TopkList() (c TopkList) {
+	c = TopkList{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.LIST")
+	return c
 }
 
-func (b *SBuilder) TopkList() STopkList {
-	return STopkList{cs: append(b.get(), "TOPK.LIST"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TopkList() (c STopkList) {
+	c = STopkList{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.LIST")
+	return c
 }
 
 func (c TopkList) Key(key string) TopkListKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkListKey)(c)
 }
 
 func (c STopkList) Key(key string) STopkListKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkListKey)(c)
 }
 
@@ -36105,12 +37509,12 @@ type TopkListKey Completed
 type STopkListKey SCompleted
 
 func (c TopkListKey) Numkeys(numkeys int64) TopkListNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (TopkListNumkeys)(c)
 }
 
 func (c STopkListKey) Numkeys(numkeys int64) STopkListNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (STopkListNumkeys)(c)
 }
 
@@ -36119,12 +37523,12 @@ type TopkListNumkeys Completed
 type STopkListNumkeys SCompleted
 
 func (c TopkListNumkeys) Withcount() TopkListWithcount {
-	c.cs = append(c.cs, "WITHCOUNT")
+	c.cs.s = append(c.cs.s, "WITHCOUNT")
 	return (TopkListWithcount)(c)
 }
 
 func (c STopkListNumkeys) Withcount() STopkListWithcount {
-	c.cs = append(c.cs, "WITHCOUNT")
+	c.cs.s = append(c.cs.s, "WITHCOUNT")
 	return (STopkListWithcount)(c)
 }
 
@@ -36152,22 +37556,26 @@ type TopkQuery Completed
 
 type STopkQuery SCompleted
 
-func (b *Builder) TopkQuery() TopkQuery {
-	return TopkQuery{cs: append(b.get(), "TOPK.QUERY"), ks: InitSlot, cf: readonly}
+func (b *Builder) TopkQuery() (c TopkQuery) {
+	c = TopkQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.QUERY")
+	return c
 }
 
-func (b *SBuilder) TopkQuery() STopkQuery {
-	return STopkQuery{cs: append(b.get(), "TOPK.QUERY"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TopkQuery() (c STopkQuery) {
+	c = STopkQuery{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOPK.QUERY")
+	return c
 }
 
 func (c TopkQuery) Key(key string) TopkQueryKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkQueryKey)(c)
 }
 
 func (c STopkQuery) Key(key string) STopkQueryKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkQueryKey)(c)
 }
 
@@ -36176,12 +37584,12 @@ type TopkQueryItem Completed
 type STopkQueryItem SCompleted
 
 func (c TopkQueryItem) Item(item ...string) TopkQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
 func (c STopkQueryItem) Item(item ...string) STopkQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return c
 }
 
@@ -36206,12 +37614,12 @@ type TopkQueryKey Completed
 type STopkQueryKey SCompleted
 
 func (c TopkQueryKey) Item(item ...string) TopkQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (TopkQueryItem)(c)
 }
 
 func (c STopkQueryKey) Item(item ...string) STopkQueryItem {
-	c.cs = append(c.cs, item...)
+	c.cs.s = append(c.cs.s, item...)
 	return (STopkQueryItem)(c)
 }
 
@@ -36219,22 +37627,26 @@ type TopkReserve Completed
 
 type STopkReserve SCompleted
 
-func (b *Builder) TopkReserve() TopkReserve {
-	return TopkReserve{cs: append(b.get(), "TOPK.RESERVE"), ks: InitSlot}
+func (b *Builder) TopkReserve() (c TopkReserve) {
+	c = TopkReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.RESERVE")
+	return c
 }
 
-func (b *SBuilder) TopkReserve() STopkReserve {
-	return STopkReserve{cs: append(b.get(), "TOPK.RESERVE"), ks: InitSlot}
+func (b *SBuilder) TopkReserve() (c STopkReserve) {
+	c = STopkReserve{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TOPK.RESERVE")
+	return c
 }
 
 func (c TopkReserve) Key(key string) TopkReserveKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TopkReserveKey)(c)
 }
 
 func (c STopkReserve) Key(key string) STopkReserveKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STopkReserveKey)(c)
 }
 
@@ -36243,12 +37655,12 @@ type TopkReserveKey Completed
 type STopkReserveKey SCompleted
 
 func (c TopkReserveKey) Topk(topk int64) TopkReserveTopk {
-	c.cs = append(c.cs, strconv.FormatInt(topk, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(topk, 10))
 	return (TopkReserveTopk)(c)
 }
 
 func (c STopkReserveKey) Topk(topk int64) STopkReserveTopk {
-	c.cs = append(c.cs, strconv.FormatInt(topk, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(topk, 10))
 	return (STopkReserveTopk)(c)
 }
 
@@ -36269,12 +37681,12 @@ type TopkReserveParamsDepth Completed
 type STopkReserveParamsDepth SCompleted
 
 func (c TopkReserveParamsDepth) Decay(decay float64) TopkReserveParamsDecay {
-	c.cs = append(c.cs, strconv.FormatFloat(decay, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(decay, 'f', -1, 64))
 	return (TopkReserveParamsDecay)(c)
 }
 
 func (c STopkReserveParamsDepth) Decay(decay float64) STopkReserveParamsDecay {
-	c.cs = append(c.cs, strconv.FormatFloat(decay, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(decay, 'f', -1, 64))
 	return (STopkReserveParamsDecay)(c)
 }
 
@@ -36283,12 +37695,12 @@ type TopkReserveParamsWidth Completed
 type STopkReserveParamsWidth SCompleted
 
 func (c TopkReserveParamsWidth) Depth(depth int64) TopkReserveParamsDepth {
-	c.cs = append(c.cs, strconv.FormatInt(depth, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(depth, 10))
 	return (TopkReserveParamsDepth)(c)
 }
 
 func (c STopkReserveParamsWidth) Depth(depth int64) STopkReserveParamsDepth {
-	c.cs = append(c.cs, strconv.FormatInt(depth, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(depth, 10))
 	return (STopkReserveParamsDepth)(c)
 }
 
@@ -36297,12 +37709,12 @@ type TopkReserveTopk Completed
 type STopkReserveTopk SCompleted
 
 func (c TopkReserveTopk) Width(width int64) TopkReserveParamsWidth {
-	c.cs = append(c.cs, strconv.FormatInt(width, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(width, 10))
 	return (TopkReserveParamsWidth)(c)
 }
 
 func (c STopkReserveTopk) Width(width int64) STopkReserveParamsWidth {
-	c.cs = append(c.cs, strconv.FormatInt(width, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(width, 10))
 	return (STopkReserveParamsWidth)(c)
 }
 
@@ -36318,16 +37730,20 @@ type Touch Completed
 
 type STouch SCompleted
 
-func (b *Builder) Touch() Touch {
-	return Touch{cs: append(b.get(), "TOUCH"), ks: InitSlot, cf: readonly}
+func (b *Builder) Touch() (c Touch) {
+	c = Touch{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOUCH")
+	return c
 }
 
-func (b *SBuilder) Touch() STouch {
-	return STouch{cs: append(b.get(), "TOUCH"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Touch() (c STouch) {
+	c = STouch{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TOUCH")
+	return c
 }
 
 func (c Touch) Key(key ...string) TouchKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (TouchKey)(c)
 }
 
@@ -36335,7 +37751,7 @@ func (c STouch) Key(key ...string) STouchKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (STouchKey)(c)
 }
 
@@ -36344,7 +37760,7 @@ type TouchKey Completed
 type STouchKey SCompleted
 
 func (c TouchKey) Key(key ...string) TouchKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -36352,7 +37768,7 @@ func (c STouchKey) Key(key ...string) STouchKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -36368,22 +37784,26 @@ type TsAdd Completed
 
 type STsAdd SCompleted
 
-func (b *Builder) TsAdd() TsAdd {
-	return TsAdd{cs: append(b.get(), "TS.ADD"), ks: InitSlot}
+func (b *Builder) TsAdd() (c TsAdd) {
+	c = TsAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.ADD")
+	return c
 }
 
-func (b *SBuilder) TsAdd() STsAdd {
-	return STsAdd{cs: append(b.get(), "TS.ADD"), ks: InitSlot}
+func (b *SBuilder) TsAdd() (c STsAdd) {
+	c = STsAdd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.ADD")
+	return c
 }
 
 func (c TsAdd) Key(key string) TsAddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsAddKey)(c)
 }
 
 func (c STsAdd) Key(key string) STsAddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsAddKey)(c)
 }
 
@@ -36393,73 +37813,73 @@ type STsAddChunkSize SCompleted
 
 func (c TsAddChunkSize) OnDuplicateBlock() TsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (TsAddOnDuplicateBlock)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateBlock() STsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (STsAddOnDuplicateBlock)(c)
 }
 
 func (c TsAddChunkSize) OnDuplicateFirst() TsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (TsAddOnDuplicateFirst)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateFirst() STsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (STsAddOnDuplicateFirst)(c)
 }
 
 func (c TsAddChunkSize) OnDuplicateLast() TsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (TsAddOnDuplicateLast)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateLast() STsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (STsAddOnDuplicateLast)(c)
 }
 
 func (c TsAddChunkSize) OnDuplicateMin() TsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (TsAddOnDuplicateMin)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateMin() STsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (STsAddOnDuplicateMin)(c)
 }
 
 func (c TsAddChunkSize) OnDuplicateMax() TsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (TsAddOnDuplicateMax)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateMax() STsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (STsAddOnDuplicateMax)(c)
 }
 
 func (c TsAddChunkSize) OnDuplicateSum() TsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (TsAddOnDuplicateSum)(c)
 }
 
 func (c STsAddChunkSize) OnDuplicateSum() STsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (STsAddOnDuplicateSum)(c)
 }
 
 func (c TsAddChunkSize) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddChunkSize) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36476,84 +37896,84 @@ type TsAddEncodingCompressed Completed
 type STsAddEncodingCompressed SCompleted
 
 func (c TsAddEncodingCompressed) ChunkSize(size int64) TsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsAddChunkSize)(c)
 }
 
 func (c STsAddEncodingCompressed) ChunkSize(size int64) STsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsAddChunkSize)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateBlock() TsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (TsAddOnDuplicateBlock)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateBlock() STsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (STsAddOnDuplicateBlock)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateFirst() TsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (TsAddOnDuplicateFirst)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateFirst() STsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (STsAddOnDuplicateFirst)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateLast() TsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (TsAddOnDuplicateLast)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateLast() STsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (STsAddOnDuplicateLast)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateMin() TsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (TsAddOnDuplicateMin)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateMin() STsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (STsAddOnDuplicateMin)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateMax() TsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (TsAddOnDuplicateMax)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateMax() STsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (STsAddOnDuplicateMax)(c)
 }
 
 func (c TsAddEncodingCompressed) OnDuplicateSum() TsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (TsAddOnDuplicateSum)(c)
 }
 
 func (c STsAddEncodingCompressed) OnDuplicateSum() STsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (STsAddOnDuplicateSum)(c)
 }
 
 func (c TsAddEncodingCompressed) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddEncodingCompressed) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36570,84 +37990,84 @@ type TsAddEncodingUncompressed Completed
 type STsAddEncodingUncompressed SCompleted
 
 func (c TsAddEncodingUncompressed) ChunkSize(size int64) TsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsAddChunkSize)(c)
 }
 
 func (c STsAddEncodingUncompressed) ChunkSize(size int64) STsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsAddChunkSize)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateBlock() TsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (TsAddOnDuplicateBlock)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateBlock() STsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (STsAddOnDuplicateBlock)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateFirst() TsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (TsAddOnDuplicateFirst)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateFirst() STsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (STsAddOnDuplicateFirst)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateLast() TsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (TsAddOnDuplicateLast)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateLast() STsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (STsAddOnDuplicateLast)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateMin() TsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (TsAddOnDuplicateMin)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateMin() STsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (STsAddOnDuplicateMin)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateMax() TsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (TsAddOnDuplicateMax)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateMax() STsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (STsAddOnDuplicateMax)(c)
 }
 
 func (c TsAddEncodingUncompressed) OnDuplicateSum() TsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (TsAddOnDuplicateSum)(c)
 }
 
 func (c STsAddEncodingUncompressed) OnDuplicateSum() STsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (STsAddOnDuplicateSum)(c)
 }
 
 func (c TsAddEncodingUncompressed) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddEncodingUncompressed) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36664,12 +38084,12 @@ type TsAddKey Completed
 type STsAddKey SCompleted
 
 func (c TsAddKey) Timestamp(timestamp int64) TsAddTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (TsAddTimestamp)(c)
 }
 
 func (c STsAddKey) Timestamp(timestamp int64) STsAddTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (STsAddTimestamp)(c)
 }
 
@@ -36678,12 +38098,12 @@ type TsAddLabels Completed
 type STsAddLabels SCompleted
 
 func (c TsAddLabels) Labels(label string, value string) TsAddLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
 func (c STsAddLabels) Labels(label string, value string) STsAddLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
@@ -36700,12 +38120,12 @@ type TsAddOnDuplicateBlock Completed
 type STsAddOnDuplicateBlock SCompleted
 
 func (c TsAddOnDuplicateBlock) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateBlock) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36722,12 +38142,12 @@ type TsAddOnDuplicateFirst Completed
 type STsAddOnDuplicateFirst SCompleted
 
 func (c TsAddOnDuplicateFirst) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateFirst) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36744,12 +38164,12 @@ type TsAddOnDuplicateLast Completed
 type STsAddOnDuplicateLast SCompleted
 
 func (c TsAddOnDuplicateLast) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateLast) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36766,12 +38186,12 @@ type TsAddOnDuplicateMax Completed
 type STsAddOnDuplicateMax SCompleted
 
 func (c TsAddOnDuplicateMax) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateMax) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36788,12 +38208,12 @@ type TsAddOnDuplicateMin Completed
 type STsAddOnDuplicateMin SCompleted
 
 func (c TsAddOnDuplicateMin) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateMin) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36810,12 +38230,12 @@ type TsAddOnDuplicateSum Completed
 type STsAddOnDuplicateSum SCompleted
 
 func (c TsAddOnDuplicateSum) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddOnDuplicateSum) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36832,104 +38252,104 @@ type TsAddRetention Completed
 type STsAddRetention SCompleted
 
 func (c TsAddRetention) EncodingUncompressed() TsAddEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (TsAddEncodingUncompressed)(c)
 }
 
 func (c STsAddRetention) EncodingUncompressed() STsAddEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (STsAddEncodingUncompressed)(c)
 }
 
 func (c TsAddRetention) EncodingCompressed() TsAddEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (TsAddEncodingCompressed)(c)
 }
 
 func (c STsAddRetention) EncodingCompressed() STsAddEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (STsAddEncodingCompressed)(c)
 }
 
 func (c TsAddRetention) ChunkSize(size int64) TsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsAddChunkSize)(c)
 }
 
 func (c STsAddRetention) ChunkSize(size int64) STsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsAddChunkSize)(c)
 }
 
 func (c TsAddRetention) OnDuplicateBlock() TsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (TsAddOnDuplicateBlock)(c)
 }
 
 func (c STsAddRetention) OnDuplicateBlock() STsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (STsAddOnDuplicateBlock)(c)
 }
 
 func (c TsAddRetention) OnDuplicateFirst() TsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (TsAddOnDuplicateFirst)(c)
 }
 
 func (c STsAddRetention) OnDuplicateFirst() STsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (STsAddOnDuplicateFirst)(c)
 }
 
 func (c TsAddRetention) OnDuplicateLast() TsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (TsAddOnDuplicateLast)(c)
 }
 
 func (c STsAddRetention) OnDuplicateLast() STsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (STsAddOnDuplicateLast)(c)
 }
 
 func (c TsAddRetention) OnDuplicateMin() TsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (TsAddOnDuplicateMin)(c)
 }
 
 func (c STsAddRetention) OnDuplicateMin() STsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (STsAddOnDuplicateMin)(c)
 }
 
 func (c TsAddRetention) OnDuplicateMax() TsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (TsAddOnDuplicateMax)(c)
 }
 
 func (c STsAddRetention) OnDuplicateMax() STsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (STsAddOnDuplicateMax)(c)
 }
 
 func (c TsAddRetention) OnDuplicateSum() TsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (TsAddOnDuplicateSum)(c)
 }
 
 func (c STsAddRetention) OnDuplicateSum() STsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (STsAddOnDuplicateSum)(c)
 }
 
 func (c TsAddRetention) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddRetention) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -36946,12 +38366,12 @@ type TsAddTimestamp Completed
 type STsAddTimestamp SCompleted
 
 func (c TsAddTimestamp) Value(value float64) TsAddValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TsAddValue)(c)
 }
 
 func (c STsAddTimestamp) Value(value float64) STsAddValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STsAddValue)(c)
 }
 
@@ -36960,114 +38380,114 @@ type TsAddValue Completed
 type STsAddValue SCompleted
 
 func (c TsAddValue) Retention(retentiontime int64) TsAddRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsAddRetention)(c)
 }
 
 func (c STsAddValue) Retention(retentiontime int64) STsAddRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsAddRetention)(c)
 }
 
 func (c TsAddValue) EncodingUncompressed() TsAddEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (TsAddEncodingUncompressed)(c)
 }
 
 func (c STsAddValue) EncodingUncompressed() STsAddEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (STsAddEncodingUncompressed)(c)
 }
 
 func (c TsAddValue) EncodingCompressed() TsAddEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (TsAddEncodingCompressed)(c)
 }
 
 func (c STsAddValue) EncodingCompressed() STsAddEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (STsAddEncodingCompressed)(c)
 }
 
 func (c TsAddValue) ChunkSize(size int64) TsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsAddChunkSize)(c)
 }
 
 func (c STsAddValue) ChunkSize(size int64) STsAddChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsAddChunkSize)(c)
 }
 
 func (c TsAddValue) OnDuplicateBlock() TsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (TsAddOnDuplicateBlock)(c)
 }
 
 func (c STsAddValue) OnDuplicateBlock() STsAddOnDuplicateBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "ON_DUPLICATE", "BLOCK")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "BLOCK")
 	return (STsAddOnDuplicateBlock)(c)
 }
 
 func (c TsAddValue) OnDuplicateFirst() TsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (TsAddOnDuplicateFirst)(c)
 }
 
 func (c STsAddValue) OnDuplicateFirst() STsAddOnDuplicateFirst {
-	c.cs = append(c.cs, "ON_DUPLICATE", "FIRST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "FIRST")
 	return (STsAddOnDuplicateFirst)(c)
 }
 
 func (c TsAddValue) OnDuplicateLast() TsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (TsAddOnDuplicateLast)(c)
 }
 
 func (c STsAddValue) OnDuplicateLast() STsAddOnDuplicateLast {
-	c.cs = append(c.cs, "ON_DUPLICATE", "LAST")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "LAST")
 	return (STsAddOnDuplicateLast)(c)
 }
 
 func (c TsAddValue) OnDuplicateMin() TsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (TsAddOnDuplicateMin)(c)
 }
 
 func (c STsAddValue) OnDuplicateMin() STsAddOnDuplicateMin {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MIN")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MIN")
 	return (STsAddOnDuplicateMin)(c)
 }
 
 func (c TsAddValue) OnDuplicateMax() TsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (TsAddOnDuplicateMax)(c)
 }
 
 func (c STsAddValue) OnDuplicateMax() STsAddOnDuplicateMax {
-	c.cs = append(c.cs, "ON_DUPLICATE", "MAX")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "MAX")
 	return (STsAddOnDuplicateMax)(c)
 }
 
 func (c TsAddValue) OnDuplicateSum() TsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (TsAddOnDuplicateSum)(c)
 }
 
 func (c STsAddValue) OnDuplicateSum() STsAddOnDuplicateSum {
-	c.cs = append(c.cs, "ON_DUPLICATE", "SUM")
+	c.cs.s = append(c.cs.s, "ON_DUPLICATE", "SUM")
 	return (STsAddOnDuplicateSum)(c)
 }
 
 func (c TsAddValue) Labels() TsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAddLabels)(c)
 }
 
 func (c STsAddValue) Labels() STsAddLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAddLabels)(c)
 }
 
@@ -37083,22 +38503,26 @@ type TsAlter Completed
 
 type STsAlter SCompleted
 
-func (b *Builder) TsAlter() TsAlter {
-	return TsAlter{cs: append(b.get(), "TS.ALTER"), ks: InitSlot}
+func (b *Builder) TsAlter() (c TsAlter) {
+	c = TsAlter{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.ALTER")
+	return c
 }
 
-func (b *SBuilder) TsAlter() STsAlter {
-	return STsAlter{cs: append(b.get(), "TS.ALTER"), ks: InitSlot}
+func (b *SBuilder) TsAlter() (c STsAlter) {
+	c = STsAlter{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.ALTER")
+	return c
 }
 
 func (c TsAlter) Key(key string) TsAlterKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsAlterKey)(c)
 }
 
 func (c STsAlter) Key(key string) STsAlterKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsAlterKey)(c)
 }
 
@@ -37107,22 +38531,22 @@ type TsAlterKey Completed
 type STsAlterKey SCompleted
 
 func (c TsAlterKey) Retention(retentiontime int64) TsAlterRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsAlterRetention)(c)
 }
 
 func (c STsAlterKey) Retention(retentiontime int64) STsAlterRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsAlterRetention)(c)
 }
 
 func (c TsAlterKey) Labels() TsAlterLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAlterLabels)(c)
 }
 
 func (c STsAlterKey) Labels() STsAlterLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAlterLabels)(c)
 }
 
@@ -37139,12 +38563,12 @@ type TsAlterLabels Completed
 type STsAlterLabels SCompleted
 
 func (c TsAlterLabels) Labels(label string, value string) TsAlterLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
 func (c STsAlterLabels) Labels(label string, value string) STsAlterLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
@@ -37161,12 +38585,12 @@ type TsAlterRetention Completed
 type STsAlterRetention SCompleted
 
 func (c TsAlterRetention) Labels() TsAlterLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsAlterLabels)(c)
 }
 
 func (c STsAlterRetention) Labels() STsAlterLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsAlterLabels)(c)
 }
 
@@ -37182,22 +38606,26 @@ type TsCreate Completed
 
 type STsCreate SCompleted
 
-func (b *Builder) TsCreate() TsCreate {
-	return TsCreate{cs: append(b.get(), "TS.CREATE"), ks: InitSlot}
+func (b *Builder) TsCreate() (c TsCreate) {
+	c = TsCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.CREATE")
+	return c
 }
 
-func (b *SBuilder) TsCreate() STsCreate {
-	return STsCreate{cs: append(b.get(), "TS.CREATE"), ks: InitSlot}
+func (b *SBuilder) TsCreate() (c STsCreate) {
+	c = STsCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.CREATE")
+	return c
 }
 
 func (c TsCreate) Key(key string) TsCreateKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsCreateKey)(c)
 }
 
 func (c STsCreate) Key(key string) STsCreateKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsCreateKey)(c)
 }
 
@@ -37207,73 +38635,73 @@ type STsCreateChunkSize SCompleted
 
 func (c TsCreateChunkSize) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (TsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicyBlock() STsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (STsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c TsCreateChunkSize) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (TsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicyFirst() STsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (STsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c TsCreateChunkSize) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (TsCreateDuplicatePolicyLast)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicyLast() STsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (STsCreateDuplicatePolicyLast)(c)
 }
 
 func (c TsCreateChunkSize) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (TsCreateDuplicatePolicyMin)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicyMin() STsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (STsCreateDuplicatePolicyMin)(c)
 }
 
 func (c TsCreateChunkSize) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (TsCreateDuplicatePolicyMax)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicyMax() STsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (STsCreateDuplicatePolicyMax)(c)
 }
 
 func (c TsCreateChunkSize) DuplicatePolicySum() TsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (TsCreateDuplicatePolicySum)(c)
 }
 
 func (c STsCreateChunkSize) DuplicatePolicySum() STsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (STsCreateDuplicatePolicySum)(c)
 }
 
 func (c TsCreateChunkSize) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateChunkSize) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37290,12 +38718,12 @@ type TsCreateDuplicatePolicyBlock Completed
 type STsCreateDuplicatePolicyBlock SCompleted
 
 func (c TsCreateDuplicatePolicyBlock) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicyBlock) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37312,12 +38740,12 @@ type TsCreateDuplicatePolicyFirst Completed
 type STsCreateDuplicatePolicyFirst SCompleted
 
 func (c TsCreateDuplicatePolicyFirst) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicyFirst) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37334,12 +38762,12 @@ type TsCreateDuplicatePolicyLast Completed
 type STsCreateDuplicatePolicyLast SCompleted
 
 func (c TsCreateDuplicatePolicyLast) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicyLast) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37356,12 +38784,12 @@ type TsCreateDuplicatePolicyMax Completed
 type STsCreateDuplicatePolicyMax SCompleted
 
 func (c TsCreateDuplicatePolicyMax) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicyMax) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37378,12 +38806,12 @@ type TsCreateDuplicatePolicyMin Completed
 type STsCreateDuplicatePolicyMin SCompleted
 
 func (c TsCreateDuplicatePolicyMin) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicyMin) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37400,12 +38828,12 @@ type TsCreateDuplicatePolicySum Completed
 type STsCreateDuplicatePolicySum SCompleted
 
 func (c TsCreateDuplicatePolicySum) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateDuplicatePolicySum) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37422,84 +38850,84 @@ type TsCreateEncodingCompressed Completed
 type STsCreateEncodingCompressed SCompleted
 
 func (c TsCreateEncodingCompressed) ChunkSize(size int64) TsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsCreateChunkSize)(c)
 }
 
 func (c STsCreateEncodingCompressed) ChunkSize(size int64) STsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsCreateChunkSize)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (TsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicyBlock() STsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (STsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (TsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicyFirst() STsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (STsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (TsCreateDuplicatePolicyLast)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicyLast() STsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (STsCreateDuplicatePolicyLast)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (TsCreateDuplicatePolicyMin)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicyMin() STsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (STsCreateDuplicatePolicyMin)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (TsCreateDuplicatePolicyMax)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicyMax() STsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (STsCreateDuplicatePolicyMax)(c)
 }
 
 func (c TsCreateEncodingCompressed) DuplicatePolicySum() TsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (TsCreateDuplicatePolicySum)(c)
 }
 
 func (c STsCreateEncodingCompressed) DuplicatePolicySum() STsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (STsCreateDuplicatePolicySum)(c)
 }
 
 func (c TsCreateEncodingCompressed) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateEncodingCompressed) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37516,84 +38944,84 @@ type TsCreateEncodingUncompressed Completed
 type STsCreateEncodingUncompressed SCompleted
 
 func (c TsCreateEncodingUncompressed) ChunkSize(size int64) TsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsCreateChunkSize)(c)
 }
 
 func (c STsCreateEncodingUncompressed) ChunkSize(size int64) STsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsCreateChunkSize)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (TsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicyBlock() STsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (STsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (TsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicyFirst() STsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (STsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (TsCreateDuplicatePolicyLast)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicyLast() STsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (STsCreateDuplicatePolicyLast)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (TsCreateDuplicatePolicyMin)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicyMin() STsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (STsCreateDuplicatePolicyMin)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (TsCreateDuplicatePolicyMax)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicyMax() STsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (STsCreateDuplicatePolicyMax)(c)
 }
 
 func (c TsCreateEncodingUncompressed) DuplicatePolicySum() TsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (TsCreateDuplicatePolicySum)(c)
 }
 
 func (c STsCreateEncodingUncompressed) DuplicatePolicySum() STsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (STsCreateDuplicatePolicySum)(c)
 }
 
 func (c TsCreateEncodingUncompressed) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateEncodingUncompressed) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37610,114 +39038,114 @@ type TsCreateKey Completed
 type STsCreateKey SCompleted
 
 func (c TsCreateKey) Retention(retentiontime int64) TsCreateRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsCreateRetention)(c)
 }
 
 func (c STsCreateKey) Retention(retentiontime int64) STsCreateRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsCreateRetention)(c)
 }
 
 func (c TsCreateKey) EncodingUncompressed() TsCreateEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (TsCreateEncodingUncompressed)(c)
 }
 
 func (c STsCreateKey) EncodingUncompressed() STsCreateEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (STsCreateEncodingUncompressed)(c)
 }
 
 func (c TsCreateKey) EncodingCompressed() TsCreateEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (TsCreateEncodingCompressed)(c)
 }
 
 func (c STsCreateKey) EncodingCompressed() STsCreateEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (STsCreateEncodingCompressed)(c)
 }
 
 func (c TsCreateKey) ChunkSize(size int64) TsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsCreateChunkSize)(c)
 }
 
 func (c STsCreateKey) ChunkSize(size int64) STsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsCreateChunkSize)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (TsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicyBlock() STsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (STsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (TsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicyFirst() STsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (STsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (TsCreateDuplicatePolicyLast)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicyLast() STsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (STsCreateDuplicatePolicyLast)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (TsCreateDuplicatePolicyMin)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicyMin() STsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (STsCreateDuplicatePolicyMin)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (TsCreateDuplicatePolicyMax)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicyMax() STsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (STsCreateDuplicatePolicyMax)(c)
 }
 
 func (c TsCreateKey) DuplicatePolicySum() TsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (TsCreateDuplicatePolicySum)(c)
 }
 
 func (c STsCreateKey) DuplicatePolicySum() STsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (STsCreateDuplicatePolicySum)(c)
 }
 
 func (c TsCreateKey) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateKey) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37734,12 +39162,12 @@ type TsCreateLabels Completed
 type STsCreateLabels SCompleted
 
 func (c TsCreateLabels) Labels(label string, value string) TsCreateLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
 func (c STsCreateLabels) Labels(label string, value string) STsCreateLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
@@ -37756,104 +39184,104 @@ type TsCreateRetention Completed
 type STsCreateRetention SCompleted
 
 func (c TsCreateRetention) EncodingUncompressed() TsCreateEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (TsCreateEncodingUncompressed)(c)
 }
 
 func (c STsCreateRetention) EncodingUncompressed() STsCreateEncodingUncompressed {
-	c.cs = append(c.cs, "ENCODING", "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "UNCOMPRESSED")
 	return (STsCreateEncodingUncompressed)(c)
 }
 
 func (c TsCreateRetention) EncodingCompressed() TsCreateEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (TsCreateEncodingCompressed)(c)
 }
 
 func (c STsCreateRetention) EncodingCompressed() STsCreateEncodingCompressed {
-	c.cs = append(c.cs, "ENCODING", "COMPRESSED")
+	c.cs.s = append(c.cs.s, "ENCODING", "COMPRESSED")
 	return (STsCreateEncodingCompressed)(c)
 }
 
 func (c TsCreateRetention) ChunkSize(size int64) TsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsCreateChunkSize)(c)
 }
 
 func (c STsCreateRetention) ChunkSize(size int64) STsCreateChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsCreateChunkSize)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicyBlock() TsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (TsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicyBlock() STsCreateDuplicatePolicyBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "BLOCK")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "BLOCK")
 	return (STsCreateDuplicatePolicyBlock)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicyFirst() TsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (TsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicyFirst() STsCreateDuplicatePolicyFirst {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "FIRST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "FIRST")
 	return (STsCreateDuplicatePolicyFirst)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicyLast() TsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (TsCreateDuplicatePolicyLast)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicyLast() STsCreateDuplicatePolicyLast {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "LAST")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "LAST")
 	return (STsCreateDuplicatePolicyLast)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicyMin() TsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (TsCreateDuplicatePolicyMin)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicyMin() STsCreateDuplicatePolicyMin {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MIN")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MIN")
 	return (STsCreateDuplicatePolicyMin)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicyMax() TsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (TsCreateDuplicatePolicyMax)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicyMax() STsCreateDuplicatePolicyMax {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "MAX")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "MAX")
 	return (STsCreateDuplicatePolicyMax)(c)
 }
 
 func (c TsCreateRetention) DuplicatePolicySum() TsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (TsCreateDuplicatePolicySum)(c)
 }
 
 func (c STsCreateRetention) DuplicatePolicySum() STsCreateDuplicatePolicySum {
-	c.cs = append(c.cs, "DUPLICATE_POLICY", "SUM")
+	c.cs.s = append(c.cs.s, "DUPLICATE_POLICY", "SUM")
 	return (STsCreateDuplicatePolicySum)(c)
 }
 
 func (c TsCreateRetention) Labels() TsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsCreateLabels)(c)
 }
 
 func (c STsCreateRetention) Labels() STsCreateLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsCreateLabels)(c)
 }
 
@@ -37869,22 +39297,26 @@ type TsCreaterule Completed
 
 type STsCreaterule SCompleted
 
-func (b *Builder) TsCreaterule() TsCreaterule {
-	return TsCreaterule{cs: append(b.get(), "TS.CREATERULE"), ks: InitSlot}
+func (b *Builder) TsCreaterule() (c TsCreaterule) {
+	c = TsCreaterule{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.CREATERULE")
+	return c
 }
 
-func (b *SBuilder) TsCreaterule() STsCreaterule {
-	return STsCreaterule{cs: append(b.get(), "TS.CREATERULE"), ks: InitSlot}
+func (b *SBuilder) TsCreaterule() (c STsCreaterule) {
+	c = STsCreaterule{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.CREATERULE")
+	return c
 }
 
 func (c TsCreaterule) Sourcekey(sourcekey string) TsCreateruleSourcekey {
-	c.cs = append(c.cs, sourcekey)
+	c.cs.s = append(c.cs.s, sourcekey)
 	return (TsCreateruleSourcekey)(c)
 }
 
 func (c STsCreaterule) Sourcekey(sourcekey string) STsCreateruleSourcekey {
 	c.ks = checkSlot(c.ks, slot(sourcekey))
-	c.cs = append(c.cs, sourcekey)
+	c.cs.s = append(c.cs.s, sourcekey)
 	return (STsCreateruleSourcekey)(c)
 }
 
@@ -37893,12 +39325,12 @@ type TsCreateruleAggregationAvg Completed
 type STsCreateruleAggregationAvg SCompleted
 
 func (c TsCreateruleAggregationAvg) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationAvg) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37907,12 +39339,12 @@ type TsCreateruleAggregationCount Completed
 type STsCreateruleAggregationCount SCompleted
 
 func (c TsCreateruleAggregationCount) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationCount) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37921,12 +39353,12 @@ type TsCreateruleAggregationFirst Completed
 type STsCreateruleAggregationFirst SCompleted
 
 func (c TsCreateruleAggregationFirst) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationFirst) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37935,12 +39367,12 @@ type TsCreateruleAggregationLast Completed
 type STsCreateruleAggregationLast SCompleted
 
 func (c TsCreateruleAggregationLast) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationLast) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37949,12 +39381,12 @@ type TsCreateruleAggregationMax Completed
 type STsCreateruleAggregationMax SCompleted
 
 func (c TsCreateruleAggregationMax) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationMax) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37963,12 +39395,12 @@ type TsCreateruleAggregationMin Completed
 type STsCreateruleAggregationMin SCompleted
 
 func (c TsCreateruleAggregationMin) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationMin) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37977,12 +39409,12 @@ type TsCreateruleAggregationRange Completed
 type STsCreateruleAggregationRange SCompleted
 
 func (c TsCreateruleAggregationRange) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationRange) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -37991,12 +39423,12 @@ type TsCreateruleAggregationStdP Completed
 type STsCreateruleAggregationStdP SCompleted
 
 func (c TsCreateruleAggregationStdP) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationStdP) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -38005,12 +39437,12 @@ type TsCreateruleAggregationStdS Completed
 type STsCreateruleAggregationStdS SCompleted
 
 func (c TsCreateruleAggregationStdS) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationStdS) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -38019,12 +39451,12 @@ type TsCreateruleAggregationSum Completed
 type STsCreateruleAggregationSum SCompleted
 
 func (c TsCreateruleAggregationSum) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationSum) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -38033,12 +39465,12 @@ type TsCreateruleAggregationVarP Completed
 type STsCreateruleAggregationVarP SCompleted
 
 func (c TsCreateruleAggregationVarP) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationVarP) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -38047,12 +39479,12 @@ type TsCreateruleAggregationVarS Completed
 type STsCreateruleAggregationVarS SCompleted
 
 func (c TsCreateruleAggregationVarS) Timebucket(timebucket int64) TsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsCreateruleTimebucket)(c)
 }
 
 func (c STsCreateruleAggregationVarS) Timebucket(timebucket int64) STsCreateruleTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsCreateruleTimebucket)(c)
 }
 
@@ -38061,122 +39493,122 @@ type TsCreateruleDestkey Completed
 type STsCreateruleDestkey SCompleted
 
 func (c TsCreateruleDestkey) AggregationAvg() TsCreateruleAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsCreateruleAggregationAvg)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationAvg() STsCreateruleAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsCreateruleAggregationAvg)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationSum() TsCreateruleAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsCreateruleAggregationSum)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationSum() STsCreateruleAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsCreateruleAggregationSum)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationMin() TsCreateruleAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsCreateruleAggregationMin)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationMin() STsCreateruleAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsCreateruleAggregationMin)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationMax() TsCreateruleAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsCreateruleAggregationMax)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationMax() STsCreateruleAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsCreateruleAggregationMax)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationRange() TsCreateruleAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsCreateruleAggregationRange)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationRange() STsCreateruleAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsCreateruleAggregationRange)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationCount() TsCreateruleAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsCreateruleAggregationCount)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationCount() STsCreateruleAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsCreateruleAggregationCount)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationFirst() TsCreateruleAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsCreateruleAggregationFirst)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationFirst() STsCreateruleAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsCreateruleAggregationFirst)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationLast() TsCreateruleAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsCreateruleAggregationLast)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationLast() STsCreateruleAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsCreateruleAggregationLast)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationStdP() TsCreateruleAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsCreateruleAggregationStdP)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationStdP() STsCreateruleAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsCreateruleAggregationStdP)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationStdS() TsCreateruleAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsCreateruleAggregationStdS)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationStdS() STsCreateruleAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsCreateruleAggregationStdS)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationVarP() TsCreateruleAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsCreateruleAggregationVarP)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationVarP() STsCreateruleAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsCreateruleAggregationVarP)(c)
 }
 
 func (c TsCreateruleDestkey) AggregationVarS() TsCreateruleAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsCreateruleAggregationVarS)(c)
 }
 
 func (c STsCreateruleDestkey) AggregationVarS() STsCreateruleAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsCreateruleAggregationVarS)(c)
 }
 
@@ -38185,13 +39617,13 @@ type TsCreateruleSourcekey Completed
 type STsCreateruleSourcekey SCompleted
 
 func (c TsCreateruleSourcekey) Destkey(destkey string) TsCreateruleDestkey {
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (TsCreateruleDestkey)(c)
 }
 
 func (c STsCreateruleSourcekey) Destkey(destkey string) STsCreateruleDestkey {
 	c.ks = checkSlot(c.ks, slot(destkey))
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (STsCreateruleDestkey)(c)
 }
 
@@ -38211,22 +39643,26 @@ type TsDecrby Completed
 
 type STsDecrby SCompleted
 
-func (b *Builder) TsDecrby() TsDecrby {
-	return TsDecrby{cs: append(b.get(), "TS.DECRBY"), ks: InitSlot}
+func (b *Builder) TsDecrby() (c TsDecrby) {
+	c = TsDecrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DECRBY")
+	return c
 }
 
-func (b *SBuilder) TsDecrby() STsDecrby {
-	return STsDecrby{cs: append(b.get(), "TS.DECRBY"), ks: InitSlot}
+func (b *SBuilder) TsDecrby() (c STsDecrby) {
+	c = STsDecrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DECRBY")
+	return c
 }
 
 func (c TsDecrby) Key(key string) TsDecrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsDecrbyKey)(c)
 }
 
 func (c STsDecrby) Key(key string) STsDecrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsDecrbyKey)(c)
 }
 
@@ -38235,12 +39671,12 @@ type TsDecrbyChunkSize Completed
 type STsDecrbyChunkSize SCompleted
 
 func (c TsDecrbyChunkSize) Labels() TsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsDecrbyLabels)(c)
 }
 
 func (c STsDecrbyChunkSize) Labels() STsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsDecrbyLabels)(c)
 }
 
@@ -38257,12 +39693,12 @@ type TsDecrbyKey Completed
 type STsDecrbyKey SCompleted
 
 func (c TsDecrbyKey) Value(value float64) TsDecrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TsDecrbyValue)(c)
 }
 
 func (c STsDecrbyKey) Value(value float64) STsDecrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STsDecrbyValue)(c)
 }
 
@@ -38271,12 +39707,12 @@ type TsDecrbyLabels Completed
 type STsDecrbyLabels SCompleted
 
 func (c TsDecrbyLabels) Labels(label string, value string) TsDecrbyLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
 func (c STsDecrbyLabels) Labels(label string, value string) STsDecrbyLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
@@ -38293,32 +39729,32 @@ type TsDecrbyRetention Completed
 type STsDecrbyRetention SCompleted
 
 func (c TsDecrbyRetention) Uncompressed() TsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsDecrbyUncompressed)(c)
 }
 
 func (c STsDecrbyRetention) Uncompressed() STsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsDecrbyUncompressed)(c)
 }
 
 func (c TsDecrbyRetention) ChunkSize(size int64) TsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsDecrbyChunkSize)(c)
 }
 
 func (c STsDecrbyRetention) ChunkSize(size int64) STsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsDecrbyChunkSize)(c)
 }
 
 func (c TsDecrbyRetention) Labels() TsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsDecrbyLabels)(c)
 }
 
 func (c STsDecrbyRetention) Labels() STsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsDecrbyLabels)(c)
 }
 
@@ -38335,42 +39771,42 @@ type TsDecrbyTimestamp Completed
 type STsDecrbyTimestamp SCompleted
 
 func (c TsDecrbyTimestamp) Retention(retentiontime int64) TsDecrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsDecrbyRetention)(c)
 }
 
 func (c STsDecrbyTimestamp) Retention(retentiontime int64) STsDecrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsDecrbyRetention)(c)
 }
 
 func (c TsDecrbyTimestamp) Uncompressed() TsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsDecrbyUncompressed)(c)
 }
 
 func (c STsDecrbyTimestamp) Uncompressed() STsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsDecrbyUncompressed)(c)
 }
 
 func (c TsDecrbyTimestamp) ChunkSize(size int64) TsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsDecrbyChunkSize)(c)
 }
 
 func (c STsDecrbyTimestamp) ChunkSize(size int64) STsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsDecrbyChunkSize)(c)
 }
 
 func (c TsDecrbyTimestamp) Labels() TsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsDecrbyLabels)(c)
 }
 
 func (c STsDecrbyTimestamp) Labels() STsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsDecrbyLabels)(c)
 }
 
@@ -38387,22 +39823,22 @@ type TsDecrbyUncompressed Completed
 type STsDecrbyUncompressed SCompleted
 
 func (c TsDecrbyUncompressed) ChunkSize(size int64) TsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsDecrbyChunkSize)(c)
 }
 
 func (c STsDecrbyUncompressed) ChunkSize(size int64) STsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsDecrbyChunkSize)(c)
 }
 
 func (c TsDecrbyUncompressed) Labels() TsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsDecrbyLabels)(c)
 }
 
 func (c STsDecrbyUncompressed) Labels() STsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsDecrbyLabels)(c)
 }
 
@@ -38419,52 +39855,52 @@ type TsDecrbyValue Completed
 type STsDecrbyValue SCompleted
 
 func (c TsDecrbyValue) Timestamp(timestamp int64) TsDecrbyTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (TsDecrbyTimestamp)(c)
 }
 
 func (c STsDecrbyValue) Timestamp(timestamp int64) STsDecrbyTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (STsDecrbyTimestamp)(c)
 }
 
 func (c TsDecrbyValue) Retention(retentiontime int64) TsDecrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsDecrbyRetention)(c)
 }
 
 func (c STsDecrbyValue) Retention(retentiontime int64) STsDecrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsDecrbyRetention)(c)
 }
 
 func (c TsDecrbyValue) Uncompressed() TsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsDecrbyUncompressed)(c)
 }
 
 func (c STsDecrbyValue) Uncompressed() STsDecrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsDecrbyUncompressed)(c)
 }
 
 func (c TsDecrbyValue) ChunkSize(size int64) TsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsDecrbyChunkSize)(c)
 }
 
 func (c STsDecrbyValue) ChunkSize(size int64) STsDecrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsDecrbyChunkSize)(c)
 }
 
 func (c TsDecrbyValue) Labels() TsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsDecrbyLabels)(c)
 }
 
 func (c STsDecrbyValue) Labels() STsDecrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsDecrbyLabels)(c)
 }
 
@@ -38480,22 +39916,26 @@ type TsDel Completed
 
 type STsDel SCompleted
 
-func (b *Builder) TsDel() TsDel {
-	return TsDel{cs: append(b.get(), "TS.DEL"), ks: InitSlot}
+func (b *Builder) TsDel() (c TsDel) {
+	c = TsDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DEL")
+	return c
 }
 
-func (b *SBuilder) TsDel() STsDel {
-	return STsDel{cs: append(b.get(), "TS.DEL"), ks: InitSlot}
+func (b *SBuilder) TsDel() (c STsDel) {
+	c = STsDel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DEL")
+	return c
 }
 
 func (c TsDel) Key(key string) TsDelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsDelKey)(c)
 }
 
 func (c STsDel) Key(key string) STsDelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsDelKey)(c)
 }
 
@@ -38504,12 +39944,12 @@ type TsDelFromTimestamp Completed
 type STsDelFromTimestamp SCompleted
 
 func (c TsDelFromTimestamp) ToTimestamp(toTimestamp int64) TsDelToTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(toTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(toTimestamp, 10))
 	return (TsDelToTimestamp)(c)
 }
 
 func (c STsDelFromTimestamp) ToTimestamp(toTimestamp int64) STsDelToTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(toTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(toTimestamp, 10))
 	return (STsDelToTimestamp)(c)
 }
 
@@ -38518,12 +39958,12 @@ type TsDelKey Completed
 type STsDelKey SCompleted
 
 func (c TsDelKey) FromTimestamp(fromTimestamp int64) TsDelFromTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromTimestamp, 10))
 	return (TsDelFromTimestamp)(c)
 }
 
 func (c STsDelKey) FromTimestamp(fromTimestamp int64) STsDelFromTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromTimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromTimestamp, 10))
 	return (STsDelFromTimestamp)(c)
 }
 
@@ -38543,22 +39983,26 @@ type TsDeleterule Completed
 
 type STsDeleterule SCompleted
 
-func (b *Builder) TsDeleterule() TsDeleterule {
-	return TsDeleterule{cs: append(b.get(), "TS.DELETERULE"), ks: InitSlot}
+func (b *Builder) TsDeleterule() (c TsDeleterule) {
+	c = TsDeleterule{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DELETERULE")
+	return c
 }
 
-func (b *SBuilder) TsDeleterule() STsDeleterule {
-	return STsDeleterule{cs: append(b.get(), "TS.DELETERULE"), ks: InitSlot}
+func (b *SBuilder) TsDeleterule() (c STsDeleterule) {
+	c = STsDeleterule{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.DELETERULE")
+	return c
 }
 
 func (c TsDeleterule) Sourcekey(sourcekey string) TsDeleteruleSourcekey {
-	c.cs = append(c.cs, sourcekey)
+	c.cs.s = append(c.cs.s, sourcekey)
 	return (TsDeleteruleSourcekey)(c)
 }
 
 func (c STsDeleterule) Sourcekey(sourcekey string) STsDeleteruleSourcekey {
 	c.ks = checkSlot(c.ks, slot(sourcekey))
-	c.cs = append(c.cs, sourcekey)
+	c.cs.s = append(c.cs.s, sourcekey)
 	return (STsDeleteruleSourcekey)(c)
 }
 
@@ -38579,13 +40023,13 @@ type TsDeleteruleSourcekey Completed
 type STsDeleteruleSourcekey SCompleted
 
 func (c TsDeleteruleSourcekey) Destkey(destkey string) TsDeleteruleDestkey {
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (TsDeleteruleDestkey)(c)
 }
 
 func (c STsDeleteruleSourcekey) Destkey(destkey string) STsDeleteruleDestkey {
 	c.ks = checkSlot(c.ks, slot(destkey))
-	c.cs = append(c.cs, destkey)
+	c.cs.s = append(c.cs.s, destkey)
 	return (STsDeleteruleDestkey)(c)
 }
 
@@ -38593,22 +40037,26 @@ type TsGet Completed
 
 type STsGet SCompleted
 
-func (b *Builder) TsGet() TsGet {
-	return TsGet{cs: append(b.get(), "TS.GET"), ks: InitSlot, cf: readonly}
+func (b *Builder) TsGet() (c TsGet) {
+	c = TsGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.GET")
+	return c
 }
 
-func (b *SBuilder) TsGet() STsGet {
-	return STsGet{cs: append(b.get(), "TS.GET"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TsGet() (c STsGet) {
+	c = STsGet{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.GET")
+	return c
 }
 
 func (c TsGet) Key(key string) TsGetKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsGetKey)(c)
 }
 
 func (c STsGet) Key(key string) STsGetKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsGetKey)(c)
 }
 
@@ -38628,22 +40076,26 @@ type TsIncrby Completed
 
 type STsIncrby SCompleted
 
-func (b *Builder) TsIncrby() TsIncrby {
-	return TsIncrby{cs: append(b.get(), "TS.INCRBY"), ks: InitSlot}
+func (b *Builder) TsIncrby() (c TsIncrby) {
+	c = TsIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.INCRBY")
+	return c
 }
 
-func (b *SBuilder) TsIncrby() STsIncrby {
-	return STsIncrby{cs: append(b.get(), "TS.INCRBY"), ks: InitSlot}
+func (b *SBuilder) TsIncrby() (c STsIncrby) {
+	c = STsIncrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.INCRBY")
+	return c
 }
 
 func (c TsIncrby) Key(key string) TsIncrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsIncrbyKey)(c)
 }
 
 func (c STsIncrby) Key(key string) STsIncrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsIncrbyKey)(c)
 }
 
@@ -38652,12 +40104,12 @@ type TsIncrbyChunkSize Completed
 type STsIncrbyChunkSize SCompleted
 
 func (c TsIncrbyChunkSize) Labels() TsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsIncrbyLabels)(c)
 }
 
 func (c STsIncrbyChunkSize) Labels() STsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsIncrbyLabels)(c)
 }
 
@@ -38674,12 +40126,12 @@ type TsIncrbyKey Completed
 type STsIncrbyKey SCompleted
 
 func (c TsIncrbyKey) Value(value float64) TsIncrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (TsIncrbyValue)(c)
 }
 
 func (c STsIncrbyKey) Value(value float64) STsIncrbyValue {
-	c.cs = append(c.cs, strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
 	return (STsIncrbyValue)(c)
 }
 
@@ -38688,12 +40140,12 @@ type TsIncrbyLabels Completed
 type STsIncrbyLabels SCompleted
 
 func (c TsIncrbyLabels) Labels(label string, value string) TsIncrbyLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
 func (c STsIncrbyLabels) Labels(label string, value string) STsIncrbyLabels {
-	c.cs = append(c.cs, label, value)
+	c.cs.s = append(c.cs.s, label, value)
 	return c
 }
 
@@ -38710,32 +40162,32 @@ type TsIncrbyRetention Completed
 type STsIncrbyRetention SCompleted
 
 func (c TsIncrbyRetention) Uncompressed() TsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsIncrbyUncompressed)(c)
 }
 
 func (c STsIncrbyRetention) Uncompressed() STsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsIncrbyUncompressed)(c)
 }
 
 func (c TsIncrbyRetention) ChunkSize(size int64) TsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsIncrbyChunkSize)(c)
 }
 
 func (c STsIncrbyRetention) ChunkSize(size int64) STsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsIncrbyChunkSize)(c)
 }
 
 func (c TsIncrbyRetention) Labels() TsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsIncrbyLabels)(c)
 }
 
 func (c STsIncrbyRetention) Labels() STsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsIncrbyLabels)(c)
 }
 
@@ -38752,42 +40204,42 @@ type TsIncrbyTimestamp Completed
 type STsIncrbyTimestamp SCompleted
 
 func (c TsIncrbyTimestamp) Retention(retentiontime int64) TsIncrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsIncrbyRetention)(c)
 }
 
 func (c STsIncrbyTimestamp) Retention(retentiontime int64) STsIncrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsIncrbyRetention)(c)
 }
 
 func (c TsIncrbyTimestamp) Uncompressed() TsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsIncrbyUncompressed)(c)
 }
 
 func (c STsIncrbyTimestamp) Uncompressed() STsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsIncrbyUncompressed)(c)
 }
 
 func (c TsIncrbyTimestamp) ChunkSize(size int64) TsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsIncrbyChunkSize)(c)
 }
 
 func (c STsIncrbyTimestamp) ChunkSize(size int64) STsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsIncrbyChunkSize)(c)
 }
 
 func (c TsIncrbyTimestamp) Labels() TsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsIncrbyLabels)(c)
 }
 
 func (c STsIncrbyTimestamp) Labels() STsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsIncrbyLabels)(c)
 }
 
@@ -38804,22 +40256,22 @@ type TsIncrbyUncompressed Completed
 type STsIncrbyUncompressed SCompleted
 
 func (c TsIncrbyUncompressed) ChunkSize(size int64) TsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsIncrbyChunkSize)(c)
 }
 
 func (c STsIncrbyUncompressed) ChunkSize(size int64) STsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsIncrbyChunkSize)(c)
 }
 
 func (c TsIncrbyUncompressed) Labels() TsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsIncrbyLabels)(c)
 }
 
 func (c STsIncrbyUncompressed) Labels() STsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsIncrbyLabels)(c)
 }
 
@@ -38836,52 +40288,52 @@ type TsIncrbyValue Completed
 type STsIncrbyValue SCompleted
 
 func (c TsIncrbyValue) Timestamp(timestamp int64) TsIncrbyTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (TsIncrbyTimestamp)(c)
 }
 
 func (c STsIncrbyValue) Timestamp(timestamp int64) STsIncrbyTimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(timestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timestamp, 10))
 	return (STsIncrbyTimestamp)(c)
 }
 
 func (c TsIncrbyValue) Retention(retentiontime int64) TsIncrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (TsIncrbyRetention)(c)
 }
 
 func (c STsIncrbyValue) Retention(retentiontime int64) STsIncrbyRetention {
-	c.cs = append(c.cs, "RETENTION", strconv.FormatInt(retentiontime, 10))
+	c.cs.s = append(c.cs.s, "RETENTION", strconv.FormatInt(retentiontime, 10))
 	return (STsIncrbyRetention)(c)
 }
 
 func (c TsIncrbyValue) Uncompressed() TsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (TsIncrbyUncompressed)(c)
 }
 
 func (c STsIncrbyValue) Uncompressed() STsIncrbyUncompressed {
-	c.cs = append(c.cs, "UNCOMPRESSED")
+	c.cs.s = append(c.cs.s, "UNCOMPRESSED")
 	return (STsIncrbyUncompressed)(c)
 }
 
 func (c TsIncrbyValue) ChunkSize(size int64) TsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (TsIncrbyChunkSize)(c)
 }
 
 func (c STsIncrbyValue) ChunkSize(size int64) STsIncrbyChunkSize {
-	c.cs = append(c.cs, "CHUNK_SIZE", strconv.FormatInt(size, 10))
+	c.cs.s = append(c.cs.s, "CHUNK_SIZE", strconv.FormatInt(size, 10))
 	return (STsIncrbyChunkSize)(c)
 }
 
 func (c TsIncrbyValue) Labels() TsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (TsIncrbyLabels)(c)
 }
 
 func (c STsIncrbyValue) Labels() STsIncrbyLabels {
-	c.cs = append(c.cs, "LABELS")
+	c.cs.s = append(c.cs.s, "LABELS")
 	return (STsIncrbyLabels)(c)
 }
 
@@ -38897,22 +40349,26 @@ type TsInfo Completed
 
 type STsInfo SCompleted
 
-func (b *Builder) TsInfo() TsInfo {
-	return TsInfo{cs: append(b.get(), "TS.INFO"), ks: InitSlot, cf: readonly}
+func (b *Builder) TsInfo() (c TsInfo) {
+	c = TsInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.INFO")
+	return c
 }
 
-func (b *SBuilder) TsInfo() STsInfo {
-	return STsInfo{cs: append(b.get(), "TS.INFO"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TsInfo() (c STsInfo) {
+	c = STsInfo{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.INFO")
+	return c
 }
 
 func (c TsInfo) Key(key string) TsInfoKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsInfoKey)(c)
 }
 
 func (c STsInfo) Key(key string) STsInfoKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsInfoKey)(c)
 }
 
@@ -38933,12 +40389,12 @@ type TsInfoKey Completed
 type STsInfoKey SCompleted
 
 func (c TsInfoKey) Debug(debug string) TsInfoDebug {
-	c.cs = append(c.cs, debug)
+	c.cs.s = append(c.cs.s, debug)
 	return (TsInfoDebug)(c)
 }
 
 func (c STsInfoKey) Debug(debug string) STsInfoDebug {
-	c.cs = append(c.cs, debug)
+	c.cs.s = append(c.cs.s, debug)
 	return (STsInfoDebug)(c)
 }
 
@@ -38954,12 +40410,16 @@ type TsMadd Completed
 
 type STsMadd SCompleted
 
-func (b *Builder) TsMadd() TsMadd {
-	return TsMadd{cs: append(b.get(), "TS.MADD"), ks: InitSlot}
+func (b *Builder) TsMadd() (c TsMadd) {
+	c = TsMadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MADD")
+	return c
 }
 
-func (b *SBuilder) TsMadd() STsMadd {
-	return STsMadd{cs: append(b.get(), "TS.MADD"), ks: InitSlot}
+func (b *SBuilder) TsMadd() (c STsMadd) {
+	c = STsMadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MADD")
+	return c
 }
 
 func (c TsMadd) KeyTimestampValue() TsMaddKeyTimestampValue {
@@ -38975,13 +40435,13 @@ type TsMaddKeyTimestampValue Completed
 type STsMaddKeyTimestampValue SCompleted
 
 func (c TsMaddKeyTimestampValue) KeyTimestampValue(key string, timestamp int64, value float64) TsMaddKeyTimestampValue {
-	c.cs = append(c.cs, key, strconv.FormatInt(timestamp, 10), strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, key, strconv.FormatInt(timestamp, 10), strconv.FormatFloat(value, 'f', -1, 64))
 	return c
 }
 
 func (c STsMaddKeyTimestampValue) KeyTimestampValue(key string, timestamp int64, value float64) STsMaddKeyTimestampValue {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key, strconv.FormatInt(timestamp, 10), strconv.FormatFloat(value, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, key, strconv.FormatInt(timestamp, 10), strconv.FormatFloat(value, 'f', -1, 64))
 	return c
 }
 
@@ -38997,45 +40457,49 @@ type TsMget Completed
 
 type STsMget SCompleted
 
-func (b *Builder) TsMget() TsMget {
-	return TsMget{cs: append(b.get(), "TS.MGET"), ks: InitSlot}
+func (b *Builder) TsMget() (c TsMget) {
+	c = TsMget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MGET")
+	return c
 }
 
-func (b *SBuilder) TsMget() STsMget {
-	return STsMget{cs: append(b.get(), "TS.MGET"), ks: InitSlot}
+func (b *SBuilder) TsMget() (c STsMget) {
+	c = STsMget{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MGET")
+	return c
 }
 
 func (c TsMget) Withlabels() TsMgetWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMgetWithlabels)(c)
 }
 
 func (c STsMget) Withlabels() STsMgetWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMgetWithlabels)(c)
 }
 
 func (c TsMget) SelectedLabels(labels []string) TsMgetSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMgetSelectedLabels)(c)
 }
 
 func (c STsMget) SelectedLabels(labels []string) STsMgetSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMgetSelectedLabels)(c)
 }
 
 func (c TsMget) Filter(filter ...string) TsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMgetFilter)(c)
 }
 
 func (c STsMget) Filter(filter ...string) STsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMgetFilter)(c)
 }
 
@@ -39044,14 +40508,14 @@ type TsMgetFilter Completed
 type STsMgetFilter SCompleted
 
 func (c TsMgetFilter) Filter(filter ...string) TsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
 func (c STsMgetFilter) Filter(filter ...string) STsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
@@ -39068,14 +40532,14 @@ type TsMgetSelectedLabels Completed
 type STsMgetSelectedLabels SCompleted
 
 func (c TsMgetSelectedLabels) Filter(filter ...string) TsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMgetFilter)(c)
 }
 
 func (c STsMgetSelectedLabels) Filter(filter ...string) STsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMgetFilter)(c)
 }
 
@@ -39084,14 +40548,14 @@ type TsMgetWithlabels Completed
 type STsMgetWithlabels SCompleted
 
 func (c TsMgetWithlabels) Filter(filter ...string) TsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMgetFilter)(c)
 }
 
 func (c STsMgetWithlabels) Filter(filter ...string) STsMgetFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMgetFilter)(c)
 }
 
@@ -39099,22 +40563,26 @@ type TsMrange Completed
 
 type STsMrange SCompleted
 
-func (b *Builder) TsMrange() TsMrange {
-	return TsMrange{cs: append(b.get(), "TS.MRANGE"), ks: InitSlot}
+func (b *Builder) TsMrange() (c TsMrange) {
+	c = TsMrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MRANGE")
+	return c
 }
 
-func (b *SBuilder) TsMrange() STsMrange {
-	return STsMrange{cs: append(b.get(), "TS.MRANGE"), ks: InitSlot}
+func (b *SBuilder) TsMrange() (c STsMrange) {
+	c = STsMrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MRANGE")
+	return c
 }
 
 func (c TsMrange) Key(key string) TsMrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsMrangeKey)(c)
 }
 
 func (c STsMrange) Key(key string) STsMrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsMrangeKey)(c)
 }
 
@@ -39123,12 +40591,12 @@ type TsMrangeAggregationAggregationAvg Completed
 type STsMrangeAggregationAggregationAvg SCompleted
 
 func (c TsMrangeAggregationAggregationAvg) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationAvg) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39137,12 +40605,12 @@ type TsMrangeAggregationAggregationCount Completed
 type STsMrangeAggregationAggregationCount SCompleted
 
 func (c TsMrangeAggregationAggregationCount) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationCount) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39151,12 +40619,12 @@ type TsMrangeAggregationAggregationFirst Completed
 type STsMrangeAggregationAggregationFirst SCompleted
 
 func (c TsMrangeAggregationAggregationFirst) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationFirst) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39165,12 +40633,12 @@ type TsMrangeAggregationAggregationLast Completed
 type STsMrangeAggregationAggregationLast SCompleted
 
 func (c TsMrangeAggregationAggregationLast) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationLast) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39179,12 +40647,12 @@ type TsMrangeAggregationAggregationMax Completed
 type STsMrangeAggregationAggregationMax SCompleted
 
 func (c TsMrangeAggregationAggregationMax) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationMax) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39193,12 +40661,12 @@ type TsMrangeAggregationAggregationMin Completed
 type STsMrangeAggregationAggregationMin SCompleted
 
 func (c TsMrangeAggregationAggregationMin) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationMin) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39207,12 +40675,12 @@ type TsMrangeAggregationAggregationRange Completed
 type STsMrangeAggregationAggregationRange SCompleted
 
 func (c TsMrangeAggregationAggregationRange) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationRange) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39221,12 +40689,12 @@ type TsMrangeAggregationAggregationStdP Completed
 type STsMrangeAggregationAggregationStdP SCompleted
 
 func (c TsMrangeAggregationAggregationStdP) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationStdP) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39235,12 +40703,12 @@ type TsMrangeAggregationAggregationStdS Completed
 type STsMrangeAggregationAggregationStdS SCompleted
 
 func (c TsMrangeAggregationAggregationStdS) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationStdS) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39249,12 +40717,12 @@ type TsMrangeAggregationAggregationSum Completed
 type STsMrangeAggregationAggregationSum SCompleted
 
 func (c TsMrangeAggregationAggregationSum) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationSum) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39263,12 +40731,12 @@ type TsMrangeAggregationAggregationVarP Completed
 type STsMrangeAggregationAggregationVarP SCompleted
 
 func (c TsMrangeAggregationAggregationVarP) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationVarP) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39277,12 +40745,12 @@ type TsMrangeAggregationAggregationVarS Completed
 type STsMrangeAggregationAggregationVarS SCompleted
 
 func (c TsMrangeAggregationAggregationVarS) Timebucket(timebucket int64) TsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrangeAggregationAggregationVarS) Timebucket(timebucket int64) STsMrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrangeAggregationTimebucket)(c)
 }
 
@@ -39291,14 +40759,14 @@ type TsMrangeAggregationTimebucket Completed
 type STsMrangeAggregationTimebucket SCompleted
 
 func (c TsMrangeAggregationTimebucket) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeAggregationTimebucket) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -39307,134 +40775,134 @@ type TsMrangeAlign Completed
 type STsMrangeAlign SCompleted
 
 func (c TsMrangeAlign) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeAlign) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeAlign) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeAlign) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeAlign) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeAlign) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeAlign) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeAlign) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeAlign) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeAlign) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeAlign) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeAlign) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeAlign) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeAlign) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeAlign) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeAlign) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeAlign) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeAlign) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeAlign) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeAlign) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeAlign) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeAlign) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeAlign) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeAlign) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeAlign) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeAlign) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -39443,144 +40911,144 @@ type TsMrangeCount Completed
 type STsMrangeCount SCompleted
 
 func (c TsMrangeCount) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeCount) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeCount) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeCount) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeCount) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeCount) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeCount) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeCount) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeCount) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeCount) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeCount) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeCount) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeCount) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeCount) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeCount) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeCount) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeCount) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeCount) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeCount) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeCount) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeCount) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeCount) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeCount) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeCount) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeCount) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeCount) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeCount) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeCount) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -39589,24 +41057,24 @@ type TsMrangeFilter Completed
 type STsMrangeFilter SCompleted
 
 func (c TsMrangeFilter) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
 func (c STsMrangeFilter) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	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 = append(c.cs, "GROUPBY", label, reduce, reducer)
+	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
 	return (TsMrangeGroupby)(c)
 }
 
 func (c STsMrangeFilter) Groupby(label string, reduce string, reducer string) STsMrangeGroupby {
-	c.cs = append(c.cs, "GROUPBY", label, reduce, reducer)
+	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
 	return (STsMrangeGroupby)(c)
 }
 
@@ -39623,202 +41091,202 @@ type TsMrangeFilterByTs Completed
 type STsMrangeFilterByTs SCompleted
 
 func (c TsMrangeFilterByTs) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c STsMrangeFilterByTs) FilterByTs(timestamp ...int64) STsMrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c TsMrangeFilterByTs) FilterByValue(min float64, max float64) TsMrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsMrangeFilterByTs) FilterByValue(min float64, max float64) STsMrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsMrangeFilterByValue)(c)
 }
 
 func (c TsMrangeFilterByTs) Withlabels() TsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrangeWithlabels)(c)
 }
 
 func (c STsMrangeFilterByTs) Withlabels() STsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrangeWithlabels)(c)
 }
 
 func (c TsMrangeFilterByTs) SelectedLabels(labels []string) TsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrangeSelectedLabels)(c)
 }
 
 func (c STsMrangeFilterByTs) SelectedLabels(labels []string) STsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrangeSelectedLabels)(c)
 }
 
 func (c TsMrangeFilterByTs) Count(count int64) TsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrangeCount)(c)
 }
 
 func (c STsMrangeFilterByTs) Count(count int64) STsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrangeCount)(c)
 }
 
 func (c TsMrangeFilterByTs) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeFilterByTs) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeFilterByTs) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeFilterByTs) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeFilterByTs) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeFilterByTs) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -39827,176 +41295,176 @@ type TsMrangeFilterByValue Completed
 type STsMrangeFilterByValue SCompleted
 
 func (c TsMrangeFilterByValue) Withlabels() TsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrangeWithlabels)(c)
 }
 
 func (c STsMrangeFilterByValue) Withlabels() STsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrangeWithlabels)(c)
 }
 
 func (c TsMrangeFilterByValue) SelectedLabels(labels []string) TsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrangeSelectedLabels)(c)
 }
 
 func (c STsMrangeFilterByValue) SelectedLabels(labels []string) STsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrangeSelectedLabels)(c)
 }
 
 func (c TsMrangeFilterByValue) Count(count int64) TsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrangeCount)(c)
 }
 
 func (c STsMrangeFilterByValue) Count(count int64) STsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrangeCount)(c)
 }
 
 func (c TsMrangeFilterByValue) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeFilterByValue) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeFilterByValue) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeFilterByValue) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeFilterByValue) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeFilterByValue) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -40005,12 +41473,12 @@ type TsMrangeFromtimestamp Completed
 type STsMrangeFromtimestamp SCompleted
 
 func (c TsMrangeFromtimestamp) Totimestamp(totimestamp int64) TsMrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (TsMrangeTotimestamp)(c)
 }
 
 func (c STsMrangeFromtimestamp) Totimestamp(totimestamp int64) STsMrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (STsMrangeTotimestamp)(c)
 }
 
@@ -40031,12 +41499,12 @@ type TsMrangeKey Completed
 type STsMrangeKey SCompleted
 
 func (c TsMrangeKey) Fromtimestamp(fromtimestamp int64) TsMrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (TsMrangeFromtimestamp)(c)
 }
 
 func (c STsMrangeKey) Fromtimestamp(fromtimestamp int64) STsMrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (STsMrangeFromtimestamp)(c)
 }
 
@@ -40045,154 +41513,154 @@ type TsMrangeSelectedLabels Completed
 type STsMrangeSelectedLabels SCompleted
 
 func (c TsMrangeSelectedLabels) Count(count int64) TsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrangeCount)(c)
 }
 
 func (c STsMrangeSelectedLabels) Count(count int64) STsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrangeCount)(c)
 }
 
 func (c TsMrangeSelectedLabels) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeSelectedLabels) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeSelectedLabels) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeSelectedLabels) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeSelectedLabels) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeSelectedLabels) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -40201,202 +41669,202 @@ type TsMrangeTotimestamp Completed
 type STsMrangeTotimestamp SCompleted
 
 func (c TsMrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (TsMrangeFilterByTs)(c)
 }
 
 func (c STsMrangeTotimestamp) FilterByTs(timestamp ...int64) STsMrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (STsMrangeFilterByTs)(c)
 }
 
 func (c TsMrangeTotimestamp) FilterByValue(min float64, max float64) TsMrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsMrangeTotimestamp) FilterByValue(min float64, max float64) STsMrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsMrangeFilterByValue)(c)
 }
 
 func (c TsMrangeTotimestamp) Withlabels() TsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrangeWithlabels)(c)
 }
 
 func (c STsMrangeTotimestamp) Withlabels() STsMrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrangeWithlabels)(c)
 }
 
 func (c TsMrangeTotimestamp) SelectedLabels(labels []string) TsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrangeSelectedLabels)(c)
 }
 
 func (c STsMrangeTotimestamp) SelectedLabels(labels []string) STsMrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrangeSelectedLabels)(c)
 }
 
 func (c TsMrangeTotimestamp) Count(count int64) TsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrangeCount)(c)
 }
 
 func (c STsMrangeTotimestamp) Count(count int64) STsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrangeCount)(c)
 }
 
 func (c TsMrangeTotimestamp) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeTotimestamp) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeTotimestamp) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeTotimestamp) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeTotimestamp) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeTotimestamp) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -40405,154 +41873,154 @@ type TsMrangeWithlabels Completed
 type STsMrangeWithlabels SCompleted
 
 func (c TsMrangeWithlabels) Count(count int64) TsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrangeCount)(c)
 }
 
 func (c STsMrangeWithlabels) Count(count int64) STsMrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrangeCount)(c)
 }
 
 func (c TsMrangeWithlabels) Align(value int64) TsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrangeAlign)(c)
 }
 
 func (c STsMrangeWithlabels) Align(value int64) STsMrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrangeAlign)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationAvg() TsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationAvg() STsMrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationSum() TsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationSum() STsMrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationMin() TsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationMin() STsMrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationMax() TsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationMax() STsMrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationRange() TsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationRange() STsMrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationCount() TsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationCount() STsMrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationFirst() TsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationFirst() STsMrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationLast() TsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationLast() STsMrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationStdP() TsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationStdP() STsMrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationStdS() TsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationStdS() STsMrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationVarP() TsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationVarP() STsMrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrangeWithlabels) AggregationVarS() TsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrangeWithlabels) AggregationVarS() STsMrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrangeWithlabels) Filter(filter ...string) TsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrangeFilter)(c)
 }
 
 func (c STsMrangeWithlabels) Filter(filter ...string) STsMrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrangeFilter)(c)
 }
 
@@ -40560,22 +42028,26 @@ type TsMrevrange Completed
 
 type STsMrevrange SCompleted
 
-func (b *Builder) TsMrevrange() TsMrevrange {
-	return TsMrevrange{cs: append(b.get(), "TS.MREVRANGE"), ks: InitSlot}
+func (b *Builder) TsMrevrange() (c TsMrevrange) {
+	c = TsMrevrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MREVRANGE")
+	return c
 }
 
-func (b *SBuilder) TsMrevrange() STsMrevrange {
-	return STsMrevrange{cs: append(b.get(), "TS.MREVRANGE"), ks: InitSlot}
+func (b *SBuilder) TsMrevrange() (c STsMrevrange) {
+	c = STsMrevrange{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "TS.MREVRANGE")
+	return c
 }
 
 func (c TsMrevrange) Key(key string) TsMrevrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsMrevrangeKey)(c)
 }
 
 func (c STsMrevrange) Key(key string) STsMrevrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsMrevrangeKey)(c)
 }
 
@@ -40584,12 +42056,12 @@ type TsMrevrangeAggregationAggregationAvg Completed
 type STsMrevrangeAggregationAggregationAvg SCompleted
 
 func (c TsMrevrangeAggregationAggregationAvg) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationAvg) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40598,12 +42070,12 @@ type TsMrevrangeAggregationAggregationCount Completed
 type STsMrevrangeAggregationAggregationCount SCompleted
 
 func (c TsMrevrangeAggregationAggregationCount) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationCount) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40612,12 +42084,12 @@ type TsMrevrangeAggregationAggregationFirst Completed
 type STsMrevrangeAggregationAggregationFirst SCompleted
 
 func (c TsMrevrangeAggregationAggregationFirst) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationFirst) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40626,12 +42098,12 @@ type TsMrevrangeAggregationAggregationLast Completed
 type STsMrevrangeAggregationAggregationLast SCompleted
 
 func (c TsMrevrangeAggregationAggregationLast) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationLast) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40640,12 +42112,12 @@ type TsMrevrangeAggregationAggregationMax Completed
 type STsMrevrangeAggregationAggregationMax SCompleted
 
 func (c TsMrevrangeAggregationAggregationMax) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationMax) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40654,12 +42126,12 @@ type TsMrevrangeAggregationAggregationMin Completed
 type STsMrevrangeAggregationAggregationMin SCompleted
 
 func (c TsMrevrangeAggregationAggregationMin) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationMin) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40668,12 +42140,12 @@ type TsMrevrangeAggregationAggregationRange Completed
 type STsMrevrangeAggregationAggregationRange SCompleted
 
 func (c TsMrevrangeAggregationAggregationRange) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationRange) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40682,12 +42154,12 @@ type TsMrevrangeAggregationAggregationStdP Completed
 type STsMrevrangeAggregationAggregationStdP SCompleted
 
 func (c TsMrevrangeAggregationAggregationStdP) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationStdP) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40696,12 +42168,12 @@ type TsMrevrangeAggregationAggregationStdS Completed
 type STsMrevrangeAggregationAggregationStdS SCompleted
 
 func (c TsMrevrangeAggregationAggregationStdS) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationStdS) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40710,12 +42182,12 @@ type TsMrevrangeAggregationAggregationSum Completed
 type STsMrevrangeAggregationAggregationSum SCompleted
 
 func (c TsMrevrangeAggregationAggregationSum) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationSum) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40724,12 +42196,12 @@ type TsMrevrangeAggregationAggregationVarP Completed
 type STsMrevrangeAggregationAggregationVarP SCompleted
 
 func (c TsMrevrangeAggregationAggregationVarP) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationVarP) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40738,12 +42210,12 @@ type TsMrevrangeAggregationAggregationVarS Completed
 type STsMrevrangeAggregationAggregationVarS SCompleted
 
 func (c TsMrevrangeAggregationAggregationVarS) Timebucket(timebucket int64) TsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsMrevrangeAggregationTimebucket)(c)
 }
 
 func (c STsMrevrangeAggregationAggregationVarS) Timebucket(timebucket int64) STsMrevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsMrevrangeAggregationTimebucket)(c)
 }
 
@@ -40752,14 +42224,14 @@ type TsMrevrangeAggregationTimebucket Completed
 type STsMrevrangeAggregationTimebucket SCompleted
 
 func (c TsMrevrangeAggregationTimebucket) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeAggregationTimebucket) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -40768,134 +42240,134 @@ type TsMrevrangeAlign Completed
 type STsMrevrangeAlign SCompleted
 
 func (c TsMrevrangeAlign) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeAlign) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeAlign) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeAlign) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeAlign) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -40904,144 +42376,144 @@ type TsMrevrangeCount Completed
 type STsMrevrangeCount SCompleted
 
 func (c TsMrevrangeCount) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeCount) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeCount) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeCount) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeCount) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeCount) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeCount) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeCount) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeCount) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeCount) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeCount) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeCount) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeCount) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeCount) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeCount) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeCount) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeCount) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeCount) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeCount) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeCount) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeCount) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeCount) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeCount) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeCount) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeCount) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeCount) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeCount) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeCount) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -41050,24 +42522,24 @@ type TsMrevrangeFilter Completed
 type STsMrevrangeFilter SCompleted
 
 func (c TsMrevrangeFilter) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
 func (c STsMrevrangeFilter) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	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 = append(c.cs, "GROUPBY", label, reduce, reducer)
+	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
 	return (TsMrevrangeGroupby)(c)
 }
 
 func (c STsMrevrangeFilter) Groupby(label string, reduce string, reducer string) STsMrevrangeGroupby {
-	c.cs = append(c.cs, "GROUPBY", label, reduce, reducer)
+	c.cs.s = append(c.cs.s, "GROUPBY", label, reduce, reducer)
 	return (STsMrevrangeGroupby)(c)
 }
 
@@ -41084,202 +42556,202 @@ type TsMrevrangeFilterByTs Completed
 type STsMrevrangeFilterByTs SCompleted
 
 func (c TsMrevrangeFilterByTs) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c STsMrevrangeFilterByTs) FilterByTs(timestamp ...int64) STsMrevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c TsMrevrangeFilterByTs) FilterByValue(min float64, max float64) TsMrevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsMrevrangeFilterByTs) FilterByValue(min float64, max float64) STsMrevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsMrevrangeFilterByValue)(c)
 }
 
 func (c TsMrevrangeFilterByTs) Withlabels() TsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrevrangeWithlabels)(c)
 }
 
 func (c STsMrevrangeFilterByTs) Withlabels() STsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrevrangeWithlabels)(c)
 }
 
 func (c TsMrevrangeFilterByTs) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrevrangeSelectedLabels)(c)
 }
 
 func (c STsMrevrangeFilterByTs) SelectedLabels(labels []string) STsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrevrangeSelectedLabels)(c)
 }
 
 func (c TsMrevrangeFilterByTs) Count(count int64) TsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrevrangeCount)(c)
 }
 
 func (c STsMrevrangeFilterByTs) Count(count int64) STsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrevrangeCount)(c)
 }
 
 func (c TsMrevrangeFilterByTs) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeFilterByTs) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeFilterByTs) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeFilterByTs) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeFilterByTs) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeFilterByTs) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -41288,176 +42760,176 @@ type TsMrevrangeFilterByValue Completed
 type STsMrevrangeFilterByValue SCompleted
 
 func (c TsMrevrangeFilterByValue) Withlabels() TsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrevrangeWithlabels)(c)
 }
 
 func (c STsMrevrangeFilterByValue) Withlabels() STsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrevrangeWithlabels)(c)
 }
 
 func (c TsMrevrangeFilterByValue) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrevrangeSelectedLabels)(c)
 }
 
 func (c STsMrevrangeFilterByValue) SelectedLabels(labels []string) STsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrevrangeSelectedLabels)(c)
 }
 
 func (c TsMrevrangeFilterByValue) Count(count int64) TsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrevrangeCount)(c)
 }
 
 func (c STsMrevrangeFilterByValue) Count(count int64) STsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrevrangeCount)(c)
 }
 
 func (c TsMrevrangeFilterByValue) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeFilterByValue) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeFilterByValue) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeFilterByValue) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeFilterByValue) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeFilterByValue) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -41466,12 +42938,12 @@ type TsMrevrangeFromtimestamp Completed
 type STsMrevrangeFromtimestamp SCompleted
 
 func (c TsMrevrangeFromtimestamp) Totimestamp(totimestamp int64) TsMrevrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (TsMrevrangeTotimestamp)(c)
 }
 
 func (c STsMrevrangeFromtimestamp) Totimestamp(totimestamp int64) STsMrevrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (STsMrevrangeTotimestamp)(c)
 }
 
@@ -41492,12 +42964,12 @@ type TsMrevrangeKey Completed
 type STsMrevrangeKey SCompleted
 
 func (c TsMrevrangeKey) Fromtimestamp(fromtimestamp int64) TsMrevrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (TsMrevrangeFromtimestamp)(c)
 }
 
 func (c STsMrevrangeKey) Fromtimestamp(fromtimestamp int64) STsMrevrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (STsMrevrangeFromtimestamp)(c)
 }
 
@@ -41506,154 +42978,154 @@ type TsMrevrangeSelectedLabels Completed
 type STsMrevrangeSelectedLabels SCompleted
 
 func (c TsMrevrangeSelectedLabels) Count(count int64) TsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrevrangeCount)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) Count(count int64) STsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrevrangeCount)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeSelectedLabels) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeSelectedLabels) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -41662,202 +43134,202 @@ type TsMrevrangeTotimestamp Completed
 type STsMrevrangeTotimestamp SCompleted
 
 func (c TsMrevrangeTotimestamp) FilterByTs(timestamp ...int64) TsMrevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (TsMrevrangeFilterByTs)(c)
 }
 
 func (c STsMrevrangeTotimestamp) FilterByTs(timestamp ...int64) STsMrevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (STsMrevrangeFilterByTs)(c)
 }
 
 func (c TsMrevrangeTotimestamp) FilterByValue(min float64, max float64) TsMrevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsMrevrangeTotimestamp) FilterByValue(min float64, max float64) STsMrevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsMrevrangeFilterByValue)(c)
 }
 
 func (c TsMrevrangeTotimestamp) Withlabels() TsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (TsMrevrangeWithlabels)(c)
 }
 
 func (c STsMrevrangeTotimestamp) Withlabels() STsMrevrangeWithlabels {
-	c.cs = append(c.cs, "WITHLABELS")
+	c.cs.s = append(c.cs.s, "WITHLABELS")
 	return (STsMrevrangeWithlabels)(c)
 }
 
 func (c TsMrevrangeTotimestamp) SelectedLabels(labels []string) TsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (TsMrevrangeSelectedLabels)(c)
 }
 
 func (c STsMrevrangeTotimestamp) SelectedLabels(labels []string) STsMrevrangeSelectedLabels {
-	c.cs = append(c.cs, "SELECTED_LABELS")
-	c.cs = append(c.cs, labels...)
+	c.cs.s = append(c.cs.s, "SELECTED_LABELS")
+	c.cs.s = append(c.cs.s, labels...)
 	return (STsMrevrangeSelectedLabels)(c)
 }
 
 func (c TsMrevrangeTotimestamp) Count(count int64) TsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrevrangeCount)(c)
 }
 
 func (c STsMrevrangeTotimestamp) Count(count int64) STsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrevrangeCount)(c)
 }
 
 func (c TsMrevrangeTotimestamp) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeTotimestamp) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeTotimestamp) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeTotimestamp) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeTotimestamp) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeTotimestamp) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -41866,154 +43338,154 @@ type TsMrevrangeWithlabels Completed
 type STsMrevrangeWithlabels SCompleted
 
 func (c TsMrevrangeWithlabels) Count(count int64) TsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsMrevrangeCount)(c)
 }
 
 func (c STsMrevrangeWithlabels) Count(count int64) STsMrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsMrevrangeCount)(c)
 }
 
 func (c TsMrevrangeWithlabels) Align(value int64) TsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsMrevrangeAlign)(c)
 }
 
 func (c STsMrevrangeWithlabels) Align(value int64) STsMrevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsMrevrangeAlign)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationAvg() TsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationAvg() STsMrevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsMrevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationSum() TsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationSum() STsMrevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsMrevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationMin() TsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationMin() STsMrevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsMrevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationMax() TsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationMax() STsMrevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsMrevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationRange() TsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationRange() STsMrevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsMrevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationCount() TsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationCount() STsMrevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsMrevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationFirst() TsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationFirst() STsMrevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsMrevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationLast() TsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationLast() STsMrevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsMrevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationStdP() TsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationStdP() STsMrevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsMrevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationStdS() TsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationStdS() STsMrevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsMrevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationVarP() TsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationVarP() STsMrevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsMrevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsMrevrangeWithlabels) AggregationVarS() TsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsMrevrangeWithlabels) AggregationVarS() STsMrevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsMrevrangeAggregationAggregationVarS)(c)
 }
 
 func (c TsMrevrangeWithlabels) Filter(filter ...string) TsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsMrevrangeFilter)(c)
 }
 
 func (c STsMrevrangeWithlabels) Filter(filter ...string) STsMrevrangeFilter {
-	c.cs = append(c.cs, "FILTER")
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, "FILTER")
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsMrevrangeFilter)(c)
 }
 
@@ -42021,21 +43493,25 @@ type TsQueryindex Completed
 
 type STsQueryindex SCompleted
 
-func (b *Builder) TsQueryindex() TsQueryindex {
-	return TsQueryindex{cs: append(b.get(), "TS.QUERYINDEX"), ks: InitSlot, cf: readonly}
+func (b *Builder) TsQueryindex() (c TsQueryindex) {
+	c = TsQueryindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.QUERYINDEX")
+	return c
 }
 
-func (b *SBuilder) TsQueryindex() STsQueryindex {
-	return STsQueryindex{cs: append(b.get(), "TS.QUERYINDEX"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TsQueryindex() (c STsQueryindex) {
+	c = STsQueryindex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.QUERYINDEX")
+	return c
 }
 
 func (c TsQueryindex) Filter(filter ...string) TsQueryindexFilter {
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, filter...)
 	return (TsQueryindexFilter)(c)
 }
 
 func (c STsQueryindex) Filter(filter ...string) STsQueryindexFilter {
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, filter...)
 	return (STsQueryindexFilter)(c)
 }
 
@@ -42044,12 +43520,12 @@ type TsQueryindexFilter Completed
 type STsQueryindexFilter SCompleted
 
 func (c TsQueryindexFilter) Filter(filter ...string) TsQueryindexFilter {
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
 func (c STsQueryindexFilter) Filter(filter ...string) STsQueryindexFilter {
-	c.cs = append(c.cs, filter...)
+	c.cs.s = append(c.cs.s, filter...)
 	return c
 }
 
@@ -42065,22 +43541,26 @@ type TsRange Completed
 
 type STsRange SCompleted
 
-func (b *Builder) TsRange() TsRange {
-	return TsRange{cs: append(b.get(), "TS.RANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) TsRange() (c TsRange) {
+	c = TsRange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.RANGE")
+	return c
 }
 
-func (b *SBuilder) TsRange() STsRange {
-	return STsRange{cs: append(b.get(), "TS.RANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TsRange() (c STsRange) {
+	c = STsRange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.RANGE")
+	return c
 }
 
 func (c TsRange) Key(key string) TsRangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsRangeKey)(c)
 }
 
 func (c STsRange) Key(key string) STsRangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsRangeKey)(c)
 }
 
@@ -42089,12 +43569,12 @@ type TsRangeAggregationAggregationAvg Completed
 type STsRangeAggregationAggregationAvg SCompleted
 
 func (c TsRangeAggregationAggregationAvg) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationAvg) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42103,12 +43583,12 @@ type TsRangeAggregationAggregationCount Completed
 type STsRangeAggregationAggregationCount SCompleted
 
 func (c TsRangeAggregationAggregationCount) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationCount) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42117,12 +43597,12 @@ type TsRangeAggregationAggregationFirst Completed
 type STsRangeAggregationAggregationFirst SCompleted
 
 func (c TsRangeAggregationAggregationFirst) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationFirst) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42131,12 +43611,12 @@ type TsRangeAggregationAggregationLast Completed
 type STsRangeAggregationAggregationLast SCompleted
 
 func (c TsRangeAggregationAggregationLast) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationLast) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42145,12 +43625,12 @@ type TsRangeAggregationAggregationMax Completed
 type STsRangeAggregationAggregationMax SCompleted
 
 func (c TsRangeAggregationAggregationMax) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationMax) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42159,12 +43639,12 @@ type TsRangeAggregationAggregationMin Completed
 type STsRangeAggregationAggregationMin SCompleted
 
 func (c TsRangeAggregationAggregationMin) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationMin) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42173,12 +43653,12 @@ type TsRangeAggregationAggregationRange Completed
 type STsRangeAggregationAggregationRange SCompleted
 
 func (c TsRangeAggregationAggregationRange) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationRange) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42187,12 +43667,12 @@ type TsRangeAggregationAggregationStdP Completed
 type STsRangeAggregationAggregationStdP SCompleted
 
 func (c TsRangeAggregationAggregationStdP) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationStdP) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42201,12 +43681,12 @@ type TsRangeAggregationAggregationStdS Completed
 type STsRangeAggregationAggregationStdS SCompleted
 
 func (c TsRangeAggregationAggregationStdS) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationStdS) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42215,12 +43695,12 @@ type TsRangeAggregationAggregationSum Completed
 type STsRangeAggregationAggregationSum SCompleted
 
 func (c TsRangeAggregationAggregationSum) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationSum) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42229,12 +43709,12 @@ type TsRangeAggregationAggregationVarP Completed
 type STsRangeAggregationAggregationVarP SCompleted
 
 func (c TsRangeAggregationAggregationVarP) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationVarP) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42243,12 +43723,12 @@ type TsRangeAggregationAggregationVarS Completed
 type STsRangeAggregationAggregationVarS SCompleted
 
 func (c TsRangeAggregationAggregationVarS) Timebucket(timebucket int64) TsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRangeAggregationTimebucket)(c)
 }
 
 func (c STsRangeAggregationAggregationVarS) Timebucket(timebucket int64) STsRangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRangeAggregationTimebucket)(c)
 }
 
@@ -42269,122 +43749,122 @@ type TsRangeAlign Completed
 type STsRangeAlign SCompleted
 
 func (c TsRangeAlign) AggregationAvg() TsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRangeAlign) AggregationAvg() STsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRangeAlign) AggregationSum() TsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRangeAggregationAggregationSum)(c)
 }
 
 func (c STsRangeAlign) AggregationSum() STsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRangeAggregationAggregationSum)(c)
 }
 
 func (c TsRangeAlign) AggregationMin() TsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRangeAggregationAggregationMin)(c)
 }
 
 func (c STsRangeAlign) AggregationMin() STsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRangeAggregationAggregationMin)(c)
 }
 
 func (c TsRangeAlign) AggregationMax() TsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRangeAggregationAggregationMax)(c)
 }
 
 func (c STsRangeAlign) AggregationMax() STsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRangeAggregationAggregationMax)(c)
 }
 
 func (c TsRangeAlign) AggregationRange() TsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRangeAggregationAggregationRange)(c)
 }
 
 func (c STsRangeAlign) AggregationRange() STsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRangeAggregationAggregationRange)(c)
 }
 
 func (c TsRangeAlign) AggregationCount() TsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRangeAggregationAggregationCount)(c)
 }
 
 func (c STsRangeAlign) AggregationCount() STsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRangeAggregationAggregationCount)(c)
 }
 
 func (c TsRangeAlign) AggregationFirst() TsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRangeAlign) AggregationFirst() STsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRangeAlign) AggregationLast() TsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRangeAggregationAggregationLast)(c)
 }
 
 func (c STsRangeAlign) AggregationLast() STsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRangeAggregationAggregationLast)(c)
 }
 
 func (c TsRangeAlign) AggregationStdP() TsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRangeAlign) AggregationStdP() STsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRangeAlign) AggregationStdS() TsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRangeAlign) AggregationStdS() STsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRangeAlign) AggregationVarP() TsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRangeAlign) AggregationVarP() STsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRangeAlign) AggregationVarS() TsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRangeAlign) AggregationVarS() STsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRangeAggregationAggregationVarS)(c)
 }
 
@@ -42401,132 +43881,132 @@ type TsRangeCount Completed
 type STsRangeCount SCompleted
 
 func (c TsRangeCount) Align(value int64) TsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRangeAlign)(c)
 }
 
 func (c STsRangeCount) Align(value int64) STsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRangeAlign)(c)
 }
 
 func (c TsRangeCount) AggregationAvg() TsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRangeCount) AggregationAvg() STsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRangeCount) AggregationSum() TsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRangeAggregationAggregationSum)(c)
 }
 
 func (c STsRangeCount) AggregationSum() STsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRangeAggregationAggregationSum)(c)
 }
 
 func (c TsRangeCount) AggregationMin() TsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRangeAggregationAggregationMin)(c)
 }
 
 func (c STsRangeCount) AggregationMin() STsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRangeAggregationAggregationMin)(c)
 }
 
 func (c TsRangeCount) AggregationMax() TsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRangeAggregationAggregationMax)(c)
 }
 
 func (c STsRangeCount) AggregationMax() STsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRangeAggregationAggregationMax)(c)
 }
 
 func (c TsRangeCount) AggregationRange() TsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRangeAggregationAggregationRange)(c)
 }
 
 func (c STsRangeCount) AggregationRange() STsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRangeAggregationAggregationRange)(c)
 }
 
 func (c TsRangeCount) AggregationCount() TsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRangeAggregationAggregationCount)(c)
 }
 
 func (c STsRangeCount) AggregationCount() STsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRangeAggregationAggregationCount)(c)
 }
 
 func (c TsRangeCount) AggregationFirst() TsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRangeCount) AggregationFirst() STsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRangeCount) AggregationLast() TsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRangeAggregationAggregationLast)(c)
 }
 
 func (c STsRangeCount) AggregationLast() STsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRangeAggregationAggregationLast)(c)
 }
 
 func (c TsRangeCount) AggregationStdP() TsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRangeCount) AggregationStdP() STsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRangeCount) AggregationStdS() TsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRangeCount) AggregationStdS() STsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRangeCount) AggregationVarP() TsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRangeCount) AggregationVarP() STsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRangeCount) AggregationVarS() TsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRangeCount) AggregationVarS() STsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRangeAggregationAggregationVarS)(c)
 }
 
@@ -42543,168 +44023,168 @@ type TsRangeFilterByTs Completed
 type STsRangeFilterByTs SCompleted
 
 func (c TsRangeFilterByTs) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c STsRangeFilterByTs) FilterByTs(timestamp ...int64) STsRangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c TsRangeFilterByTs) FilterByValue(min float64, max float64) TsRangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsRangeFilterByTs) FilterByValue(min float64, max float64) STsRangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsRangeFilterByValue)(c)
 }
 
 func (c TsRangeFilterByTs) Count(count int64) TsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRangeCount)(c)
 }
 
 func (c STsRangeFilterByTs) Count(count int64) STsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRangeCount)(c)
 }
 
 func (c TsRangeFilterByTs) Align(value int64) TsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRangeAlign)(c)
 }
 
 func (c STsRangeFilterByTs) Align(value int64) STsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRangeAlign)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationAvg() TsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationAvg() STsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationSum() TsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRangeAggregationAggregationSum)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationSum() STsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRangeAggregationAggregationSum)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationMin() TsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRangeAggregationAggregationMin)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationMin() STsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRangeAggregationAggregationMin)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationMax() TsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRangeAggregationAggregationMax)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationMax() STsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRangeAggregationAggregationMax)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationRange() TsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRangeAggregationAggregationRange)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationRange() STsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRangeAggregationAggregationRange)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationCount() TsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRangeAggregationAggregationCount)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationCount() STsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRangeAggregationAggregationCount)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationFirst() TsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationFirst() STsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationLast() TsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRangeAggregationAggregationLast)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationLast() STsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRangeAggregationAggregationLast)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationStdP() TsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationStdP() STsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationStdS() TsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationStdS() STsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationVarP() TsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationVarP() STsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRangeFilterByTs) AggregationVarS() TsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRangeFilterByTs) AggregationVarS() STsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRangeAggregationAggregationVarS)(c)
 }
 
@@ -42721,142 +44201,142 @@ type TsRangeFilterByValue Completed
 type STsRangeFilterByValue SCompleted
 
 func (c TsRangeFilterByValue) Count(count int64) TsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRangeCount)(c)
 }
 
 func (c STsRangeFilterByValue) Count(count int64) STsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRangeCount)(c)
 }
 
 func (c TsRangeFilterByValue) Align(value int64) TsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRangeAlign)(c)
 }
 
 func (c STsRangeFilterByValue) Align(value int64) STsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRangeAlign)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationAvg() TsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationAvg() STsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationSum() TsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRangeAggregationAggregationSum)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationSum() STsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRangeAggregationAggregationSum)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationMin() TsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRangeAggregationAggregationMin)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationMin() STsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRangeAggregationAggregationMin)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationMax() TsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRangeAggregationAggregationMax)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationMax() STsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRangeAggregationAggregationMax)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationRange() TsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRangeAggregationAggregationRange)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationRange() STsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRangeAggregationAggregationRange)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationCount() TsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRangeAggregationAggregationCount)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationCount() STsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRangeAggregationAggregationCount)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationFirst() TsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationFirst() STsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationLast() TsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRangeAggregationAggregationLast)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationLast() STsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRangeAggregationAggregationLast)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationStdP() TsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationStdP() STsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationStdS() TsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationStdS() STsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationVarP() TsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationVarP() STsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRangeFilterByValue) AggregationVarS() TsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRangeFilterByValue) AggregationVarS() STsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRangeAggregationAggregationVarS)(c)
 }
 
@@ -42873,12 +44353,12 @@ type TsRangeFromtimestamp Completed
 type STsRangeFromtimestamp SCompleted
 
 func (c TsRangeFromtimestamp) Totimestamp(totimestamp int64) TsRangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (TsRangeTotimestamp)(c)
 }
 
 func (c STsRangeFromtimestamp) Totimestamp(totimestamp int64) STsRangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (STsRangeTotimestamp)(c)
 }
 
@@ -42887,12 +44367,12 @@ type TsRangeKey Completed
 type STsRangeKey SCompleted
 
 func (c TsRangeKey) Fromtimestamp(fromtimestamp int64) TsRangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (TsRangeFromtimestamp)(c)
 }
 
 func (c STsRangeKey) Fromtimestamp(fromtimestamp int64) STsRangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (STsRangeFromtimestamp)(c)
 }
 
@@ -42901,168 +44381,168 @@ type TsRangeTotimestamp Completed
 type STsRangeTotimestamp SCompleted
 
 func (c TsRangeTotimestamp) FilterByTs(timestamp ...int64) TsRangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (TsRangeFilterByTs)(c)
 }
 
 func (c STsRangeTotimestamp) FilterByTs(timestamp ...int64) STsRangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (STsRangeFilterByTs)(c)
 }
 
 func (c TsRangeTotimestamp) FilterByValue(min float64, max float64) TsRangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsRangeTotimestamp) FilterByValue(min float64, max float64) STsRangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsRangeFilterByValue)(c)
 }
 
 func (c TsRangeTotimestamp) Count(count int64) TsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRangeCount)(c)
 }
 
 func (c STsRangeTotimestamp) Count(count int64) STsRangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRangeCount)(c)
 }
 
 func (c TsRangeTotimestamp) Align(value int64) TsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRangeAlign)(c)
 }
 
 func (c STsRangeTotimestamp) Align(value int64) STsRangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRangeAlign)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationAvg() TsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationAvg() STsRangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationSum() TsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRangeAggregationAggregationSum)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationSum() STsRangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRangeAggregationAggregationSum)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationMin() TsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRangeAggregationAggregationMin)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationMin() STsRangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRangeAggregationAggregationMin)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationMax() TsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRangeAggregationAggregationMax)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationMax() STsRangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRangeAggregationAggregationMax)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationRange() TsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRangeAggregationAggregationRange)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationRange() STsRangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRangeAggregationAggregationRange)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationCount() TsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRangeAggregationAggregationCount)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationCount() STsRangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRangeAggregationAggregationCount)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationFirst() TsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationFirst() STsRangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationLast() TsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRangeAggregationAggregationLast)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationLast() STsRangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRangeAggregationAggregationLast)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationStdP() TsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationStdP() STsRangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationStdS() TsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationStdS() STsRangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationVarP() TsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationVarP() STsRangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRangeTotimestamp) AggregationVarS() TsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRangeTotimestamp) AggregationVarS() STsRangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRangeAggregationAggregationVarS)(c)
 }
 
@@ -43078,22 +44558,26 @@ type TsRevrange Completed
 
 type STsRevrange SCompleted
 
-func (b *Builder) TsRevrange() TsRevrange {
-	return TsRevrange{cs: append(b.get(), "TS.REVRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) TsRevrange() (c TsRevrange) {
+	c = TsRevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.REVRANGE")
+	return c
 }
 
-func (b *SBuilder) TsRevrange() STsRevrange {
-	return STsRevrange{cs: append(b.get(), "TS.REVRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) TsRevrange() (c STsRevrange) {
+	c = STsRevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TS.REVRANGE")
+	return c
 }
 
 func (c TsRevrange) Key(key string) TsRevrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TsRevrangeKey)(c)
 }
 
 func (c STsRevrange) Key(key string) STsRevrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STsRevrangeKey)(c)
 }
 
@@ -43102,12 +44586,12 @@ type TsRevrangeAggregationAggregationAvg Completed
 type STsRevrangeAggregationAggregationAvg SCompleted
 
 func (c TsRevrangeAggregationAggregationAvg) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationAvg) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43116,12 +44600,12 @@ type TsRevrangeAggregationAggregationCount Completed
 type STsRevrangeAggregationAggregationCount SCompleted
 
 func (c TsRevrangeAggregationAggregationCount) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationCount) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43130,12 +44614,12 @@ type TsRevrangeAggregationAggregationFirst Completed
 type STsRevrangeAggregationAggregationFirst SCompleted
 
 func (c TsRevrangeAggregationAggregationFirst) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationFirst) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43144,12 +44628,12 @@ type TsRevrangeAggregationAggregationLast Completed
 type STsRevrangeAggregationAggregationLast SCompleted
 
 func (c TsRevrangeAggregationAggregationLast) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationLast) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43158,12 +44642,12 @@ type TsRevrangeAggregationAggregationMax Completed
 type STsRevrangeAggregationAggregationMax SCompleted
 
 func (c TsRevrangeAggregationAggregationMax) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationMax) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43172,12 +44656,12 @@ type TsRevrangeAggregationAggregationMin Completed
 type STsRevrangeAggregationAggregationMin SCompleted
 
 func (c TsRevrangeAggregationAggregationMin) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationMin) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43186,12 +44670,12 @@ type TsRevrangeAggregationAggregationRange Completed
 type STsRevrangeAggregationAggregationRange SCompleted
 
 func (c TsRevrangeAggregationAggregationRange) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationRange) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43200,12 +44684,12 @@ type TsRevrangeAggregationAggregationStdP Completed
 type STsRevrangeAggregationAggregationStdP SCompleted
 
 func (c TsRevrangeAggregationAggregationStdP) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationStdP) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43214,12 +44698,12 @@ type TsRevrangeAggregationAggregationStdS Completed
 type STsRevrangeAggregationAggregationStdS SCompleted
 
 func (c TsRevrangeAggregationAggregationStdS) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationStdS) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43228,12 +44712,12 @@ type TsRevrangeAggregationAggregationSum Completed
 type STsRevrangeAggregationAggregationSum SCompleted
 
 func (c TsRevrangeAggregationAggregationSum) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationSum) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43242,12 +44726,12 @@ type TsRevrangeAggregationAggregationVarP Completed
 type STsRevrangeAggregationAggregationVarP SCompleted
 
 func (c TsRevrangeAggregationAggregationVarP) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationVarP) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43256,12 +44740,12 @@ type TsRevrangeAggregationAggregationVarS Completed
 type STsRevrangeAggregationAggregationVarS SCompleted
 
 func (c TsRevrangeAggregationAggregationVarS) Timebucket(timebucket int64) TsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (TsRevrangeAggregationTimebucket)(c)
 }
 
 func (c STsRevrangeAggregationAggregationVarS) Timebucket(timebucket int64) STsRevrangeAggregationTimebucket {
-	c.cs = append(c.cs, strconv.FormatInt(timebucket, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timebucket, 10))
 	return (STsRevrangeAggregationTimebucket)(c)
 }
 
@@ -43282,122 +44766,122 @@ type TsRevrangeAlign Completed
 type STsRevrangeAlign SCompleted
 
 func (c TsRevrangeAlign) AggregationAvg() TsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRevrangeAlign) AggregationAvg() STsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRevrangeAlign) AggregationSum() TsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsRevrangeAlign) AggregationSum() STsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsRevrangeAlign) AggregationMin() TsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsRevrangeAlign) AggregationMin() STsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsRevrangeAlign) AggregationMax() TsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsRevrangeAlign) AggregationMax() STsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsRevrangeAlign) AggregationRange() TsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsRevrangeAlign) AggregationRange() STsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsRevrangeAlign) AggregationCount() TsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsRevrangeAlign) AggregationCount() STsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsRevrangeAlign) AggregationFirst() TsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRevrangeAlign) AggregationFirst() STsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRevrangeAlign) AggregationLast() TsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsRevrangeAlign) AggregationLast() STsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsRevrangeAlign) AggregationStdP() TsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRevrangeAlign) AggregationStdP() STsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRevrangeAlign) AggregationStdS() TsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRevrangeAlign) AggregationStdS() STsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRevrangeAlign) AggregationVarP() TsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRevrangeAlign) AggregationVarP() STsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRevrangeAlign) AggregationVarS() TsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRevrangeAlign) AggregationVarS() STsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRevrangeAggregationAggregationVarS)(c)
 }
 
@@ -43414,132 +44898,132 @@ type TsRevrangeCount Completed
 type STsRevrangeCount SCompleted
 
 func (c TsRevrangeCount) Align(value int64) TsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRevrangeAlign)(c)
 }
 
 func (c STsRevrangeCount) Align(value int64) STsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRevrangeAlign)(c)
 }
 
 func (c TsRevrangeCount) AggregationAvg() TsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRevrangeCount) AggregationAvg() STsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRevrangeCount) AggregationSum() TsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsRevrangeCount) AggregationSum() STsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsRevrangeCount) AggregationMin() TsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsRevrangeCount) AggregationMin() STsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsRevrangeCount) AggregationMax() TsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsRevrangeCount) AggregationMax() STsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsRevrangeCount) AggregationRange() TsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsRevrangeCount) AggregationRange() STsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsRevrangeCount) AggregationCount() TsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsRevrangeCount) AggregationCount() STsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsRevrangeCount) AggregationFirst() TsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRevrangeCount) AggregationFirst() STsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRevrangeCount) AggregationLast() TsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsRevrangeCount) AggregationLast() STsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsRevrangeCount) AggregationStdP() TsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRevrangeCount) AggregationStdP() STsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRevrangeCount) AggregationStdS() TsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRevrangeCount) AggregationStdS() STsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRevrangeCount) AggregationVarP() TsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRevrangeCount) AggregationVarP() STsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRevrangeCount) AggregationVarS() TsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRevrangeCount) AggregationVarS() STsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRevrangeAggregationAggregationVarS)(c)
 }
 
@@ -43556,168 +45040,168 @@ type TsRevrangeFilterByTs Completed
 type STsRevrangeFilterByTs SCompleted
 
 func (c TsRevrangeFilterByTs) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c STsRevrangeFilterByTs) FilterByTs(timestamp ...int64) STsRevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c TsRevrangeFilterByTs) FilterByValue(min float64, max float64) TsRevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsRevrangeFilterByTs) FilterByValue(min float64, max float64) STsRevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsRevrangeFilterByValue)(c)
 }
 
 func (c TsRevrangeFilterByTs) Count(count int64) TsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRevrangeCount)(c)
 }
 
 func (c STsRevrangeFilterByTs) Count(count int64) STsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRevrangeCount)(c)
 }
 
 func (c TsRevrangeFilterByTs) Align(value int64) TsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRevrangeAlign)(c)
 }
 
 func (c STsRevrangeFilterByTs) Align(value int64) STsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRevrangeAlign)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationAvg() TsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationAvg() STsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationSum() TsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationSum() STsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationMin() TsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationMin() STsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationMax() TsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationMax() STsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationRange() TsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationRange() STsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationCount() TsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationCount() STsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationFirst() TsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationFirst() STsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationLast() TsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationLast() STsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationStdP() TsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationStdP() STsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationStdS() TsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationStdS() STsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationVarP() TsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationVarP() STsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRevrangeFilterByTs) AggregationVarS() TsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRevrangeFilterByTs) AggregationVarS() STsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRevrangeAggregationAggregationVarS)(c)
 }
 
@@ -43734,142 +45218,142 @@ type TsRevrangeFilterByValue Completed
 type STsRevrangeFilterByValue SCompleted
 
 func (c TsRevrangeFilterByValue) Count(count int64) TsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRevrangeCount)(c)
 }
 
 func (c STsRevrangeFilterByValue) Count(count int64) STsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRevrangeCount)(c)
 }
 
 func (c TsRevrangeFilterByValue) Align(value int64) TsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRevrangeAlign)(c)
 }
 
 func (c STsRevrangeFilterByValue) Align(value int64) STsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRevrangeAlign)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationAvg() TsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationAvg() STsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationSum() TsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationSum() STsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationMin() TsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationMin() STsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationMax() TsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationMax() STsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationRange() TsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationRange() STsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationCount() TsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationCount() STsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationFirst() TsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationFirst() STsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationLast() TsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationLast() STsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationStdP() TsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationStdP() STsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationStdS() TsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationStdS() STsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationVarP() TsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationVarP() STsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRevrangeFilterByValue) AggregationVarS() TsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRevrangeFilterByValue) AggregationVarS() STsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRevrangeAggregationAggregationVarS)(c)
 }
 
@@ -43886,12 +45370,12 @@ type TsRevrangeFromtimestamp Completed
 type STsRevrangeFromtimestamp SCompleted
 
 func (c TsRevrangeFromtimestamp) Totimestamp(totimestamp int64) TsRevrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (TsRevrangeTotimestamp)(c)
 }
 
 func (c STsRevrangeFromtimestamp) Totimestamp(totimestamp int64) STsRevrangeTotimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(totimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(totimestamp, 10))
 	return (STsRevrangeTotimestamp)(c)
 }
 
@@ -43900,12 +45384,12 @@ type TsRevrangeKey Completed
 type STsRevrangeKey SCompleted
 
 func (c TsRevrangeKey) Fromtimestamp(fromtimestamp int64) TsRevrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (TsRevrangeFromtimestamp)(c)
 }
 
 func (c STsRevrangeKey) Fromtimestamp(fromtimestamp int64) STsRevrangeFromtimestamp {
-	c.cs = append(c.cs, strconv.FormatInt(fromtimestamp, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(fromtimestamp, 10))
 	return (STsRevrangeFromtimestamp)(c)
 }
 
@@ -43914,168 +45398,168 @@ type TsRevrangeTotimestamp Completed
 type STsRevrangeTotimestamp SCompleted
 
 func (c TsRevrangeTotimestamp) FilterByTs(timestamp ...int64) TsRevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (TsRevrangeFilterByTs)(c)
 }
 
 func (c STsRevrangeTotimestamp) FilterByTs(timestamp ...int64) STsRevrangeFilterByTs {
-	c.cs = append(c.cs, "FILTER_BY_TS")
+	c.cs.s = append(c.cs.s, "FILTER_BY_TS")
 	for _, n := range timestamp {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (STsRevrangeFilterByTs)(c)
 }
 
 func (c TsRevrangeTotimestamp) FilterByValue(min float64, max float64) TsRevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	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 STsRevrangeTotimestamp) FilterByValue(min float64, max float64) STsRevrangeFilterByValue {
-	c.cs = append(c.cs, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, "FILTER_BY_VALUE", strconv.FormatFloat(min, 'f', -1, 64), strconv.FormatFloat(max, 'f', -1, 64))
 	return (STsRevrangeFilterByValue)(c)
 }
 
 func (c TsRevrangeTotimestamp) Count(count int64) TsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (TsRevrangeCount)(c)
 }
 
 func (c STsRevrangeTotimestamp) Count(count int64) STsRevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (STsRevrangeCount)(c)
 }
 
 func (c TsRevrangeTotimestamp) Align(value int64) TsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (TsRevrangeAlign)(c)
 }
 
 func (c STsRevrangeTotimestamp) Align(value int64) STsRevrangeAlign {
-	c.cs = append(c.cs, "ALIGN", strconv.FormatInt(value, 10))
+	c.cs.s = append(c.cs.s, "ALIGN", strconv.FormatInt(value, 10))
 	return (STsRevrangeAlign)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationAvg() TsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (TsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationAvg() STsRevrangeAggregationAggregationAvg {
-	c.cs = append(c.cs, "AGGREGATION", "avg")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "avg")
 	return (STsRevrangeAggregationAggregationAvg)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationSum() TsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (TsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationSum() STsRevrangeAggregationAggregationSum {
-	c.cs = append(c.cs, "AGGREGATION", "sum")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "sum")
 	return (STsRevrangeAggregationAggregationSum)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationMin() TsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (TsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationMin() STsRevrangeAggregationAggregationMin {
-	c.cs = append(c.cs, "AGGREGATION", "min")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "min")
 	return (STsRevrangeAggregationAggregationMin)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationMax() TsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (TsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationMax() STsRevrangeAggregationAggregationMax {
-	c.cs = append(c.cs, "AGGREGATION", "max")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "max")
 	return (STsRevrangeAggregationAggregationMax)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationRange() TsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (TsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationRange() STsRevrangeAggregationAggregationRange {
-	c.cs = append(c.cs, "AGGREGATION", "range")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "range")
 	return (STsRevrangeAggregationAggregationRange)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationCount() TsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (TsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationCount() STsRevrangeAggregationAggregationCount {
-	c.cs = append(c.cs, "AGGREGATION", "count")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "count")
 	return (STsRevrangeAggregationAggregationCount)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationFirst() TsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (TsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationFirst() STsRevrangeAggregationAggregationFirst {
-	c.cs = append(c.cs, "AGGREGATION", "first")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "first")
 	return (STsRevrangeAggregationAggregationFirst)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationLast() TsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (TsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationLast() STsRevrangeAggregationAggregationLast {
-	c.cs = append(c.cs, "AGGREGATION", "last")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "last")
 	return (STsRevrangeAggregationAggregationLast)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationStdP() TsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (TsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationStdP() STsRevrangeAggregationAggregationStdP {
-	c.cs = append(c.cs, "AGGREGATION", "std.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.p")
 	return (STsRevrangeAggregationAggregationStdP)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationStdS() TsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (TsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationStdS() STsRevrangeAggregationAggregationStdS {
-	c.cs = append(c.cs, "AGGREGATION", "std.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "std.s")
 	return (STsRevrangeAggregationAggregationStdS)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationVarP() TsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (TsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationVarP() STsRevrangeAggregationAggregationVarP {
-	c.cs = append(c.cs, "AGGREGATION", "var.p")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.p")
 	return (STsRevrangeAggregationAggregationVarP)(c)
 }
 
 func (c TsRevrangeTotimestamp) AggregationVarS() TsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (TsRevrangeAggregationAggregationVarS)(c)
 }
 
 func (c STsRevrangeTotimestamp) AggregationVarS() STsRevrangeAggregationAggregationVarS {
-	c.cs = append(c.cs, "AGGREGATION", "var.s")
+	c.cs.s = append(c.cs.s, "AGGREGATION", "var.s")
 	return (STsRevrangeAggregationAggregationVarS)(c)
 }
 
@@ -44091,22 +45575,26 @@ type Ttl Completed
 
 type STtl SCompleted
 
-func (b *Builder) Ttl() Ttl {
-	return Ttl{cs: append(b.get(), "TTL"), ks: InitSlot, cf: readonly}
+func (b *Builder) Ttl() (c Ttl) {
+	c = Ttl{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TTL")
+	return c
 }
 
-func (b *SBuilder) Ttl() STtl {
-	return STtl{cs: append(b.get(), "TTL"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Ttl() (c STtl) {
+	c = STtl{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TTL")
+	return c
 }
 
 func (c Ttl) Key(key string) TtlKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TtlKey)(c)
 }
 
 func (c STtl) Key(key string) STtlKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STtlKey)(c)
 }
 
@@ -44134,22 +45622,26 @@ type Type Completed
 
 type SType SCompleted
 
-func (b *Builder) Type() Type {
-	return Type{cs: append(b.get(), "TYPE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Type() (c Type) {
+	c = Type{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TYPE")
+	return c
 }
 
-func (b *SBuilder) Type() SType {
-	return SType{cs: append(b.get(), "TYPE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Type() (c SType) {
+	c = SType{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "TYPE")
+	return c
 }
 
 func (c Type) Key(key string) TypeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (TypeKey)(c)
 }
 
 func (c SType) Key(key string) STypeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (STypeKey)(c)
 }
 
@@ -44177,16 +45669,20 @@ type Unlink Completed
 
 type SUnlink SCompleted
 
-func (b *Builder) Unlink() Unlink {
-	return Unlink{cs: append(b.get(), "UNLINK"), ks: InitSlot}
+func (b *Builder) Unlink() (c Unlink) {
+	c = Unlink{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "UNLINK")
+	return c
 }
 
-func (b *SBuilder) Unlink() SUnlink {
-	return SUnlink{cs: append(b.get(), "UNLINK"), ks: InitSlot}
+func (b *SBuilder) Unlink() (c SUnlink) {
+	c = SUnlink{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "UNLINK")
+	return c
 }
 
 func (c Unlink) Key(key ...string) UnlinkKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (UnlinkKey)(c)
 }
 
@@ -44194,7 +45690,7 @@ func (c SUnlink) Key(key ...string) SUnlinkKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SUnlinkKey)(c)
 }
 
@@ -44203,7 +45699,7 @@ type UnlinkKey Completed
 type SUnlinkKey SCompleted
 
 func (c UnlinkKey) Key(key ...string) UnlinkKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -44211,7 +45707,7 @@ func (c SUnlinkKey) Key(key ...string) SUnlinkKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -44227,21 +45723,25 @@ type Unsubscribe Completed
 
 type SUnsubscribe SCompleted
 
-func (b *Builder) Unsubscribe() Unsubscribe {
-	return Unsubscribe{cs: append(b.get(), "UNSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *Builder) Unsubscribe() (c Unsubscribe) {
+	c = Unsubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "UNSUBSCRIBE")
+	return c
 }
 
-func (b *SBuilder) Unsubscribe() SUnsubscribe {
-	return SUnsubscribe{cs: append(b.get(), "UNSUBSCRIBE"), ks: InitSlot, cf: noRetTag}
+func (b *SBuilder) Unsubscribe() (c SUnsubscribe) {
+	c = SUnsubscribe{cs: b.get(), ks: InitSlot, cf: noRetTag}
+	c.cs.s = append(c.cs.s, "UNSUBSCRIBE")
+	return c
 }
 
 func (c Unsubscribe) Channel(channel ...string) UnsubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (UnsubscribeChannel)(c)
 }
 
 func (c SUnsubscribe) Channel(channel ...string) SUnsubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return (SUnsubscribeChannel)(c)
 }
 
@@ -44258,12 +45758,12 @@ type UnsubscribeChannel Completed
 type SUnsubscribeChannel SCompleted
 
 func (c UnsubscribeChannel) Channel(channel ...string) UnsubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
 func (c SUnsubscribeChannel) Channel(channel ...string) SUnsubscribeChannel {
-	c.cs = append(c.cs, channel...)
+	c.cs.s = append(c.cs.s, channel...)
 	return c
 }
 
@@ -44279,12 +45779,16 @@ type Unwatch Completed
 
 type SUnwatch SCompleted
 
-func (b *Builder) Unwatch() Unwatch {
-	return Unwatch{cs: append(b.get(), "UNWATCH"), ks: InitSlot}
+func (b *Builder) Unwatch() (c Unwatch) {
+	c = Unwatch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "UNWATCH")
+	return c
 }
 
-func (b *SBuilder) Unwatch() SUnwatch {
-	return SUnwatch{cs: append(b.get(), "UNWATCH"), ks: InitSlot}
+func (b *SBuilder) Unwatch() (c SUnwatch) {
+	c = SUnwatch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "UNWATCH")
+	return c
 }
 
 func (c Unwatch) Build() Completed {
@@ -44299,21 +45803,25 @@ type Wait Completed
 
 type SWait SCompleted
 
-func (b *Builder) Wait() Wait {
-	return Wait{cs: append(b.get(), "WAIT"), ks: InitSlot, cf: blockTag}
+func (b *Builder) Wait() (c Wait) {
+	c = Wait{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "WAIT")
+	return c
 }
 
-func (b *SBuilder) Wait() SWait {
-	return SWait{cs: append(b.get(), "WAIT"), ks: InitSlot, cf: blockTag}
+func (b *SBuilder) Wait() (c SWait) {
+	c = SWait{cs: b.get(), ks: InitSlot, cf: blockTag}
+	c.cs.s = append(c.cs.s, "WAIT")
+	return c
 }
 
 func (c Wait) Numreplicas(numreplicas int64) WaitNumreplicas {
-	c.cs = append(c.cs, strconv.FormatInt(numreplicas, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numreplicas, 10))
 	return (WaitNumreplicas)(c)
 }
 
 func (c SWait) Numreplicas(numreplicas int64) SWaitNumreplicas {
-	c.cs = append(c.cs, strconv.FormatInt(numreplicas, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numreplicas, 10))
 	return (SWaitNumreplicas)(c)
 }
 
@@ -44322,12 +45830,12 @@ type WaitNumreplicas Completed
 type SWaitNumreplicas SCompleted
 
 func (c WaitNumreplicas) Timeout(timeout int64) WaitTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (WaitTimeout)(c)
 }
 
 func (c SWaitNumreplicas) Timeout(timeout int64) SWaitTimeout {
-	c.cs = append(c.cs, strconv.FormatInt(timeout, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(timeout, 10))
 	return (SWaitTimeout)(c)
 }
 
@@ -44347,16 +45855,20 @@ type Watch Completed
 
 type SWatch SCompleted
 
-func (b *Builder) Watch() Watch {
-	return Watch{cs: append(b.get(), "WATCH"), ks: InitSlot}
+func (b *Builder) Watch() (c Watch) {
+	c = Watch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "WATCH")
+	return c
 }
 
-func (b *SBuilder) Watch() SWatch {
-	return SWatch{cs: append(b.get(), "WATCH"), ks: InitSlot}
+func (b *SBuilder) Watch() (c SWatch) {
+	c = SWatch{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "WATCH")
+	return c
 }
 
 func (c Watch) Key(key ...string) WatchKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (WatchKey)(c)
 }
 
@@ -44364,7 +45876,7 @@ func (c SWatch) Key(key ...string) SWatchKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SWatchKey)(c)
 }
 
@@ -44373,7 +45885,7 @@ type WatchKey Completed
 type SWatchKey SCompleted
 
 func (c WatchKey) Key(key ...string) WatchKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -44381,7 +45893,7 @@ func (c SWatchKey) Key(key ...string) SWatchKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -44397,22 +45909,26 @@ type Xack Completed
 
 type SXack SCompleted
 
-func (b *Builder) Xack() Xack {
-	return Xack{cs: append(b.get(), "XACK"), ks: InitSlot}
+func (b *Builder) Xack() (c Xack) {
+	c = Xack{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XACK")
+	return c
 }
 
-func (b *SBuilder) Xack() SXack {
-	return SXack{cs: append(b.get(), "XACK"), ks: InitSlot}
+func (b *SBuilder) Xack() (c SXack) {
+	c = SXack{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XACK")
+	return c
 }
 
 func (c Xack) Key(key string) XackKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XackKey)(c)
 }
 
 func (c SXack) Key(key string) SXackKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXackKey)(c)
 }
 
@@ -44421,12 +45937,12 @@ type XackGroup Completed
 type SXackGroup SCompleted
 
 func (c XackGroup) Id(id ...string) XackId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (XackId)(c)
 }
 
 func (c SXackGroup) Id(id ...string) SXackId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (SXackId)(c)
 }
 
@@ -44435,12 +45951,12 @@ type XackId Completed
 type SXackId SCompleted
 
 func (c XackId) Id(id ...string) XackId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c SXackId) Id(id ...string) SXackId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
@@ -44457,12 +45973,12 @@ type XackKey Completed
 type SXackKey SCompleted
 
 func (c XackKey) Group(group string) XackGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (XackGroup)(c)
 }
 
 func (c SXackKey) Group(group string) SXackGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (SXackGroup)(c)
 }
 
@@ -44470,22 +45986,26 @@ type Xadd Completed
 
 type SXadd SCompleted
 
-func (b *Builder) Xadd() Xadd {
-	return Xadd{cs: append(b.get(), "XADD"), ks: InitSlot}
+func (b *Builder) Xadd() (c Xadd) {
+	c = Xadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XADD")
+	return c
 }
 
-func (b *SBuilder) Xadd() SXadd {
-	return SXadd{cs: append(b.get(), "XADD"), ks: InitSlot}
+func (b *SBuilder) Xadd() (c SXadd) {
+	c = SXadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XADD")
+	return c
 }
 
 func (c Xadd) Key(key string) XaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XaddKey)(c)
 }
 
 func (c SXadd) Key(key string) SXaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXaddKey)(c)
 }
 
@@ -44494,12 +46014,12 @@ type XaddFieldValue Completed
 type SXaddFieldValue SCompleted
 
 func (c XaddFieldValue) FieldValue(field string, value string) XaddFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
 func (c SXaddFieldValue) FieldValue(field string, value string) SXaddFieldValue {
-	c.cs = append(c.cs, field, value)
+	c.cs.s = append(c.cs.s, field, value)
 	return c
 }
 
@@ -44528,42 +46048,42 @@ type XaddKey Completed
 type SXaddKey SCompleted
 
 func (c XaddKey) Nomkstream() XaddNomkstream {
-	c.cs = append(c.cs, "NOMKSTREAM")
+	c.cs.s = append(c.cs.s, "NOMKSTREAM")
 	return (XaddNomkstream)(c)
 }
 
 func (c SXaddKey) Nomkstream() SXaddNomkstream {
-	c.cs = append(c.cs, "NOMKSTREAM")
+	c.cs.s = append(c.cs.s, "NOMKSTREAM")
 	return (SXaddNomkstream)(c)
 }
 
 func (c XaddKey) Maxlen() XaddTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (XaddTrimStrategyMaxlen)(c)
 }
 
 func (c SXaddKey) Maxlen() SXaddTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (SXaddTrimStrategyMaxlen)(c)
 }
 
 func (c XaddKey) Minid() XaddTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (XaddTrimStrategyMinid)(c)
 }
 
 func (c SXaddKey) Minid() SXaddTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (SXaddTrimStrategyMinid)(c)
 }
 
 func (c XaddKey) Id(id string) XaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XaddId)(c)
 }
 
 func (c SXaddKey) Id(id string) SXaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXaddId)(c)
 }
 
@@ -44572,32 +46092,32 @@ type XaddNomkstream Completed
 type SXaddNomkstream SCompleted
 
 func (c XaddNomkstream) Maxlen() XaddTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (XaddTrimStrategyMaxlen)(c)
 }
 
 func (c SXaddNomkstream) Maxlen() SXaddTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (SXaddTrimStrategyMaxlen)(c)
 }
 
 func (c XaddNomkstream) Minid() XaddTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (XaddTrimStrategyMinid)(c)
 }
 
 func (c SXaddNomkstream) Minid() SXaddTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (SXaddTrimStrategyMinid)(c)
 }
 
 func (c XaddNomkstream) Id(id string) XaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XaddId)(c)
 }
 
 func (c SXaddNomkstream) Id(id string) SXaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXaddId)(c)
 }
 
@@ -44606,12 +46126,12 @@ type XaddTrimLimit Completed
 type SXaddTrimLimit SCompleted
 
 func (c XaddTrimLimit) Id(id string) XaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XaddId)(c)
 }
 
 func (c SXaddTrimLimit) Id(id string) SXaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXaddId)(c)
 }
 
@@ -44620,12 +46140,12 @@ type XaddTrimOperatorAlmost Completed
 type SXaddTrimOperatorAlmost SCompleted
 
 func (c XaddTrimOperatorAlmost) Threshold(threshold string) XaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XaddTrimThreshold)(c)
 }
 
 func (c SXaddTrimOperatorAlmost) Threshold(threshold string) SXaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXaddTrimThreshold)(c)
 }
 
@@ -44634,12 +46154,12 @@ type XaddTrimOperatorExact Completed
 type SXaddTrimOperatorExact SCompleted
 
 func (c XaddTrimOperatorExact) Threshold(threshold string) XaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XaddTrimThreshold)(c)
 }
 
 func (c SXaddTrimOperatorExact) Threshold(threshold string) SXaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXaddTrimThreshold)(c)
 }
 
@@ -44648,32 +46168,32 @@ type XaddTrimStrategyMaxlen Completed
 type SXaddTrimStrategyMaxlen SCompleted
 
 func (c XaddTrimStrategyMaxlen) Exact() XaddTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (XaddTrimOperatorExact)(c)
 }
 
 func (c SXaddTrimStrategyMaxlen) Exact() SXaddTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (SXaddTrimOperatorExact)(c)
 }
 
 func (c XaddTrimStrategyMaxlen) Almost() XaddTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (XaddTrimOperatorAlmost)(c)
 }
 
 func (c SXaddTrimStrategyMaxlen) Almost() SXaddTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (SXaddTrimOperatorAlmost)(c)
 }
 
 func (c XaddTrimStrategyMaxlen) Threshold(threshold string) XaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XaddTrimThreshold)(c)
 }
 
 func (c SXaddTrimStrategyMaxlen) Threshold(threshold string) SXaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXaddTrimThreshold)(c)
 }
 
@@ -44682,32 +46202,32 @@ type XaddTrimStrategyMinid Completed
 type SXaddTrimStrategyMinid SCompleted
 
 func (c XaddTrimStrategyMinid) Exact() XaddTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (XaddTrimOperatorExact)(c)
 }
 
 func (c SXaddTrimStrategyMinid) Exact() SXaddTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (SXaddTrimOperatorExact)(c)
 }
 
 func (c XaddTrimStrategyMinid) Almost() XaddTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (XaddTrimOperatorAlmost)(c)
 }
 
 func (c SXaddTrimStrategyMinid) Almost() SXaddTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (SXaddTrimOperatorAlmost)(c)
 }
 
 func (c XaddTrimStrategyMinid) Threshold(threshold string) XaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XaddTrimThreshold)(c)
 }
 
 func (c SXaddTrimStrategyMinid) Threshold(threshold string) SXaddTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXaddTrimThreshold)(c)
 }
 
@@ -44716,22 +46236,22 @@ type XaddTrimThreshold Completed
 type SXaddTrimThreshold SCompleted
 
 func (c XaddTrimThreshold) Limit(count int64) XaddTrimLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
 	return (XaddTrimLimit)(c)
 }
 
 func (c SXaddTrimThreshold) Limit(count int64) SXaddTrimLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
 	return (SXaddTrimLimit)(c)
 }
 
 func (c XaddTrimThreshold) Id(id string) XaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XaddId)(c)
 }
 
 func (c SXaddTrimThreshold) Id(id string) SXaddId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXaddId)(c)
 }
 
@@ -44739,22 +46259,26 @@ type Xautoclaim Completed
 
 type SXautoclaim SCompleted
 
-func (b *Builder) Xautoclaim() Xautoclaim {
-	return Xautoclaim{cs: append(b.get(), "XAUTOCLAIM"), ks: InitSlot}
+func (b *Builder) Xautoclaim() (c Xautoclaim) {
+	c = Xautoclaim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XAUTOCLAIM")
+	return c
 }
 
-func (b *SBuilder) Xautoclaim() SXautoclaim {
-	return SXautoclaim{cs: append(b.get(), "XAUTOCLAIM"), ks: InitSlot}
+func (b *SBuilder) Xautoclaim() (c SXautoclaim) {
+	c = SXautoclaim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XAUTOCLAIM")
+	return c
 }
 
 func (c Xautoclaim) Key(key string) XautoclaimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XautoclaimKey)(c)
 }
 
 func (c SXautoclaim) Key(key string) SXautoclaimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXautoclaimKey)(c)
 }
 
@@ -44763,12 +46287,12 @@ type XautoclaimConsumer Completed
 type SXautoclaimConsumer SCompleted
 
 func (c XautoclaimConsumer) MinIdleTime(minIdleTime string) XautoclaimMinIdleTime {
-	c.cs = append(c.cs, minIdleTime)
+	c.cs.s = append(c.cs.s, minIdleTime)
 	return (XautoclaimMinIdleTime)(c)
 }
 
 func (c SXautoclaimConsumer) MinIdleTime(minIdleTime string) SXautoclaimMinIdleTime {
-	c.cs = append(c.cs, minIdleTime)
+	c.cs.s = append(c.cs.s, minIdleTime)
 	return (SXautoclaimMinIdleTime)(c)
 }
 
@@ -44777,12 +46301,12 @@ type XautoclaimCount Completed
 type SXautoclaimCount SCompleted
 
 func (c XautoclaimCount) Justid() XautoclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XautoclaimJustid)(c)
 }
 
 func (c SXautoclaimCount) Justid() SXautoclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXautoclaimJustid)(c)
 }
 
@@ -44799,12 +46323,12 @@ type XautoclaimGroup Completed
 type SXautoclaimGroup SCompleted
 
 func (c XautoclaimGroup) Consumer(consumer string) XautoclaimConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (XautoclaimConsumer)(c)
 }
 
 func (c SXautoclaimGroup) Consumer(consumer string) SXautoclaimConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (SXautoclaimConsumer)(c)
 }
 
@@ -44825,12 +46349,12 @@ type XautoclaimKey Completed
 type SXautoclaimKey SCompleted
 
 func (c XautoclaimKey) Group(group string) XautoclaimGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (XautoclaimGroup)(c)
 }
 
 func (c SXautoclaimKey) Group(group string) SXautoclaimGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (SXautoclaimGroup)(c)
 }
 
@@ -44839,12 +46363,12 @@ type XautoclaimMinIdleTime Completed
 type SXautoclaimMinIdleTime SCompleted
 
 func (c XautoclaimMinIdleTime) Start(start string) XautoclaimStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (XautoclaimStart)(c)
 }
 
 func (c SXautoclaimMinIdleTime) Start(start string) SXautoclaimStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (SXautoclaimStart)(c)
 }
 
@@ -44853,22 +46377,22 @@ type XautoclaimStart Completed
 type SXautoclaimStart SCompleted
 
 func (c XautoclaimStart) Count(count int64) XautoclaimCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XautoclaimCount)(c)
 }
 
 func (c SXautoclaimStart) Count(count int64) SXautoclaimCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXautoclaimCount)(c)
 }
 
 func (c XautoclaimStart) Justid() XautoclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XautoclaimJustid)(c)
 }
 
 func (c SXautoclaimStart) Justid() SXautoclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXautoclaimJustid)(c)
 }
 
@@ -44884,22 +46408,26 @@ type Xclaim Completed
 
 type SXclaim SCompleted
 
-func (b *Builder) Xclaim() Xclaim {
-	return Xclaim{cs: append(b.get(), "XCLAIM"), ks: InitSlot}
+func (b *Builder) Xclaim() (c Xclaim) {
+	c = Xclaim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XCLAIM")
+	return c
 }
 
-func (b *SBuilder) Xclaim() SXclaim {
-	return SXclaim{cs: append(b.get(), "XCLAIM"), ks: InitSlot}
+func (b *SBuilder) Xclaim() (c SXclaim) {
+	c = SXclaim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XCLAIM")
+	return c
 }
 
 func (c Xclaim) Key(key string) XclaimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XclaimKey)(c)
 }
 
 func (c SXclaim) Key(key string) SXclaimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXclaimKey)(c)
 }
 
@@ -44908,12 +46436,12 @@ type XclaimConsumer Completed
 type SXclaimConsumer SCompleted
 
 func (c XclaimConsumer) MinIdleTime(minIdleTime string) XclaimMinIdleTime {
-	c.cs = append(c.cs, minIdleTime)
+	c.cs.s = append(c.cs.s, minIdleTime)
 	return (XclaimMinIdleTime)(c)
 }
 
 func (c SXclaimConsumer) MinIdleTime(minIdleTime string) SXclaimMinIdleTime {
-	c.cs = append(c.cs, minIdleTime)
+	c.cs.s = append(c.cs.s, minIdleTime)
 	return (SXclaimMinIdleTime)(c)
 }
 
@@ -44922,12 +46450,12 @@ type XclaimForce Completed
 type SXclaimForce SCompleted
 
 func (c XclaimForce) Justid() XclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XclaimJustid)(c)
 }
 
 func (c SXclaimForce) Justid() SXclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXclaimJustid)(c)
 }
 
@@ -44944,12 +46472,12 @@ type XclaimGroup Completed
 type SXclaimGroup SCompleted
 
 func (c XclaimGroup) Consumer(consumer string) XclaimConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (XclaimConsumer)(c)
 }
 
 func (c SXclaimGroup) Consumer(consumer string) SXclaimConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (SXclaimConsumer)(c)
 }
 
@@ -44958,62 +46486,62 @@ type XclaimId Completed
 type SXclaimId SCompleted
 
 func (c XclaimId) Id(id ...string) XclaimId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c SXclaimId) Id(id ...string) SXclaimId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c XclaimId) Idle(ms int64) XclaimIdle {
-	c.cs = append(c.cs, "IDLE", strconv.FormatInt(ms, 10))
+	c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(ms, 10))
 	return (XclaimIdle)(c)
 }
 
 func (c SXclaimId) Idle(ms int64) SXclaimIdle {
-	c.cs = append(c.cs, "IDLE", strconv.FormatInt(ms, 10))
+	c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(ms, 10))
 	return (SXclaimIdle)(c)
 }
 
 func (c XclaimId) Time(msUnixTime int64) XclaimTime {
-	c.cs = append(c.cs, "TIME", strconv.FormatInt(msUnixTime, 10))
+	c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
 	return (XclaimTime)(c)
 }
 
 func (c SXclaimId) Time(msUnixTime int64) SXclaimTime {
-	c.cs = append(c.cs, "TIME", strconv.FormatInt(msUnixTime, 10))
+	c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
 	return (SXclaimTime)(c)
 }
 
 func (c XclaimId) Retrycount(count int64) XclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (XclaimRetrycount)(c)
 }
 
 func (c SXclaimId) Retrycount(count int64) SXclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (SXclaimRetrycount)(c)
 }
 
 func (c XclaimId) Force() XclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (XclaimForce)(c)
 }
 
 func (c SXclaimId) Force() SXclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SXclaimForce)(c)
 }
 
 func (c XclaimId) Justid() XclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XclaimJustid)(c)
 }
 
 func (c SXclaimId) Justid() SXclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXclaimJustid)(c)
 }
 
@@ -45030,42 +46558,42 @@ type XclaimIdle Completed
 type SXclaimIdle SCompleted
 
 func (c XclaimIdle) Time(msUnixTime int64) XclaimTime {
-	c.cs = append(c.cs, "TIME", strconv.FormatInt(msUnixTime, 10))
+	c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
 	return (XclaimTime)(c)
 }
 
 func (c SXclaimIdle) Time(msUnixTime int64) SXclaimTime {
-	c.cs = append(c.cs, "TIME", strconv.FormatInt(msUnixTime, 10))
+	c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
 	return (SXclaimTime)(c)
 }
 
 func (c XclaimIdle) Retrycount(count int64) XclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (XclaimRetrycount)(c)
 }
 
 func (c SXclaimIdle) Retrycount(count int64) SXclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (SXclaimRetrycount)(c)
 }
 
 func (c XclaimIdle) Force() XclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (XclaimForce)(c)
 }
 
 func (c SXclaimIdle) Force() SXclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SXclaimForce)(c)
 }
 
 func (c XclaimIdle) Justid() XclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XclaimJustid)(c)
 }
 
 func (c SXclaimIdle) Justid() SXclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXclaimJustid)(c)
 }
 
@@ -45094,12 +46622,12 @@ type XclaimKey Completed
 type SXclaimKey SCompleted
 
 func (c XclaimKey) Group(group string) XclaimGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (XclaimGroup)(c)
 }
 
 func (c SXclaimKey) Group(group string) SXclaimGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (SXclaimGroup)(c)
 }
 
@@ -45108,12 +46636,12 @@ type XclaimMinIdleTime Completed
 type SXclaimMinIdleTime SCompleted
 
 func (c XclaimMinIdleTime) Id(id ...string) XclaimId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (XclaimId)(c)
 }
 
 func (c SXclaimMinIdleTime) Id(id ...string) SXclaimId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (SXclaimId)(c)
 }
 
@@ -45122,22 +46650,22 @@ type XclaimRetrycount Completed
 type SXclaimRetrycount SCompleted
 
 func (c XclaimRetrycount) Force() XclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (XclaimForce)(c)
 }
 
 func (c SXclaimRetrycount) Force() SXclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SXclaimForce)(c)
 }
 
 func (c XclaimRetrycount) Justid() XclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XclaimJustid)(c)
 }
 
 func (c SXclaimRetrycount) Justid() SXclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXclaimJustid)(c)
 }
 
@@ -45154,32 +46682,32 @@ type XclaimTime Completed
 type SXclaimTime SCompleted
 
 func (c XclaimTime) Retrycount(count int64) XclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (XclaimRetrycount)(c)
 }
 
 func (c SXclaimTime) Retrycount(count int64) SXclaimRetrycount {
-	c.cs = append(c.cs, "RETRYCOUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
 	return (SXclaimRetrycount)(c)
 }
 
 func (c XclaimTime) Force() XclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (XclaimForce)(c)
 }
 
 func (c SXclaimTime) Force() SXclaimForce {
-	c.cs = append(c.cs, "FORCE")
+	c.cs.s = append(c.cs.s, "FORCE")
 	return (SXclaimForce)(c)
 }
 
 func (c XclaimTime) Justid() XclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (XclaimJustid)(c)
 }
 
 func (c SXclaimTime) Justid() SXclaimJustid {
-	c.cs = append(c.cs, "JUSTID")
+	c.cs.s = append(c.cs.s, "JUSTID")
 	return (SXclaimJustid)(c)
 }
 
@@ -45195,22 +46723,26 @@ type Xdel Completed
 
 type SXdel SCompleted
 
-func (b *Builder) Xdel() Xdel {
-	return Xdel{cs: append(b.get(), "XDEL"), ks: InitSlot}
+func (b *Builder) Xdel() (c Xdel) {
+	c = Xdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XDEL")
+	return c
 }
 
-func (b *SBuilder) Xdel() SXdel {
-	return SXdel{cs: append(b.get(), "XDEL"), ks: InitSlot}
+func (b *SBuilder) Xdel() (c SXdel) {
+	c = SXdel{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XDEL")
+	return c
 }
 
 func (c Xdel) Key(key string) XdelKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XdelKey)(c)
 }
 
 func (c SXdel) Key(key string) SXdelKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXdelKey)(c)
 }
 
@@ -45219,12 +46751,12 @@ type XdelId Completed
 type SXdelId SCompleted
 
 func (c XdelId) Id(id ...string) XdelId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c SXdelId) Id(id ...string) SXdelId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
@@ -45241,12 +46773,12 @@ type XdelKey Completed
 type SXdelKey SCompleted
 
 func (c XdelKey) Id(id ...string) XdelId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (XdelId)(c)
 }
 
 func (c SXdelKey) Id(id ...string) SXdelId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (SXdelId)(c)
 }
 
@@ -45254,22 +46786,26 @@ type XgroupCreate Completed
 
 type SXgroupCreate SCompleted
 
-func (b *Builder) XgroupCreate() XgroupCreate {
-	return XgroupCreate{cs: append(b.get(), "XGROUP", "CREATE"), ks: InitSlot}
+func (b *Builder) XgroupCreate() (c XgroupCreate) {
+	c = XgroupCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "CREATE")
+	return c
 }
 
-func (b *SBuilder) XgroupCreate() SXgroupCreate {
-	return SXgroupCreate{cs: append(b.get(), "XGROUP", "CREATE"), ks: InitSlot}
+func (b *SBuilder) XgroupCreate() (c SXgroupCreate) {
+	c = SXgroupCreate{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "CREATE")
+	return c
 }
 
 func (c XgroupCreate) Key(key string) XgroupCreateKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XgroupCreateKey)(c)
 }
 
 func (c SXgroupCreate) Key(key string) SXgroupCreateKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXgroupCreateKey)(c)
 }
 
@@ -45278,12 +46814,12 @@ type XgroupCreateGroupname Completed
 type SXgroupCreateGroupname SCompleted
 
 func (c XgroupCreateGroupname) Id(id string) XgroupCreateId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XgroupCreateId)(c)
 }
 
 func (c SXgroupCreateGroupname) Id(id string) SXgroupCreateId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXgroupCreateId)(c)
 }
 
@@ -45292,12 +46828,12 @@ type XgroupCreateId Completed
 type SXgroupCreateId SCompleted
 
 func (c XgroupCreateId) Mkstream() XgroupCreateMkstream {
-	c.cs = append(c.cs, "MKSTREAM")
+	c.cs.s = append(c.cs.s, "MKSTREAM")
 	return (XgroupCreateMkstream)(c)
 }
 
 func (c SXgroupCreateId) Mkstream() SXgroupCreateMkstream {
-	c.cs = append(c.cs, "MKSTREAM")
+	c.cs.s = append(c.cs.s, "MKSTREAM")
 	return (SXgroupCreateMkstream)(c)
 }
 
@@ -45314,12 +46850,12 @@ type XgroupCreateKey Completed
 type SXgroupCreateKey SCompleted
 
 func (c XgroupCreateKey) Groupname(groupname string) XgroupCreateGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XgroupCreateGroupname)(c)
 }
 
 func (c SXgroupCreateKey) Groupname(groupname string) SXgroupCreateGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXgroupCreateGroupname)(c)
 }
 
@@ -45339,22 +46875,26 @@ type XgroupCreateconsumer Completed
 
 type SXgroupCreateconsumer SCompleted
 
-func (b *Builder) XgroupCreateconsumer() XgroupCreateconsumer {
-	return XgroupCreateconsumer{cs: append(b.get(), "XGROUP", "CREATECONSUMER"), ks: InitSlot}
+func (b *Builder) XgroupCreateconsumer() (c XgroupCreateconsumer) {
+	c = XgroupCreateconsumer{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "CREATECONSUMER")
+	return c
 }
 
-func (b *SBuilder) XgroupCreateconsumer() SXgroupCreateconsumer {
-	return SXgroupCreateconsumer{cs: append(b.get(), "XGROUP", "CREATECONSUMER"), ks: InitSlot}
+func (b *SBuilder) XgroupCreateconsumer() (c SXgroupCreateconsumer) {
+	c = SXgroupCreateconsumer{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "CREATECONSUMER")
+	return c
 }
 
 func (c XgroupCreateconsumer) Key(key string) XgroupCreateconsumerKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XgroupCreateconsumerKey)(c)
 }
 
 func (c SXgroupCreateconsumer) Key(key string) SXgroupCreateconsumerKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXgroupCreateconsumerKey)(c)
 }
 
@@ -45375,12 +46915,12 @@ type XgroupCreateconsumerGroupname Completed
 type SXgroupCreateconsumerGroupname SCompleted
 
 func (c XgroupCreateconsumerGroupname) Consumername(consumername string) XgroupCreateconsumerConsumername {
-	c.cs = append(c.cs, consumername)
+	c.cs.s = append(c.cs.s, consumername)
 	return (XgroupCreateconsumerConsumername)(c)
 }
 
 func (c SXgroupCreateconsumerGroupname) Consumername(consumername string) SXgroupCreateconsumerConsumername {
-	c.cs = append(c.cs, consumername)
+	c.cs.s = append(c.cs.s, consumername)
 	return (SXgroupCreateconsumerConsumername)(c)
 }
 
@@ -45389,12 +46929,12 @@ type XgroupCreateconsumerKey Completed
 type SXgroupCreateconsumerKey SCompleted
 
 func (c XgroupCreateconsumerKey) Groupname(groupname string) XgroupCreateconsumerGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XgroupCreateconsumerGroupname)(c)
 }
 
 func (c SXgroupCreateconsumerKey) Groupname(groupname string) SXgroupCreateconsumerGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXgroupCreateconsumerGroupname)(c)
 }
 
@@ -45402,22 +46942,26 @@ type XgroupDelconsumer Completed
 
 type SXgroupDelconsumer SCompleted
 
-func (b *Builder) XgroupDelconsumer() XgroupDelconsumer {
-	return XgroupDelconsumer{cs: append(b.get(), "XGROUP", "DELCONSUMER"), ks: InitSlot}
+func (b *Builder) XgroupDelconsumer() (c XgroupDelconsumer) {
+	c = XgroupDelconsumer{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "DELCONSUMER")
+	return c
 }
 
-func (b *SBuilder) XgroupDelconsumer() SXgroupDelconsumer {
-	return SXgroupDelconsumer{cs: append(b.get(), "XGROUP", "DELCONSUMER"), ks: InitSlot}
+func (b *SBuilder) XgroupDelconsumer() (c SXgroupDelconsumer) {
+	c = SXgroupDelconsumer{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "DELCONSUMER")
+	return c
 }
 
 func (c XgroupDelconsumer) Key(key string) XgroupDelconsumerKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XgroupDelconsumerKey)(c)
 }
 
 func (c SXgroupDelconsumer) Key(key string) SXgroupDelconsumerKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXgroupDelconsumerKey)(c)
 }
 
@@ -45438,12 +46982,12 @@ type XgroupDelconsumerGroupname Completed
 type SXgroupDelconsumerGroupname SCompleted
 
 func (c XgroupDelconsumerGroupname) Consumername(consumername string) XgroupDelconsumerConsumername {
-	c.cs = append(c.cs, consumername)
+	c.cs.s = append(c.cs.s, consumername)
 	return (XgroupDelconsumerConsumername)(c)
 }
 
 func (c SXgroupDelconsumerGroupname) Consumername(consumername string) SXgroupDelconsumerConsumername {
-	c.cs = append(c.cs, consumername)
+	c.cs.s = append(c.cs.s, consumername)
 	return (SXgroupDelconsumerConsumername)(c)
 }
 
@@ -45452,12 +46996,12 @@ type XgroupDelconsumerKey Completed
 type SXgroupDelconsumerKey SCompleted
 
 func (c XgroupDelconsumerKey) Groupname(groupname string) XgroupDelconsumerGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XgroupDelconsumerGroupname)(c)
 }
 
 func (c SXgroupDelconsumerKey) Groupname(groupname string) SXgroupDelconsumerGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXgroupDelconsumerGroupname)(c)
 }
 
@@ -45465,22 +47009,26 @@ type XgroupDestroy Completed
 
 type SXgroupDestroy SCompleted
 
-func (b *Builder) XgroupDestroy() XgroupDestroy {
-	return XgroupDestroy{cs: append(b.get(), "XGROUP", "DESTROY"), ks: InitSlot}
+func (b *Builder) XgroupDestroy() (c XgroupDestroy) {
+	c = XgroupDestroy{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "DESTROY")
+	return c
 }
 
-func (b *SBuilder) XgroupDestroy() SXgroupDestroy {
-	return SXgroupDestroy{cs: append(b.get(), "XGROUP", "DESTROY"), ks: InitSlot}
+func (b *SBuilder) XgroupDestroy() (c SXgroupDestroy) {
+	c = SXgroupDestroy{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "DESTROY")
+	return c
 }
 
 func (c XgroupDestroy) Key(key string) XgroupDestroyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XgroupDestroyKey)(c)
 }
 
 func (c SXgroupDestroy) Key(key string) SXgroupDestroyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXgroupDestroyKey)(c)
 }
 
@@ -45501,12 +47049,12 @@ type XgroupDestroyKey Completed
 type SXgroupDestroyKey SCompleted
 
 func (c XgroupDestroyKey) Groupname(groupname string) XgroupDestroyGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XgroupDestroyGroupname)(c)
 }
 
 func (c SXgroupDestroyKey) Groupname(groupname string) SXgroupDestroyGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXgroupDestroyGroupname)(c)
 }
 
@@ -45514,12 +47062,16 @@ type XgroupHelp Completed
 
 type SXgroupHelp SCompleted
 
-func (b *Builder) XgroupHelp() XgroupHelp {
-	return XgroupHelp{cs: append(b.get(), "XGROUP", "HELP"), ks: InitSlot}
+func (b *Builder) XgroupHelp() (c XgroupHelp) {
+	c = XgroupHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "HELP")
+	return c
 }
 
-func (b *SBuilder) XgroupHelp() SXgroupHelp {
-	return SXgroupHelp{cs: append(b.get(), "XGROUP", "HELP"), ks: InitSlot}
+func (b *SBuilder) XgroupHelp() (c SXgroupHelp) {
+	c = SXgroupHelp{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "HELP")
+	return c
 }
 
 func (c XgroupHelp) Build() Completed {
@@ -45534,22 +47086,26 @@ type XgroupSetid Completed
 
 type SXgroupSetid SCompleted
 
-func (b *Builder) XgroupSetid() XgroupSetid {
-	return XgroupSetid{cs: append(b.get(), "XGROUP", "SETID"), ks: InitSlot}
+func (b *Builder) XgroupSetid() (c XgroupSetid) {
+	c = XgroupSetid{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "SETID")
+	return c
 }
 
-func (b *SBuilder) XgroupSetid() SXgroupSetid {
-	return SXgroupSetid{cs: append(b.get(), "XGROUP", "SETID"), ks: InitSlot}
+func (b *SBuilder) XgroupSetid() (c SXgroupSetid) {
+	c = SXgroupSetid{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XGROUP", "SETID")
+	return c
 }
 
 func (c XgroupSetid) Key(key string) XgroupSetidKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XgroupSetidKey)(c)
 }
 
 func (c SXgroupSetid) Key(key string) SXgroupSetidKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXgroupSetidKey)(c)
 }
 
@@ -45558,12 +47114,12 @@ type XgroupSetidGroupname Completed
 type SXgroupSetidGroupname SCompleted
 
 func (c XgroupSetidGroupname) Id(id string) XgroupSetidId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (XgroupSetidId)(c)
 }
 
 func (c SXgroupSetidGroupname) Id(id string) SXgroupSetidId {
-	c.cs = append(c.cs, id)
+	c.cs.s = append(c.cs.s, id)
 	return (SXgroupSetidId)(c)
 }
 
@@ -45584,12 +47140,12 @@ type XgroupSetidKey Completed
 type SXgroupSetidKey SCompleted
 
 func (c XgroupSetidKey) Groupname(groupname string) XgroupSetidGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XgroupSetidGroupname)(c)
 }
 
 func (c SXgroupSetidKey) Groupname(groupname string) SXgroupSetidGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXgroupSetidGroupname)(c)
 }
 
@@ -45597,22 +47153,26 @@ type XinfoConsumers Completed
 
 type SXinfoConsumers SCompleted
 
-func (b *Builder) XinfoConsumers() XinfoConsumers {
-	return XinfoConsumers{cs: append(b.get(), "XINFO", "CONSUMERS"), ks: InitSlot, cf: readonly}
+func (b *Builder) XinfoConsumers() (c XinfoConsumers) {
+	c = XinfoConsumers{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "CONSUMERS")
+	return c
 }
 
-func (b *SBuilder) XinfoConsumers() SXinfoConsumers {
-	return SXinfoConsumers{cs: append(b.get(), "XINFO", "CONSUMERS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) XinfoConsumers() (c SXinfoConsumers) {
+	c = SXinfoConsumers{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "CONSUMERS")
+	return c
 }
 
 func (c XinfoConsumers) Key(key string) XinfoConsumersKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XinfoConsumersKey)(c)
 }
 
 func (c SXinfoConsumers) Key(key string) SXinfoConsumersKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXinfoConsumersKey)(c)
 }
 
@@ -45633,12 +47193,12 @@ type XinfoConsumersKey Completed
 type SXinfoConsumersKey SCompleted
 
 func (c XinfoConsumersKey) Groupname(groupname string) XinfoConsumersGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (XinfoConsumersGroupname)(c)
 }
 
 func (c SXinfoConsumersKey) Groupname(groupname string) SXinfoConsumersGroupname {
-	c.cs = append(c.cs, groupname)
+	c.cs.s = append(c.cs.s, groupname)
 	return (SXinfoConsumersGroupname)(c)
 }
 
@@ -45646,22 +47206,26 @@ type XinfoGroups Completed
 
 type SXinfoGroups SCompleted
 
-func (b *Builder) XinfoGroups() XinfoGroups {
-	return XinfoGroups{cs: append(b.get(), "XINFO", "GROUPS"), ks: InitSlot, cf: readonly}
+func (b *Builder) XinfoGroups() (c XinfoGroups) {
+	c = XinfoGroups{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "GROUPS")
+	return c
 }
 
-func (b *SBuilder) XinfoGroups() SXinfoGroups {
-	return SXinfoGroups{cs: append(b.get(), "XINFO", "GROUPS"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) XinfoGroups() (c SXinfoGroups) {
+	c = SXinfoGroups{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "GROUPS")
+	return c
 }
 
 func (c XinfoGroups) Key(key string) XinfoGroupsKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XinfoGroupsKey)(c)
 }
 
 func (c SXinfoGroups) Key(key string) SXinfoGroupsKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXinfoGroupsKey)(c)
 }
 
@@ -45681,12 +47245,16 @@ type XinfoHelp Completed
 
 type SXinfoHelp SCompleted
 
-func (b *Builder) XinfoHelp() XinfoHelp {
-	return XinfoHelp{cs: append(b.get(), "XINFO", "HELP"), ks: InitSlot, cf: readonly}
+func (b *Builder) XinfoHelp() (c XinfoHelp) {
+	c = XinfoHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "HELP")
+	return c
 }
 
-func (b *SBuilder) XinfoHelp() SXinfoHelp {
-	return SXinfoHelp{cs: append(b.get(), "XINFO", "HELP"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) XinfoHelp() (c SXinfoHelp) {
+	c = SXinfoHelp{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "HELP")
+	return c
 }
 
 func (c XinfoHelp) Build() Completed {
@@ -45701,22 +47269,26 @@ type XinfoStream Completed
 
 type SXinfoStream SCompleted
 
-func (b *Builder) XinfoStream() XinfoStream {
-	return XinfoStream{cs: append(b.get(), "XINFO", "STREAM"), ks: InitSlot, cf: readonly}
+func (b *Builder) XinfoStream() (c XinfoStream) {
+	c = XinfoStream{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "STREAM")
+	return c
 }
 
-func (b *SBuilder) XinfoStream() SXinfoStream {
-	return SXinfoStream{cs: append(b.get(), "XINFO", "STREAM"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) XinfoStream() (c SXinfoStream) {
+	c = SXinfoStream{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XINFO", "STREAM")
+	return c
 }
 
 func (c XinfoStream) Key(key string) XinfoStreamKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XinfoStreamKey)(c)
 }
 
 func (c SXinfoStream) Key(key string) SXinfoStreamKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXinfoStreamKey)(c)
 }
 
@@ -45737,12 +47309,12 @@ type XinfoStreamFullFull Completed
 type SXinfoStreamFullFull SCompleted
 
 func (c XinfoStreamFullFull) Count(count int64) XinfoStreamFullCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XinfoStreamFullCount)(c)
 }
 
 func (c SXinfoStreamFullFull) Count(count int64) SXinfoStreamFullCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXinfoStreamFullCount)(c)
 }
 
@@ -45759,12 +47331,12 @@ type XinfoStreamKey Completed
 type SXinfoStreamKey SCompleted
 
 func (c XinfoStreamKey) Full() XinfoStreamFullFull {
-	c.cs = append(c.cs, "FULL")
+	c.cs.s = append(c.cs.s, "FULL")
 	return (XinfoStreamFullFull)(c)
 }
 
 func (c SXinfoStreamKey) Full() SXinfoStreamFullFull {
-	c.cs = append(c.cs, "FULL")
+	c.cs.s = append(c.cs.s, "FULL")
 	return (SXinfoStreamFullFull)(c)
 }
 
@@ -45780,22 +47352,26 @@ type Xlen Completed
 
 type SXlen SCompleted
 
-func (b *Builder) Xlen() Xlen {
-	return Xlen{cs: append(b.get(), "XLEN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Xlen() (c Xlen) {
+	c = Xlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XLEN")
+	return c
 }
 
-func (b *SBuilder) Xlen() SXlen {
-	return SXlen{cs: append(b.get(), "XLEN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Xlen() (c SXlen) {
+	c = SXlen{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XLEN")
+	return c
 }
 
 func (c Xlen) Key(key string) XlenKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XlenKey)(c)
 }
 
 func (c SXlen) Key(key string) SXlenKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXlenKey)(c)
 }
 
@@ -45815,22 +47391,26 @@ type Xpending Completed
 
 type SXpending SCompleted
 
-func (b *Builder) Xpending() Xpending {
-	return Xpending{cs: append(b.get(), "XPENDING"), ks: InitSlot, cf: readonly}
+func (b *Builder) Xpending() (c Xpending) {
+	c = Xpending{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XPENDING")
+	return c
 }
 
-func (b *SBuilder) Xpending() SXpending {
-	return SXpending{cs: append(b.get(), "XPENDING"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Xpending() (c SXpending) {
+	c = SXpending{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XPENDING")
+	return c
 }
 
 func (c Xpending) Key(key string) XpendingKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XpendingKey)(c)
 }
 
 func (c SXpending) Key(key string) SXpendingKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXpendingKey)(c)
 }
 
@@ -45851,12 +47431,12 @@ type XpendingFiltersCount Completed
 type SXpendingFiltersCount SCompleted
 
 func (c XpendingFiltersCount) Consumer(consumer string) XpendingFiltersConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (XpendingFiltersConsumer)(c)
 }
 
 func (c SXpendingFiltersCount) Consumer(consumer string) SXpendingFiltersConsumer {
-	c.cs = append(c.cs, consumer)
+	c.cs.s = append(c.cs.s, consumer)
 	return (SXpendingFiltersConsumer)(c)
 }
 
@@ -45873,12 +47453,12 @@ type XpendingFiltersEnd Completed
 type SXpendingFiltersEnd SCompleted
 
 func (c XpendingFiltersEnd) Count(count int64) XpendingFiltersCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (XpendingFiltersCount)(c)
 }
 
 func (c SXpendingFiltersEnd) Count(count int64) SXpendingFiltersCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SXpendingFiltersCount)(c)
 }
 
@@ -45887,12 +47467,12 @@ type XpendingFiltersIdle Completed
 type SXpendingFiltersIdle SCompleted
 
 func (c XpendingFiltersIdle) Start(start string) XpendingFiltersStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (XpendingFiltersStart)(c)
 }
 
 func (c SXpendingFiltersIdle) Start(start string) SXpendingFiltersStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (SXpendingFiltersStart)(c)
 }
 
@@ -45901,12 +47481,12 @@ type XpendingFiltersStart Completed
 type SXpendingFiltersStart SCompleted
 
 func (c XpendingFiltersStart) End(end string) XpendingFiltersEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (XpendingFiltersEnd)(c)
 }
 
 func (c SXpendingFiltersStart) End(end string) SXpendingFiltersEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (SXpendingFiltersEnd)(c)
 }
 
@@ -45915,12 +47495,12 @@ type XpendingGroup Completed
 type SXpendingGroup SCompleted
 
 func (c XpendingGroup) Idle(minIdleTime int64) XpendingFiltersIdle {
-	c.cs = append(c.cs, "IDLE", strconv.FormatInt(minIdleTime, 10))
+	c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(minIdleTime, 10))
 	return (XpendingFiltersIdle)(c)
 }
 
 func (c SXpendingGroup) Idle(minIdleTime int64) SXpendingFiltersIdle {
-	c.cs = append(c.cs, "IDLE", strconv.FormatInt(minIdleTime, 10))
+	c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(minIdleTime, 10))
 	return (SXpendingFiltersIdle)(c)
 }
 
@@ -45937,12 +47517,12 @@ type XpendingKey Completed
 type SXpendingKey SCompleted
 
 func (c XpendingKey) Group(group string) XpendingGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (XpendingGroup)(c)
 }
 
 func (c SXpendingKey) Group(group string) SXpendingGroup {
-	c.cs = append(c.cs, group)
+	c.cs.s = append(c.cs.s, group)
 	return (SXpendingGroup)(c)
 }
 
@@ -45950,22 +47530,26 @@ type Xrange Completed
 
 type SXrange SCompleted
 
-func (b *Builder) Xrange() Xrange {
-	return Xrange{cs: append(b.get(), "XRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Xrange() (c Xrange) {
+	c = Xrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XRANGE")
+	return c
 }
 
-func (b *SBuilder) Xrange() SXrange {
-	return SXrange{cs: append(b.get(), "XRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Xrange() (c SXrange) {
+	c = SXrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XRANGE")
+	return c
 }
 
 func (c Xrange) Key(key string) XrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XrangeKey)(c)
 }
 
 func (c SXrange) Key(key string) SXrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXrangeKey)(c)
 }
 
@@ -45986,12 +47570,12 @@ type XrangeEnd Completed
 type SXrangeEnd SCompleted
 
 func (c XrangeEnd) Count(count int64) XrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XrangeCount)(c)
 }
 
 func (c SXrangeEnd) Count(count int64) SXrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXrangeCount)(c)
 }
 
@@ -46008,12 +47592,12 @@ type XrangeKey Completed
 type SXrangeKey SCompleted
 
 func (c XrangeKey) Start(start string) XrangeStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (XrangeStart)(c)
 }
 
 func (c SXrangeKey) Start(start string) SXrangeStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (SXrangeStart)(c)
 }
 
@@ -46022,12 +47606,12 @@ type XrangeStart Completed
 type SXrangeStart SCompleted
 
 func (c XrangeStart) End(end string) XrangeEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (XrangeEnd)(c)
 }
 
 func (c SXrangeStart) End(end string) SXrangeEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (SXrangeEnd)(c)
 }
 
@@ -46035,43 +47619,47 @@ type Xread Completed
 
 type SXread SCompleted
 
-func (b *Builder) Xread() Xread {
-	return Xread{cs: append(b.get(), "XREAD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Xread() (c Xread) {
+	c = Xread{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XREAD")
+	return c
 }
 
-func (b *SBuilder) Xread() SXread {
-	return SXread{cs: append(b.get(), "XREAD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Xread() (c SXread) {
+	c = SXread{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XREAD")
+	return c
 }
 
 func (c Xread) Count(count int64) XreadCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XreadCount)(c)
 }
 
 func (c SXread) Count(count int64) SXreadCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXreadCount)(c)
 }
 
 func (c Xread) Block(milliseconds int64) XreadBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (XreadBlock)(c)
 }
 
 func (c SXread) Block(milliseconds int64) SXreadBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (SXreadBlock)(c)
 }
 
 func (c Xread) Streams() XreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadStreams)(c)
 }
 
 func (c SXread) Streams() SXreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadStreams)(c)
 }
 
@@ -46080,12 +47668,12 @@ type XreadBlock Completed
 type SXreadBlock SCompleted
 
 func (c XreadBlock) Streams() XreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadStreams)(c)
 }
 
 func (c SXreadBlock) Streams() SXreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadStreams)(c)
 }
 
@@ -46095,23 +47683,23 @@ type SXreadCount SCompleted
 
 func (c XreadCount) Block(milliseconds int64) XreadBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (XreadBlock)(c)
 }
 
 func (c SXreadCount) Block(milliseconds int64) SXreadBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (SXreadBlock)(c)
 }
 
 func (c XreadCount) Streams() XreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadStreams)(c)
 }
 
 func (c SXreadCount) Streams() SXreadStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadStreams)(c)
 }
 
@@ -46120,12 +47708,12 @@ type XreadId Completed
 type SXreadId SCompleted
 
 func (c XreadId) Id(id ...string) XreadId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c SXreadId) Id(id ...string) SXreadId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
@@ -46142,7 +47730,7 @@ type XreadKey Completed
 type SXreadKey SCompleted
 
 func (c XreadKey) Key(key ...string) XreadKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -46150,17 +47738,17 @@ func (c SXreadKey) Key(key ...string) SXreadKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c XreadKey) Id(id ...string) XreadId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (XreadId)(c)
 }
 
 func (c SXreadKey) Id(id ...string) SXreadId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (SXreadId)(c)
 }
 
@@ -46169,7 +47757,7 @@ type XreadStreams Completed
 type SXreadStreams SCompleted
 
 func (c XreadStreams) Key(key ...string) XreadKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (XreadKey)(c)
 }
 
@@ -46177,7 +47765,7 @@ func (c SXreadStreams) Key(key ...string) SXreadKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SXreadKey)(c)
 }
 
@@ -46185,21 +47773,25 @@ type Xreadgroup Completed
 
 type SXreadgroup SCompleted
 
-func (b *Builder) Xreadgroup() Xreadgroup {
-	return Xreadgroup{cs: append(b.get(), "XREADGROUP"), ks: InitSlot}
+func (b *Builder) Xreadgroup() (c Xreadgroup) {
+	c = Xreadgroup{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XREADGROUP")
+	return c
 }
 
-func (b *SBuilder) Xreadgroup() SXreadgroup {
-	return SXreadgroup{cs: append(b.get(), "XREADGROUP"), ks: InitSlot}
+func (b *SBuilder) Xreadgroup() (c SXreadgroup) {
+	c = SXreadgroup{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XREADGROUP")
+	return c
 }
 
 func (c Xreadgroup) Group(group string, consumer string) XreadgroupGroup {
-	c.cs = append(c.cs, "GROUP", group, consumer)
+	c.cs.s = append(c.cs.s, "GROUP", group, consumer)
 	return (XreadgroupGroup)(c)
 }
 
 func (c SXreadgroup) Group(group string, consumer string) SXreadgroupGroup {
-	c.cs = append(c.cs, "GROUP", group, consumer)
+	c.cs.s = append(c.cs.s, "GROUP", group, consumer)
 	return (SXreadgroupGroup)(c)
 }
 
@@ -46208,22 +47800,22 @@ type XreadgroupBlock Completed
 type SXreadgroupBlock SCompleted
 
 func (c XreadgroupBlock) Noack() XreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (XreadgroupNoack)(c)
 }
 
 func (c SXreadgroupBlock) Noack() SXreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (SXreadgroupNoack)(c)
 }
 
 func (c XreadgroupBlock) Streams() XreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadgroupStreams)(c)
 }
 
 func (c SXreadgroupBlock) Streams() SXreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadgroupStreams)(c)
 }
 
@@ -46233,33 +47825,33 @@ type SXreadgroupCount SCompleted
 
 func (c XreadgroupCount) Block(milliseconds int64) XreadgroupBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (XreadgroupBlock)(c)
 }
 
 func (c SXreadgroupCount) Block(milliseconds int64) SXreadgroupBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (SXreadgroupBlock)(c)
 }
 
 func (c XreadgroupCount) Noack() XreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (XreadgroupNoack)(c)
 }
 
 func (c SXreadgroupCount) Noack() SXreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (SXreadgroupNoack)(c)
 }
 
 func (c XreadgroupCount) Streams() XreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadgroupStreams)(c)
 }
 
 func (c SXreadgroupCount) Streams() SXreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadgroupStreams)(c)
 }
 
@@ -46268,44 +47860,44 @@ type XreadgroupGroup Completed
 type SXreadgroupGroup SCompleted
 
 func (c XreadgroupGroup) Count(count int64) XreadgroupCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XreadgroupCount)(c)
 }
 
 func (c SXreadgroupGroup) Count(count int64) SXreadgroupCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXreadgroupCount)(c)
 }
 
 func (c XreadgroupGroup) Block(milliseconds int64) XreadgroupBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (XreadgroupBlock)(c)
 }
 
 func (c SXreadgroupGroup) Block(milliseconds int64) SXreadgroupBlock {
 	c.cf = blockTag
-	c.cs = append(c.cs, "BLOCK", strconv.FormatInt(milliseconds, 10))
+	c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
 	return (SXreadgroupBlock)(c)
 }
 
 func (c XreadgroupGroup) Noack() XreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (XreadgroupNoack)(c)
 }
 
 func (c SXreadgroupGroup) Noack() SXreadgroupNoack {
-	c.cs = append(c.cs, "NOACK")
+	c.cs.s = append(c.cs.s, "NOACK")
 	return (SXreadgroupNoack)(c)
 }
 
 func (c XreadgroupGroup) Streams() XreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadgroupStreams)(c)
 }
 
 func (c SXreadgroupGroup) Streams() SXreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadgroupStreams)(c)
 }
 
@@ -46314,12 +47906,12 @@ type XreadgroupId Completed
 type SXreadgroupId SCompleted
 
 func (c XreadgroupId) Id(id ...string) XreadgroupId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
 func (c SXreadgroupId) Id(id ...string) SXreadgroupId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return c
 }
 
@@ -46336,7 +47928,7 @@ type XreadgroupKey Completed
 type SXreadgroupKey SCompleted
 
 func (c XreadgroupKey) Key(key ...string) XreadgroupKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -46344,17 +47936,17 @@ func (c SXreadgroupKey) Key(key ...string) SXreadgroupKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c XreadgroupKey) Id(id ...string) XreadgroupId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (XreadgroupId)(c)
 }
 
 func (c SXreadgroupKey) Id(id ...string) SXreadgroupId {
-	c.cs = append(c.cs, id...)
+	c.cs.s = append(c.cs.s, id...)
 	return (SXreadgroupId)(c)
 }
 
@@ -46363,12 +47955,12 @@ type XreadgroupNoack Completed
 type SXreadgroupNoack SCompleted
 
 func (c XreadgroupNoack) Streams() XreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (XreadgroupStreams)(c)
 }
 
 func (c SXreadgroupNoack) Streams() SXreadgroupStreams {
-	c.cs = append(c.cs, "STREAMS")
+	c.cs.s = append(c.cs.s, "STREAMS")
 	return (SXreadgroupStreams)(c)
 }
 
@@ -46377,7 +47969,7 @@ type XreadgroupStreams Completed
 type SXreadgroupStreams SCompleted
 
 func (c XreadgroupStreams) Key(key ...string) XreadgroupKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (XreadgroupKey)(c)
 }
 
@@ -46385,7 +47977,7 @@ func (c SXreadgroupStreams) Key(key ...string) SXreadgroupKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SXreadgroupKey)(c)
 }
 
@@ -46393,22 +47985,26 @@ type Xrevrange Completed
 
 type SXrevrange SCompleted
 
-func (b *Builder) Xrevrange() Xrevrange {
-	return Xrevrange{cs: append(b.get(), "XREVRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Xrevrange() (c Xrevrange) {
+	c = Xrevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XREVRANGE")
+	return c
 }
 
-func (b *SBuilder) Xrevrange() SXrevrange {
-	return SXrevrange{cs: append(b.get(), "XREVRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Xrevrange() (c SXrevrange) {
+	c = SXrevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "XREVRANGE")
+	return c
 }
 
 func (c Xrevrange) Key(key string) XrevrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XrevrangeKey)(c)
 }
 
 func (c SXrevrange) Key(key string) SXrevrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXrevrangeKey)(c)
 }
 
@@ -46429,12 +48025,12 @@ type XrevrangeEnd Completed
 type SXrevrangeEnd SCompleted
 
 func (c XrevrangeEnd) Start(start string) XrevrangeStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (XrevrangeStart)(c)
 }
 
 func (c SXrevrangeEnd) Start(start string) SXrevrangeStart {
-	c.cs = append(c.cs, start)
+	c.cs.s = append(c.cs.s, start)
 	return (SXrevrangeStart)(c)
 }
 
@@ -46443,12 +48039,12 @@ type XrevrangeKey Completed
 type SXrevrangeKey SCompleted
 
 func (c XrevrangeKey) End(end string) XrevrangeEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (XrevrangeEnd)(c)
 }
 
 func (c SXrevrangeKey) End(end string) SXrevrangeEnd {
-	c.cs = append(c.cs, end)
+	c.cs.s = append(c.cs.s, end)
 	return (SXrevrangeEnd)(c)
 }
 
@@ -46457,12 +48053,12 @@ type XrevrangeStart Completed
 type SXrevrangeStart SCompleted
 
 func (c XrevrangeStart) Count(count int64) XrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (XrevrangeCount)(c)
 }
 
 func (c SXrevrangeStart) Count(count int64) SXrevrangeCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SXrevrangeCount)(c)
 }
 
@@ -46478,22 +48074,26 @@ type Xtrim Completed
 
 type SXtrim SCompleted
 
-func (b *Builder) Xtrim() Xtrim {
-	return Xtrim{cs: append(b.get(), "XTRIM"), ks: InitSlot}
+func (b *Builder) Xtrim() (c Xtrim) {
+	c = Xtrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XTRIM")
+	return c
 }
 
-func (b *SBuilder) Xtrim() SXtrim {
-	return SXtrim{cs: append(b.get(), "XTRIM"), ks: InitSlot}
+func (b *SBuilder) Xtrim() (c SXtrim) {
+	c = SXtrim{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "XTRIM")
+	return c
 }
 
 func (c Xtrim) Key(key string) XtrimKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (XtrimKey)(c)
 }
 
 func (c SXtrim) Key(key string) SXtrimKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SXtrimKey)(c)
 }
 
@@ -46502,22 +48102,22 @@ type XtrimKey Completed
 type SXtrimKey SCompleted
 
 func (c XtrimKey) Maxlen() XtrimTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (XtrimTrimStrategyMaxlen)(c)
 }
 
 func (c SXtrimKey) Maxlen() SXtrimTrimStrategyMaxlen {
-	c.cs = append(c.cs, "MAXLEN")
+	c.cs.s = append(c.cs.s, "MAXLEN")
 	return (SXtrimTrimStrategyMaxlen)(c)
 }
 
 func (c XtrimKey) Minid() XtrimTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (XtrimTrimStrategyMinid)(c)
 }
 
 func (c SXtrimKey) Minid() SXtrimTrimStrategyMinid {
-	c.cs = append(c.cs, "MINID")
+	c.cs.s = append(c.cs.s, "MINID")
 	return (SXtrimTrimStrategyMinid)(c)
 }
 
@@ -46538,12 +48138,12 @@ type XtrimTrimOperatorAlmost Completed
 type SXtrimTrimOperatorAlmost SCompleted
 
 func (c XtrimTrimOperatorAlmost) Threshold(threshold string) XtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XtrimTrimThreshold)(c)
 }
 
 func (c SXtrimTrimOperatorAlmost) Threshold(threshold string) SXtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXtrimTrimThreshold)(c)
 }
 
@@ -46552,12 +48152,12 @@ type XtrimTrimOperatorExact Completed
 type SXtrimTrimOperatorExact SCompleted
 
 func (c XtrimTrimOperatorExact) Threshold(threshold string) XtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XtrimTrimThreshold)(c)
 }
 
 func (c SXtrimTrimOperatorExact) Threshold(threshold string) SXtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXtrimTrimThreshold)(c)
 }
 
@@ -46566,32 +48166,32 @@ type XtrimTrimStrategyMaxlen Completed
 type SXtrimTrimStrategyMaxlen SCompleted
 
 func (c XtrimTrimStrategyMaxlen) Exact() XtrimTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (XtrimTrimOperatorExact)(c)
 }
 
 func (c SXtrimTrimStrategyMaxlen) Exact() SXtrimTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (SXtrimTrimOperatorExact)(c)
 }
 
 func (c XtrimTrimStrategyMaxlen) Almost() XtrimTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (XtrimTrimOperatorAlmost)(c)
 }
 
 func (c SXtrimTrimStrategyMaxlen) Almost() SXtrimTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (SXtrimTrimOperatorAlmost)(c)
 }
 
 func (c XtrimTrimStrategyMaxlen) Threshold(threshold string) XtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XtrimTrimThreshold)(c)
 }
 
 func (c SXtrimTrimStrategyMaxlen) Threshold(threshold string) SXtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXtrimTrimThreshold)(c)
 }
 
@@ -46600,32 +48200,32 @@ type XtrimTrimStrategyMinid Completed
 type SXtrimTrimStrategyMinid SCompleted
 
 func (c XtrimTrimStrategyMinid) Exact() XtrimTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (XtrimTrimOperatorExact)(c)
 }
 
 func (c SXtrimTrimStrategyMinid) Exact() SXtrimTrimOperatorExact {
-	c.cs = append(c.cs, "=")
+	c.cs.s = append(c.cs.s, "=")
 	return (SXtrimTrimOperatorExact)(c)
 }
 
 func (c XtrimTrimStrategyMinid) Almost() XtrimTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (XtrimTrimOperatorAlmost)(c)
 }
 
 func (c SXtrimTrimStrategyMinid) Almost() SXtrimTrimOperatorAlmost {
-	c.cs = append(c.cs, "~")
+	c.cs.s = append(c.cs.s, "~")
 	return (SXtrimTrimOperatorAlmost)(c)
 }
 
 func (c XtrimTrimStrategyMinid) Threshold(threshold string) XtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (XtrimTrimThreshold)(c)
 }
 
 func (c SXtrimTrimStrategyMinid) Threshold(threshold string) SXtrimTrimThreshold {
-	c.cs = append(c.cs, threshold)
+	c.cs.s = append(c.cs.s, threshold)
 	return (SXtrimTrimThreshold)(c)
 }
 
@@ -46634,12 +48234,12 @@ type XtrimTrimThreshold Completed
 type SXtrimTrimThreshold SCompleted
 
 func (c XtrimTrimThreshold) Limit(count int64) XtrimTrimLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
 	return (XtrimTrimLimit)(c)
 }
 
 func (c SXtrimTrimThreshold) Limit(count int64) SXtrimTrimLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
 	return (SXtrimTrimLimit)(c)
 }
 
@@ -46655,22 +48255,26 @@ type Zadd Completed
 
 type SZadd SCompleted
 
-func (b *Builder) Zadd() Zadd {
-	return Zadd{cs: append(b.get(), "ZADD"), ks: InitSlot}
+func (b *Builder) Zadd() (c Zadd) {
+	c = Zadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZADD")
+	return c
 }
 
-func (b *SBuilder) Zadd() SZadd {
-	return SZadd{cs: append(b.get(), "ZADD"), ks: InitSlot}
+func (b *SBuilder) Zadd() (c SZadd) {
+	c = SZadd{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZADD")
+	return c
 }
 
 func (c Zadd) Key(key string) ZaddKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZaddKey)(c)
 }
 
 func (c SZadd) Key(key string) SZaddKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZaddKey)(c)
 }
 
@@ -46679,12 +48283,12 @@ type ZaddChangeCh Completed
 type SZaddChangeCh SCompleted
 
 func (c ZaddChangeCh) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddChangeCh) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46701,22 +48305,22 @@ type ZaddComparisonGt Completed
 type SZaddComparisonGt SCompleted
 
 func (c ZaddComparisonGt) Ch() ZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (ZaddChangeCh)(c)
 }
 
 func (c SZaddComparisonGt) Ch() SZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SZaddChangeCh)(c)
 }
 
 func (c ZaddComparisonGt) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddComparisonGt) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46733,22 +48337,22 @@ type ZaddComparisonLt Completed
 type SZaddComparisonLt SCompleted
 
 func (c ZaddComparisonLt) Ch() ZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (ZaddChangeCh)(c)
 }
 
 func (c SZaddComparisonLt) Ch() SZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SZaddChangeCh)(c)
 }
 
 func (c ZaddComparisonLt) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddComparisonLt) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46765,42 +48369,42 @@ type ZaddConditionNx Completed
 type SZaddConditionNx SCompleted
 
 func (c ZaddConditionNx) Gt() ZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (ZaddComparisonGt)(c)
 }
 
 func (c SZaddConditionNx) Gt() SZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SZaddComparisonGt)(c)
 }
 
 func (c ZaddConditionNx) Lt() ZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (ZaddComparisonLt)(c)
 }
 
 func (c SZaddConditionNx) Lt() SZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SZaddComparisonLt)(c)
 }
 
 func (c ZaddConditionNx) Ch() ZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (ZaddChangeCh)(c)
 }
 
 func (c SZaddConditionNx) Ch() SZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SZaddChangeCh)(c)
 }
 
 func (c ZaddConditionNx) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddConditionNx) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46817,42 +48421,42 @@ type ZaddConditionXx Completed
 type SZaddConditionXx SCompleted
 
 func (c ZaddConditionXx) Gt() ZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (ZaddComparisonGt)(c)
 }
 
 func (c SZaddConditionXx) Gt() SZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SZaddComparisonGt)(c)
 }
 
 func (c ZaddConditionXx) Lt() ZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (ZaddComparisonLt)(c)
 }
 
 func (c SZaddConditionXx) Lt() SZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SZaddComparisonLt)(c)
 }
 
 func (c ZaddConditionXx) Ch() ZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (ZaddChangeCh)(c)
 }
 
 func (c SZaddConditionXx) Ch() SZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SZaddChangeCh)(c)
 }
 
 func (c ZaddConditionXx) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddConditionXx) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46881,62 +48485,62 @@ type ZaddKey Completed
 type SZaddKey SCompleted
 
 func (c ZaddKey) Nx() ZaddConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (ZaddConditionNx)(c)
 }
 
 func (c SZaddKey) Nx() SZaddConditionNx {
-	c.cs = append(c.cs, "NX")
+	c.cs.s = append(c.cs.s, "NX")
 	return (SZaddConditionNx)(c)
 }
 
 func (c ZaddKey) Xx() ZaddConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (ZaddConditionXx)(c)
 }
 
 func (c SZaddKey) Xx() SZaddConditionXx {
-	c.cs = append(c.cs, "XX")
+	c.cs.s = append(c.cs.s, "XX")
 	return (SZaddConditionXx)(c)
 }
 
 func (c ZaddKey) Gt() ZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (ZaddComparisonGt)(c)
 }
 
 func (c SZaddKey) Gt() SZaddComparisonGt {
-	c.cs = append(c.cs, "GT")
+	c.cs.s = append(c.cs.s, "GT")
 	return (SZaddComparisonGt)(c)
 }
 
 func (c ZaddKey) Lt() ZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (ZaddComparisonLt)(c)
 }
 
 func (c SZaddKey) Lt() SZaddComparisonLt {
-	c.cs = append(c.cs, "LT")
+	c.cs.s = append(c.cs.s, "LT")
 	return (SZaddComparisonLt)(c)
 }
 
 func (c ZaddKey) Ch() ZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (ZaddChangeCh)(c)
 }
 
 func (c SZaddKey) Ch() SZaddChangeCh {
-	c.cs = append(c.cs, "CH")
+	c.cs.s = append(c.cs.s, "CH")
 	return (SZaddChangeCh)(c)
 }
 
 func (c ZaddKey) Incr() ZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (ZaddIncrementIncr)(c)
 }
 
 func (c SZaddKey) Incr() SZaddIncrementIncr {
-	c.cs = append(c.cs, "INCR")
+	c.cs.s = append(c.cs.s, "INCR")
 	return (SZaddIncrementIncr)(c)
 }
 
@@ -46953,12 +48557,12 @@ type ZaddScoreMember Completed
 type SZaddScoreMember SCompleted
 
 func (c ZaddScoreMember) ScoreMember(score float64, member string) ZaddScoreMember {
-	c.cs = append(c.cs, strconv.FormatFloat(score, 'f', -1, 64), member)
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(score, 'f', -1, 64), member)
 	return c
 }
 
 func (c SZaddScoreMember) ScoreMember(score float64, member string) SZaddScoreMember {
-	c.cs = append(c.cs, strconv.FormatFloat(score, 'f', -1, 64), member)
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(score, 'f', -1, 64), member)
 	return c
 }
 
@@ -46974,22 +48578,26 @@ type Zcard Completed
 
 type SZcard SCompleted
 
-func (b *Builder) Zcard() Zcard {
-	return Zcard{cs: append(b.get(), "ZCARD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zcard() (c Zcard) {
+	c = Zcard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZCARD")
+	return c
 }
 
-func (b *SBuilder) Zcard() SZcard {
-	return SZcard{cs: append(b.get(), "ZCARD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zcard() (c SZcard) {
+	c = SZcard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZCARD")
+	return c
 }
 
 func (c Zcard) Key(key string) ZcardKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZcardKey)(c)
 }
 
 func (c SZcard) Key(key string) SZcardKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZcardKey)(c)
 }
 
@@ -47017,22 +48625,26 @@ type Zcount Completed
 
 type SZcount SCompleted
 
-func (b *Builder) Zcount() Zcount {
-	return Zcount{cs: append(b.get(), "ZCOUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zcount() (c Zcount) {
+	c = Zcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZCOUNT")
+	return c
 }
 
-func (b *SBuilder) Zcount() SZcount {
-	return SZcount{cs: append(b.get(), "ZCOUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zcount() (c SZcount) {
+	c = SZcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZCOUNT")
+	return c
 }
 
 func (c Zcount) Key(key string) ZcountKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZcountKey)(c)
 }
 
 func (c SZcount) Key(key string) SZcountKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZcountKey)(c)
 }
 
@@ -47041,12 +48653,12 @@ type ZcountKey Completed
 type SZcountKey SCompleted
 
 func (c ZcountKey) Min(min float64) ZcountMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (ZcountMin)(c)
 }
 
 func (c SZcountKey) Min(min float64) SZcountMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (SZcountMin)(c)
 }
 
@@ -47075,12 +48687,12 @@ type ZcountMin Completed
 type SZcountMin SCompleted
 
 func (c ZcountMin) Max(max float64) ZcountMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (ZcountMax)(c)
 }
 
 func (c SZcountMin) Max(max float64) SZcountMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (SZcountMax)(c)
 }
 
@@ -47088,21 +48700,25 @@ type Zdiff Completed
 
 type SZdiff SCompleted
 
-func (b *Builder) Zdiff() Zdiff {
-	return Zdiff{cs: append(b.get(), "ZDIFF"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zdiff() (c Zdiff) {
+	c = Zdiff{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZDIFF")
+	return c
 }
 
-func (b *SBuilder) Zdiff() SZdiff {
-	return SZdiff{cs: append(b.get(), "ZDIFF"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zdiff() (c SZdiff) {
+	c = SZdiff{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZDIFF")
+	return c
 }
 
 func (c Zdiff) Numkeys(numkeys int64) ZdiffNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZdiffNumkeys)(c)
 }
 
 func (c SZdiff) Numkeys(numkeys int64) SZdiffNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZdiffNumkeys)(c)
 }
 
@@ -47111,7 +48727,7 @@ type ZdiffKey Completed
 type SZdiffKey SCompleted
 
 func (c ZdiffKey) Key(key ...string) ZdiffKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47119,17 +48735,17 @@ func (c SZdiffKey) Key(key ...string) SZdiffKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZdiffKey) Withscores() ZdiffWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZdiffWithscores)(c)
 }
 
 func (c SZdiffKey) Withscores() SZdiffWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZdiffWithscores)(c)
 }
 
@@ -47146,7 +48762,7 @@ type ZdiffNumkeys Completed
 type SZdiffNumkeys SCompleted
 
 func (c ZdiffNumkeys) Key(key ...string) ZdiffKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZdiffKey)(c)
 }
 
@@ -47154,7 +48770,7 @@ func (c SZdiffNumkeys) Key(key ...string) SZdiffKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZdiffKey)(c)
 }
 
@@ -47174,22 +48790,26 @@ type Zdiffstore Completed
 
 type SZdiffstore SCompleted
 
-func (b *Builder) Zdiffstore() Zdiffstore {
-	return Zdiffstore{cs: append(b.get(), "ZDIFFSTORE"), ks: InitSlot}
+func (b *Builder) Zdiffstore() (c Zdiffstore) {
+	c = Zdiffstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZDIFFSTORE")
+	return c
 }
 
-func (b *SBuilder) Zdiffstore() SZdiffstore {
-	return SZdiffstore{cs: append(b.get(), "ZDIFFSTORE"), ks: InitSlot}
+func (b *SBuilder) Zdiffstore() (c SZdiffstore) {
+	c = SZdiffstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZDIFFSTORE")
+	return c
 }
 
 func (c Zdiffstore) Destination(destination string) ZdiffstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (ZdiffstoreDestination)(c)
 }
 
 func (c SZdiffstore) Destination(destination string) SZdiffstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SZdiffstoreDestination)(c)
 }
 
@@ -47198,12 +48818,12 @@ type ZdiffstoreDestination Completed
 type SZdiffstoreDestination SCompleted
 
 func (c ZdiffstoreDestination) Numkeys(numkeys int64) ZdiffstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZdiffstoreNumkeys)(c)
 }
 
 func (c SZdiffstoreDestination) Numkeys(numkeys int64) SZdiffstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZdiffstoreNumkeys)(c)
 }
 
@@ -47212,7 +48832,7 @@ type ZdiffstoreKey Completed
 type SZdiffstoreKey SCompleted
 
 func (c ZdiffstoreKey) Key(key ...string) ZdiffstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47220,7 +48840,7 @@ func (c SZdiffstoreKey) Key(key ...string) SZdiffstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47237,7 +48857,7 @@ type ZdiffstoreNumkeys Completed
 type SZdiffstoreNumkeys SCompleted
 
 func (c ZdiffstoreNumkeys) Key(key ...string) ZdiffstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZdiffstoreKey)(c)
 }
 
@@ -47245,7 +48865,7 @@ func (c SZdiffstoreNumkeys) Key(key ...string) SZdiffstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZdiffstoreKey)(c)
 }
 
@@ -47253,22 +48873,26 @@ type Zincrby Completed
 
 type SZincrby SCompleted
 
-func (b *Builder) Zincrby() Zincrby {
-	return Zincrby{cs: append(b.get(), "ZINCRBY"), ks: InitSlot}
+func (b *Builder) Zincrby() (c Zincrby) {
+	c = Zincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZINCRBY")
+	return c
 }
 
-func (b *SBuilder) Zincrby() SZincrby {
-	return SZincrby{cs: append(b.get(), "ZINCRBY"), ks: InitSlot}
+func (b *SBuilder) Zincrby() (c SZincrby) {
+	c = SZincrby{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZINCRBY")
+	return c
 }
 
 func (c Zincrby) Key(key string) ZincrbyKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZincrbyKey)(c)
 }
 
 func (c SZincrby) Key(key string) SZincrbyKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZincrbyKey)(c)
 }
 
@@ -47277,12 +48901,12 @@ type ZincrbyIncrement Completed
 type SZincrbyIncrement SCompleted
 
 func (c ZincrbyIncrement) Member(member string) ZincrbyMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (ZincrbyMember)(c)
 }
 
 func (c SZincrbyIncrement) Member(member string) SZincrbyMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SZincrbyMember)(c)
 }
 
@@ -47291,12 +48915,12 @@ type ZincrbyKey Completed
 type SZincrbyKey SCompleted
 
 func (c ZincrbyKey) Increment(increment int64) ZincrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (ZincrbyIncrement)(c)
 }
 
 func (c SZincrbyKey) Increment(increment int64) SZincrbyIncrement {
-	c.cs = append(c.cs, strconv.FormatInt(increment, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
 	return (SZincrbyIncrement)(c)
 }
 
@@ -47316,21 +48940,25 @@ type Zinter Completed
 
 type SZinter SCompleted
 
-func (b *Builder) Zinter() Zinter {
-	return Zinter{cs: append(b.get(), "ZINTER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zinter() (c Zinter) {
+	c = Zinter{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZINTER")
+	return c
 }
 
-func (b *SBuilder) Zinter() SZinter {
-	return SZinter{cs: append(b.get(), "ZINTER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zinter() (c SZinter) {
+	c = SZinter{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZINTER")
+	return c
 }
 
 func (c Zinter) Numkeys(numkeys int64) ZinterNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZinterNumkeys)(c)
 }
 
 func (c SZinter) Numkeys(numkeys int64) SZinterNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZinterNumkeys)(c)
 }
 
@@ -47339,12 +48967,12 @@ type ZinterAggregateMax Completed
 type SZinterAggregateMax SCompleted
 
 func (c ZinterAggregateMax) Withscores() ZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZinterWithscores)(c)
 }
 
 func (c SZinterAggregateMax) Withscores() SZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZinterWithscores)(c)
 }
 
@@ -47361,12 +48989,12 @@ type ZinterAggregateMin Completed
 type SZinterAggregateMin SCompleted
 
 func (c ZinterAggregateMin) Withscores() ZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZinterWithscores)(c)
 }
 
 func (c SZinterAggregateMin) Withscores() SZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZinterWithscores)(c)
 }
 
@@ -47383,12 +49011,12 @@ type ZinterAggregateSum Completed
 type SZinterAggregateSum SCompleted
 
 func (c ZinterAggregateSum) Withscores() ZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZinterWithscores)(c)
 }
 
 func (c SZinterAggregateSum) Withscores() SZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZinterWithscores)(c)
 }
 
@@ -47405,7 +49033,7 @@ type ZinterKey Completed
 type SZinterKey SCompleted
 
 func (c ZinterKey) Key(key ...string) ZinterKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47413,63 +49041,63 @@ func (c SZinterKey) Key(key ...string) SZinterKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZinterKey) Weights(weight ...int64) ZinterWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ZinterWeights)(c)
 }
 
 func (c SZinterKey) Weights(weight ...int64) SZinterWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SZinterWeights)(c)
 }
 
 func (c ZinterKey) AggregateSum() ZinterAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZinterAggregateSum)(c)
 }
 
 func (c SZinterKey) AggregateSum() SZinterAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZinterAggregateSum)(c)
 }
 
 func (c ZinterKey) AggregateMin() ZinterAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZinterAggregateMin)(c)
 }
 
 func (c SZinterKey) AggregateMin() SZinterAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZinterAggregateMin)(c)
 }
 
 func (c ZinterKey) AggregateMax() ZinterAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZinterAggregateMax)(c)
 }
 
 func (c SZinterKey) AggregateMax() SZinterAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZinterAggregateMax)(c)
 }
 
 func (c ZinterKey) Withscores() ZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZinterWithscores)(c)
 }
 
 func (c SZinterKey) Withscores() SZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZinterWithscores)(c)
 }
 
@@ -47486,7 +49114,7 @@ type ZinterNumkeys Completed
 type SZinterNumkeys SCompleted
 
 func (c ZinterNumkeys) Key(key ...string) ZinterKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZinterKey)(c)
 }
 
@@ -47494,7 +49122,7 @@ func (c SZinterNumkeys) Key(key ...string) SZinterKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZinterKey)(c)
 }
 
@@ -47503,58 +49131,58 @@ type ZinterWeights Completed
 type SZinterWeights SCompleted
 
 func (c ZinterWeights) Weights(weight ...int64) ZinterWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SZinterWeights) Weights(weight ...int64) SZinterWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c ZinterWeights) AggregateSum() ZinterAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZinterAggregateSum)(c)
 }
 
 func (c SZinterWeights) AggregateSum() SZinterAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZinterAggregateSum)(c)
 }
 
 func (c ZinterWeights) AggregateMin() ZinterAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZinterAggregateMin)(c)
 }
 
 func (c SZinterWeights) AggregateMin() SZinterAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZinterAggregateMin)(c)
 }
 
 func (c ZinterWeights) AggregateMax() ZinterAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZinterAggregateMax)(c)
 }
 
 func (c SZinterWeights) AggregateMax() SZinterAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZinterAggregateMax)(c)
 }
 
 func (c ZinterWeights) Withscores() ZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZinterWithscores)(c)
 }
 
 func (c SZinterWeights) Withscores() SZinterWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZinterWithscores)(c)
 }
 
@@ -47582,21 +49210,25 @@ type Zintercard Completed
 
 type SZintercard SCompleted
 
-func (b *Builder) Zintercard() Zintercard {
-	return Zintercard{cs: append(b.get(), "ZINTERCARD"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zintercard() (c Zintercard) {
+	c = Zintercard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZINTERCARD")
+	return c
 }
 
-func (b *SBuilder) Zintercard() SZintercard {
-	return SZintercard{cs: append(b.get(), "ZINTERCARD"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zintercard() (c SZintercard) {
+	c = SZintercard{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZINTERCARD")
+	return c
 }
 
 func (c Zintercard) Numkeys(numkeys int64) ZintercardNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZintercardNumkeys)(c)
 }
 
 func (c SZintercard) Numkeys(numkeys int64) SZintercardNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZintercardNumkeys)(c)
 }
 
@@ -47605,7 +49237,7 @@ type ZintercardKey Completed
 type SZintercardKey SCompleted
 
 func (c ZintercardKey) Key(key ...string) ZintercardKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47613,17 +49245,17 @@ func (c SZintercardKey) Key(key ...string) SZintercardKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZintercardKey) Limit(limit int64) ZintercardLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(limit, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(limit, 10))
 	return (ZintercardLimit)(c)
 }
 
 func (c SZintercardKey) Limit(limit int64) SZintercardLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(limit, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(limit, 10))
 	return (SZintercardLimit)(c)
 }
 
@@ -47652,7 +49284,7 @@ type ZintercardNumkeys Completed
 type SZintercardNumkeys SCompleted
 
 func (c ZintercardNumkeys) Key(key ...string) ZintercardKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZintercardKey)(c)
 }
 
@@ -47660,7 +49292,7 @@ func (c SZintercardNumkeys) Key(key ...string) SZintercardKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZintercardKey)(c)
 }
 
@@ -47668,22 +49300,26 @@ type Zinterstore Completed
 
 type SZinterstore SCompleted
 
-func (b *Builder) Zinterstore() Zinterstore {
-	return Zinterstore{cs: append(b.get(), "ZINTERSTORE"), ks: InitSlot}
+func (b *Builder) Zinterstore() (c Zinterstore) {
+	c = Zinterstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZINTERSTORE")
+	return c
 }
 
-func (b *SBuilder) Zinterstore() SZinterstore {
-	return SZinterstore{cs: append(b.get(), "ZINTERSTORE"), ks: InitSlot}
+func (b *SBuilder) Zinterstore() (c SZinterstore) {
+	c = SZinterstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZINTERSTORE")
+	return c
 }
 
 func (c Zinterstore) Destination(destination string) ZinterstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (ZinterstoreDestination)(c)
 }
 
 func (c SZinterstore) Destination(destination string) SZinterstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SZinterstoreDestination)(c)
 }
 
@@ -47728,12 +49364,12 @@ type ZinterstoreDestination Completed
 type SZinterstoreDestination SCompleted
 
 func (c ZinterstoreDestination) Numkeys(numkeys int64) ZinterstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZinterstoreNumkeys)(c)
 }
 
 func (c SZinterstoreDestination) Numkeys(numkeys int64) SZinterstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZinterstoreNumkeys)(c)
 }
 
@@ -47742,7 +49378,7 @@ type ZinterstoreKey Completed
 type SZinterstoreKey SCompleted
 
 func (c ZinterstoreKey) Key(key ...string) ZinterstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -47750,53 +49386,53 @@ func (c SZinterstoreKey) Key(key ...string) SZinterstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZinterstoreKey) Weights(weight ...int64) ZinterstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ZinterstoreWeights)(c)
 }
 
 func (c SZinterstoreKey) Weights(weight ...int64) SZinterstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SZinterstoreWeights)(c)
 }
 
 func (c ZinterstoreKey) AggregateSum() ZinterstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZinterstoreAggregateSum)(c)
 }
 
 func (c SZinterstoreKey) AggregateSum() SZinterstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZinterstoreAggregateSum)(c)
 }
 
 func (c ZinterstoreKey) AggregateMin() ZinterstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZinterstoreAggregateMin)(c)
 }
 
 func (c SZinterstoreKey) AggregateMin() SZinterstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZinterstoreAggregateMin)(c)
 }
 
 func (c ZinterstoreKey) AggregateMax() ZinterstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZinterstoreAggregateMax)(c)
 }
 
 func (c SZinterstoreKey) AggregateMax() SZinterstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZinterstoreAggregateMax)(c)
 }
 
@@ -47813,7 +49449,7 @@ type ZinterstoreNumkeys Completed
 type SZinterstoreNumkeys SCompleted
 
 func (c ZinterstoreNumkeys) Key(key ...string) ZinterstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZinterstoreKey)(c)
 }
 
@@ -47821,7 +49457,7 @@ func (c SZinterstoreNumkeys) Key(key ...string) SZinterstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZinterstoreKey)(c)
 }
 
@@ -47830,48 +49466,48 @@ type ZinterstoreWeights Completed
 type SZinterstoreWeights SCompleted
 
 func (c ZinterstoreWeights) Weights(weight ...int64) ZinterstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SZinterstoreWeights) Weights(weight ...int64) SZinterstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c ZinterstoreWeights) AggregateSum() ZinterstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZinterstoreAggregateSum)(c)
 }
 
 func (c SZinterstoreWeights) AggregateSum() SZinterstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZinterstoreAggregateSum)(c)
 }
 
 func (c ZinterstoreWeights) AggregateMin() ZinterstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZinterstoreAggregateMin)(c)
 }
 
 func (c SZinterstoreWeights) AggregateMin() SZinterstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZinterstoreAggregateMin)(c)
 }
 
 func (c ZinterstoreWeights) AggregateMax() ZinterstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZinterstoreAggregateMax)(c)
 }
 
 func (c SZinterstoreWeights) AggregateMax() SZinterstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZinterstoreAggregateMax)(c)
 }
 
@@ -47887,22 +49523,26 @@ type Zlexcount Completed
 
 type SZlexcount SCompleted
 
-func (b *Builder) Zlexcount() Zlexcount {
-	return Zlexcount{cs: append(b.get(), "ZLEXCOUNT"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zlexcount() (c Zlexcount) {
+	c = Zlexcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZLEXCOUNT")
+	return c
 }
 
-func (b *SBuilder) Zlexcount() SZlexcount {
-	return SZlexcount{cs: append(b.get(), "ZLEXCOUNT"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zlexcount() (c SZlexcount) {
+	c = SZlexcount{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZLEXCOUNT")
+	return c
 }
 
 func (c Zlexcount) Key(key string) ZlexcountKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZlexcountKey)(c)
 }
 
 func (c SZlexcount) Key(key string) SZlexcountKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZlexcountKey)(c)
 }
 
@@ -47911,12 +49551,12 @@ type ZlexcountKey Completed
 type SZlexcountKey SCompleted
 
 func (c ZlexcountKey) Min(min string) ZlexcountMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZlexcountMin)(c)
 }
 
 func (c SZlexcountKey) Min(min string) SZlexcountMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZlexcountMin)(c)
 }
 
@@ -47945,12 +49585,12 @@ type ZlexcountMin Completed
 type SZlexcountMin SCompleted
 
 func (c ZlexcountMin) Max(max string) ZlexcountMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZlexcountMax)(c)
 }
 
 func (c SZlexcountMin) Max(max string) SZlexcountMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZlexcountMax)(c)
 }
 
@@ -47958,21 +49598,25 @@ type Zmpop Completed
 
 type SZmpop SCompleted
 
-func (b *Builder) Zmpop() Zmpop {
-	return Zmpop{cs: append(b.get(), "ZMPOP"), ks: InitSlot}
+func (b *Builder) Zmpop() (c Zmpop) {
+	c = Zmpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZMPOP")
+	return c
 }
 
-func (b *SBuilder) Zmpop() SZmpop {
-	return SZmpop{cs: append(b.get(), "ZMPOP"), ks: InitSlot}
+func (b *SBuilder) Zmpop() (c SZmpop) {
+	c = SZmpop{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZMPOP")
+	return c
 }
 
 func (c Zmpop) Numkeys(numkeys int64) ZmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZmpopNumkeys)(c)
 }
 
 func (c SZmpop) Numkeys(numkeys int64) SZmpopNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZmpopNumkeys)(c)
 }
 
@@ -47993,7 +49637,7 @@ type ZmpopKey Completed
 type SZmpopKey SCompleted
 
 func (c ZmpopKey) Key(key ...string) ZmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -48001,27 +49645,27 @@ func (c SZmpopKey) Key(key ...string) SZmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZmpopKey) Min() ZmpopWhereMin {
-	c.cs = append(c.cs, "MIN")
+	c.cs.s = append(c.cs.s, "MIN")
 	return (ZmpopWhereMin)(c)
 }
 
 func (c SZmpopKey) Min() SZmpopWhereMin {
-	c.cs = append(c.cs, "MIN")
+	c.cs.s = append(c.cs.s, "MIN")
 	return (SZmpopWhereMin)(c)
 }
 
 func (c ZmpopKey) Max() ZmpopWhereMax {
-	c.cs = append(c.cs, "MAX")
+	c.cs.s = append(c.cs.s, "MAX")
 	return (ZmpopWhereMax)(c)
 }
 
 func (c SZmpopKey) Max() SZmpopWhereMax {
-	c.cs = append(c.cs, "MAX")
+	c.cs.s = append(c.cs.s, "MAX")
 	return (SZmpopWhereMax)(c)
 }
 
@@ -48030,7 +49674,7 @@ type ZmpopNumkeys Completed
 type SZmpopNumkeys SCompleted
 
 func (c ZmpopNumkeys) Key(key ...string) ZmpopKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZmpopKey)(c)
 }
 
@@ -48038,7 +49682,7 @@ func (c SZmpopNumkeys) Key(key ...string) SZmpopKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZmpopKey)(c)
 }
 
@@ -48047,12 +49691,12 @@ type ZmpopWhereMax Completed
 type SZmpopWhereMax SCompleted
 
 func (c ZmpopWhereMax) Count(count int64) ZmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ZmpopCount)(c)
 }
 
 func (c SZmpopWhereMax) Count(count int64) SZmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SZmpopCount)(c)
 }
 
@@ -48069,12 +49713,12 @@ type ZmpopWhereMin Completed
 type SZmpopWhereMin SCompleted
 
 func (c ZmpopWhereMin) Count(count int64) ZmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ZmpopCount)(c)
 }
 
 func (c SZmpopWhereMin) Count(count int64) SZmpopCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SZmpopCount)(c)
 }
 
@@ -48090,22 +49734,26 @@ type Zmscore Completed
 
 type SZmscore SCompleted
 
-func (b *Builder) Zmscore() Zmscore {
-	return Zmscore{cs: append(b.get(), "ZMSCORE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zmscore() (c Zmscore) {
+	c = Zmscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZMSCORE")
+	return c
 }
 
-func (b *SBuilder) Zmscore() SZmscore {
-	return SZmscore{cs: append(b.get(), "ZMSCORE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zmscore() (c SZmscore) {
+	c = SZmscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZMSCORE")
+	return c
 }
 
 func (c Zmscore) Key(key string) ZmscoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZmscoreKey)(c)
 }
 
 func (c SZmscore) Key(key string) SZmscoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZmscoreKey)(c)
 }
 
@@ -48114,12 +49762,12 @@ type ZmscoreKey Completed
 type SZmscoreKey SCompleted
 
 func (c ZmscoreKey) Member(member ...string) ZmscoreMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (ZmscoreMember)(c)
 }
 
 func (c SZmscoreKey) Member(member ...string) SZmscoreMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SZmscoreMember)(c)
 }
 
@@ -48128,12 +49776,12 @@ type ZmscoreMember Completed
 type SZmscoreMember SCompleted
 
 func (c ZmscoreMember) Member(member ...string) ZmscoreMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SZmscoreMember) Member(member ...string) SZmscoreMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -48157,22 +49805,26 @@ type Zpopmax Completed
 
 type SZpopmax SCompleted
 
-func (b *Builder) Zpopmax() Zpopmax {
-	return Zpopmax{cs: append(b.get(), "ZPOPMAX"), ks: InitSlot}
+func (b *Builder) Zpopmax() (c Zpopmax) {
+	c = Zpopmax{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZPOPMAX")
+	return c
 }
 
-func (b *SBuilder) Zpopmax() SZpopmax {
-	return SZpopmax{cs: append(b.get(), "ZPOPMAX"), ks: InitSlot}
+func (b *SBuilder) Zpopmax() (c SZpopmax) {
+	c = SZpopmax{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZPOPMAX")
+	return c
 }
 
 func (c Zpopmax) Key(key string) ZpopmaxKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZpopmaxKey)(c)
 }
 
 func (c SZpopmax) Key(key string) SZpopmaxKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZpopmaxKey)(c)
 }
 
@@ -48193,12 +49845,12 @@ type ZpopmaxKey Completed
 type SZpopmaxKey SCompleted
 
 func (c ZpopmaxKey) Count(count int64) ZpopmaxCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (ZpopmaxCount)(c)
 }
 
 func (c SZpopmaxKey) Count(count int64) SZpopmaxCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SZpopmaxCount)(c)
 }
 
@@ -48214,22 +49866,26 @@ type Zpopmin Completed
 
 type SZpopmin SCompleted
 
-func (b *Builder) Zpopmin() Zpopmin {
-	return Zpopmin{cs: append(b.get(), "ZPOPMIN"), ks: InitSlot}
+func (b *Builder) Zpopmin() (c Zpopmin) {
+	c = Zpopmin{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZPOPMIN")
+	return c
 }
 
-func (b *SBuilder) Zpopmin() SZpopmin {
-	return SZpopmin{cs: append(b.get(), "ZPOPMIN"), ks: InitSlot}
+func (b *SBuilder) Zpopmin() (c SZpopmin) {
+	c = SZpopmin{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZPOPMIN")
+	return c
 }
 
 func (c Zpopmin) Key(key string) ZpopminKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZpopminKey)(c)
 }
 
 func (c SZpopmin) Key(key string) SZpopminKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZpopminKey)(c)
 }
 
@@ -48250,12 +49906,12 @@ type ZpopminKey Completed
 type SZpopminKey SCompleted
 
 func (c ZpopminKey) Count(count int64) ZpopminCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (ZpopminCount)(c)
 }
 
 func (c SZpopminKey) Count(count int64) SZpopminCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SZpopminCount)(c)
 }
 
@@ -48271,22 +49927,26 @@ type Zrandmember Completed
 
 type SZrandmember SCompleted
 
-func (b *Builder) Zrandmember() Zrandmember {
-	return Zrandmember{cs: append(b.get(), "ZRANDMEMBER"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrandmember() (c Zrandmember) {
+	c = Zrandmember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANDMEMBER")
+	return c
 }
 
-func (b *SBuilder) Zrandmember() SZrandmember {
-	return SZrandmember{cs: append(b.get(), "ZRANDMEMBER"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrandmember() (c SZrandmember) {
+	c = SZrandmember{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANDMEMBER")
+	return c
 }
 
 func (c Zrandmember) Key(key string) ZrandmemberKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrandmemberKey)(c)
 }
 
 func (c SZrandmember) Key(key string) SZrandmemberKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrandmemberKey)(c)
 }
 
@@ -48295,12 +49955,12 @@ type ZrandmemberKey Completed
 type SZrandmemberKey SCompleted
 
 func (c ZrandmemberKey) Count(count int64) ZrandmemberOptionsCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (ZrandmemberOptionsCount)(c)
 }
 
 func (c SZrandmemberKey) Count(count int64) SZrandmemberOptionsCount {
-	c.cs = append(c.cs, strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
 	return (SZrandmemberOptionsCount)(c)
 }
 
@@ -48317,12 +49977,12 @@ type ZrandmemberOptionsCount Completed
 type SZrandmemberOptionsCount SCompleted
 
 func (c ZrandmemberOptionsCount) Withscores() ZrandmemberOptionsWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrandmemberOptionsWithscores)(c)
 }
 
 func (c SZrandmemberOptionsCount) Withscores() SZrandmemberOptionsWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrandmemberOptionsWithscores)(c)
 }
 
@@ -48350,22 +50010,26 @@ type Zrange Completed
 
 type SZrange SCompleted
 
-func (b *Builder) Zrange() Zrange {
-	return Zrange{cs: append(b.get(), "ZRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrange() (c Zrange) {
+	c = Zrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGE")
+	return c
 }
 
-func (b *SBuilder) Zrange() SZrange {
-	return SZrange{cs: append(b.get(), "ZRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrange() (c SZrange) {
+	c = SZrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGE")
+	return c
 }
 
 func (c Zrange) Key(key string) ZrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrangeKey)(c)
 }
 
 func (c SZrange) Key(key string) SZrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrangeKey)(c)
 }
 
@@ -48374,12 +50038,12 @@ type ZrangeKey Completed
 type SZrangeKey SCompleted
 
 func (c ZrangeKey) Min(min string) ZrangeMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZrangeMin)(c)
 }
 
 func (c SZrangeKey) Min(min string) SZrangeMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZrangeMin)(c)
 }
 
@@ -48388,12 +50052,12 @@ type ZrangeLimit Completed
 type SZrangeLimit SCompleted
 
 func (c ZrangeLimit) Withscores() ZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangeWithscores)(c)
 }
 
 func (c SZrangeLimit) Withscores() SZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangeWithscores)(c)
 }
 
@@ -48418,52 +50082,52 @@ type ZrangeMax Completed
 type SZrangeMax SCompleted
 
 func (c ZrangeMax) Byscore() ZrangeSortbyByscore {
-	c.cs = append(c.cs, "BYSCORE")
+	c.cs.s = append(c.cs.s, "BYSCORE")
 	return (ZrangeSortbyByscore)(c)
 }
 
 func (c SZrangeMax) Byscore() SZrangeSortbyByscore {
-	c.cs = append(c.cs, "BYSCORE")
+	c.cs.s = append(c.cs.s, "BYSCORE")
 	return (SZrangeSortbyByscore)(c)
 }
 
 func (c ZrangeMax) Bylex() ZrangeSortbyBylex {
-	c.cs = append(c.cs, "BYLEX")
+	c.cs.s = append(c.cs.s, "BYLEX")
 	return (ZrangeSortbyBylex)(c)
 }
 
 func (c SZrangeMax) Bylex() SZrangeSortbyBylex {
-	c.cs = append(c.cs, "BYLEX")
+	c.cs.s = append(c.cs.s, "BYLEX")
 	return (SZrangeSortbyBylex)(c)
 }
 
 func (c ZrangeMax) Rev() ZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangeRev)(c)
 }
 
 func (c SZrangeMax) Rev() SZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangeRev)(c)
 }
 
 func (c ZrangeMax) Limit(offset int64, count int64) ZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangeLimit)(c)
 }
 
 func (c SZrangeMax) Limit(offset int64, count int64) SZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangeLimit)(c)
 }
 
 func (c ZrangeMax) Withscores() ZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangeWithscores)(c)
 }
 
 func (c SZrangeMax) Withscores() SZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangeWithscores)(c)
 }
 
@@ -48488,12 +50152,12 @@ type ZrangeMin Completed
 type SZrangeMin SCompleted
 
 func (c ZrangeMin) Max(max string) ZrangeMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZrangeMax)(c)
 }
 
 func (c SZrangeMin) Max(max string) SZrangeMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZrangeMax)(c)
 }
 
@@ -48502,22 +50166,22 @@ type ZrangeRev Completed
 type SZrangeRev SCompleted
 
 func (c ZrangeRev) Limit(offset int64, count int64) ZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangeLimit)(c)
 }
 
 func (c SZrangeRev) Limit(offset int64, count int64) SZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangeLimit)(c)
 }
 
 func (c ZrangeRev) Withscores() ZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangeWithscores)(c)
 }
 
 func (c SZrangeRev) Withscores() SZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangeWithscores)(c)
 }
 
@@ -48542,32 +50206,32 @@ type ZrangeSortbyBylex Completed
 type SZrangeSortbyBylex SCompleted
 
 func (c ZrangeSortbyBylex) Rev() ZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangeRev)(c)
 }
 
 func (c SZrangeSortbyBylex) Rev() SZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangeRev)(c)
 }
 
 func (c ZrangeSortbyBylex) Limit(offset int64, count int64) ZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangeLimit)(c)
 }
 
 func (c SZrangeSortbyBylex) Limit(offset int64, count int64) SZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangeLimit)(c)
 }
 
 func (c ZrangeSortbyBylex) Withscores() ZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangeWithscores)(c)
 }
 
 func (c SZrangeSortbyBylex) Withscores() SZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangeWithscores)(c)
 }
 
@@ -48592,32 +50256,32 @@ type ZrangeSortbyByscore Completed
 type SZrangeSortbyByscore SCompleted
 
 func (c ZrangeSortbyByscore) Rev() ZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangeRev)(c)
 }
 
 func (c SZrangeSortbyByscore) Rev() SZrangeRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangeRev)(c)
 }
 
 func (c ZrangeSortbyByscore) Limit(offset int64, count int64) ZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangeLimit)(c)
 }
 
 func (c SZrangeSortbyByscore) Limit(offset int64, count int64) SZrangeLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangeLimit)(c)
 }
 
 func (c ZrangeSortbyByscore) Withscores() ZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangeWithscores)(c)
 }
 
 func (c SZrangeSortbyByscore) Withscores() SZrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangeWithscores)(c)
 }
 
@@ -48661,22 +50325,26 @@ type Zrangebylex Completed
 
 type SZrangebylex SCompleted
 
-func (b *Builder) Zrangebylex() Zrangebylex {
-	return Zrangebylex{cs: append(b.get(), "ZRANGEBYLEX"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrangebylex() (c Zrangebylex) {
+	c = Zrangebylex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGEBYLEX")
+	return c
 }
 
-func (b *SBuilder) Zrangebylex() SZrangebylex {
-	return SZrangebylex{cs: append(b.get(), "ZRANGEBYLEX"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrangebylex() (c SZrangebylex) {
+	c = SZrangebylex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGEBYLEX")
+	return c
 }
 
 func (c Zrangebylex) Key(key string) ZrangebylexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrangebylexKey)(c)
 }
 
 func (c SZrangebylex) Key(key string) SZrangebylexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrangebylexKey)(c)
 }
 
@@ -48685,12 +50353,12 @@ type ZrangebylexKey Completed
 type SZrangebylexKey SCompleted
 
 func (c ZrangebylexKey) Min(min string) ZrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZrangebylexMin)(c)
 }
 
 func (c SZrangebylexKey) Min(min string) SZrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZrangebylexMin)(c)
 }
 
@@ -48719,12 +50387,12 @@ type ZrangebylexMax Completed
 type SZrangebylexMax SCompleted
 
 func (c ZrangebylexMax) Limit(offset int64, count int64) ZrangebylexLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangebylexLimit)(c)
 }
 
 func (c SZrangebylexMax) Limit(offset int64, count int64) SZrangebylexLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangebylexLimit)(c)
 }
 
@@ -48749,12 +50417,12 @@ type ZrangebylexMin Completed
 type SZrangebylexMin SCompleted
 
 func (c ZrangebylexMin) Max(max string) ZrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZrangebylexMax)(c)
 }
 
 func (c SZrangebylexMin) Max(max string) SZrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZrangebylexMax)(c)
 }
 
@@ -48762,22 +50430,26 @@ type Zrangebyscore Completed
 
 type SZrangebyscore SCompleted
 
-func (b *Builder) Zrangebyscore() Zrangebyscore {
-	return Zrangebyscore{cs: append(b.get(), "ZRANGEBYSCORE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrangebyscore() (c Zrangebyscore) {
+	c = Zrangebyscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGEBYSCORE")
+	return c
 }
 
-func (b *SBuilder) Zrangebyscore() SZrangebyscore {
-	return SZrangebyscore{cs: append(b.get(), "ZRANGEBYSCORE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrangebyscore() (c SZrangebyscore) {
+	c = SZrangebyscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANGEBYSCORE")
+	return c
 }
 
 func (c Zrangebyscore) Key(key string) ZrangebyscoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrangebyscoreKey)(c)
 }
 
 func (c SZrangebyscore) Key(key string) SZrangebyscoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrangebyscoreKey)(c)
 }
 
@@ -48786,12 +50458,12 @@ type ZrangebyscoreKey Completed
 type SZrangebyscoreKey SCompleted
 
 func (c ZrangebyscoreKey) Min(min float64) ZrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (ZrangebyscoreMin)(c)
 }
 
 func (c SZrangebyscoreKey) Min(min float64) SZrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (SZrangebyscoreMin)(c)
 }
 
@@ -48820,22 +50492,22 @@ type ZrangebyscoreMax Completed
 type SZrangebyscoreMax SCompleted
 
 func (c ZrangebyscoreMax) Withscores() ZrangebyscoreWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrangebyscoreWithscores)(c)
 }
 
 func (c SZrangebyscoreMax) Withscores() SZrangebyscoreWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrangebyscoreWithscores)(c)
 }
 
 func (c ZrangebyscoreMax) Limit(offset int64, count int64) ZrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangebyscoreLimit)(c)
 }
 
 func (c SZrangebyscoreMax) Limit(offset int64, count int64) SZrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangebyscoreLimit)(c)
 }
 
@@ -48860,12 +50532,12 @@ type ZrangebyscoreMin Completed
 type SZrangebyscoreMin SCompleted
 
 func (c ZrangebyscoreMin) Max(max float64) ZrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (ZrangebyscoreMax)(c)
 }
 
 func (c SZrangebyscoreMin) Max(max float64) SZrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (SZrangebyscoreMax)(c)
 }
 
@@ -48874,12 +50546,12 @@ type ZrangebyscoreWithscores Completed
 type SZrangebyscoreWithscores SCompleted
 
 func (c ZrangebyscoreWithscores) Limit(offset int64, count int64) ZrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangebyscoreLimit)(c)
 }
 
 func (c SZrangebyscoreWithscores) Limit(offset int64, count int64) SZrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangebyscoreLimit)(c)
 }
 
@@ -48903,22 +50575,26 @@ type Zrangestore Completed
 
 type SZrangestore SCompleted
 
-func (b *Builder) Zrangestore() Zrangestore {
-	return Zrangestore{cs: append(b.get(), "ZRANGESTORE"), ks: InitSlot}
+func (b *Builder) Zrangestore() (c Zrangestore) {
+	c = Zrangestore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZRANGESTORE")
+	return c
 }
 
-func (b *SBuilder) Zrangestore() SZrangestore {
-	return SZrangestore{cs: append(b.get(), "ZRANGESTORE"), ks: InitSlot}
+func (b *SBuilder) Zrangestore() (c SZrangestore) {
+	c = SZrangestore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZRANGESTORE")
+	return c
 }
 
 func (c Zrangestore) Dst(dst string) ZrangestoreDst {
-	c.cs = append(c.cs, dst)
+	c.cs.s = append(c.cs.s, dst)
 	return (ZrangestoreDst)(c)
 }
 
 func (c SZrangestore) Dst(dst string) SZrangestoreDst {
 	c.ks = checkSlot(c.ks, slot(dst))
-	c.cs = append(c.cs, dst)
+	c.cs.s = append(c.cs.s, dst)
 	return (SZrangestoreDst)(c)
 }
 
@@ -48927,13 +50603,13 @@ type ZrangestoreDst Completed
 type SZrangestoreDst SCompleted
 
 func (c ZrangestoreDst) Src(src string) ZrangestoreSrc {
-	c.cs = append(c.cs, src)
+	c.cs.s = append(c.cs.s, src)
 	return (ZrangestoreSrc)(c)
 }
 
 func (c SZrangestoreDst) Src(src string) SZrangestoreSrc {
 	c.ks = checkSlot(c.ks, slot(src))
-	c.cs = append(c.cs, src)
+	c.cs.s = append(c.cs.s, src)
 	return (SZrangestoreSrc)(c)
 }
 
@@ -48954,42 +50630,42 @@ type ZrangestoreMax Completed
 type SZrangestoreMax SCompleted
 
 func (c ZrangestoreMax) Byscore() ZrangestoreSortbyByscore {
-	c.cs = append(c.cs, "BYSCORE")
+	c.cs.s = append(c.cs.s, "BYSCORE")
 	return (ZrangestoreSortbyByscore)(c)
 }
 
 func (c SZrangestoreMax) Byscore() SZrangestoreSortbyByscore {
-	c.cs = append(c.cs, "BYSCORE")
+	c.cs.s = append(c.cs.s, "BYSCORE")
 	return (SZrangestoreSortbyByscore)(c)
 }
 
 func (c ZrangestoreMax) Bylex() ZrangestoreSortbyBylex {
-	c.cs = append(c.cs, "BYLEX")
+	c.cs.s = append(c.cs.s, "BYLEX")
 	return (ZrangestoreSortbyBylex)(c)
 }
 
 func (c SZrangestoreMax) Bylex() SZrangestoreSortbyBylex {
-	c.cs = append(c.cs, "BYLEX")
+	c.cs.s = append(c.cs.s, "BYLEX")
 	return (SZrangestoreSortbyBylex)(c)
 }
 
 func (c ZrangestoreMax) Rev() ZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangestoreRev)(c)
 }
 
 func (c SZrangestoreMax) Rev() SZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangestoreRev)(c)
 }
 
 func (c ZrangestoreMax) Limit(offset int64, count int64) ZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangestoreLimit)(c)
 }
 
 func (c SZrangestoreMax) Limit(offset int64, count int64) SZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangestoreLimit)(c)
 }
 
@@ -49006,12 +50682,12 @@ type ZrangestoreMin Completed
 type SZrangestoreMin SCompleted
 
 func (c ZrangestoreMin) Max(max string) ZrangestoreMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZrangestoreMax)(c)
 }
 
 func (c SZrangestoreMin) Max(max string) SZrangestoreMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZrangestoreMax)(c)
 }
 
@@ -49020,12 +50696,12 @@ type ZrangestoreRev Completed
 type SZrangestoreRev SCompleted
 
 func (c ZrangestoreRev) Limit(offset int64, count int64) ZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangestoreLimit)(c)
 }
 
 func (c SZrangestoreRev) Limit(offset int64, count int64) SZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangestoreLimit)(c)
 }
 
@@ -49042,22 +50718,22 @@ type ZrangestoreSortbyBylex Completed
 type SZrangestoreSortbyBylex SCompleted
 
 func (c ZrangestoreSortbyBylex) Rev() ZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangestoreRev)(c)
 }
 
 func (c SZrangestoreSortbyBylex) Rev() SZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangestoreRev)(c)
 }
 
 func (c ZrangestoreSortbyBylex) Limit(offset int64, count int64) ZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangestoreLimit)(c)
 }
 
 func (c SZrangestoreSortbyBylex) Limit(offset int64, count int64) SZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangestoreLimit)(c)
 }
 
@@ -49074,22 +50750,22 @@ type ZrangestoreSortbyByscore Completed
 type SZrangestoreSortbyByscore SCompleted
 
 func (c ZrangestoreSortbyByscore) Rev() ZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (ZrangestoreRev)(c)
 }
 
 func (c SZrangestoreSortbyByscore) Rev() SZrangestoreRev {
-	c.cs = append(c.cs, "REV")
+	c.cs.s = append(c.cs.s, "REV")
 	return (SZrangestoreRev)(c)
 }
 
 func (c ZrangestoreSortbyByscore) Limit(offset int64, count int64) ZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrangestoreLimit)(c)
 }
 
 func (c SZrangestoreSortbyByscore) Limit(offset int64, count int64) SZrangestoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrangestoreLimit)(c)
 }
 
@@ -49106,12 +50782,12 @@ type ZrangestoreSrc Completed
 type SZrangestoreSrc SCompleted
 
 func (c ZrangestoreSrc) Min(min string) ZrangestoreMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZrangestoreMin)(c)
 }
 
 func (c SZrangestoreSrc) Min(min string) SZrangestoreMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZrangestoreMin)(c)
 }
 
@@ -49119,22 +50795,26 @@ type Zrank Completed
 
 type SZrank SCompleted
 
-func (b *Builder) Zrank() Zrank {
-	return Zrank{cs: append(b.get(), "ZRANK"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrank() (c Zrank) {
+	c = Zrank{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANK")
+	return c
 }
 
-func (b *SBuilder) Zrank() SZrank {
-	return SZrank{cs: append(b.get(), "ZRANK"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrank() (c SZrank) {
+	c = SZrank{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZRANK")
+	return c
 }
 
 func (c Zrank) Key(key string) ZrankKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrankKey)(c)
 }
 
 func (c SZrank) Key(key string) SZrankKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrankKey)(c)
 }
 
@@ -49143,12 +50823,12 @@ type ZrankKey Completed
 type SZrankKey SCompleted
 
 func (c ZrankKey) Member(member string) ZrankMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (ZrankMember)(c)
 }
 
 func (c SZrankKey) Member(member string) SZrankMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SZrankMember)(c)
 }
 
@@ -49176,22 +50856,26 @@ type Zrem Completed
 
 type SZrem SCompleted
 
-func (b *Builder) Zrem() Zrem {
-	return Zrem{cs: append(b.get(), "ZREM"), ks: InitSlot}
+func (b *Builder) Zrem() (c Zrem) {
+	c = Zrem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREM")
+	return c
 }
 
-func (b *SBuilder) Zrem() SZrem {
-	return SZrem{cs: append(b.get(), "ZREM"), ks: InitSlot}
+func (b *SBuilder) Zrem() (c SZrem) {
+	c = SZrem{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREM")
+	return c
 }
 
 func (c Zrem) Key(key string) ZremKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZremKey)(c)
 }
 
 func (c SZrem) Key(key string) SZremKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZremKey)(c)
 }
 
@@ -49200,12 +50884,12 @@ type ZremKey Completed
 type SZremKey SCompleted
 
 func (c ZremKey) Member(member ...string) ZremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (ZremMember)(c)
 }
 
 func (c SZremKey) Member(member ...string) SZremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return (SZremMember)(c)
 }
 
@@ -49214,12 +50898,12 @@ type ZremMember Completed
 type SZremMember SCompleted
 
 func (c ZremMember) Member(member ...string) ZremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
 func (c SZremMember) Member(member ...string) SZremMember {
-	c.cs = append(c.cs, member...)
+	c.cs.s = append(c.cs.s, member...)
 	return c
 }
 
@@ -49235,22 +50919,26 @@ type Zremrangebylex Completed
 
 type SZremrangebylex SCompleted
 
-func (b *Builder) Zremrangebylex() Zremrangebylex {
-	return Zremrangebylex{cs: append(b.get(), "ZREMRANGEBYLEX"), ks: InitSlot}
+func (b *Builder) Zremrangebylex() (c Zremrangebylex) {
+	c = Zremrangebylex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYLEX")
+	return c
 }
 
-func (b *SBuilder) Zremrangebylex() SZremrangebylex {
-	return SZremrangebylex{cs: append(b.get(), "ZREMRANGEBYLEX"), ks: InitSlot}
+func (b *SBuilder) Zremrangebylex() (c SZremrangebylex) {
+	c = SZremrangebylex{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYLEX")
+	return c
 }
 
 func (c Zremrangebylex) Key(key string) ZremrangebylexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZremrangebylexKey)(c)
 }
 
 func (c SZremrangebylex) Key(key string) SZremrangebylexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZremrangebylexKey)(c)
 }
 
@@ -49259,12 +50947,12 @@ type ZremrangebylexKey Completed
 type SZremrangebylexKey SCompleted
 
 func (c ZremrangebylexKey) Min(min string) ZremrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZremrangebylexMin)(c)
 }
 
 func (c SZremrangebylexKey) Min(min string) SZremrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZremrangebylexMin)(c)
 }
 
@@ -49285,12 +50973,12 @@ type ZremrangebylexMin Completed
 type SZremrangebylexMin SCompleted
 
 func (c ZremrangebylexMin) Max(max string) ZremrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZremrangebylexMax)(c)
 }
 
 func (c SZremrangebylexMin) Max(max string) SZremrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZremrangebylexMax)(c)
 }
 
@@ -49298,22 +50986,26 @@ type Zremrangebyrank Completed
 
 type SZremrangebyrank SCompleted
 
-func (b *Builder) Zremrangebyrank() Zremrangebyrank {
-	return Zremrangebyrank{cs: append(b.get(), "ZREMRANGEBYRANK"), ks: InitSlot}
+func (b *Builder) Zremrangebyrank() (c Zremrangebyrank) {
+	c = Zremrangebyrank{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYRANK")
+	return c
 }
 
-func (b *SBuilder) Zremrangebyrank() SZremrangebyrank {
-	return SZremrangebyrank{cs: append(b.get(), "ZREMRANGEBYRANK"), ks: InitSlot}
+func (b *SBuilder) Zremrangebyrank() (c SZremrangebyrank) {
+	c = SZremrangebyrank{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYRANK")
+	return c
 }
 
 func (c Zremrangebyrank) Key(key string) ZremrangebyrankKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZremrangebyrankKey)(c)
 }
 
 func (c SZremrangebyrank) Key(key string) SZremrangebyrankKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZremrangebyrankKey)(c)
 }
 
@@ -49322,12 +51014,12 @@ type ZremrangebyrankKey Completed
 type SZremrangebyrankKey SCompleted
 
 func (c ZremrangebyrankKey) Start(start int64) ZremrangebyrankStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (ZremrangebyrankStart)(c)
 }
 
 func (c SZremrangebyrankKey) Start(start int64) SZremrangebyrankStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SZremrangebyrankStart)(c)
 }
 
@@ -49336,12 +51028,12 @@ type ZremrangebyrankStart Completed
 type SZremrangebyrankStart SCompleted
 
 func (c ZremrangebyrankStart) Stop(stop int64) ZremrangebyrankStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (ZremrangebyrankStop)(c)
 }
 
 func (c SZremrangebyrankStart) Stop(stop int64) SZremrangebyrankStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SZremrangebyrankStop)(c)
 }
 
@@ -49361,22 +51053,26 @@ type Zremrangebyscore Completed
 
 type SZremrangebyscore SCompleted
 
-func (b *Builder) Zremrangebyscore() Zremrangebyscore {
-	return Zremrangebyscore{cs: append(b.get(), "ZREMRANGEBYSCORE"), ks: InitSlot}
+func (b *Builder) Zremrangebyscore() (c Zremrangebyscore) {
+	c = Zremrangebyscore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYSCORE")
+	return c
 }
 
-func (b *SBuilder) Zremrangebyscore() SZremrangebyscore {
-	return SZremrangebyscore{cs: append(b.get(), "ZREMRANGEBYSCORE"), ks: InitSlot}
+func (b *SBuilder) Zremrangebyscore() (c SZremrangebyscore) {
+	c = SZremrangebyscore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZREMRANGEBYSCORE")
+	return c
 }
 
 func (c Zremrangebyscore) Key(key string) ZremrangebyscoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZremrangebyscoreKey)(c)
 }
 
 func (c SZremrangebyscore) Key(key string) SZremrangebyscoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZremrangebyscoreKey)(c)
 }
 
@@ -49385,12 +51081,12 @@ type ZremrangebyscoreKey Completed
 type SZremrangebyscoreKey SCompleted
 
 func (c ZremrangebyscoreKey) Min(min float64) ZremrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (ZremrangebyscoreMin)(c)
 }
 
 func (c SZremrangebyscoreKey) Min(min float64) SZremrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (SZremrangebyscoreMin)(c)
 }
 
@@ -49411,12 +51107,12 @@ type ZremrangebyscoreMin Completed
 type SZremrangebyscoreMin SCompleted
 
 func (c ZremrangebyscoreMin) Max(max float64) ZremrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (ZremrangebyscoreMax)(c)
 }
 
 func (c SZremrangebyscoreMin) Max(max float64) SZremrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (SZremrangebyscoreMax)(c)
 }
 
@@ -49424,22 +51120,26 @@ type Zrevrange Completed
 
 type SZrevrange SCompleted
 
-func (b *Builder) Zrevrange() Zrevrange {
-	return Zrevrange{cs: append(b.get(), "ZREVRANGE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrevrange() (c Zrevrange) {
+	c = Zrevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGE")
+	return c
 }
 
-func (b *SBuilder) Zrevrange() SZrevrange {
-	return SZrevrange{cs: append(b.get(), "ZREVRANGE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrevrange() (c SZrevrange) {
+	c = SZrevrange{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGE")
+	return c
 }
 
 func (c Zrevrange) Key(key string) ZrevrangeKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrevrangeKey)(c)
 }
 
 func (c SZrevrange) Key(key string) SZrevrangeKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrevrangeKey)(c)
 }
 
@@ -49448,12 +51148,12 @@ type ZrevrangeKey Completed
 type SZrevrangeKey SCompleted
 
 func (c ZrevrangeKey) Start(start int64) ZrevrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (ZrevrangeStart)(c)
 }
 
 func (c SZrevrangeKey) Start(start int64) SZrevrangeStart {
-	c.cs = append(c.cs, strconv.FormatInt(start, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
 	return (SZrevrangeStart)(c)
 }
 
@@ -49462,12 +51162,12 @@ type ZrevrangeStart Completed
 type SZrevrangeStart SCompleted
 
 func (c ZrevrangeStart) Stop(stop int64) ZrevrangeStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (ZrevrangeStop)(c)
 }
 
 func (c SZrevrangeStart) Stop(stop int64) SZrevrangeStop {
-	c.cs = append(c.cs, strconv.FormatInt(stop, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(stop, 10))
 	return (SZrevrangeStop)(c)
 }
 
@@ -49476,12 +51176,12 @@ type ZrevrangeStop Completed
 type SZrevrangeStop SCompleted
 
 func (c ZrevrangeStop) Withscores() ZrevrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrevrangeWithscores)(c)
 }
 
 func (c SZrevrangeStop) Withscores() SZrevrangeWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrevrangeWithscores)(c)
 }
 
@@ -49525,22 +51225,26 @@ type Zrevrangebylex Completed
 
 type SZrevrangebylex SCompleted
 
-func (b *Builder) Zrevrangebylex() Zrevrangebylex {
-	return Zrevrangebylex{cs: append(b.get(), "ZREVRANGEBYLEX"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrevrangebylex() (c Zrevrangebylex) {
+	c = Zrevrangebylex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGEBYLEX")
+	return c
 }
 
-func (b *SBuilder) Zrevrangebylex() SZrevrangebylex {
-	return SZrevrangebylex{cs: append(b.get(), "ZREVRANGEBYLEX"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrevrangebylex() (c SZrevrangebylex) {
+	c = SZrevrangebylex{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGEBYLEX")
+	return c
 }
 
 func (c Zrevrangebylex) Key(key string) ZrevrangebylexKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrevrangebylexKey)(c)
 }
 
 func (c SZrevrangebylex) Key(key string) SZrevrangebylexKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrevrangebylexKey)(c)
 }
 
@@ -49549,12 +51253,12 @@ type ZrevrangebylexKey Completed
 type SZrevrangebylexKey SCompleted
 
 func (c ZrevrangebylexKey) Max(max string) ZrevrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (ZrevrangebylexMax)(c)
 }
 
 func (c SZrevrangebylexKey) Max(max string) SZrevrangebylexMax {
-	c.cs = append(c.cs, max)
+	c.cs.s = append(c.cs.s, max)
 	return (SZrevrangebylexMax)(c)
 }
 
@@ -49583,12 +51287,12 @@ type ZrevrangebylexMax Completed
 type SZrevrangebylexMax SCompleted
 
 func (c ZrevrangebylexMax) Min(min string) ZrevrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (ZrevrangebylexMin)(c)
 }
 
 func (c SZrevrangebylexMax) Min(min string) SZrevrangebylexMin {
-	c.cs = append(c.cs, min)
+	c.cs.s = append(c.cs.s, min)
 	return (SZrevrangebylexMin)(c)
 }
 
@@ -49597,12 +51301,12 @@ type ZrevrangebylexMin Completed
 type SZrevrangebylexMin SCompleted
 
 func (c ZrevrangebylexMin) Limit(offset int64, count int64) ZrevrangebylexLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrevrangebylexLimit)(c)
 }
 
 func (c SZrevrangebylexMin) Limit(offset int64, count int64) SZrevrangebylexLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrevrangebylexLimit)(c)
 }
 
@@ -49626,22 +51330,26 @@ type Zrevrangebyscore Completed
 
 type SZrevrangebyscore SCompleted
 
-func (b *Builder) Zrevrangebyscore() Zrevrangebyscore {
-	return Zrevrangebyscore{cs: append(b.get(), "ZREVRANGEBYSCORE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrevrangebyscore() (c Zrevrangebyscore) {
+	c = Zrevrangebyscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGEBYSCORE")
+	return c
 }
 
-func (b *SBuilder) Zrevrangebyscore() SZrevrangebyscore {
-	return SZrevrangebyscore{cs: append(b.get(), "ZREVRANGEBYSCORE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrevrangebyscore() (c SZrevrangebyscore) {
+	c = SZrevrangebyscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANGEBYSCORE")
+	return c
 }
 
 func (c Zrevrangebyscore) Key(key string) ZrevrangebyscoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrevrangebyscoreKey)(c)
 }
 
 func (c SZrevrangebyscore) Key(key string) SZrevrangebyscoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrevrangebyscoreKey)(c)
 }
 
@@ -49650,12 +51358,12 @@ type ZrevrangebyscoreKey Completed
 type SZrevrangebyscoreKey SCompleted
 
 func (c ZrevrangebyscoreKey) Max(max float64) ZrevrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (ZrevrangebyscoreMax)(c)
 }
 
 func (c SZrevrangebyscoreKey) Max(max float64) SZrevrangebyscoreMax {
-	c.cs = append(c.cs, strconv.FormatFloat(max, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(max, 'f', -1, 64))
 	return (SZrevrangebyscoreMax)(c)
 }
 
@@ -49684,12 +51392,12 @@ type ZrevrangebyscoreMax Completed
 type SZrevrangebyscoreMax SCompleted
 
 func (c ZrevrangebyscoreMax) Min(min float64) ZrevrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (ZrevrangebyscoreMin)(c)
 }
 
 func (c SZrevrangebyscoreMax) Min(min float64) SZrevrangebyscoreMin {
-	c.cs = append(c.cs, strconv.FormatFloat(min, 'f', -1, 64))
+	c.cs.s = append(c.cs.s, strconv.FormatFloat(min, 'f', -1, 64))
 	return (SZrevrangebyscoreMin)(c)
 }
 
@@ -49698,22 +51406,22 @@ type ZrevrangebyscoreMin Completed
 type SZrevrangebyscoreMin SCompleted
 
 func (c ZrevrangebyscoreMin) Withscores() ZrevrangebyscoreWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZrevrangebyscoreWithscores)(c)
 }
 
 func (c SZrevrangebyscoreMin) Withscores() SZrevrangebyscoreWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZrevrangebyscoreWithscores)(c)
 }
 
 func (c ZrevrangebyscoreMin) Limit(offset int64, count int64) ZrevrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrevrangebyscoreLimit)(c)
 }
 
 func (c SZrevrangebyscoreMin) Limit(offset int64, count int64) SZrevrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrevrangebyscoreLimit)(c)
 }
 
@@ -49738,12 +51446,12 @@ type ZrevrangebyscoreWithscores Completed
 type SZrevrangebyscoreWithscores SCompleted
 
 func (c ZrevrangebyscoreWithscores) Limit(offset int64, count int64) ZrevrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (ZrevrangebyscoreLimit)(c)
 }
 
 func (c SZrevrangebyscoreWithscores) Limit(offset int64, count int64) SZrevrangebyscoreLimit {
-	c.cs = append(c.cs, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(offset, 10), strconv.FormatInt(count, 10))
 	return (SZrevrangebyscoreLimit)(c)
 }
 
@@ -49767,22 +51475,26 @@ type Zrevrank Completed
 
 type SZrevrank SCompleted
 
-func (b *Builder) Zrevrank() Zrevrank {
-	return Zrevrank{cs: append(b.get(), "ZREVRANK"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zrevrank() (c Zrevrank) {
+	c = Zrevrank{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANK")
+	return c
 }
 
-func (b *SBuilder) Zrevrank() SZrevrank {
-	return SZrevrank{cs: append(b.get(), "ZREVRANK"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zrevrank() (c SZrevrank) {
+	c = SZrevrank{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZREVRANK")
+	return c
 }
 
 func (c Zrevrank) Key(key string) ZrevrankKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZrevrankKey)(c)
 }
 
 func (c SZrevrank) Key(key string) SZrevrankKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZrevrankKey)(c)
 }
 
@@ -49791,12 +51503,12 @@ type ZrevrankKey Completed
 type SZrevrankKey SCompleted
 
 func (c ZrevrankKey) Member(member string) ZrevrankMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (ZrevrankMember)(c)
 }
 
 func (c SZrevrankKey) Member(member string) SZrevrankMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SZrevrankMember)(c)
 }
 
@@ -49824,22 +51536,26 @@ type Zscan Completed
 
 type SZscan SCompleted
 
-func (b *Builder) Zscan() Zscan {
-	return Zscan{cs: append(b.get(), "ZSCAN"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zscan() (c Zscan) {
+	c = Zscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZSCAN")
+	return c
 }
 
-func (b *SBuilder) Zscan() SZscan {
-	return SZscan{cs: append(b.get(), "ZSCAN"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zscan() (c SZscan) {
+	c = SZscan{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZSCAN")
+	return c
 }
 
 func (c Zscan) Key(key string) ZscanKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZscanKey)(c)
 }
 
 func (c SZscan) Key(key string) SZscanKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZscanKey)(c)
 }
 
@@ -49860,22 +51576,22 @@ type ZscanCursor Completed
 type SZscanCursor SCompleted
 
 func (c ZscanCursor) Match(pattern string) ZscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (ZscanMatch)(c)
 }
 
 func (c SZscanCursor) Match(pattern string) SZscanMatch {
-	c.cs = append(c.cs, "MATCH", pattern)
+	c.cs.s = append(c.cs.s, "MATCH", pattern)
 	return (SZscanMatch)(c)
 }
 
 func (c ZscanCursor) Count(count int64) ZscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ZscanCount)(c)
 }
 
 func (c SZscanCursor) Count(count int64) SZscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SZscanCount)(c)
 }
 
@@ -49892,12 +51608,12 @@ type ZscanKey Completed
 type SZscanKey SCompleted
 
 func (c ZscanKey) Cursor(cursor int64) ZscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (ZscanCursor)(c)
 }
 
 func (c SZscanKey) Cursor(cursor int64) SZscanCursor {
-	c.cs = append(c.cs, strconv.FormatInt(cursor, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(cursor, 10))
 	return (SZscanCursor)(c)
 }
 
@@ -49906,12 +51622,12 @@ type ZscanMatch Completed
 type SZscanMatch SCompleted
 
 func (c ZscanMatch) Count(count int64) ZscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (ZscanCount)(c)
 }
 
 func (c SZscanMatch) Count(count int64) SZscanCount {
-	c.cs = append(c.cs, "COUNT", strconv.FormatInt(count, 10))
+	c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
 	return (SZscanCount)(c)
 }
 
@@ -49927,22 +51643,26 @@ type Zscore Completed
 
 type SZscore SCompleted
 
-func (b *Builder) Zscore() Zscore {
-	return Zscore{cs: append(b.get(), "ZSCORE"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zscore() (c Zscore) {
+	c = Zscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZSCORE")
+	return c
 }
 
-func (b *SBuilder) Zscore() SZscore {
-	return SZscore{cs: append(b.get(), "ZSCORE"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zscore() (c SZscore) {
+	c = SZscore{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZSCORE")
+	return c
 }
 
 func (c Zscore) Key(key string) ZscoreKey {
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (ZscoreKey)(c)
 }
 
 func (c SZscore) Key(key string) SZscoreKey {
 	c.ks = checkSlot(c.ks, slot(key))
-	c.cs = append(c.cs, key)
+	c.cs.s = append(c.cs.s, key)
 	return (SZscoreKey)(c)
 }
 
@@ -49951,12 +51671,12 @@ type ZscoreKey Completed
 type SZscoreKey SCompleted
 
 func (c ZscoreKey) Member(member string) ZscoreMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (ZscoreMember)(c)
 }
 
 func (c SZscoreKey) Member(member string) SZscoreMember {
-	c.cs = append(c.cs, member)
+	c.cs.s = append(c.cs.s, member)
 	return (SZscoreMember)(c)
 }
 
@@ -49984,21 +51704,25 @@ type Zunion Completed
 
 type SZunion SCompleted
 
-func (b *Builder) Zunion() Zunion {
-	return Zunion{cs: append(b.get(), "ZUNION"), ks: InitSlot, cf: readonly}
+func (b *Builder) Zunion() (c Zunion) {
+	c = Zunion{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZUNION")
+	return c
 }
 
-func (b *SBuilder) Zunion() SZunion {
-	return SZunion{cs: append(b.get(), "ZUNION"), ks: InitSlot, cf: readonly}
+func (b *SBuilder) Zunion() (c SZunion) {
+	c = SZunion{cs: b.get(), ks: InitSlot, cf: readonly}
+	c.cs.s = append(c.cs.s, "ZUNION")
+	return c
 }
 
 func (c Zunion) Numkeys(numkeys int64) ZunionNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZunionNumkeys)(c)
 }
 
 func (c SZunion) Numkeys(numkeys int64) SZunionNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZunionNumkeys)(c)
 }
 
@@ -50007,12 +51731,12 @@ type ZunionAggregateMax Completed
 type SZunionAggregateMax SCompleted
 
 func (c ZunionAggregateMax) Withscores() ZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZunionWithscores)(c)
 }
 
 func (c SZunionAggregateMax) Withscores() SZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZunionWithscores)(c)
 }
 
@@ -50029,12 +51753,12 @@ type ZunionAggregateMin Completed
 type SZunionAggregateMin SCompleted
 
 func (c ZunionAggregateMin) Withscores() ZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZunionWithscores)(c)
 }
 
 func (c SZunionAggregateMin) Withscores() SZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZunionWithscores)(c)
 }
 
@@ -50051,12 +51775,12 @@ type ZunionAggregateSum Completed
 type SZunionAggregateSum SCompleted
 
 func (c ZunionAggregateSum) Withscores() ZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZunionWithscores)(c)
 }
 
 func (c SZunionAggregateSum) Withscores() SZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZunionWithscores)(c)
 }
 
@@ -50073,7 +51797,7 @@ type ZunionKey Completed
 type SZunionKey SCompleted
 
 func (c ZunionKey) Key(key ...string) ZunionKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -50081,63 +51805,63 @@ func (c SZunionKey) Key(key ...string) SZunionKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZunionKey) Weights(weight ...int64) ZunionWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ZunionWeights)(c)
 }
 
 func (c SZunionKey) Weights(weight ...int64) SZunionWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SZunionWeights)(c)
 }
 
 func (c ZunionKey) AggregateSum() ZunionAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZunionAggregateSum)(c)
 }
 
 func (c SZunionKey) AggregateSum() SZunionAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZunionAggregateSum)(c)
 }
 
 func (c ZunionKey) AggregateMin() ZunionAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZunionAggregateMin)(c)
 }
 
 func (c SZunionKey) AggregateMin() SZunionAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZunionAggregateMin)(c)
 }
 
 func (c ZunionKey) AggregateMax() ZunionAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZunionAggregateMax)(c)
 }
 
 func (c SZunionKey) AggregateMax() SZunionAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZunionAggregateMax)(c)
 }
 
 func (c ZunionKey) Withscores() ZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZunionWithscores)(c)
 }
 
 func (c SZunionKey) Withscores() SZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZunionWithscores)(c)
 }
 
@@ -50154,7 +51878,7 @@ type ZunionNumkeys Completed
 type SZunionNumkeys SCompleted
 
 func (c ZunionNumkeys) Key(key ...string) ZunionKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZunionKey)(c)
 }
 
@@ -50162,7 +51886,7 @@ func (c SZunionNumkeys) Key(key ...string) SZunionKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZunionKey)(c)
 }
 
@@ -50171,58 +51895,58 @@ type ZunionWeights Completed
 type SZunionWeights SCompleted
 
 func (c ZunionWeights) Weights(weight ...int64) ZunionWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SZunionWeights) Weights(weight ...int64) SZunionWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c ZunionWeights) AggregateSum() ZunionAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZunionAggregateSum)(c)
 }
 
 func (c SZunionWeights) AggregateSum() SZunionAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZunionAggregateSum)(c)
 }
 
 func (c ZunionWeights) AggregateMin() ZunionAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZunionAggregateMin)(c)
 }
 
 func (c SZunionWeights) AggregateMin() SZunionAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZunionAggregateMin)(c)
 }
 
 func (c ZunionWeights) AggregateMax() ZunionAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZunionAggregateMax)(c)
 }
 
 func (c SZunionWeights) AggregateMax() SZunionAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZunionAggregateMax)(c)
 }
 
 func (c ZunionWeights) Withscores() ZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (ZunionWithscores)(c)
 }
 
 func (c SZunionWeights) Withscores() SZunionWithscores {
-	c.cs = append(c.cs, "WITHSCORES")
+	c.cs.s = append(c.cs.s, "WITHSCORES")
 	return (SZunionWithscores)(c)
 }
 
@@ -50250,22 +51974,26 @@ type Zunionstore Completed
 
 type SZunionstore SCompleted
 
-func (b *Builder) Zunionstore() Zunionstore {
-	return Zunionstore{cs: append(b.get(), "ZUNIONSTORE"), ks: InitSlot}
+func (b *Builder) Zunionstore() (c Zunionstore) {
+	c = Zunionstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZUNIONSTORE")
+	return c
 }
 
-func (b *SBuilder) Zunionstore() SZunionstore {
-	return SZunionstore{cs: append(b.get(), "ZUNIONSTORE"), ks: InitSlot}
+func (b *SBuilder) Zunionstore() (c SZunionstore) {
+	c = SZunionstore{cs: b.get(), ks: InitSlot}
+	c.cs.s = append(c.cs.s, "ZUNIONSTORE")
+	return c
 }
 
 func (c Zunionstore) Destination(destination string) ZunionstoreDestination {
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (ZunionstoreDestination)(c)
 }
 
 func (c SZunionstore) Destination(destination string) SZunionstoreDestination {
 	c.ks = checkSlot(c.ks, slot(destination))
-	c.cs = append(c.cs, destination)
+	c.cs.s = append(c.cs.s, destination)
 	return (SZunionstoreDestination)(c)
 }
 
@@ -50310,12 +52038,12 @@ type ZunionstoreDestination Completed
 type SZunionstoreDestination SCompleted
 
 func (c ZunionstoreDestination) Numkeys(numkeys int64) ZunionstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (ZunionstoreNumkeys)(c)
 }
 
 func (c SZunionstoreDestination) Numkeys(numkeys int64) SZunionstoreNumkeys {
-	c.cs = append(c.cs, strconv.FormatInt(numkeys, 10))
+	c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
 	return (SZunionstoreNumkeys)(c)
 }
 
@@ -50324,7 +52052,7 @@ type ZunionstoreKey Completed
 type SZunionstoreKey SCompleted
 
 func (c ZunionstoreKey) Key(key ...string) ZunionstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
@@ -50332,53 +52060,53 @@ func (c SZunionstoreKey) Key(key ...string) SZunionstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return c
 }
 
 func (c ZunionstoreKey) Weights(weight ...int64) ZunionstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (ZunionstoreWeights)(c)
 }
 
 func (c SZunionstoreKey) Weights(weight ...int64) SZunionstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return (SZunionstoreWeights)(c)
 }
 
 func (c ZunionstoreKey) AggregateSum() ZunionstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZunionstoreAggregateSum)(c)
 }
 
 func (c SZunionstoreKey) AggregateSum() SZunionstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZunionstoreAggregateSum)(c)
 }
 
 func (c ZunionstoreKey) AggregateMin() ZunionstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZunionstoreAggregateMin)(c)
 }
 
 func (c SZunionstoreKey) AggregateMin() SZunionstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZunionstoreAggregateMin)(c)
 }
 
 func (c ZunionstoreKey) AggregateMax() ZunionstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZunionstoreAggregateMax)(c)
 }
 
 func (c SZunionstoreKey) AggregateMax() SZunionstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZunionstoreAggregateMax)(c)
 }
 
@@ -50395,7 +52123,7 @@ type ZunionstoreNumkeys Completed
 type SZunionstoreNumkeys SCompleted
 
 func (c ZunionstoreNumkeys) Key(key ...string) ZunionstoreKey {
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (ZunionstoreKey)(c)
 }
 
@@ -50403,7 +52131,7 @@ func (c SZunionstoreNumkeys) Key(key ...string) SZunionstoreKey {
 	for _, k := range key {
 		c.ks = checkSlot(c.ks, slot(k))
 	}
-	c.cs = append(c.cs, key...)
+	c.cs.s = append(c.cs.s, key...)
 	return (SZunionstoreKey)(c)
 }
 
@@ -50412,48 +52140,48 @@ type ZunionstoreWeights Completed
 type SZunionstoreWeights SCompleted
 
 func (c ZunionstoreWeights) Weights(weight ...int64) ZunionstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c SZunionstoreWeights) Weights(weight ...int64) SZunionstoreWeights {
-	c.cs = append(c.cs, "WEIGHTS")
+	c.cs.s = append(c.cs.s, "WEIGHTS")
 	for _, n := range weight {
-		c.cs = append(c.cs, strconv.FormatInt(n, 10))
+		c.cs.s = append(c.cs.s, strconv.FormatInt(n, 10))
 	}
 	return c
 }
 
 func (c ZunionstoreWeights) AggregateSum() ZunionstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (ZunionstoreAggregateSum)(c)
 }
 
 func (c SZunionstoreWeights) AggregateSum() SZunionstoreAggregateSum {
-	c.cs = append(c.cs, "AGGREGATE", "SUM")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "SUM")
 	return (SZunionstoreAggregateSum)(c)
 }
 
 func (c ZunionstoreWeights) AggregateMin() ZunionstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (ZunionstoreAggregateMin)(c)
 }
 
 func (c SZunionstoreWeights) AggregateMin() SZunionstoreAggregateMin {
-	c.cs = append(c.cs, "AGGREGATE", "MIN")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MIN")
 	return (SZunionstoreAggregateMin)(c)
 }
 
 func (c ZunionstoreWeights) AggregateMax() ZunionstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (ZunionstoreAggregateMax)(c)
 }
 
 func (c SZunionstoreWeights) AggregateMax() SZunionstoreAggregateMax {
-	c.cs = append(c.cs, "AGGREGATE", "MAX")
+	c.cs.s = append(c.cs.s, "AGGREGATE", "MAX")
 	return (SZunionstoreAggregateMax)(c)
 }