rueian/rueidis

// Code generated DO NOT EDIT

package cmds

import "strconv"

type Bitcount Incomplete

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

func (c Bitcount) Key(key string) BitcountKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (BitcountKey)(c)
}

type BitcountIndexEnd Incomplete

func (c BitcountIndexEnd) Byte() BitcountIndexIndexUnitByte {
    c.cs.s = append(c.cs.s, "BYTE")
    return (BitcountIndexIndexUnitByte)(c)
}

func (c BitcountIndexEnd) Bit() BitcountIndexIndexUnitBit {
    c.cs.s = append(c.cs.s, "BIT")
    return (BitcountIndexIndexUnitBit)(c)
}

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

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

type BitcountIndexIndexUnitBit Incomplete

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

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

type BitcountIndexIndexUnitByte Incomplete

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

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

type BitcountIndexStart Incomplete

func (c BitcountIndexStart) End(end int64) BitcountIndexEnd {
    c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
    return (BitcountIndexEnd)(c)
}

type BitcountKey Incomplete

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

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

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

type Bitfield Incomplete

func (b Builder) Bitfield() (c Bitfield) {
    c = Bitfield{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BITFIELD")
    return c
}

func (c Bitfield) Key(key string) BitfieldKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (BitfieldKey)(c)
}

type BitfieldKey Incomplete

func (c BitfieldKey) Get(encoding string, offset int64) BitfieldOperationGet {
    c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
    return (BitfieldOperationGet)(c)
}

func (c BitfieldKey) OverflowWrap() BitfieldOperationWriteOverflowWrap {
    c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
    return (BitfieldOperationWriteOverflowWrap)(c)
}

func (c BitfieldKey) OverflowSat() BitfieldOperationWriteOverflowSat {
    c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
    return (BitfieldOperationWriteOverflowSat)(c)
}

func (c BitfieldKey) OverflowFail() BitfieldOperationWriteOverflowFail {
    c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
    return (BitfieldOperationWriteOverflowFail)(c)
}

func (c BitfieldKey) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldKey) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

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

type BitfieldOperationGet Incomplete

func (c BitfieldOperationGet) OverflowWrap() BitfieldOperationWriteOverflowWrap {
    c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
    return (BitfieldOperationWriteOverflowWrap)(c)
}

func (c BitfieldOperationGet) OverflowSat() BitfieldOperationWriteOverflowSat {
    c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
    return (BitfieldOperationWriteOverflowSat)(c)
}

func (c BitfieldOperationGet) OverflowFail() BitfieldOperationWriteOverflowFail {
    c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
    return (BitfieldOperationWriteOverflowFail)(c)
}

func (c BitfieldOperationGet) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldOperationGet) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

func (c BitfieldOperationGet) Get(encoding string, offset int64) BitfieldOperationGet {
    c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
    return c
}

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

type BitfieldOperationWriteOverflowFail Incomplete

func (c BitfieldOperationWriteOverflowFail) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldOperationWriteOverflowFail) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

type BitfieldOperationWriteOverflowSat Incomplete

func (c BitfieldOperationWriteOverflowSat) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldOperationWriteOverflowSat) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

type BitfieldOperationWriteOverflowWrap Incomplete

func (c BitfieldOperationWriteOverflowWrap) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldOperationWriteOverflowWrap) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

type BitfieldOperationWriteSetIncrby Incomplete

func (c BitfieldOperationWriteSetIncrby) Get(encoding string, offset int64) BitfieldOperationGet {
    c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
    return (BitfieldOperationGet)(c)
}

func (c BitfieldOperationWriteSetIncrby) OverflowWrap() BitfieldOperationWriteOverflowWrap {
    c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
    return (BitfieldOperationWriteOverflowWrap)(c)
}

func (c BitfieldOperationWriteSetIncrby) OverflowSat() BitfieldOperationWriteOverflowSat {
    c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
    return (BitfieldOperationWriteOverflowSat)(c)
}

func (c BitfieldOperationWriteSetIncrby) OverflowFail() BitfieldOperationWriteOverflowFail {
    c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
    return (BitfieldOperationWriteOverflowFail)(c)
}

func (c BitfieldOperationWriteSetIncrby) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return (BitfieldOperationWriteSetSet)(c)
}

func (c BitfieldOperationWriteSetIncrby) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return c
}

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

type BitfieldOperationWriteSetSet Incomplete

func (c BitfieldOperationWriteSetSet) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
    c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
    return (BitfieldOperationWriteSetIncrby)(c)
}

func (c BitfieldOperationWriteSetSet) Get(encoding string, offset int64) BitfieldOperationGet {
    c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
    return (BitfieldOperationGet)(c)
}

func (c BitfieldOperationWriteSetSet) OverflowWrap() BitfieldOperationWriteOverflowWrap {
    c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
    return (BitfieldOperationWriteOverflowWrap)(c)
}

func (c BitfieldOperationWriteSetSet) OverflowSat() BitfieldOperationWriteOverflowSat {
    c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
    return (BitfieldOperationWriteOverflowSat)(c)
}

func (c BitfieldOperationWriteSetSet) OverflowFail() BitfieldOperationWriteOverflowFail {
    c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
    return (BitfieldOperationWriteOverflowFail)(c)
}

func (c BitfieldOperationWriteSetSet) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
    c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
    return c
}

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

type BitfieldRo Incomplete

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

func (c BitfieldRo) Key(key string) BitfieldRoKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (BitfieldRoKey)(c)
}

type BitfieldRoGet Incomplete

func (c BitfieldRoGet) Get(encoding string, offset int64) BitfieldRoGet {
    c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
    return c
}

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

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

type BitfieldRoKey Incomplete

func (c BitfieldRoKey) Get() BitfieldRoGet {
    return (BitfieldRoGet)(c)
}

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

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

type Bitop Incomplete

func (b Builder) Bitop() (c Bitop) {
    c = Bitop{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BITOP")
    return c
}

func (c Bitop) And() BitopOperationAnd {
    c.cs.s = append(c.cs.s, "AND")
    return (BitopOperationAnd)(c)
}

func (c Bitop) Or() BitopOperationOr {
    c.cs.s = append(c.cs.s, "OR")
    return (BitopOperationOr)(c)
}

func (c Bitop) Xor() BitopOperationXor {
    c.cs.s = append(c.cs.s, "XOR")
    return (BitopOperationXor)(c)
}

func (c Bitop) Not() BitopOperationNot {
    c.cs.s = append(c.cs.s, "NOT")
    return (BitopOperationNot)(c)
}

type BitopDestkey Incomplete

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

type BitopKey Incomplete

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

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

type BitopOperationAnd Incomplete

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

type BitopOperationNot Incomplete

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

type BitopOperationOr Incomplete

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

type BitopOperationXor Incomplete

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

type Bitpos Incomplete

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

func (c Bitpos) Key(key string) BitposKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (BitposKey)(c)
}

type BitposBit Incomplete

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

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

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

type BitposIndexEndIndexEnd Incomplete

func (c BitposIndexEndIndexEnd) Byte() BitposIndexEndIndexIndexUnitByte {
    c.cs.s = append(c.cs.s, "BYTE")
    return (BitposIndexEndIndexIndexUnitByte)(c)
}

func (c BitposIndexEndIndexEnd) Bit() BitposIndexEndIndexIndexUnitBit {
    c.cs.s = append(c.cs.s, "BIT")
    return (BitposIndexEndIndexIndexUnitBit)(c)
}

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

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

type BitposIndexEndIndexIndexUnitBit Incomplete

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

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

type BitposIndexEndIndexIndexUnitByte Incomplete

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

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

type BitposIndexStart Incomplete

func (c BitposIndexStart) End(end int64) BitposIndexEndIndexEnd {
    c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
    return (BitposIndexEndIndexEnd)(c)
}

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

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

type BitposKey Incomplete

func (c BitposKey) Bit(bit int64) BitposBit {
    c.cs.s = append(c.cs.s, strconv.FormatInt(bit, 10))
    return (BitposBit)(c)
}

type Getbit Incomplete

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

func (c Getbit) Key(key string) GetbitKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (GetbitKey)(c)
}

type GetbitKey Incomplete

func (c GetbitKey) Offset(offset int64) GetbitOffset {
    c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
    return (GetbitOffset)(c)
}

type GetbitOffset Incomplete

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

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

type Setbit Incomplete

func (b Builder) Setbit() (c Setbit) {
    c = Setbit{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "SETBIT")
    return c
}

func (c Setbit) Key(key string) SetbitKey {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(key)
    } else {
        c.ks = check(c.ks, slot(key))
    }
    c.cs.s = append(c.cs.s, key)
    return (SetbitKey)(c)
}

type SetbitKey Incomplete

func (c SetbitKey) Offset(offset int64) SetbitOffset {
    c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
    return (SetbitOffset)(c)
}

type SetbitOffset Incomplete

func (c SetbitOffset) Value(value int64) SetbitValue {
    c.cs.s = append(c.cs.s, strconv.FormatInt(value, 10))
    return (SetbitValue)(c)
}

type SetbitValue Incomplete

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