rueian/rueidis

// Code generated DO NOT EDIT

package cmds

type Psubscribe Incomplete

func (b Builder) Psubscribe() (c Psubscribe) {
    c = Psubscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "PSUBSCRIBE")
    return c
}

func (c Psubscribe) Pattern(pattern ...string) PsubscribePattern {
    c.cs.s = append(c.cs.s, pattern...)
    return (PsubscribePattern)(c)
}

type PsubscribePattern Incomplete

func (c PsubscribePattern) Pattern(pattern ...string) PsubscribePattern {
    c.cs.s = append(c.cs.s, pattern...)
    return c
}

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

type Publish Incomplete

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

func (c Publish) Channel(channel string) PublishChannel {
    c.cs.s = append(c.cs.s, channel)
    return (PublishChannel)(c)
}

type PublishChannel Incomplete

func (c PublishChannel) Message(message string) PublishMessage {
    c.cs.s = append(c.cs.s, message)
    return (PublishMessage)(c)
}

type PublishMessage Incomplete

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

type PubsubChannels Incomplete

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

func (c PubsubChannels) Pattern(pattern string) PubsubChannelsPattern {
    c.cs.s = append(c.cs.s, pattern)
    return (PubsubChannelsPattern)(c)
}

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

type PubsubChannelsPattern Incomplete

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

type PubsubHelp Incomplete

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

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

type PubsubNumpat Incomplete

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

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

type PubsubNumsub Incomplete

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

func (c PubsubNumsub) Channel(channel ...string) PubsubNumsubChannel {
    c.cs.s = append(c.cs.s, channel...)
    return (PubsubNumsubChannel)(c)
}

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

type PubsubNumsubChannel Incomplete

func (c PubsubNumsubChannel) Channel(channel ...string) PubsubNumsubChannel {
    c.cs.s = append(c.cs.s, channel...)
    return c
}

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

type PubsubShardchannels Incomplete

func (b Builder) PubsubShardchannels() (c PubsubShardchannels) {
    c = PubsubShardchannels{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "PUBSUB", "SHARDCHANNELS")
    return c
}

func (c PubsubShardchannels) Pattern(pattern string) PubsubShardchannelsPattern {
    c.cs.s = append(c.cs.s, pattern)
    return (PubsubShardchannelsPattern)(c)
}

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

type PubsubShardchannelsPattern Incomplete

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

type PubsubShardnumsub Incomplete

func (b Builder) PubsubShardnumsub() (c PubsubShardnumsub) {
    c = PubsubShardnumsub{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "PUBSUB", "SHARDNUMSUB")
    return c
}

func (c PubsubShardnumsub) Channel(channel ...string) PubsubShardnumsubChannel {
    c.cs.s = append(c.cs.s, channel...)
    return (PubsubShardnumsubChannel)(c)
}

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

type PubsubShardnumsubChannel Incomplete

func (c PubsubShardnumsubChannel) Channel(channel ...string) PubsubShardnumsubChannel {
    c.cs.s = append(c.cs.s, channel...)
    return c
}

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

type Punsubscribe Incomplete

func (b Builder) Punsubscribe() (c Punsubscribe) {
    c = Punsubscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "PUNSUBSCRIBE")
    return c
}

func (c Punsubscribe) Pattern(pattern ...string) PunsubscribePattern {
    c.cs.s = append(c.cs.s, pattern...)
    return (PunsubscribePattern)(c)
}

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

type PunsubscribePattern Incomplete

func (c PunsubscribePattern) Pattern(pattern ...string) PunsubscribePattern {
    c.cs.s = append(c.cs.s, pattern...)
    return c
}

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

type Spublish Incomplete

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

func (c Spublish) Channel(channel string) SpublishChannel {
    if c.ks&NoSlot == NoSlot {
        c.ks = NoSlot | slot(channel)
    } else {
        c.ks = check(c.ks, slot(channel))
    }
    c.cs.s = append(c.cs.s, channel)
    return (SpublishChannel)(c)
}

type SpublishChannel Incomplete

func (c SpublishChannel) Message(message string) SpublishMessage {
    c.cs.s = append(c.cs.s, message)
    return (SpublishMessage)(c)
}

type SpublishMessage Incomplete

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

type Ssubscribe Incomplete

func (b Builder) Ssubscribe() (c Ssubscribe) {
    c = Ssubscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "SSUBSCRIBE")
    return c
}

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

type SsubscribeChannel Incomplete

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

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

type Subscribe Incomplete

func (b Builder) Subscribe() (c Subscribe) {
    c = Subscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "SUBSCRIBE")
    return c
}

func (c Subscribe) Channel(channel ...string) SubscribeChannel {
    c.cs.s = append(c.cs.s, channel...)
    return (SubscribeChannel)(c)
}

type SubscribeChannel Incomplete

func (c SubscribeChannel) Channel(channel ...string) SubscribeChannel {
    c.cs.s = append(c.cs.s, channel...)
    return c
}

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

type Sunsubscribe Incomplete

func (b Builder) Sunsubscribe() (c Sunsubscribe) {
    c = Sunsubscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "SUNSUBSCRIBE")
    return c
}

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

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

type SunsubscribeChannel Incomplete

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

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

type Unsubscribe Incomplete

func (b Builder) Unsubscribe() (c Unsubscribe) {
    c = Unsubscribe{cs: get(), ks: b.ks, cf: int16(noRetTag)}
    c.cs.s = append(c.cs.s, "UNSUBSCRIBE")
    return c
}

func (c Unsubscribe) Channel(channel ...string) UnsubscribeChannel {
    c.cs.s = append(c.cs.s, channel...)
    return (UnsubscribeChannel)(c)
}

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

type UnsubscribeChannel Incomplete

func (c UnsubscribeChannel) Channel(channel ...string) UnsubscribeChannel {
    c.cs.s = append(c.cs.s, channel...)
    return c
}

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