ruststream_fred/pipeline/

commands.rs

// Generated by scripts/gen_pipeline_commands.py from fred's command interfaces; regenerate rather
// than edit.

//! The commands a handler queues into its delivery's segment, one per fred command method.

// The summaries are fred's own prose, copied as it is written.
#![allow(
    clippy::too_many_arguments,
    clippy::missing_errors_doc,
    clippy::doc_markdown
)]

use fred::bytes::Bytes;
use fred::bytes_utils::Str;
use fred::error::Error;
use fred::interfaces::{
    FunctionInterface, HashesInterface, KeysInterface, ListInterface, PubsubInterface,
    SetsInterface, SortedSetsInterface, StreamsInterface,
};
use fred::types::lists::{LMoveDirection, ListLocation};
use fred::types::scripts::FnPolicy;
use fred::types::sorted_sets::{
    AggregateOptions, MultipleWeights, MultipleZaddValues, Ordering, ZCmp, ZRange, ZSort,
};
use fred::types::streams::{MultipleIDs, MultipleOrderedPairs, XCap, XID, XPendingArgs};
use fred::types::{
    Expiration, ExpireOptions, Key, Limit, Map, MultipleKeys, MultipleStrings, MultipleValues,
    SetOptions, SortOrder, Value,
};

use super::{RedisPipeline, Segment};

impl RedisPipeline {
    /// Return a random key from the currently selected database.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn randomkey(&self) -> Result<(), Error> {
        match self.segment().await? {
            Segment::Plain(segment) => segment.randomkey::<()>().await,
            Segment::Atomic(segment) => segment.randomkey::<()>().await,
        }
    }

    /// This command copies the value stored at the source key to the destination key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn copy<S, D>(
        &self,
        source: S,
        destination: D,
        db: Option<u8>,
        replace: bool,
    ) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .copy::<(), S, D>(source, destination, db, replace)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .copy::<(), S, D>(source, destination, db, replace)
                    .await
            }
        }
    }

    /// Serialize the value stored at `key` in a Redis-specific format and return it as bulk string.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn dump<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.dump::<(), K>(key).await,
            Segment::Atomic(segment) => segment.dump::<(), K>(key).await,
        }
    }

    /// Returns the string representation of the type of the value stored at key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn r#type<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.r#type::<(), K>(key).await,
            Segment::Atomic(segment) => segment.r#type::<(), K>(key).await,
        }
    }

    /// Create a key associated with a value that is obtained by deserializing the provided serialized value
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn restore<K>(
        &self,
        key: K,
        ttl: i64,
        serialized: Value,
        replace: bool,
        absttl: bool,
        idletime: Option<i64>,
        frequency: Option<i64>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .restore::<(), K>(key, ttl, serialized, replace, absttl, idletime, frequency)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .restore::<(), K>(key, ttl, serialized, replace, absttl, idletime, frequency)
                    .await
            }
        }
    }

    /// Set a value with optional NX|XX, EX|PX|EXAT|PXAT|KEEPTTL, and GET arguments.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn set<K, V>(
        &self,
        key: K,
        value: V,
        expire: Option<Expiration>,
        options: Option<SetOptions>,
        get: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .set::<(), K, V>(key, value, expire, options, get)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .set::<(), K, V>(key, value, expire, options, get)
                    .await
            }
        }
    }

    /// Sets `key` to `value` if `key` does not exist.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn setnx<K, V>(&self, key: K, value: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.setnx::<(), K, V>(key, value).await,
            Segment::Atomic(segment) => segment.setnx::<(), K, V>(key, value).await,
        }
    }

    /// Read a value from the server.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn get<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.get::<(), K>(key).await,
            Segment::Atomic(segment) => segment.get::<(), K>(key).await,
        }
    }

    /// Returns the substring of the string value stored at `key` with offsets `start` and `end` (both inclusive).
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn getrange<K>(&self, key: K, start: usize, end: usize) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.getrange::<(), K>(key, start, end).await,
            Segment::Atomic(segment) => segment.getrange::<(), K>(key, start, end).await,
        }
    }

    /// Overwrites part of the string stored at `key`, starting at the specified `offset`, for the entire length of `value`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn setrange<K, V>(&self, key: K, offset: u32, value: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.setrange::<(), K, V>(key, offset, value).await,
            Segment::Atomic(segment) => segment.setrange::<(), K, V>(key, offset, value).await,
        }
    }

    /// Atomically sets `key` to `value` and returns the old value stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn getset<K, V>(&self, key: K, value: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.getset::<(), K, V>(key, value).await,
            Segment::Atomic(segment) => segment.getset::<(), K, V>(key, value).await,
        }
    }

    /// Get the value of key and delete the key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn getdel<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.getdel::<(), K>(key).await,
            Segment::Atomic(segment) => segment.getdel::<(), K>(key).await,
        }
    }

    /// Returns the length of the string value stored at key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn strlen<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.strlen::<(), K>(key).await,
            Segment::Atomic(segment) => segment.strlen::<(), K>(key).await,
        }
    }

    /// Removes the specified keys.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn del<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.del::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.del::<(), K>(keys).await,
        }
    }

    /// Unlinks the specified keys.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn unlink<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.unlink::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.unlink::<(), K>(keys).await,
        }
    }

    /// Renames `source` key to `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn rename<S, D>(&self, source: S, destination: D) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.rename::<(), S, D>(source, destination).await,
            Segment::Atomic(segment) => segment.rename::<(), S, D>(source, destination).await,
        }
    }

    /// Renames `source` key to `destination` if `destination` does not yet exist.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn renamenx<S, D>(&self, source: S, destination: D) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.renamenx::<(), S, D>(source, destination).await,
            Segment::Atomic(segment) => segment.renamenx::<(), S, D>(source, destination).await,
        }
    }

    /// Append `value` to `key` if it's a string.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn append<K, V>(&self, key: K, value: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.append::<(), K, V>(key, value).await,
            Segment::Atomic(segment) => segment.append::<(), K, V>(key, value).await,
        }
    }

    /// Returns the values of all specified keys.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn mget<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.mget::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.mget::<(), K>(keys).await,
        }
    }

    /// Sets the given keys to their respective values.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn mset<V>(&self, values: V) -> Result<(), Error>
    where
        V: TryInto<Map> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.mset(values).await,
            Segment::Atomic(segment) => segment.mset(values).await,
        }
    }

    /// Sets the given keys to their respective values.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn msetnx<V>(&self, values: V) -> Result<(), Error>
    where
        V: TryInto<Map> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.msetnx::<(), V>(values).await,
            Segment::Atomic(segment) => segment.msetnx::<(), V>(values).await,
        }
    }

    /// Increments the number stored at `key` by one.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn incr<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.incr::<(), K>(key).await,
            Segment::Atomic(segment) => segment.incr::<(), K>(key).await,
        }
    }

    /// Increments the number stored at `key` by `val`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn incr_by<K>(&self, key: K, val: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.incr_by::<(), K>(key, val).await,
            Segment::Atomic(segment) => segment.incr_by::<(), K>(key, val).await,
        }
    }

    /// Increment the string representing a floating point number stored at key by `val`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn incr_by_float<K>(&self, key: K, val: f64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.incr_by_float::<(), K>(key, val).await,
            Segment::Atomic(segment) => segment.incr_by_float::<(), K>(key, val).await,
        }
    }

    /// Decrements the number stored at `key` by one.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn decr<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.decr::<(), K>(key).await,
            Segment::Atomic(segment) => segment.decr::<(), K>(key).await,
        }
    }

    /// Decrements the number stored at `key` by `val`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn decr_by<K>(&self, key: K, val: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.decr_by::<(), K>(key, val).await,
            Segment::Atomic(segment) => segment.decr_by::<(), K>(key, val).await,
        }
    }

    /// Returns the remaining time to live of a key that has a timeout, in seconds.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn ttl<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.ttl::<(), K>(key).await,
            Segment::Atomic(segment) => segment.ttl::<(), K>(key).await,
        }
    }

    /// Returns the remaining time to live of a key that has a timeout, in milliseconds.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pttl<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pttl::<(), K>(key).await,
            Segment::Atomic(segment) => segment.pttl::<(), K>(key).await,
        }
    }

    /// Remove the existing timeout on a key, turning the key from volatile (a key with an expiration) to persistent (a key that will never expire as no timeout is associated).
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn persist<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.persist::<(), K>(key).await,
            Segment::Atomic(segment) => segment.persist::<(), K>(key).await,
        }
    }

    /// Set a timeout on key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn expire<K>(
        &self,
        key: K,
        seconds: i64,
        options: Option<ExpireOptions>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.expire::<(), K>(key, seconds, options).await,
            Segment::Atomic(segment) => segment.expire::<(), K>(key, seconds, options).await,
        }
    }

    /// Set a timeout on a key based on a UNIX timestamp.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn expire_at<K>(
        &self,
        key: K,
        timestamp: i64,
        options: Option<ExpireOptions>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.expire_at::<(), K>(key, timestamp, options).await,
            Segment::Atomic(segment) => segment.expire_at::<(), K>(key, timestamp, options).await,
        }
    }

    /// Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn expire_time<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.expire_time::<(), K>(key).await,
            Segment::Atomic(segment) => segment.expire_time::<(), K>(key).await,
        }
    }

    /// This command works exactly like EXPIRE but the time to live of the key is specified in milliseconds instead of seconds.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pexpire<K>(
        &self,
        key: K,
        milliseconds: i64,
        options: Option<ExpireOptions>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pexpire::<(), K>(key, milliseconds, options).await,
            Segment::Atomic(segment) => segment.pexpire::<(), K>(key, milliseconds, options).await,
        }
    }

    /// PEXPIREAT has the same effect and semantic as EXPIREAT, but the Unix time at which the key will expire is specified in milliseconds instead of seconds.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pexpire_at<K>(
        &self,
        key: K,
        timestamp: i64,
        options: Option<ExpireOptions>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pexpire_at::<(), K>(key, timestamp, options).await,
            Segment::Atomic(segment) => segment.pexpire_at::<(), K>(key, timestamp, options).await,
        }
    }

    /// PEXPIRETIME has the same semantic as EXPIRETIME, but returns the absolute Unix expiration timestamp in milliseconds instead of seconds.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pexpire_time<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pexpire_time::<(), K>(key).await,
            Segment::Atomic(segment) => segment.pexpire_time::<(), K>(key).await,
        }
    }

    /// Returns number of keys that exist from the `keys` arguments.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn exists<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.exists::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.exists::<(), K>(keys).await,
        }
    }

    /// Returns all fields and values of the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hgetall<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hgetall::<(), K>(key).await,
            Segment::Atomic(segment) => segment.hgetall::<(), K>(key).await,
        }
    }

    /// Removes the specified fields from the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hdel<K, F>(&self, key: K, fields: F) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hdel::<(), K, F>(key, fields).await,
            Segment::Atomic(segment) => segment.hdel::<(), K, F>(key, fields).await,
        }
    }

    /// Returns if `field` is an existing field in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hexists<K, F>(&self, key: K, field: F) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hexists::<(), K, F>(key, field).await,
            Segment::Atomic(segment) => segment.hexists::<(), K, F>(key, field).await,
        }
    }

    /// Returns the value associated with `field` in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hget<K, F>(&self, key: K, field: F) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hget::<(), K, F>(key, field).await,
            Segment::Atomic(segment) => segment.hget::<(), K, F>(key, field).await,
        }
    }

    /// Increments the number stored at `field` in the hash stored at `key` by `increment`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hincrby<K, F>(&self, key: K, field: F, increment: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hincrby::<(), K, F>(key, field, increment).await,
            Segment::Atomic(segment) => segment.hincrby::<(), K, F>(key, field, increment).await,
        }
    }

    /// Increment the specified `field` of a hash stored at `key`, and representing a floating point number, by the specified `increment`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hincrbyfloat<K, F>(&self, key: K, field: F, increment: f64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .hincrbyfloat::<(), K, F>(key, field, increment)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .hincrbyfloat::<(), K, F>(key, field, increment)
                    .await
            }
        }
    }

    /// Returns all field names in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hkeys<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hkeys::<(), K>(key).await,
            Segment::Atomic(segment) => segment.hkeys::<(), K>(key).await,
        }
    }

    /// Returns the number of fields contained in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hlen<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hlen::<(), K>(key).await,
            Segment::Atomic(segment) => segment.hlen::<(), K>(key).await,
        }
    }

    /// Returns the values associated with the specified `fields` in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hmget<K, F>(&self, key: K, fields: F) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hmget::<(), K, F>(key, fields).await,
            Segment::Atomic(segment) => segment.hmget::<(), K, F>(key, fields).await,
        }
    }

    /// Sets the specified fields to their respective values in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hmset<K, V>(&self, key: K, values: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Map> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hmset::<(), K, V>(key, values).await,
            Segment::Atomic(segment) => segment.hmset::<(), K, V>(key, values).await,
        }
    }

    /// Sets fields in the hash stored at `key` to their provided values.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hset<K, V>(&self, key: K, values: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Map> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hset::<(), K, V>(key, values).await,
            Segment::Atomic(segment) => segment.hset::<(), K, V>(key, values).await,
        }
    }

    /// Sets `field` in the hash stored at `key` to `value`, only if `field` does not yet exist.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hsetnx<K, F, V>(&self, key: K, field: F, value: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hsetnx::<(), K, F, V>(key, field, value).await,
            Segment::Atomic(segment) => segment.hsetnx::<(), K, F, V>(key, field, value).await,
        }
    }

    /// When called with just the `key` argument, return a random field from the hash value stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hrandfield<K>(&self, key: K, count: Option<(i64, bool)>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hrandfield::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.hrandfield::<(), K>(key, count).await,
        }
    }

    /// Returns the string length of the value associated with `field` in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hstrlen<K, F>(&self, key: K, field: F) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        F: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hstrlen::<(), K, F>(key, field).await,
            Segment::Atomic(segment) => segment.hstrlen::<(), K, F>(key, field).await,
        }
    }

    /// Returns all values in the hash stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn hvals<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.hvals::<(), K>(key).await,
            Segment::Atomic(segment) => segment.hvals::<(), K>(key).await,
        }
    }

    /// Pops one or more elements from the first non-empty list key from the list of provided key names.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lmpop<K>(
        &self,
        keys: K,
        direction: LMoveDirection,
        count: Option<i64>,
    ) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lmpop::<(), K>(keys, direction, count).await,
            Segment::Atomic(segment) => segment.lmpop::<(), K>(keys, direction, count).await,
        }
    }

    /// Returns the element at index in the list stored at key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lindex<K>(&self, key: K, index: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lindex::<(), K>(key, index).await,
            Segment::Atomic(segment) => segment.lindex::<(), K>(key, index).await,
        }
    }

    /// Inserts element in the list stored at key either before or after the reference value `pivot`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn linsert<K, P, V>(
        &self,
        key: K,
        location: ListLocation,
        pivot: P,
        element: V,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        P: TryInto<Value> + Send,
        P::Error: Into<Error> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .linsert::<(), K, P, V>(key, location, pivot, element)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .linsert::<(), K, P, V>(key, location, pivot, element)
                    .await
            }
        }
    }

    /// Returns the length of the list stored at key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn llen<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.llen::<(), K>(key).await,
            Segment::Atomic(segment) => segment.llen::<(), K>(key).await,
        }
    }

    /// Removes and returns the first elements of the list stored at key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lpop<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lpop::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.lpop::<(), K>(key, count).await,
        }
    }

    /// The command returns the index of matching elements inside a Redis list.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lpos<K, V>(
        &self,
        key: K,
        element: V,
        rank: Option<i64>,
        count: Option<i64>,
        maxlen: Option<i64>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .lpos::<(), K, V>(key, element, rank, count, maxlen)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .lpos::<(), K, V>(key, element, rank, count, maxlen)
                    .await
            }
        }
    }

    /// Insert all the specified values at the head of the list stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lpush<K, V>(&self, key: K, elements: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lpush::<(), K, V>(key, elements).await,
            Segment::Atomic(segment) => segment.lpush::<(), K, V>(key, elements).await,
        }
    }

    /// Inserts specified values at the head of the list stored at `key`, only if `key` already exists and holds a list.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lpushx<K, V>(&self, key: K, elements: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lpushx::<(), K, V>(key, elements).await,
            Segment::Atomic(segment) => segment.lpushx::<(), K, V>(key, elements).await,
        }
    }

    /// Returns the specified elements of the list stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lrange<K>(&self, key: K, start: i64, stop: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lrange::<(), K>(key, start, stop).await,
            Segment::Atomic(segment) => segment.lrange::<(), K>(key, start, stop).await,
        }
    }

    /// Removes the first `count` occurrences of elements equal to `element` from the list stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lrem<K, V>(&self, key: K, count: i64, element: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lrem::<(), K, V>(key, count, element).await,
            Segment::Atomic(segment) => segment.lrem::<(), K, V>(key, count, element).await,
        }
    }

    /// Sets the list element at `index` to `element`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lset<K, V>(&self, key: K, index: i64, element: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.lset::<(), K, V>(key, index, element).await,
            Segment::Atomic(segment) => segment.lset::<(), K, V>(key, index, element).await,
        }
    }

    /// Trim an existing list so that it will contain only the specified range of elements specified.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn ltrim<K>(&self, key: K, start: i64, stop: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.ltrim::<(), K>(key, start, stop).await,
            Segment::Atomic(segment) => segment.ltrim::<(), K>(key, start, stop).await,
        }
    }

    /// Removes and returns the last elements of the list stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn rpop<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.rpop::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.rpop::<(), K>(key, count).await,
        }
    }

    /// Atomically returns and removes the last element (tail) of the list stored at `source`, and pushes the element at the first element (head) of the list stored at `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn rpoplpush<S, D>(&self, source: S, dest: D) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.rpoplpush::<(), S, D>(source, dest).await,
            Segment::Atomic(segment) => segment.rpoplpush::<(), S, D>(source, dest).await,
        }
    }

    /// Atomically returns and removes the first/last element (head/tail depending on the source direction argument) of the list stored at `source`, and pushes the element at the first/last element (head/tail depending on the destination direction argument) of the list stored at `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn lmove<S, D>(
        &self,
        source: S,
        dest: D,
        source_direction: LMoveDirection,
        dest_direction: LMoveDirection,
    ) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .lmove::<(), S, D>(source, dest, source_direction, dest_direction)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .lmove::<(), S, D>(source, dest, source_direction, dest_direction)
                    .await
            }
        }
    }

    /// Insert all the specified values at the tail of the list stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn rpush<K, V>(&self, key: K, elements: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.rpush::<(), K, V>(key, elements).await,
            Segment::Atomic(segment) => segment.rpush::<(), K, V>(key, elements).await,
        }
    }

    /// Inserts specified values at the tail of the list stored at `key`, only if key already exists and holds a list.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn rpushx<K, V>(&self, key: K, elements: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.rpushx::<(), K, V>(key, elements).await,
            Segment::Atomic(segment) => segment.rpushx::<(), K, V>(key, elements).await,
        }
    }

    /// Returns or stores the elements contained in the list, set or sorted set at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sort<K, S>(
        &self,
        key: K,
        by: Option<Str>,
        limit: Option<Limit>,
        get: S,
        order: Option<SortOrder>,
        alpha: bool,
        store: Option<Key>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<MultipleStrings> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .sort::<(), K, S>(key, by, limit, get, order, alpha, store)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .sort::<(), K, S>(key, by, limit, get, order, alpha, store)
                    .await
            }
        }
    }

    /// Read-only variant of the SORT command.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sort_ro<K, S>(
        &self,
        key: K,
        by: Option<Str>,
        limit: Option<Limit>,
        get: S,
        order: Option<SortOrder>,
        alpha: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<MultipleStrings> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .sort_ro::<(), K, S>(key, by, limit, get, order, alpha)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .sort_ro::<(), K, S>(key, by, limit, get, order, alpha)
                    .await
            }
        }
    }

    /// Add the specified members to the set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sadd<K, V>(&self, key: K, members: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sadd::<(), K, V>(key, members).await,
            Segment::Atomic(segment) => segment.sadd::<(), K, V>(key, members).await,
        }
    }

    /// Returns the set cardinality (number of elements) of the set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn scard<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.scard::<(), K>(key).await,
            Segment::Atomic(segment) => segment.scard::<(), K>(key).await,
        }
    }

    /// Returns the members of the set resulting from the difference between the first set and all the successive sets.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sdiff<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sdiff::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.sdiff::<(), K>(keys).await,
        }
    }

    /// This command is equal to SDIFF, but instead of returning the resulting set, it is stored in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sdiffstore<D, K>(&self, dest: D, keys: K) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sdiffstore::<(), D, K>(dest, keys).await,
            Segment::Atomic(segment) => segment.sdiffstore::<(), D, K>(dest, keys).await,
        }
    }

    /// Returns the members of the set resulting from the intersection of all the given sets.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sinter<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sinter::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.sinter::<(), K>(keys).await,
        }
    }

    /// This command is equal to SINTER, but instead of returning the resulting set, it is stored in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sinterstore<D, K>(&self, dest: D, keys: K) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sinterstore::<(), D, K>(dest, keys).await,
            Segment::Atomic(segment) => segment.sinterstore::<(), D, K>(dest, keys).await,
        }
    }

    /// Returns if `member` is a member of the set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sismember<K, V>(&self, key: K, member: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sismember::<(), K, V>(key, member).await,
            Segment::Atomic(segment) => segment.sismember::<(), K, V>(key, member).await,
        }
    }

    /// Returns whether each member is a member of the set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn smismember<K, V>(&self, key: K, members: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.smismember::<(), K, V>(key, members).await,
            Segment::Atomic(segment) => segment.smismember::<(), K, V>(key, members).await,
        }
    }

    /// Returns all the members of the set value stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn smembers<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.smembers::<(), K>(key).await,
            Segment::Atomic(segment) => segment.smembers::<(), K>(key).await,
        }
    }

    /// Move `member` from the set at `source` to the set at `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn smove<S, D, V>(&self, source: S, dest: D, member: V) -> Result<(), Error>
    where
        S: Into<Key> + Send,
        D: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.smove::<(), S, D, V>(source, dest, member).await,
            Segment::Atomic(segment) => segment.smove::<(), S, D, V>(source, dest, member).await,
        }
    }

    /// Removes and returns one or more random members from the set value store at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn spop<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.spop::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.spop::<(), K>(key, count).await,
        }
    }

    /// When called with just the key argument, return a random element from the set value stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn srandmember<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.srandmember::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.srandmember::<(), K>(key, count).await,
        }
    }

    /// Remove the specified members from the set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn srem<K, V>(&self, key: K, members: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.srem::<(), K, V>(key, members).await,
            Segment::Atomic(segment) => segment.srem::<(), K, V>(key, members).await,
        }
    }

    /// Returns the members of the set resulting from the union of all the given sets.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sunion<K>(&self, keys: K) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sunion::<(), K>(keys).await,
            Segment::Atomic(segment) => segment.sunion::<(), K>(keys).await,
        }
    }

    /// This command is equal to SUNION, but instead of returning the resulting set, it is stored in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn sunionstore<D, K>(&self, dest: D, keys: K) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.sunionstore::<(), D, K>(dest, keys).await,
            Segment::Atomic(segment) => segment.sunionstore::<(), D, K>(dest, keys).await,
        }
    }

    /// Adds all the specified members with the specified scores to the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zadd<K, V>(
        &self,
        key: K,
        options: Option<SetOptions>,
        ordering: Option<Ordering>,
        changed: bool,
        incr: bool,
        values: V,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleZaddValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zadd::<(), K, V>(key, options, ordering, changed, incr, values)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zadd::<(), K, V>(key, options, ordering, changed, incr, values)
                    .await
            }
        }
    }

    /// Returns the sorted set cardinality (number of elements) of the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zcard<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zcard::<(), K>(key).await,
            Segment::Atomic(segment) => segment.zcard::<(), K>(key).await,
        }
    }

    /// Returns the number of elements in the sorted set at `key` with a score between `min` and `max`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zcount<K>(&self, key: K, min: f64, max: f64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zcount::<(), K>(key, min, max).await,
            Segment::Atomic(segment) => segment.zcount::<(), K>(key, min, max).await,
        }
    }

    /// This command is similar to ZDIFFSTORE, but instead of storing the resulting sorted set, it is returned to the client.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zdiff<K>(&self, keys: K, withscores: bool) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zdiff::<(), K>(keys, withscores).await,
            Segment::Atomic(segment) => segment.zdiff::<(), K>(keys, withscores).await,
        }
    }

    /// Computes the difference between the first and all successive input sorted sets and stores the result in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zdiffstore<D, K>(&self, dest: D, keys: K) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zdiffstore::<(), D, K>(dest, keys).await,
            Segment::Atomic(segment) => segment.zdiffstore::<(), D, K>(dest, keys).await,
        }
    }

    /// Increments the score of `member` in the sorted set stored at `key` by `increment`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zincrby<K, V>(&self, key: K, increment: f64, member: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zincrby::<(), K, V>(key, increment, member).await,
            Segment::Atomic(segment) => segment.zincrby::<(), K, V>(key, increment, member).await,
        }
    }

    /// This command is similar to ZINTERSTORE, but instead of storing the resulting sorted set, it is returned to the client.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zinter<K, W>(
        &self,
        keys: K,
        weights: W,
        aggregate: Option<AggregateOptions>,
        withscores: bool,
    ) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
        W: Into<MultipleWeights> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zinter::<(), K, W>(keys, weights, aggregate, withscores)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zinter::<(), K, W>(keys, weights, aggregate, withscores)
                    .await
            }
        }
    }

    /// Computes the intersection of the sorted sets given by the specified keys, and stores the result in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zinterstore<D, K, W>(
        &self,
        dest: D,
        keys: K,
        weights: W,
        aggregate: Option<AggregateOptions>,
    ) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
        W: Into<MultipleWeights> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zinterstore::<(), D, K, W>(dest, keys, weights, aggregate)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zinterstore::<(), D, K, W>(dest, keys, weights, aggregate)
                    .await
            }
        }
    }

    /// When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at key with a value between min and max.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zlexcount<K, M, N>(&self, key: K, min: M, max: N) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zlexcount::<(), K, M, N>(key, min, max).await,
            Segment::Atomic(segment) => segment.zlexcount::<(), K, M, N>(key, min, max).await,
        }
    }

    /// Removes and returns up to count members with the highest scores in the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zpopmax<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zpopmax::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.zpopmax::<(), K>(key, count).await,
        }
    }

    /// Removes and returns up to count members with the lowest scores in the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zpopmin<K>(&self, key: K, count: Option<usize>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zpopmin::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.zpopmin::<(), K>(key, count).await,
        }
    }

    /// Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of key names.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zmpop<K>(&self, keys: K, sort: ZCmp, count: Option<i64>) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zmpop::<(), K>(keys, sort, count).await,
            Segment::Atomic(segment) => segment.zmpop::<(), K>(keys, sort, count).await,
        }
    }

    /// When called with just the key argument, return a random element from the sorted set value stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrandmember<K>(&self, key: K, count: Option<(i64, bool)>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zrandmember::<(), K>(key, count).await,
            Segment::Atomic(segment) => segment.zrandmember::<(), K>(key, count).await,
        }
    }

    /// This command is like ZRANGE, but stores the result in the `destination` key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrangestore<D, S, M, N>(
        &self,
        dest: D,
        source: S,
        min: M,
        max: N,
        sort: Option<ZSort>,
        rev: bool,
        limit: Option<Limit>,
    ) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        S: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrangestore::<(), D, S, M, N>(dest, source, min, max, sort, rev, limit)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrangestore::<(), D, S, M, N>(dest, source, min, max, sort, rev, limit)
                    .await
            }
        }
    }

    /// Returns the specified range of elements in the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrange<K, M, N>(
        &self,
        key: K,
        min: M,
        max: N,
        sort: Option<ZSort>,
        rev: bool,
        limit: Option<Limit>,
        withscores: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrange::<(), K, M, N>(key, min, max, sort, rev, limit, withscores)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrange::<(), K, M, N>(key, min, max, sort, rev, limit, withscores)
                    .await
            }
        }
    }

    /// When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at `key` with a value between `min` and `max`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrangebylex<K, M, N>(
        &self,
        key: K,
        min: M,
        max: N,
        limit: Option<Limit>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrangebylex::<(), K, M, N>(key, min, max, limit)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrangebylex::<(), K, M, N>(key, min, max, limit)
                    .await
            }
        }
    }

    /// When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at `key` with a value between `max` and `min`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrevrangebylex<K, M, N>(
        &self,
        key: K,
        max: M,
        min: N,
        limit: Option<Limit>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrevrangebylex::<(), K, M, N>(key, max, min, limit)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrevrangebylex::<(), K, M, N>(key, max, min, limit)
                    .await
            }
        }
    }

    /// Returns all the elements in the sorted set at key with a score between `min` and `max` (including elements with score equal to `min` or `max`).
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrangebyscore<K, M, N>(
        &self,
        key: K,
        min: M,
        max: N,
        withscores: bool,
        limit: Option<Limit>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrangebyscore::<(), K, M, N>(key, min, max, withscores, limit)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrangebyscore::<(), K, M, N>(key, min, max, withscores, limit)
                    .await
            }
        }
    }

    /// Returns all the elements in the sorted set at `key` with a score between `max` and `min` (including elements with score equal to `max` or `min`).
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrevrangebyscore<K, M, N>(
        &self,
        key: K,
        max: M,
        min: N,
        withscores: bool,
        limit: Option<Limit>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrevrangebyscore::<(), K, M, N>(key, max, min, withscores, limit)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrevrangebyscore::<(), K, M, N>(key, max, min, withscores, limit)
                    .await
            }
        }
    }

    /// Returns the rank of member in the sorted set stored at `key`, with the scores ordered from low to high.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrank<K, V>(&self, key: K, member: V, withscore: bool) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zrank::<(), K, V>(key, member, withscore).await,
            Segment::Atomic(segment) => segment.zrank::<(), K, V>(key, member, withscore).await,
        }
    }

    /// Removes the specified members from the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrem<K, V>(&self, key: K, members: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zrem::<(), K, V>(key, members).await,
            Segment::Atomic(segment) => segment.zrem::<(), K, V>(key, members).await,
        }
    }

    /// When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at `key` between the lexicographical range specified by `min` and `max`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zremrangebylex<K, M, N>(&self, key: K, min: M, max: N) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zremrangebylex::<(), K, M, N>(key, min, max).await,
            Segment::Atomic(segment) => segment.zremrangebylex::<(), K, M, N>(key, min, max).await,
        }
    }

    /// Removes all elements in the sorted set stored at `key` with rank between `start` and `stop`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zremrangebyrank<K>(&self, key: K, start: i64, stop: i64) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zremrangebyrank::<(), K>(key, start, stop).await,
            Segment::Atomic(segment) => segment.zremrangebyrank::<(), K>(key, start, stop).await,
        }
    }

    /// Removes all elements in the sorted set stored at `key` with a score between `min` and `max`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zremrangebyscore<K, M, N>(&self, key: K, min: M, max: N) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        M: TryInto<ZRange> + Send,
        M::Error: Into<Error> + Send,
        N: TryInto<ZRange> + Send,
        N::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zremrangebyscore::<(), K, M, N>(key, min, max).await,
            Segment::Atomic(segment) => {
                segment.zremrangebyscore::<(), K, M, N>(key, min, max).await
            }
        }
    }

    /// Returns the specified range of elements in the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrevrange<K>(
        &self,
        key: K,
        start: i64,
        stop: i64,
        withscores: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zrevrange::<(), K>(key, start, stop, withscores)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zrevrange::<(), K>(key, start, stop, withscores)
                    .await
            }
        }
    }

    /// Returns the rank of `member` in the sorted set stored at `key`, with the scores ordered from high to low.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zrevrank<K, V>(&self, key: K, member: V, withscore: bool) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zrevrank::<(), K, V>(key, member, withscore).await,
            Segment::Atomic(segment) => segment.zrevrank::<(), K, V>(key, member, withscore).await,
        }
    }

    /// Returns the score of `member` in the sorted set at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zscore<K, V>(&self, key: K, member: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zscore::<(), K, V>(key, member).await,
            Segment::Atomic(segment) => segment.zscore::<(), K, V>(key, member).await,
        }
    }

    /// This command is similar to ZUNIONSTORE, but instead of storing the resulting sorted set, it is returned to the client.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zunion<K, W>(
        &self,
        keys: K,
        weights: W,
        aggregate: Option<AggregateOptions>,
        withscores: bool,
    ) -> Result<(), Error>
    where
        K: Into<MultipleKeys> + Send,
        W: Into<MultipleWeights> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zunion::<(), K, W>(keys, weights, aggregate, withscores)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zunion::<(), K, W>(keys, weights, aggregate, withscores)
                    .await
            }
        }
    }

    /// Computes the union of the sorted sets given by the specified keys, and stores the result in `destination`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zunionstore<D, K, W>(
        &self,
        dest: D,
        keys: K,
        weights: W,
        aggregate: Option<AggregateOptions>,
    ) -> Result<(), Error>
    where
        D: Into<Key> + Send,
        K: Into<MultipleKeys> + Send,
        W: Into<MultipleWeights> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .zunionstore::<(), D, K, W>(dest, keys, weights, aggregate)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .zunionstore::<(), D, K, W>(dest, keys, weights, aggregate)
                    .await
            }
        }
    }

    /// Returns the scores associated with the specified members in the sorted set stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn zmscore<K, V>(&self, key: K, members: V) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.zmscore::<(), K, V>(key, members).await,
            Segment::Atomic(segment) => segment.zmscore::<(), K, V>(key, members).await,
        }
    }

    /// This command returns the list of consumers that belong to the `groupname` consumer group of the stream stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xinfo_consumers<K, S>(&self, key: K, groupname: S) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xinfo_consumers::<(), K, S>(key, groupname).await,
            Segment::Atomic(segment) => segment.xinfo_consumers::<(), K, S>(key, groupname).await,
        }
    }

    /// This command returns the list of all consumers groups of the stream stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xinfo_groups<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xinfo_groups::<(), K>(key).await,
            Segment::Atomic(segment) => segment.xinfo_groups::<(), K>(key).await,
        }
    }

    /// This command returns information about the stream stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xinfo_stream<K>(&self, key: K, full: bool, count: Option<u64>) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xinfo_stream::<(), K>(key, full, count).await,
            Segment::Atomic(segment) => segment.xinfo_stream::<(), K>(key, full, count).await,
        }
    }

    /// Appends the specified stream entry to the stream at the specified key.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xadd<K, C, I, F>(
        &self,
        key: K,
        nomkstream: bool,
        cap: C,
        id: I,
        fields: F,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        I: Into<XID> + Send,
        F: TryInto<MultipleOrderedPairs> + Send,
        F::Error: Into<Error> + Send,
        C: TryInto<XCap> + Send,
        C::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xadd::<(), K, C, I, F>(key, nomkstream, cap, id, fields)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xadd::<(), K, C, I, F>(key, nomkstream, cap, id, fields)
                    .await
            }
        }
    }

    /// Trims the stream by evicting older entries (entries with lower IDs) if needed.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xtrim<K, C>(&self, key: K, cap: C) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        C: TryInto<XCap> + Send,
        C::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xtrim::<(), K, C>(key, cap).await,
            Segment::Atomic(segment) => segment.xtrim::<(), K, C>(key, cap).await,
        }
    }

    /// Removes the specified entries from a stream, and returns the number of entries deleted.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xdel<K, S>(&self, key: K, ids: S) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<MultipleStrings> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xdel::<(), K, S>(key, ids).await,
            Segment::Atomic(segment) => segment.xdel::<(), K, S>(key, ids).await,
        }
    }

    /// The command returns the stream entries matching a given range of IDs.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xrange<K, S, E>(
        &self,
        key: K,
        start: S,
        end: E,
        count: Option<u64>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: TryInto<Value> + Send,
        S::Error: Into<Error> + Send,
        E: TryInto<Value> + Send,
        E::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xrange::<(), K, S, E>(key, start, end, count).await,
            Segment::Atomic(segment) => segment.xrange::<(), K, S, E>(key, start, end, count).await,
        }
    }

    /// Similar to `XRANGE`, but with the results returned in reverse order.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xrevrange<K, S, E>(
        &self,
        key: K,
        end: E,
        start: S,
        count: Option<u64>,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: TryInto<Value> + Send,
        S::Error: Into<Error> + Send,
        E: TryInto<Value> + Send,
        E::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xrevrange::<(), K, S, E>(key, end, start, count)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xrevrange::<(), K, S, E>(key, end, start, count)
                    .await
            }
        }
    }

    /// Returns the number of entries inside a stream.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xlen<K>(&self, key: K) -> Result<(), Error>
    where
        K: Into<Key> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xlen::<(), K>(key).await,
            Segment::Atomic(segment) => segment.xlen::<(), K>(key).await,
        }
    }

    /// This command creates a new consumer group uniquely identified by `groupname` for the stream stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xgroup_create<K, S, I>(
        &self,
        key: K,
        groupname: S,
        id: I,
        mkstream: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<Str> + Send,
        I: Into<XID> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xgroup_create::<(), K, S, I>(key, groupname, id, mkstream)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xgroup_create::<(), K, S, I>(key, groupname, id, mkstream)
                    .await
            }
        }
    }

    /// Create a consumer named `consumername` in the consumer group `groupname` of the stream that's stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xgroup_createconsumer<K, G, C>(
        &self,
        key: K,
        groupname: G,
        consumername: C,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        C: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xgroup_createconsumer::<(), K, G, C>(key, groupname, consumername)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xgroup_createconsumer::<(), K, G, C>(key, groupname, consumername)
                    .await
            }
        }
    }

    /// Delete a consumer named `consumername` in the consumer group `groupname` of the stream that's stored at `key`.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xgroup_delconsumer<K, G, C>(
        &self,
        key: K,
        groupname: G,
        consumername: C,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        C: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xgroup_delconsumer::<(), K, G, C>(key, groupname, consumername)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xgroup_delconsumer::<(), K, G, C>(key, groupname, consumername)
                    .await
            }
        }
    }

    /// Completely destroy a consumer group.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xgroup_destroy<K, S>(&self, key: K, groupname: S) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xgroup_destroy::<(), K, S>(key, groupname).await,
            Segment::Atomic(segment) => segment.xgroup_destroy::<(), K, S>(key, groupname).await,
        }
    }

    /// Set the last delivered ID for a consumer group.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xgroup_setid<K, S, I>(&self, key: K, groupname: S, id: I) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        S: Into<Str> + Send,
        I: Into<XID> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xgroup_setid::<(), K, S, I>(key, groupname, id)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xgroup_setid::<(), K, S, I>(key, groupname, id)
                    .await
            }
        }
    }

    /// Remove one or more messages from the Pending Entries List (PEL) of a stream consumer group.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xack<K, G, I>(&self, key: K, group: G, ids: I) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        I: Into<MultipleIDs> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xack::<(), K, G, I>(key, group, ids).await,
            Segment::Atomic(segment) => segment.xack::<(), K, G, I>(key, group, ids).await,
        }
    }

    /// In the context of a stream consumer group, this command changes the ownership of a pending message, so that the new owner is the consumer specified as the command argument.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xclaim<K, G, C, I>(
        &self,
        key: K,
        group: G,
        consumer: C,
        min_idle_time: u64,
        ids: I,
        idle: Option<u64>,
        time: Option<u64>,
        retry_count: Option<u64>,
        force: bool,
        justid: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        C: Into<Str> + Send,
        I: Into<MultipleIDs> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xclaim::<(), K, G, C, I>(
                        key,
                        group,
                        consumer,
                        min_idle_time,
                        ids,
                        idle,
                        time,
                        retry_count,
                        force,
                        justid,
                    )
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xclaim::<(), K, G, C, I>(
                        key,
                        group,
                        consumer,
                        min_idle_time,
                        ids,
                        idle,
                        time,
                        retry_count,
                        force,
                        justid,
                    )
                    .await
            }
        }
    }

    /// This command transfers ownership of pending stream entries that match the specified criteria.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xautoclaim<K, G, C, I>(
        &self,
        key: K,
        group: G,
        consumer: C,
        min_idle_time: u64,
        start: I,
        count: Option<u64>,
        justid: bool,
    ) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        C: Into<Str> + Send,
        I: Into<XID> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .xautoclaim::<(), K, G, C, I>(
                        key,
                        group,
                        consumer,
                        min_idle_time,
                        start,
                        count,
                        justid,
                    )
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .xautoclaim::<(), K, G, C, I>(
                        key,
                        group,
                        consumer,
                        min_idle_time,
                        start,
                        count,
                        justid,
                    )
                    .await
            }
        }
    }

    /// Inspect the list of pending messages in a consumer group.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn xpending<K, G, A>(&self, key: K, group: G, args: A) -> Result<(), Error>
    where
        K: Into<Key> + Send,
        G: Into<Str> + Send,
        A: Into<XPendingArgs> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.xpending::<(), K, G, A>(key, group, args).await,
            Segment::Atomic(segment) => segment.xpending::<(), K, G, A>(key, group, args).await,
        }
    }

    /// Invoke a function.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn fcall<F, K, V>(&self, func: F, keys: K, args: V) -> Result<(), Error>
    where
        F: Into<Str> + Send,
        K: Into<MultipleKeys> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.fcall::<(), F, K, V>(func, keys, args).await,
            Segment::Atomic(segment) => segment.fcall::<(), F, K, V>(func, keys, args).await,
        }
    }

    /// This is a read-only variant of the FCALL command that cannot execute commands that modify data.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn fcall_ro<F, K, V>(&self, func: F, keys: K, args: V) -> Result<(), Error>
    where
        F: Into<Str> + Send,
        K: Into<MultipleKeys> + Send,
        V: TryInto<MultipleValues> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.fcall_ro::<(), F, K, V>(func, keys, args).await,
            Segment::Atomic(segment) => segment.fcall_ro::<(), F, K, V>(func, keys, args).await,
        }
    }

    /// Delete a library and all its functions.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_delete<S>(&self, library_name: S) -> Result<(), Error>
    where
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_delete::<(), S>(library_name).await,
            Segment::Atomic(segment) => segment.function_delete::<(), S>(library_name).await,
        }
    }

    /// Return the serialized payload of loaded libraries.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_dump(&self) -> Result<(), Error> {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_dump::<()>().await,
            Segment::Atomic(segment) => segment.function_dump::<()>().await,
        }
    }

    /// Deletes all the libraries.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_flush(&self, r#async: bool) -> Result<(), Error> {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_flush::<()>(r#async).await,
            Segment::Atomic(segment) => segment.function_flush::<()>(r#async).await,
        }
    }

    /// Return information about the functions and libraries.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_list<S>(
        &self,
        library_name: Option<S>,
        withcode: bool,
    ) -> Result<(), Error>
    where
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_list::<(), S>(library_name, withcode).await,
            Segment::Atomic(segment) => {
                segment.function_list::<(), S>(library_name, withcode).await
            }
        }
    }

    /// Load a library to Redis.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_load<S>(&self, replace: bool, code: S) -> Result<(), Error>
    where
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_load::<(), S>(replace, code).await,
            Segment::Atomic(segment) => segment.function_load::<(), S>(replace, code).await,
        }
    }

    /// Restore libraries from the serialized payload.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_restore<B, P>(&self, serialized: B, policy: P) -> Result<(), Error>
    where
        B: Into<Bytes> + Send,
        P: TryInto<FnPolicy> + Send,
        P::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => {
                segment
                    .function_restore::<(), B, P>(serialized, policy)
                    .await
            }
            Segment::Atomic(segment) => {
                segment
                    .function_restore::<(), B, P>(serialized, policy)
                    .await
            }
        }
    }

    /// Return information about the function that's currently running and information about the available execution engines.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn function_stats(&self) -> Result<(), Error> {
        match self.segment().await? {
            Segment::Plain(segment) => segment.function_stats::<()>().await,
            Segment::Atomic(segment) => segment.function_stats::<()>().await,
        }
    }

    /// Publish a message on the PubSub interface, returning the number of clients that received the message.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn publish<S, V>(&self, channel: S, message: V) -> Result<(), Error>
    where
        S: Into<Str> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.publish::<(), S, V>(channel, message).await,
            Segment::Atomic(segment) => segment.publish::<(), S, V>(channel, message).await,
        }
    }

    /// Posts a message to the given shard channel.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn spublish<S, V>(&self, channel: S, message: V) -> Result<(), Error>
    where
        S: Into<Str> + Send,
        V: TryInto<Value> + Send,
        V::Error: Into<Error> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.spublish::<(), S, V>(channel, message).await,
            Segment::Atomic(segment) => segment.spublish::<(), S, V>(channel, message).await,
        }
    }

    /// Lists the currently active channels.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pubsub_channels<S>(&self, pattern: S) -> Result<(), Error>
    where
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pubsub_channels::<(), S>(pattern).await,
            Segment::Atomic(segment) => segment.pubsub_channels::<(), S>(pattern).await,
        }
    }

    /// Returns the number of unique patterns that are subscribed to by clients.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pubsub_numpat(&self) -> Result<(), Error> {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pubsub_numpat::<()>().await,
            Segment::Atomic(segment) => segment.pubsub_numpat::<()>().await,
        }
    }

    /// Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pubsub_numsub<S>(&self, channels: S) -> Result<(), Error>
    where
        S: Into<MultipleStrings> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pubsub_numsub::<(), S>(channels).await,
            Segment::Atomic(segment) => segment.pubsub_numsub::<(), S>(channels).await,
        }
    }

    /// Lists the currently active shard channels.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pubsub_shardchannels<S>(&self, pattern: S) -> Result<(), Error>
    where
        S: Into<Str> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pubsub_shardchannels::<(), S>(pattern).await,
            Segment::Atomic(segment) => segment.pubsub_shardchannels::<(), S>(pattern).await,
        }
    }

    /// Returns the number of subscribers for the specified shard channels.
    ///
    /// Queued into this delivery's segment; it runs after the handler returns, when
    /// the delivery is acknowledged.
    pub async fn pubsub_shardnumsub<S>(&self, channels: S) -> Result<(), Error>
    where
        S: Into<MultipleStrings> + Send,
    {
        match self.segment().await? {
            Segment::Plain(segment) => segment.pubsub_shardnumsub::<(), S>(channels).await,
            Segment::Atomic(segment) => segment.pubsub_shardnumsub::<(), S>(channels).await,
        }
    }
}