@upstash/redis 0.0.0-ci.f79c0d6d7212dfe450359da7ed92d84d639af819-20231031072701 → 0.0.0-ci.fa1d496e56b9c6b274a4edb64a8fbcbcb5d5080b-20251205201758

package/{zmscore-10fd3773.d.ts → zmscore-DhpQcqpW.d.mts}

@@ -23,7 +23,10 @@ type RedisOptions = {
      * @default true
      */
     automaticDeserialization?: boolean;
+    latencyLogging?: boolean;
     enableTelemetry?: boolean;
+    enableAutoPipelining?: boolean;
+    readYourWrites?: boolean;
 };
 
 type CacheSetting = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
@@ -33,12 +36,37 @@ type UpstashRequest = {
      * Request body will be serialized to json
      */
     body?: unknown;
+    /**
+     * Additional headers for the request
+     */
+    headers?: Record<string, string>;
+    upstashSyncToken?: string;
+    /**
+     * Callback for handling streaming messages
+     */
+    onMessage?: (data: string) => void;
+    /**
+     * Whether this request expects a streaming response
+     */
+    isStreaming?: boolean;
+    /**
+     * Abort signal for the request
+     */
+    signal?: AbortSignal;
 };
 type UpstashResponse<TResult> = {
     result?: TResult;
     error?: string;
 };
 interface Requester {
+    /**
+     * When this flag is enabled, any subsequent commands issued by this client are guaranteed to observe the effects of all earlier writes submitted by the same client.
+     */
+    readYourWrites?: boolean;
+    /**
+     * This token is used to ensure that the client is in sync with the server. On each request, we send this token in the header, and the server will return a new token.
+     */
+    upstashSyncToken?: string;
     request: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>;
 }
 type RetryConfig = false | {
@@ -49,7 +77,7 @@ type RetryConfig = false | {
      */
     retries?: number;
     /**
-     * A backoff function receives the current retry cound and returns a number in milliseconds to wait before retrying.
+     * A backoff function receives the current retry count and returns a number in milliseconds to wait before retrying.
      *
      * @default
      * ```ts
@@ -58,6 +86,9 @@ type RetryConfig = false | {
      */
     backoff?: (retryCount: number) => number;
 };
+type Options$1 = {
+    backend?: string;
+};
 type RequesterConfig = {
     /**
      * Configure the retry behaviour in case of network errors
@@ -92,6 +123,19 @@ type RequesterConfig = {
      */
     cache?: CacheSetting;
 };
+type HttpClientConfig = {
+    headers?: Record<string, string>;
+    baseUrl: string;
+    options?: Options$1;
+    retry?: RetryConfig;
+    agent?: any;
+    signal?: AbortSignal | (() => AbortSignal);
+    keepAlive?: boolean;
+    /**
+     * When this flag is enabled, any subsequent commands issued by this client are guaranteed to observe the effects of all earlier writes submitted by the same client.
+     */
+    readYourWrites?: boolean;
+} & RequesterConfig;
 
 type Serialize = (data: unknown) => string | number | boolean;
 type Deserialize<TResult, TData> = (result: TResult) => TData;
@@ -106,6 +150,32 @@ type CommandOptions<TResult, TData> = {
      * @default true
      */
     automaticDeserialization?: boolean;
+    latencyLogging?: boolean;
+    /**
+     * Additional headers to be sent with the request
+     */
+    headers?: Record<string, string>;
+    /**
+     * Path to append to the URL
+     */
+    path?: string[];
+    /**
+     * Options for streaming requests, mainly used for subscribe, monitor commands
+     **/
+    streamOptions?: {
+        /**
+         * Callback to be called when a message is received
+         */
+        onMessage?: (data: string) => void;
+        /**
+         * Whether the request is streaming
+         */
+        isStreaming?: boolean;
+        /**
+         * Signal to abort the request
+         */
+        signal?: AbortSignal;
+    };
 };
 /**
  * Command offers default (de)serialization and the exec method to all commands.
@@ -117,6 +187,11 @@ declare class Command<TResult, TData> {
     readonly command: (string | number | boolean)[];
     readonly serialize: Serialize;
     readonly deserialize: Deserialize<TResult, TData>;
+    protected readonly headers?: Record<string, string>;
+    protected readonly path?: string[];
+    protected readonly onMessage?: (data: string) => void;
+    protected readonly isStreaming: boolean;
+    protected readonly signal?: AbortSignal;
     /**
      * Create a new command instance.
      *
@@ -212,18 +287,6 @@ declare class ScriptFlushCommand extends Command<"OK", "OK"> {
     constructor([opts]: [opts?: ScriptFlushCommandOptions], cmdOpts?: CommandOptions<"OK", "OK">);
 }
 
-type ScanCommandOptions = {
-    match?: string;
-    count?: number;
-    type?: string;
-};
-/**
- * @see https://redis.io/commands/scan
- */
-declare class ScanCommand extends Command<[number, string[]], [number, string[]]> {
-    constructor([cursor, opts]: [cursor: number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[number, string[]], [number, string[]]>);
-}
-
 type GeoAddCommandOptions = {
     nx?: boolean;
     xx?: never;
@@ -233,11 +296,11 @@ type GeoAddCommandOptions = {
 } & {
     ch?: boolean;
 });
-interface GeoMember<TMemberType> {
+type GeoMember<TMemberType> = {
     latitude: number;
     longitude: number;
     member: TMemberType;
-}
+};
 /**
  * @see https://redis.io/commands/geoadd
  */
@@ -249,6 +312,11 @@ declare class GeoAddCommand<TMemberType = string> extends Command<number | null,
     ], opts?: CommandOptions<number | null, number | null>);
 }
 
+type ExpireOption = "NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt";
+declare class ExpireCommand extends Command<"0" | "1", 0 | 1> {
+    constructor(cmd: [key: string, seconds: number, option?: ExpireOption], opts?: CommandOptions<"0" | "1", 0 | 1>);
+}
+
 /**
  * @see https://redis.io/commands/append
  */
@@ -264,6 +332,28 @@ declare class BitCountCommand extends Command<number, number> {
     constructor(cmd: [key: string, start: number, end: number], opts?: CommandOptions<number, number>);
 }
 
+type SubCommandArgs<TRest extends unknown[] = []> = [
+    encoding: string,
+    offset: number | string,
+    ...rest: TRest
+];
+/**
+ * @see https://redis.io/commands/bitfield
+ */
+declare class BitFieldCommand<T = Promise<number[]>> {
+    private client;
+    private opts?;
+    private execOperation;
+    private command;
+    constructor(args: [key: string], client: Requester, opts?: CommandOptions<number[], number[]> | undefined, execOperation?: (command: Command<number[], number[]>) => T);
+    private chain;
+    get(...args: SubCommandArgs): this;
+    set(...args: SubCommandArgs<[value: number]>): this;
+    incrby(...args: SubCommandArgs<[increment: number]>): this;
+    overflow(overflow: "WRAP" | "SAT" | "FAIL"): this;
+    exec(): T;
+}
+
 /**
  * @see https://redis.io/commands/bitop
  */
@@ -323,6 +413,13 @@ declare class EchoCommand extends Command<string, string> {
     constructor(cmd: [message: string], opts?: CommandOptions<string, string>);
 }
 
+/**
+ * @see https://redis.io/commands/eval_ro
+ */
+declare class EvalROCommand<TArgs extends unknown[], TData> extends Command<unknown, TData> {
+    constructor([script, keys, args]: [script: string, keys: string[], args: TArgs], opts?: CommandOptions<unknown, TData>);
+}
+
 /**
  * @see https://redis.io/commands/eval
  */
@@ -330,6 +427,13 @@ declare class EvalCommand<TArgs extends unknown[], TData> extends Command<unknow
     constructor([script, keys, args]: [script: string, keys: string[], args: TArgs], opts?: CommandOptions<unknown, TData>);
 }
 
+/**
+ * @see https://redis.io/commands/evalsha_ro
+ */
+declare class EvalshaROCommand<TArgs extends unknown[], TData> extends Command<unknown, TData> {
+    constructor([sha, keys, args]: [sha: string, keys: string[], args?: TArgs], opts?: CommandOptions<unknown, TData>);
+}
+
 /**
  * @see https://redis.io/commands/evalsha
  */
@@ -344,18 +448,11 @@ declare class ExistsCommand extends Command<number, number> {
     constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>);
 }
 
-/**
- * @see https://redis.io/commands/expire
- */
-declare class ExpireCommand extends Command<"0" | "1", 0 | 1> {
-    constructor(cmd: [key: string, seconds: number], opts?: CommandOptions<"0" | "1", 0 | 1>);
-}
-
 /**
  * @see https://redis.io/commands/expireat
  */
 declare class ExpireAtCommand extends Command<"0" | "1", 0 | 1> {
-    constructor(cmd: [key: string, unix: number], opts?: CommandOptions<"0" | "1", 0 | 1>);
+    constructor(cmd: [key: string, unix: number, option?: ExpireOption], opts?: CommandOptions<"0" | "1", 0 | 1>);
 }
 
 /**
@@ -388,6 +485,13 @@ declare class GeoDistCommand<TMemberType = string> extends Command<number | null
     ], opts?: CommandOptions<number | null, number | null>);
 }
 
+/**
+ * @see https://redis.io/commands/geohash
+ */
+declare class GeoHashCommand<TMember = string> extends Command<(string | null)[], (string | null)[]> {
+    constructor(cmd: [string, ...TMember[]], opts?: CommandOptions<(string | null)[], (string | null)[]>);
+}
+
 type Coordinates = {
     lng: number;
     lat: number;
@@ -399,13 +503,6 @@ declare class GeoPosCommand<TMember = string> extends Command<(string | null)[][
     constructor(cmd: [string, ...(TMember[] | TMember[])], opts?: CommandOptions<(string | null)[][], Coordinates[]>);
 }
 
-/**
- * @see https://redis.io/commands/geohash
- */
-declare class GeoHashCommand<TMember = string> extends Command<(string | null)[], (string | null)[]> {
-    constructor(cmd: [string, ...(TMember[] | TMember[])], opts?: CommandOptions<(string | null)[], (string | null)[]>);
-}
-
 type RadiusOptions$1 = "M" | "KM" | "FT" | "MI";
 type CenterPoint$1<TMemberType> = {
     type: "FROMMEMBER" | "frommember";
@@ -530,6 +627,50 @@ declare class GetDelCommand<TData = string> extends Command<unknown | null, TDat
     constructor(cmd: [key: string], opts?: CommandOptions<unknown | null, TData | null>);
 }
 
+type GetExCommandOptions = {
+    ex: number;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist?: never;
+} | {
+    ex?: never;
+    px: number;
+    exat?: never;
+    pxat?: never;
+    persist?: never;
+} | {
+    ex?: never;
+    px?: never;
+    exat: number;
+    pxat?: never;
+    persist?: never;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat: number;
+    persist?: never;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist: true;
+} | {
+    ex?: never;
+    px?: never;
+    exat?: never;
+    pxat?: never;
+    persist?: never;
+};
+/**
+ * @see https://redis.io/commands/getex
+ */
+declare class GetExCommand<TData = string> extends Command<unknown | null, TData | null> {
+    constructor([key, opts]: [key: string, opts?: GetExCommandOptions], cmdOpts?: CommandOptions<unknown | null, TData | null>);
+}
+
 /**
  * @see https://redis.io/commands/getrange
  */
@@ -558,6 +699,58 @@ declare class HExistsCommand extends Command<number, number> {
     constructor(cmd: [key: string, field: string], opts?: CommandOptions<number, number>);
 }
 
+declare class HExpireCommand extends Command<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]> {
+    constructor(cmd: [
+        key: string,
+        fields: (string | number) | (string | number)[],
+        seconds: number,
+        option?: ExpireOption
+    ], opts?: CommandOptions<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]>);
+}
+
+declare class HExpireAtCommand extends Command<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]> {
+    constructor(cmd: [
+        key: string,
+        fields: (string | number) | (string | number)[],
+        timestamp: number,
+        option?: ExpireOption
+    ], opts?: CommandOptions<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]>);
+}
+
+declare class HExpireTimeCommand extends Command<number[], number[]> {
+    constructor(cmd: [key: string, fields: (string | number) | (string | number)[]], opts?: CommandOptions<number[], number[]>);
+}
+
+declare class HPersistCommand extends Command<(-2 | -1 | 1)[], (-2 | -1 | 1)[]> {
+    constructor(cmd: [key: string, fields: (string | number) | (string | number)[]], opts?: CommandOptions<(-2 | -1 | 1)[], (-2 | -1 | 1)[]>);
+}
+
+declare class HPExpireCommand extends Command<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]> {
+    constructor(cmd: [
+        key: string,
+        fields: (string | number) | (string | number)[],
+        milliseconds: number,
+        option?: ExpireOption
+    ], opts?: CommandOptions<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]>);
+}
+
+declare class HPExpireAtCommand extends Command<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]> {
+    constructor(cmd: [
+        key: string,
+        fields: (string | number) | (string | number)[],
+        timestamp: number,
+        option?: ExpireOption
+    ], opts?: CommandOptions<(-2 | 0 | 1 | 2)[], (-2 | 0 | 1 | 2)[]>);
+}
+
+declare class HPExpireTimeCommand extends Command<number[], number[]> {
+    constructor(cmd: [key: string, fields: (string | number) | (string | number)[]], opts?: CommandOptions<number[], number[]>);
+}
+
+declare class HPTtlCommand extends Command<number[], number[]> {
+    constructor(cmd: [key: string, fields: (string | number) | (string | number)[]], opts?: CommandOptions<number[], number[]>);
+}
+
 /**
  * @see https://redis.io/commands/hget
  */
@@ -619,9 +812,7 @@ declare class HMGetCommand<TData extends Record<string, unknown>> extends Comman
  * @see https://redis.io/commands/hmset
  */
 declare class HMSetCommand<TData> extends Command<"OK", "OK"> {
-    constructor([key, kv]: [key: string, kv: {
-        [field: string]: TData;
-    }], opts?: CommandOptions<"OK", "OK">);
+    constructor([key, kv]: [key: string, kv: Record<string, TData>], opts?: CommandOptions<"OK", "OK">);
 }
 
 /**
@@ -633,26 +824,57 @@ declare class HRandFieldCommand<TData extends string | string[] | Record<string,
     constructor(cmd: [key: string, count: number, withValues: boolean], opts?: CommandOptions<string[], Partial<TData>>);
 }
 
+type ScanCommandOptionsStandard = {
+    match?: string;
+    count?: number;
+    type?: string;
+    withType?: false;
+};
+type ScanCommandOptionsWithType = {
+    match?: string;
+    count?: number;
+    /**
+     * Includes types of each key in the result
+     *
+     * @example
+     * ```typescript
+     * await redis.scan("0", { withType: true })
+     * // ["0", [{ key: "key1", type: "string" }, { key: "key2", type: "list" }]]
+     * ```
+     */
+    withType: true;
+};
+type ScanCommandOptions = ScanCommandOptionsStandard | ScanCommandOptionsWithType;
+type ScanResultStandard = [string, string[]];
+type ScanResultWithType = [string, {
+    key: string;
+    type: string;
+}[]];
+/**
+ * @see https://redis.io/commands/scan
+ */
+declare class ScanCommand<TData = ScanResultStandard> extends Command<[string, string[]], TData> {
+    constructor([cursor, opts]: [cursor: string | number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[string, string[]], TData>);
+}
+
 /**
  * @see https://redis.io/commands/hscan
  */
 declare class HScanCommand extends Command<[
-    number,
+    string,
     (string | number)[]
 ], [
-    number,
+    string,
     (string | number)[]
 ]> {
-    constructor([key, cursor, cmdOpts]: [key: string, cursor: number, cmdOpts?: ScanCommandOptions], opts?: CommandOptions<[number, (string | number)[]], [number, (string | number)[]]>);
+    constructor([key, cursor, cmdOpts]: [key: string, cursor: string | number, cmdOpts?: ScanCommandOptions], opts?: CommandOptions<[string, (string | number)[]], [string, (string | number)[]]>);
 }
 
 /**
  * @see https://redis.io/commands/hset
  */
 declare class HSetCommand<TData> extends Command<number, number> {
-    constructor([key, kv]: [key: string, kv: {
-        [field: string]: TData;
-    }], opts?: CommandOptions<number, number>);
+    constructor([key, kv]: [key: string, kv: Record<string, TData>], opts?: CommandOptions<number, number>);
 }
 
 /**
@@ -669,6 +891,10 @@ declare class HStrLenCommand extends Command<number, number> {
     constructor(cmd: [key: string, field: string], opts?: CommandOptions<number, number>);
 }
 
+declare class HTtlCommand extends Command<number[], number[]> {
+    constructor(cmd: [key: string, fields: (string | number) | (string | number)[]], opts?: CommandOptions<number[], number[]>);
+}
+
 /**
  * @see https://redis.io/commands/hvals
  */
@@ -775,13 +1001,31 @@ declare class JsonGetCommand<TData extends (unknown | Record<string, unknown>) |
     ] | [key: string, ...path: string[]], opts?: CommandOptions<TData | null, TData | null>);
 }
 
+/**
+ * @see https://redis.io/commands/json.merge
+ */
+declare class JsonMergeCommand<TData extends string | number | Record<string, unknown> | Array<unknown>> extends Command<"OK" | null, "OK" | null> {
+    constructor(cmd: [key: string, path: string, value: TData], opts?: CommandOptions<"OK" | null, "OK" | null>);
+}
+
 /**
  * @see https://redis.io/commands/json.mget
  */
-declare class JsonMGetCommand<TData extends (unknown | Record<string, unknown>)[]> extends Command<TData, TData> {
+declare class JsonMGetCommand<TData = unknown[]> extends Command<TData, TData> {
     constructor(cmd: [keys: string[], path: string], opts?: CommandOptions<TData, TData>);
 }
 
+/**
+ * @see https://redis.io/commands/json.mset
+ */
+declare class JsonMSetCommand<TData extends number | string | boolean | Record<string, unknown> | (number | string | boolean | Record<string, unknown>)[]> extends Command<"OK" | null, "OK" | null> {
+    constructor(cmd: {
+        key: string;
+        path: string;
+        value: TData;
+    }[], opts?: CommandOptions<"OK" | null, "OK" | null>);
+}
+
 /**
  * @see https://redis.io/commands/json.numincrby
  */
@@ -938,25 +1182,21 @@ declare class LTrimCommand extends Command<"OK", "OK"> {
  * @see https://redis.io/commands/mget
  */
 declare class MGetCommand<TData extends unknown[]> extends Command<(string | null)[], TData> {
-    constructor(cmd: [string[]] | [...(string[] | string[])], opts?: CommandOptions<(string | null)[], TData>);
+    constructor(cmd: [string[]] | [...string[]], opts?: CommandOptions<(string | null)[], TData>);
 }
 
 /**
  * @see https://redis.io/commands/mset
  */
 declare class MSetCommand<TData> extends Command<"OK", "OK"> {
-    constructor([kv]: [kv: {
-        [key: string]: TData;
-    }], opts?: CommandOptions<"OK", "OK">);
+    constructor([kv]: [kv: Record<string, TData>], opts?: CommandOptions<"OK", "OK">);
 }
 
 /**
  * @see https://redis.io/commands/msetnx
  */
 declare class MSetNXCommand<TData = string> extends Command<number, number> {
-    constructor([kv]: [kv: {
-        [key: string]: TData;
-    }], opts?: CommandOptions<number, number>);
+    constructor([kv]: [kv: Record<string, TData>], opts?: CommandOptions<number, number>);
 }
 
 /**
@@ -970,14 +1210,14 @@ declare class PersistCommand extends Command<"0" | "1", 0 | 1> {
  * @see https://redis.io/commands/pexpire
  */
 declare class PExpireCommand extends Command<"0" | "1", 0 | 1> {
-    constructor(cmd: [key: string, milliseconds: number], opts?: CommandOptions<"0" | "1", 0 | 1>);
+    constructor(cmd: [key: string, milliseconds: number, option?: ExpireOption], opts?: CommandOptions<"0" | "1", 0 | 1>);
 }
 
 /**
  * @see https://redis.io/commands/pexpireat
  */
 declare class PExpireAtCommand extends Command<"0" | "1", 0 | 1> {
-    constructor(cmd: [key: string, unix: number], opts?: CommandOptions<"0" | "1", 0 | 1>);
+    constructor(cmd: [key: string, unix: number, option?: ExpireOption], opts?: CommandOptions<"0" | "1", 0 | 1>);
 }
 
 /**
@@ -1054,7 +1294,7 @@ declare class RPushXCommand<TData = string> extends Command<number, number> {
  * @see https://redis.io/commands/sadd
  */
 declare class SAddCommand<TData = string> extends Command<number, number> {
-    constructor(cmd: [key: string, ...members: TData[]], opts?: CommandOptions<number, number>);
+    constructor(cmd: [key: string, member: TData, ...members: TData[]], opts?: CommandOptions<number, number>);
 }
 
 /**
@@ -1242,13 +1482,13 @@ declare class SRemCommand<TData = string> extends Command<number, number> {
  * @see https://redis.io/commands/sscan
  */
 declare class SScanCommand extends Command<[
-    number,
+    string,
     (string | number)[]
 ], [
-    number,
+    string,
     (string | number)[]
 ]> {
-    constructor([key, cursor, opts]: [key: string, cursor: number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[number, (string | number)[]], [number, (string | number)[]]>);
+    constructor([key, cursor, opts]: [key: string, cursor: string | number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[string, (string | number)[]], [string, (string | number)[]]>);
 }
 
 /**
@@ -1323,9 +1563,7 @@ declare class XAddCommand extends Command<string, string> {
     constructor([key, id, entries, opts]: [
         key: string,
         id: "*" | string,
-        entries: {
-            [field: string]: unknown;
-        },
+        entries: Record<string, unknown>,
         opts?: XAddCommandOptions
     ], commandOptions?: CommandOptions<string, string>);
 }
@@ -1334,7 +1572,75 @@ declare class XRangeCommand<TData extends Record<string, Record<string, unknown>
     constructor([key, start, end, count]: [key: string, start: string, end: string, count?: number], opts?: CommandOptions<unknown[], TData[]>);
 }
 
-type ZAddCommandOptions = ({
+type XReadCommandOptions = [
+    key: string | string[],
+    id: string | string[],
+    options?: {
+        count?: number;
+        /**
+         * @deprecated block is not yet supported in Upstash Redis
+         */
+        blockMS?: number;
+    }
+];
+type XReadOptions = XReadCommandOptions extends [infer K, infer I, ...any[]] ? K extends string ? I extends string ? [
+    key: string,
+    id: string,
+    options?: {
+        count?: number;
+        /**
+         * @deprecated block is not yet supported in Upstash Redis
+         */
+        blockMS?: number;
+    }
+] : never : K extends string[] ? I extends string[] ? [
+    key: string[],
+    id: string[],
+    options?: {
+        count?: number;
+        /**
+         * @deprecated block is not yet supported in Upstash Redis
+         */
+        blockMS?: number;
+    }
+] : never : never : never;
+/**
+ * @see https://redis.io/commands/xread
+ */
+declare class XReadCommand extends Command<number, unknown[]> {
+    constructor([key, id, options]: XReadOptions, opts?: CommandOptions<number, unknown[]>);
+}
+
+type Options = {
+    count?: number;
+    /**
+     * @deprecated block is not yet supported in Upstash Redis
+     */
+    blockMS?: number;
+    NOACK?: boolean;
+};
+type XReadGroupCommandOptions = [
+    group: string,
+    consumer: string,
+    key: string | string[],
+    id: string | string[],
+    options?: Options
+];
+type XReadGroupOptions = XReadGroupCommandOptions extends [
+    string,
+    string,
+    infer TKey,
+    infer TId,
+    ...any[]
+] ? TKey extends string ? TId extends string ? [group: string, consumer: string, key: string, id: string, options?: Options] : never : TKey extends string[] ? TId extends string[] ? [group: string, consumer: string, key: string[], id: string[], options?: Options] : never : never : never;
+/**
+ * @see https://redis.io/commands/xreadgroup
+ */
+declare class XReadGroupCommand extends Command<number, unknown[]> {
+    constructor([group, consumer, key, id, options]: XReadGroupOptions, opts?: CommandOptions<number, unknown[]>);
+}
+
+type NXAndXXOptions = {
     nx: true;
     xx?: never;
 } | {
@@ -1343,12 +1649,23 @@ type ZAddCommandOptions = ({
 } | {
     nx?: never;
     xx?: never;
-}) & {
-    ch?: true;
 };
-type ZAddCommandOptionsWithIncr = ZAddCommandOptions & {
-    incr: true;
+type LTAndGTOptions = {
+    lt: true;
+    gt?: never;
+} | {
+    lt?: never;
+    gt: true;
+} | {
+    lt?: never;
+    gt?: never;
+};
+type ZAddCommandOptions = NXAndXXOptions & LTAndGTOptions & {
+    ch?: true;
+} & {
+    incr?: true;
 };
+type Arg2<TData> = ScoreMember<TData> | ZAddCommandOptions;
 type ScoreMember<TData> = {
     score: number;
     member: TData;
@@ -1357,12 +1674,7 @@ type ScoreMember<TData> = {
  * @see https://redis.io/commands/zadd
  */
 declare class ZAddCommand<TData = string> extends Command<number | null, number | null> {
-    constructor(cmd: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]], opts?: CommandOptions<number | null, number | null>);
-    constructor(cmd: [
-        key: string,
-        opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
-        ...scoreMemberPairs: ScoreMember<TData>[]
-    ], opts?: CommandOptions<number | null, number | null>);
+    constructor([key, arg1, ...arg2]: [string, Arg2<TData>, ...ScoreMember<TData>[]], opts?: CommandOptions<number | null, number | null>);
 }
 
 /**
@@ -1481,7 +1793,11 @@ declare class ZRemRangeByRankCommand extends Command<number, number> {
  * @see https://redis.io/commands/zremrangebyscore
  */
 declare class ZRemRangeByScoreCommand extends Command<number, number> {
-    constructor(cmd: [key: string, min: number, max: number], opts?: CommandOptions<number, number>);
+    constructor(cmd: [
+        key: string,
+        min: number | `(${number}` | "-inf" | "+inf",
+        max: number | `(${number}` | "-inf" | "+inf"
+    ], opts?: CommandOptions<number, number>);
 }
 
 /**
@@ -1495,13 +1811,13 @@ declare class ZRevRankCommand<TData> extends Command<number | null, number | nul
  * @see https://redis.io/commands/zscan
  */
 declare class ZScanCommand extends Command<[
-    number,
+    string,
     (string | number)[]
 ], [
-    number,
+    string,
     (string | number)[]
 ]> {
-    constructor([key, cursor, opts]: [key: string, cursor: number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[number, (string | number)[]], [number, (string | number)[]]>);
+    constructor([key, cursor, opts]: [key: string, cursor: string | number, opts?: ScanCommandOptions], cmdOpts?: CommandOptions<[string, (string | number)[]], [string, (string | number)[]]>);
 }
 
 /**
@@ -1511,9 +1827,79 @@ declare class ZScoreCommand<TData> extends Command<string | null, number | null>
     constructor(cmd: [key: string, member: TData], opts?: CommandOptions<string | null, number | null>);
 }
 
+type BaseMessageData<TMessage> = {
+    channel: string;
+    message: TMessage;
+};
+type PatternMessageData<TMessage> = BaseMessageData<TMessage> & {
+    pattern: string;
+};
+type SubscriptionCountEvent = number;
+type MessageEventMap<TMessage> = {
+    message: BaseMessageData<TMessage>;
+    subscribe: SubscriptionCountEvent;
+    unsubscribe: SubscriptionCountEvent;
+    pmessage: PatternMessageData<TMessage>;
+    psubscribe: SubscriptionCountEvent;
+    punsubscribe: SubscriptionCountEvent;
+    error: Error;
+    [key: `message:${string}`]: BaseMessageData<TMessage>;
+    [key: `pmessage:${string}`]: PatternMessageData<TMessage>;
+};
+type EventType = keyof MessageEventMap<any>;
+type Listener<TMessage, T extends EventType> = (event: MessageEventMap<TMessage>[T]) => void;
+declare class Subscriber<TMessage = any> extends EventTarget {
+    private subscriptions;
+    private client;
+    private listeners;
+    private opts?;
+    constructor(client: Requester, channels: string[], isPattern?: boolean, opts?: Pick<RedisOptions, "automaticDeserialization">);
+    private subscribeToChannel;
+    private subscribeToPattern;
+    private handleMessage;
+    private dispatchToListeners;
+    on<T extends keyof MessageEventMap<TMessage>>(type: T, listener: Listener<TMessage, T>): void;
+    removeAllListeners(): void;
+    unsubscribe(channels?: string[]): Promise<void>;
+    getSubscribedChannels(): string[];
+}
+
 type InferResponseData<T extends unknown[]> = {
     [K in keyof T]: T[K] extends Command<any, infer TData> ? TData : unknown;
 };
+interface ExecMethod<TCommands extends Command<any, any>[]> {
+    /**
+     * Send the pipeline request to upstash.
+     *
+     * Returns an array with the results of all pipelined commands.
+     *
+     * If all commands are statically chained from start to finish, types are inferred. You can still define a return type manually if necessary though:
+     * ```ts
+     * const p = redis.pipeline()
+     * p.get("key")
+     * const result = p.exec<[{ greeting: string }]>()
+     * ```
+     *
+     * If one of the commands get an error, the whole pipeline fails. Alternatively, you can set the keepErrors option to true in order to get the errors individually.
+     *
+     * If keepErrors is set to true, a list of objects is returned where each object corresponds to a command and is of type: `{ result: unknown, error?: string }`.
+     *
+     * ```ts
+     * const p = redis.pipeline()
+     * p.get("key")
+     *
+     * const result = await p.exec({ keepErrors: true });
+     * const getResult = result[0].result
+     * const getError = result[0].error
+     * ```
+     */
+    <TCommandResults extends unknown[] = [] extends TCommands ? unknown[] : InferResponseData<TCommands>>(): Promise<TCommandResults>;
+    <TCommandResults extends unknown[] = [] extends TCommands ? unknown[] : InferResponseData<TCommands>>(options: {
+        keepErrors: true;
+    }): Promise<{
+        [K in keyof TCommandResults]: UpstashResponse<TCommandResults[K]>;
+    }>;
+}
 /**
  * Upstash REST API supports command pipelining to send multiple commands in
  * batch, instead of sending each command one by one and waiting for a response.
@@ -1562,19 +1948,7 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
         commandOptions?: CommandOptions<any, any>;
         multiExec?: boolean;
     });
-    /**
-     * Send the pipeline request to upstash.
-     *
-     * Returns an array with the results of all pipelined commands.
-     *
-     * If all commands are statically chained from start to finish, types are inferred. You can still define a return type manually if necessary though:
-     * ```ts
-     * const p = redis.pipeline()
-     * p.get("key")
-     * const result = p.exec<[{ greeting: string }]>()
-     * ```
-     */
-    exec: <TCommandResults extends unknown[] = [] extends TCommands ? unknown[] : InferResponseData<TCommands>>() => Promise<TCommandResults>;
+    exec: ExecMethod<TCommands>;
     /**
      * Returns the length of pipeline before the execution
      */
@@ -1592,6 +1966,23 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @see https://redis.io/commands/bitcount
      */
     bitcount: (key: string, start: number, end: number) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * Returns an instance that can be used to execute `BITFIELD` commands on one key.
+     *
+     * @example
+     * ```typescript
+     * redis.set("mykey", 0);
+     * const result = await redis.pipeline()
+     *   .bitfield("mykey")
+     *   .set("u4", 0, 16)
+     *   .incr("u4", "#1", 1)
+     *   .exec();
+     * console.log(result); // [[0, 1]]
+     * ```
+     *
+     * @see https://redis.io/commands/bitfield
+     */
+    bitfield: (key: string) => BitFieldCommand<Pipeline<[...TCommands, Command<any, number[]>]>>;
     /**
      * @see https://redis.io/commands/bitop
      */
@@ -1633,10 +2024,18 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @see https://redis.io/commands/echo
      */
     echo: (message: string) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://redis.io/commands/eval_ro
+     */
+    evalRo: <TArgs extends unknown[], TData = unknown>(script: string, keys: string[], args: TArgs) => Pipeline<[...TCommands, Command<any, TData>]>;
     /**
      * @see https://redis.io/commands/eval
      */
     eval: <TArgs extends unknown[], TData = unknown>(script: string, keys: string[], args: TArgs) => Pipeline<[...TCommands, Command<any, TData>]>;
+    /**
+     * @see https://redis.io/commands/evalsha_ro
+     */
+    evalshaRo: <TArgs extends unknown[], TData = unknown>(sha1: string, keys: string[], args: TArgs) => Pipeline<[...TCommands, Command<any, TData>]>;
     /**
      * @see https://redis.io/commands/evalsha
      */
@@ -1648,11 +2047,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/expire
      */
-    expire: (key: string, seconds: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    expire: (key: string, seconds: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
     /**
      * @see https://redis.io/commands/expireat
      */
-    expireat: (key: string, unix: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    expireat: (key: string, unix: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
     /**
      * @see https://redis.io/commands/flushall
      */
@@ -1661,36 +2060,202 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @see https://redis.io/commands/flushdb
      */
     flushdb: (opts?: {
-        async?: boolean | undefined;
+        async?: boolean;
     } | undefined) => Pipeline<[...TCommands, Command<any, "OK">]>;
     /**
-     * @see https://redis.io/commands/get
+     * @see https://redis.io/commands/geoadd
      */
-    get: <TData>(key: string) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    geoadd: <TData>(args_0: string, args_1: GeoAddCommandOptions | GeoMember<TData>, ...args_2: GeoMember<TData>[]) => Pipeline<[...TCommands, Command<any, number | null>]>;
     /**
-     * @see https://redis.io/commands/getbit
+     * @see https://redis.io/commands/geodist
      */
-    getbit: (key: string, offset: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    geodist: <TData>(key: string, member1: TData, member2: TData, unit?: "M" | "KM" | "FT" | "MI" | undefined) => Pipeline<[...TCommands, Command<any, number | null>]>;
     /**
-     * @see https://redis.io/commands/getdel
+     * @see https://redis.io/commands/geopos
      */
-    getdel: <TData>(key: string) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    geopos: <TData>(args_0: string, ...args_1: TData[]) => Pipeline<[...TCommands, Command<any, {
+        lng: number;
+        lat: number;
+    }[]>]>;
     /**
-     * @see https://redis.io/commands/getrange
+     * @see https://redis.io/commands/geohash
      */
-    getrange: (key: string, start: number, end: number) => Pipeline<[...TCommands, Command<any, string>]>;
+    geohash: <TData>(args_0: string, ...args_1: TData[]) => Pipeline<[...TCommands, Command<any, (string | null)[]>]>;
     /**
-     * @see https://redis.io/commands/getset
+     * @see https://redis.io/commands/geosearch
      */
-    getset: <TData>(key: string, value: TData) => Pipeline<[...TCommands, Command<any, TData | null>]>;
-    /**
-     * @see https://redis.io/commands/hdel
+    geosearch: <TData>(key: string, centerPoint: {
+        type: "FROMLONLAT" | "fromlonlat";
+        coordinate: {
+            lon: number;
+            lat: number;
+        };
+    } | {
+        type: "FROMMEMBER" | "frommember";
+        member: TData;
+    }, shape: {
+        type: "BYRADIUS" | "byradius";
+        radius: number;
+        radiusType: "M" | "KM" | "FT" | "MI";
+    } | {
+        type: "BYBOX" | "bybox";
+        rect: {
+            width: number;
+            height: number;
+        };
+        rectType: "M" | "KM" | "FT" | "MI";
+    }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
+        count?: {
+            limit: number;
+            any?: boolean;
+        };
+        withCoord?: boolean;
+        withDist?: boolean;
+        withHash?: boolean;
+    } | undefined) => Pipeline<[...TCommands, Command<any, ({
+        member: TData;
+    } & {
+        coord?: {
+            long: number;
+            lat: number;
+        } | undefined;
+        dist?: number | undefined;
+        hash?: string | undefined;
+    })[]>]>;
+    /**
+     * @see https://redis.io/commands/geosearchstore
+     */
+    geosearchstore: <TData>(destination: string, key: string, centerPoint: {
+        type: "FROMLONLAT" | "fromlonlat";
+        coordinate: {
+            lon: number;
+            lat: number;
+        };
+    } | {
+        type: "FROMMEMBER" | "frommember";
+        member: TData;
+    }, shape: {
+        type: "BYRADIUS" | "byradius";
+        radius: number;
+        radiusType: "M" | "KM" | "FT" | "MI";
+    } | {
+        type: "BYBOX" | "bybox";
+        rect: {
+            width: number;
+            height: number;
+        };
+        rectType: "M" | "KM" | "FT" | "MI";
+    }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
+        count?: {
+            limit: number;
+            any?: boolean;
+        };
+        storeDist?: boolean;
+    } | undefined) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/get
+     */
+    get: <TData>(key: string) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://redis.io/commands/getbit
+     */
+    getbit: (key: string, offset: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    /**
+     * @see https://redis.io/commands/getdel
+     */
+    getdel: <TData>(key: string) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://redis.io/commands/getex
+     */
+    getex: <TData>(key: string, opts?: ({
+        ex: number;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px: number;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat: number;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat: number;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist: true;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    }) | undefined) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://redis.io/commands/getrange
+     */
+    getrange: (key: string, start: number, end: number) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://redis.io/commands/getset
+     */
+    getset: <TData>(key: string, value: TData) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://redis.io/commands/hdel
      */
     hdel: (key: string, ...fields: string[]) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
     /**
      * @see https://redis.io/commands/hexists
      */
     hexists: (key: string, field: string) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/hexpire
+     */
+    hexpire: (key: string, fields: string | number | (string | number)[], seconds: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, (0 | 1 | 2 | -2)[]>]>;
+    /**
+     * @see https://redis.io/commands/hexpireat
+     */
+    hexpireat: (key: string, fields: string | number | (string | number)[], timestamp: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, (0 | 1 | 2 | -2)[]>]>;
+    /**
+     * @see https://redis.io/commands/hexpiretime
+     */
+    hexpiretime: (key: string, fields: string | number | (string | number)[]) => Pipeline<[...TCommands, Command<any, number[]>]>;
+    /**
+     * @see https://redis.io/commands/httl
+     */
+    httl: (key: string, fields: string | number | (string | number)[]) => Pipeline<[...TCommands, Command<any, number[]>]>;
+    /**
+     * @see https://redis.io/commands/hpexpire
+     */
+    hpexpire: (key: string, fields: string | number | (string | number)[], milliseconds: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, (0 | 1 | 2 | -2)[]>]>;
+    /**
+     * @see https://redis.io/commands/hpexpireat
+     */
+    hpexpireat: (key: string, fields: string | number | (string | number)[], timestamp: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, (0 | 1 | 2 | -2)[]>]>;
+    /**
+     * @see https://redis.io/commands/hpexpiretime
+     */
+    hpexpiretime: (key: string, fields: string | number | (string | number)[]) => Pipeline<[...TCommands, Command<any, number[]>]>;
+    /**
+     * @see https://redis.io/commands/hpttl
+     */
+    hpttl: (key: string, fields: string | number | (string | number)[]) => Pipeline<[...TCommands, Command<any, number[]>]>;
+    /**
+     * @see https://redis.io/commands/hpersist
+     */
+    hpersist: (key: string, fields: string | number | (string | number)[]) => Pipeline<[...TCommands, Command<any, (1 | -2 | -1)[]>]>;
     /**
      * @see https://redis.io/commands/hget
      */
@@ -1722,9 +2287,7 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/hmset
      */
-    hmset: <TData>(key: string, kv: {
-        [field: string]: TData;
-    }) => Pipeline<[...TCommands, Command<any, "OK">]>;
+    hmset: <TData>(key: string, kv: Record<string, TData>) => Pipeline<[...TCommands, Command<any, "OK">]>;
     /**
      * @see https://redis.io/commands/hrandfield
      */
@@ -1732,13 +2295,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/hscan
      */
-    hscan: (key: string, cursor: number, cmdOpts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [number, (string | number)[]]>]>;
+    hscan: (key: string, cursor: string | number, cmdOpts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [string, (string | number)[]]>]>;
     /**
      * @see https://redis.io/commands/hset
      */
-    hset: <TData>(key: string, kv: {
-        [field: string]: TData;
-    }) => Pipeline<[...TCommands, Command<any, number>]>;
+    hset: <TData>(key: string, kv: Record<string, TData>) => Pipeline<[...TCommands, Command<any, number>]>;
     /**
      * @see https://redis.io/commands/hsetnx
      */
@@ -1787,13 +2348,17 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @see https://redis.io/commands/lpop
      */
     lpop: <TData>(key: string, count?: number | undefined) => Pipeline<[...TCommands, Command<any, TData | null>]>;
+    /**
+     * @see https://redis.io/commands/lmpop
+     */
+    lmpop: <TData>(numkeys: number, keys: string[], args_2: "LEFT" | "RIGHT", count?: number | undefined) => Pipeline<[...TCommands, Command<any, [string, TData[]] | null>]>;
     /**
      * @see https://redis.io/commands/lpos
      */
     lpos: <TData>(key: string, element: unknown, opts?: {
-        rank?: number | undefined;
-        count?: number | undefined;
-        maxLen?: number | undefined;
+        rank?: number;
+        count?: number;
+        maxLen?: number;
     } | undefined) => Pipeline<[...TCommands, Command<any, TData>]>;
     /**
      * @see https://redis.io/commands/lpush
@@ -1826,15 +2391,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/mset
      */
-    mset: <TData>(kv: {
-        [key: string]: TData;
-    }) => Pipeline<[...TCommands, Command<any, "OK">]>;
+    mset: <TData>(kv: Record<string, TData>) => Pipeline<[...TCommands, Command<any, "OK">]>;
     /**
      * @see https://redis.io/commands/msetnx
      */
-    msetnx: <TData>(kv: {
-        [key: string]: TData;
-    }) => Pipeline<[...TCommands, Command<any, number>]>;
+    msetnx: <TData>(kv: Record<string, TData>) => Pipeline<[...TCommands, Command<any, number>]>;
     /**
      * @see https://redis.io/commands/persist
      */
@@ -1842,11 +2403,23 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/pexpire
      */
-    pexpire: (key: string, milliseconds: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    pexpire: (key: string, milliseconds: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
     /**
      * @see https://redis.io/commands/pexpireat
      */
-    pexpireat: (key: string, unix: number) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    pexpireat: (key: string, unix: number, option?: ExpireOption | undefined) => Pipeline<[...TCommands, Command<any, 0 | 1>]>;
+    /**
+     * @see https://redis.io/commands/pfadd
+     */
+    pfadd: (args_0: string, ...args_1: unknown[]) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/pfcount
+     */
+    pfcount: (args_0: string, ...args_1: string[]) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/pfmerge
+     */
+    pfmerge: (destination_key: string, ...args_1: string[]) => Pipeline<[...TCommands, Command<any, "OK">]>;
     /**
      * @see https://redis.io/commands/ping
      */
@@ -1890,11 +2463,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/sadd
      */
-    sadd: <TData>(key: string, ...members: TData[]) => Pipeline<[...TCommands, Command<any, number>]>;
+    sadd: <TData>(key: string, member: TData, ...members: TData[]) => Pipeline<[...TCommands, Command<any, number>]>;
     /**
      * @see https://redis.io/commands/scan
      */
-    scan: (cursor: number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [number, string[]]>]>;
+    scan: (cursor: string | number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, any>]>;
     /**
      * @see https://redis.io/commands/scard
      */
@@ -1975,7 +2548,7 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/sscan
      */
-    sscan: (key: string, cursor: number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [number, (string | number)[]]>]>;
+    sscan: (key: string, cursor: string | number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [string, (string | number)[]]>]>;
     /**
      * @see https://redis.io/commands/strlen
      */
@@ -2011,7 +2584,127 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/zadd
      */
-    zadd: <TData>(...args: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]] | [key: string, opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr, ScoreMember<TData>, ...ScoreMember<TData>[]]) => Pipeline<[...TCommands, Command<any, number | null>]>;
+    zadd: <TData>(...args: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]] | [key: string, opts: ZAddCommandOptions, ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]]) => Pipeline<[...TCommands, Command<any, number | null>]>;
+    /**
+     * @see https://redis.io/commands/xadd
+     */
+    xadd: (key: string, id: string, entries: Record<string, unknown>, opts?: {
+        nomkStream?: boolean;
+        trim?: ({
+            type: "MAXLEN" | "maxlen";
+            threshold: number;
+        } | {
+            type: "MINID" | "minid";
+            threshold: string;
+        }) & ({
+            comparison: "~";
+            limit?: number;
+        } | {
+            comparison: "=";
+            limit?: never;
+        });
+    } | undefined) => Pipeline<[...TCommands, Command<any, string>]>;
+    /**
+     * @see https://redis.io/commands/xack
+     */
+    xack: (key: string, group: string, id: string | string[]) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/xdel
+     */
+    xdel: (key: string, ids: string | string[]) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/xgroup
+     */
+    xgroup: (key: string, opts: {
+        type: "CREATE";
+        group: string;
+        id: `$` | string;
+        options?: {
+            MKSTREAM?: boolean;
+            ENTRIESREAD?: number;
+        };
+    } | {
+        type: "CREATECONSUMER";
+        group: string;
+        consumer: string;
+    } | {
+        type: "DELCONSUMER";
+        group: string;
+        consumer: string;
+    } | {
+        type: "DESTROY";
+        group: string;
+    } | {
+        type: "SETID";
+        group: string;
+        id: `$` | string;
+        options?: {
+            ENTRIESREAD?: number;
+        };
+    }) => Pipeline<[...TCommands, Command<any, never>]>;
+    /**
+     * @see https://redis.io/commands/xread
+     */
+    xread: (...args: CommandArgs<typeof XReadCommand>) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xreadgroup
+     */
+    xreadgroup: (...args: CommandArgs<typeof XReadGroupCommand>) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xinfo
+     */
+    xinfo: (key: string, options: {
+        type: "CONSUMERS";
+        group: string;
+    } | {
+        type: "GROUPS";
+    }) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xlen
+     */
+    xlen: (key: string) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/xpending
+     */
+    xpending: (key: string, group: string, start: string, end: string, count: number, options?: {
+        idleTime?: number;
+        consumer?: string | string[];
+    } | undefined) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xclaim
+     */
+    xclaim: (key: string, group: string, consumer: string, minIdleTime: number, id: string | string[], options?: {
+        idleMS?: number;
+        timeMS?: number;
+        retryCount?: number;
+        force?: boolean;
+        justId?: boolean;
+        lastId?: number;
+    } | undefined) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xautoclaim
+     */
+    xautoclaim: (key: string, group: string, consumer: string, minIdleTime: number, start: string, options?: {
+        count?: number;
+        justId?: boolean;
+    } | undefined) => Pipeline<[...TCommands, Command<any, unknown[]>]>;
+    /**
+     * @see https://redis.io/commands/xtrim
+     */
+    xtrim: (key: string, options: {
+        strategy: "MAXLEN" | "MINID";
+        exactness?: "~" | "=";
+        threshold: number | string;
+        limit?: number;
+    }) => Pipeline<[...TCommands, Command<any, number>]>;
+    /**
+     * @see https://redis.io/commands/xrange
+     */
+    xrange: (key: string, start: string, end: string, count?: number | undefined) => Pipeline<[...TCommands, Command<any, Record<string, Record<string, unknown>>>]>;
+    /**
+     * @see https://redis.io/commands/xrevrange
+     */
+    xrevrange: (key: string, end: string, start: string, count?: number | undefined) => Pipeline<[...TCommands, Command<any, Record<string, Record<string, unknown>>>]>;
     /**
      * @see https://redis.io/commands/zcard
      */
@@ -2047,21 +2740,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/zrange
      */
-    zrange: <TData extends unknown[]>(...args: [key: string, min: number, max: number, opts?: ZRangeCommandOptions] | [
-        key: string,
-        min: `(${string}` | `[${string}` | "-" | "+",
-        max: `(${string}` | `[${string}` | "-" | "+",
-        opts: {
-            byLex: true;
-        } & ZRangeCommandOptions
-    ] | [
-        key: string,
-        min: number | `(${number}` | "-inf" | "+inf",
-        max: number | `(${number}` | "-inf" | "+inf",
-        opts: {
-            byScore: true;
-        } & ZRangeCommandOptions
-    ]) => Pipeline<[...TCommands, Command<any, TData>]>;
+    zrange: <TData extends unknown[]>(...args: [key: string, min: number, max: number, opts?: ZRangeCommandOptions] | [key: string, min: `(${string}` | `[${string}` | "-" | "+", max: `(${string}` | `[${string}` | "-" | "+", opts: {
+        byLex: true;
+    } & ZRangeCommandOptions] | [key: string, min: number | `(${number}` | "-inf" | "+inf", max: number | `(${number}` | "-inf" | "+inf", opts: {
+        byScore: true;
+    } & ZRangeCommandOptions]) => Pipeline<[...TCommands, Command<any, TData>]>;
     /**
      * @see https://redis.io/commands/zrank
      */
@@ -2081,7 +2764,7 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/zremrangebyscore
      */
-    zremrangebyscore: (key: string, min: number, max: number) => Pipeline<[...TCommands, Command<any, number>]>;
+    zremrangebyscore: (key: string, min: number | `(${number}` | "-inf" | "+inf", max: number | `(${number}` | "-inf" | "+inf") => Pipeline<[...TCommands, Command<any, number>]>;
     /**
      * @see https://redis.io/commands/zrevrank
      */
@@ -2089,7 +2772,7 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/zscan
      */
-    zscan: (key: string, cursor: number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [number, (string | number)[]]>]>;
+    zscan: (key: string, cursor: string | number, opts?: ScanCommandOptions | undefined) => Pipeline<[...TCommands, Command<any, [string, (string | number)[]]>]>;
     /**
      * @see https://redis.io/commands/zscore
      */
@@ -2142,104 +2825,22 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
          * @see https://redis.io/commands/json.forget
          */
         forget: (key: string, path?: string | undefined) => Pipeline<[...TCommands, Command<any, number>]>;
-        /**
-         * @see https://redis.io/commands/geoadd
-         */
-        geoadd: (args_0: string, args_1: GeoAddCommandOptions | GeoMember<unknown>, ...args_2: GeoMember<unknown>[]) => Pipeline<[...TCommands, Command<any, number | null>]>;
-        /**
-         * @see https://redis.io/commands/geodist
-         */
-        geodist: (key: string, member1: unknown, member2: unknown, unit?: "M" | "KM" | "FT" | "MI" | undefined) => Pipeline<[...TCommands, Command<any, number | null>]>;
-        /**
-         * @see https://redis.io/commands/geopos
-         */
-        geopos: (args_0: string, ...args_1: unknown[]) => Pipeline<[...TCommands, Command<any, {
-            lng: number;
-            lat: number;
-        }[]>]>;
-        /**
-         * @see https://redis.io/commands/geohash
-         */
-        geohash: (args_0: string, ...args_1: unknown[]) => Pipeline<[...TCommands, Command<any, (string | null)[]>]>;
-        /**
-         * @see https://redis.io/commands/geosearch
-         */
-        geosearch: (key: string, centerPoint: {
-            type: "FROMLONLAT" | "fromlonlat";
-            coordinate: {
-                lon: number;
-                lat: number;
-            };
-        } | {
-            type: "FROMMEMBER" | "frommember";
-            member: unknown;
-        }, shape: {
-            type: "BYRADIUS" | "byradius";
-            radius: number;
-            radiusType: "M" | "KM" | "FT" | "MI";
-        } | {
-            type: "BYBOX" | "bybox";
-            rect: {
-                width: number;
-                height: number;
-            };
-            rectType: "M" | "KM" | "FT" | "MI";
-        }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
-            count?: {
-                limit: number;
-                any?: boolean | undefined;
-            } | undefined;
-            withCoord?: boolean | undefined;
-            withDist?: boolean | undefined;
-            withHash?: boolean | undefined;
-        } | undefined) => Pipeline<[...TCommands, Command<any, ({
-            member: unknown;
-        } & {
-            coord?: {
-                long: number;
-                lat: number;
-            } | undefined;
-            dist?: number | undefined;
-            hash?: string | undefined;
-        })[]>]>;
-        /**
-         * @see https://redis.io/commands/geosearchstore
-         */
-        geosearchstore: (destination: string, key: string, centerPoint: {
-            type: "FROMLONLAT" | "fromlonlat";
-            coordinate: {
-                lon: number;
-                lat: number;
-            };
-        } | {
-            type: "FROMMEMBER" | "frommember";
-            member: unknown;
-        }, shape: {
-            type: "BYRADIUS" | "byradius";
-            radius: number;
-            radiusType: "M" | "KM" | "FT" | "MI";
-        } | {
-            type: "BYBOX" | "bybox";
-            rect: {
-                width: number;
-                height: number;
-            };
-            rectType: "M" | "KM" | "FT" | "MI";
-        }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
-            count?: {
-                limit: number;
-                any?: boolean | undefined;
-            } | undefined;
-            storeDist?: boolean | undefined;
-        } | undefined) => Pipeline<[...TCommands, Command<any, number>]>;
         /**
          * @see https://redis.io/commands/json.get
          */
         get: (...args: CommandArgs<typeof JsonGetCommand>) => Pipeline<[...TCommands, Command<any, any>]>;
+        /**
+         * @see https://redis.io/commands/json.merge
+         */
+        merge: (key: string, path: string, value: string | number | unknown[] | Record<string, unknown>) => Pipeline<[...TCommands, Command<any, "OK" | null>]>;
         /**
          * @see https://redis.io/commands/json.mget
          */
         mget: (keys: string[], path: string) => Pipeline<[...TCommands, Command<any, any>]>;
+        /**
+         * @see https://redis.io/commands/json.mset
+         */
+        mset: (...args: CommandArgs<typeof JsonMSetCommand>) => Pipeline<[...TCommands, Command<any, "OK" | null>]>;
         /**
          * @see https://redis.io/commands/json.numincrby
          */
@@ -2265,9 +2866,9 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
          */
         set: (key: string, path: string, value: string | number | boolean | Record<string, unknown> | (string | number | boolean | Record<string, unknown>)[], opts?: {
             nx: true;
-            xx?: undefined;
+            xx?: never;
         } | {
-            nx?: undefined;
+            nx?: never;
             xx: true;
         } | undefined) => Pipeline<[...TCommands, Command<any, "OK" | null>]>;
         /**
@@ -2307,9 +2908,20 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
  */
 declare class Script<TResult = unknown> {
     readonly script: string;
-    readonly sha1: string;
+    /**
+     * @deprecated This property is initialized to an empty string and will be set in the init method
+     * asynchronously. Do not use this property immidiately after the constructor.
+     *
+     * This property is only exposed for backwards compatibility and will be removed in the
+     * future major release.
+     */
+    sha1: string;
     private readonly redis;
     constructor(redis: Redis, script: string);
+    /**
+     * Initialize the script by computing its SHA-1 hash.
+     */
+    private init;
     /**
      * Send an `EVAL` command to redis.
      */
@@ -2331,6 +2943,56 @@ declare class Script<TResult = unknown> {
     private digest;
 }
 
+/**
+ * Creates a new script.
+ *
+ * Scripts offer the ability to optimistically try to execute a script without having to send the
+ * entire script to the server. If the script is loaded on the server, it tries again by sending
+ * the entire script. Afterwards, the script is cached on the server.
+ *
+ * @example
+ * ```ts
+ * const redis = new Redis({...})
+ *
+ * const script = redis.createScript<string>("return ARGV[1];", { readOnly: true })
+ * const arg1 = await script.evalRo([], ["Hello World"])
+ * expect(arg1, "Hello World")
+ * ```
+ */
+declare class ScriptRO<TResult = unknown> {
+    readonly script: string;
+    /**
+     * @deprecated This property is initialized to an empty string and will be set in the init method
+     * asynchronously. Do not use this property immidiately after the constructor.
+     *
+     * This property is only exposed for backwards compatibility and will be removed in the
+     * future major release.
+     */
+    sha1: string;
+    private readonly redis;
+    constructor(redis: Redis, script: string);
+    private init;
+    /**
+     * Send an `EVAL_RO` command to redis.
+     */
+    evalRo(keys: string[], args: string[]): Promise<TResult>;
+    /**
+     * Calculates the sha1 hash of the script and then calls `EVALSHA_RO`.
+     */
+    evalshaRo(keys: string[], args: string[]): Promise<TResult>;
+    /**
+     * Optimistically try to run `EVALSHA_RO` first.
+     * If the script is not loaded in redis, it will fall back and try again with `EVAL_RO`.
+     *
+     * Following calls will be able to use the cached script
+     */
+    exec(keys: string[], args: string[]): Promise<TResult>;
+    /**
+     * Compute the sha1 hash of the script and return its hex representation.
+     */
+    private digest;
+}
+
 /**
  * Serverless redis client for upstash.
  */
@@ -2338,6 +3000,7 @@ declare class Redis {
     protected client: Requester;
     protected opts?: CommandOptions<any, any>;
     protected enableTelemetry: boolean;
+    protected enableAutoPipelining: boolean;
     /**
      * Create a new redis client
      *
@@ -2350,6 +3013,8 @@ declare class Redis {
      * ```
      */
     constructor(client: Requester, opts?: RedisOptions);
+    get readYourWritesSyncToken(): string | undefined;
+    set readYourWritesSyncToken(session: string | undefined);
     get json(): {
         /**
          * @see https://redis.io/commands/json.arrappend
@@ -2388,103 +3053,21 @@ declare class Redis {
          */
         forget: (key: string, path?: string | undefined) => Promise<number>;
         /**
-         * @see https://redis.io/commands/geoadd
-         */
-        geoadd: (args_0: string, args_1: GeoAddCommandOptions | GeoMember<unknown>, ...args_2: GeoMember<unknown>[]) => Promise<number | null>;
-        /**
-         * @see https://redis.io/commands/geopos
-         */
-        geopos: (args_0: string, ...args_1: unknown[]) => Promise<{
-            lng: number;
-            lat: number;
-        }[]>;
-        /**
-         * @see https://redis.io/commands/geodist
-         */
-        geodist: (key: string, member1: unknown, member2: unknown, unit?: "M" | "KM" | "FT" | "MI" | undefined) => Promise<number | null>;
-        /**
-         * @see https://redis.io/commands/geohash
+         * @see https://redis.io/commands/json.get
          */
-        geohash: (args_0: string, ...args_1: unknown[]) => Promise<(string | null)[]>;
+        get: <TData>(...args: CommandArgs<typeof JsonGetCommand>) => Promise<TData | null>;
         /**
-         * @see https://redis.io/commands/geosearch
+         * @see https://redis.io/commands/json.merge
          */
-        geosearch: (key: string, centerPoint: {
-            type: "FROMLONLAT" | "fromlonlat";
-            coordinate: {
-                lon: number;
-                lat: number;
-            };
-        } | {
-            type: "FROMMEMBER" | "frommember";
-            member: unknown;
-        }, shape: {
-            type: "BYRADIUS" | "byradius";
-            radius: number;
-            radiusType: "M" | "KM" | "FT" | "MI";
-        } | {
-            type: "BYBOX" | "bybox";
-            rect: {
-                width: number;
-                height: number;
-            };
-            rectType: "M" | "KM" | "FT" | "MI";
-        }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
-            count?: {
-                limit: number;
-                any?: boolean | undefined;
-            } | undefined;
-            withCoord?: boolean | undefined;
-            withDist?: boolean | undefined;
-            withHash?: boolean | undefined;
-        } | undefined) => Promise<({
-            member: unknown;
-        } & {
-            coord?: {
-                long: number;
-                lat: number;
-            } | undefined;
-            dist?: number | undefined;
-            hash?: string | undefined;
-        })[]>;
+        merge: (key: string, path: string, value: string | number | unknown[] | Record<string, unknown>) => Promise<"OK" | null>;
         /**
-         * @see https://redis.io/commands/geosearchstore
-         */
-        geosearchstore: (destination: string, key: string, centerPoint: {
-            type: "FROMLONLAT" | "fromlonlat";
-            coordinate: {
-                lon: number;
-                lat: number;
-            };
-        } | {
-            type: "FROMMEMBER" | "frommember";
-            member: unknown;
-        }, shape: {
-            type: "BYRADIUS" | "byradius";
-            radius: number;
-            radiusType: "M" | "KM" | "FT" | "MI";
-        } | {
-            type: "BYBOX" | "bybox";
-            rect: {
-                width: number;
-                height: number;
-            };
-            rectType: "M" | "KM" | "FT" | "MI";
-        }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
-            count?: {
-                limit: number;
-                any?: boolean | undefined;
-            } | undefined;
-            storeDist?: boolean | undefined;
-        } | undefined) => Promise<number>;
-        /**
-         * @see https://redis.io/commands/json.get
+         * @see https://redis.io/commands/json.mget
          */
-        get: (...args: CommandArgs<typeof JsonGetCommand>) => Promise<any>;
+        mget: <TData>(keys: string[], path: string) => Promise<TData>;
         /**
-         * @see https://redis.io/commands/json.mget
+         * @see https://redis.io/commands/json.mset
          */
-        mget: (keys: string[], path: string) => Promise<any>;
+        mset: (...args: CommandArgs<typeof JsonMSetCommand>) => Promise<"OK" | null>;
         /**
          * @see https://redis.io/commands/json.numincrby
          */
@@ -2510,9 +3093,9 @@ declare class Redis {
          */
         set: (key: string, path: string, value: string | number | boolean | Record<string, unknown> | (string | number | boolean | Record<string, unknown>)[], opts?: {
             nx: true;
-            xx?: undefined;
+            xx?: never;
         } | {
-            nx?: undefined;
+            nx?: never;
             xx: true;
         } | undefined) => Promise<"OK" | null>;
         /**
@@ -2540,13 +3123,44 @@ declare class Redis {
      * Technically this is not private, we can hide it from intellisense by doing this
      */
     protected addTelemetry: (telemetry: Telemetry) => void;
-    createScript(script: string): Script;
+    /**
+     * Creates a new script.
+     *
+     * Scripts offer the ability to optimistically try to execute a script without having to send the
+     * entire script to the server. If the script is loaded on the server, it tries again by sending
+     * the entire script. Afterwards, the script is cached on the server.
+     *
+     * @param script - The script to create
+     * @param opts - Optional options to pass to the script `{ readonly?: boolean }`
+     * @returns A new script
+     *
+     * @example
+     * ```ts
+     * const redis = new Redis({...})
+     *
+     * const script = redis.createScript<string>("return ARGV[1];")
+     * const arg1 = await script.eval([], ["Hello World"])
+     * expect(arg1, "Hello World")
+     * ```
+     * @example
+     * ```ts
+     * const redis = new Redis({...})
+     *
+     * const script = redis.createScript<string>("return ARGV[1];", { readonly: true })
+     * const arg1 = await script.evalRo([], ["Hello World"])
+     * expect(arg1, "Hello World")
+     * ```
+     */
+    createScript<TResult = unknown, TReadonly extends boolean = false>(script: string, opts?: {
+        readonly?: TReadonly;
+    }): TReadonly extends true ? ScriptRO<TResult> : Script<TResult>;
     /**
      * Create a new pipeline that allows you to send requests in bulk.
      *
      * @see {@link Pipeline}
      */
     pipeline: () => Pipeline<[]>;
+    protected autoPipeline: () => Redis;
     /**
      * Create a new transaction to allow executing multiple steps atomically.
      *
@@ -2557,6 +3171,22 @@ declare class Redis {
      * @see {@link Pipeline}
      */
     multi: () => Pipeline<[]>;
+    /**
+     * Returns an instance that can be used to execute `BITFIELD` commands on one key.
+     *
+     * @example
+     * ```typescript
+     * redis.set("mykey", 0);
+     * const result = await redis.bitfield("mykey")
+     *   .set("u4", 0, 16)
+     *   .incr("u4", "#1", 1)
+     *   .exec();
+     * console.log(result); // [0, 1]
+     * ```
+     *
+     * @see https://redis.io/commands/bitfield
+     */
+    bitfield: (key: string) => BitFieldCommand<Promise<number[]>>;
     /**
      * @see https://redis.io/commands/append
      */
@@ -2602,14 +3232,26 @@ declare class Redis {
      * @see https://redis.io/commands/echo
      */
     echo: (message: string) => Promise<string>;
+    /**
+     * @see https://redis.io/commands/eval_ro
+     */
+    evalRo: <TArgs extends unknown[], TData = unknown>(script: string, keys: string[], args: TArgs) => Promise<TData>;
     /**
      * @see https://redis.io/commands/eval
      */
     eval: <TArgs extends unknown[], TData = unknown>(script: string, keys: string[], args: TArgs) => Promise<TData>;
+    /**
+     * @see https://redis.io/commands/evalsha_ro
+     */
+    evalshaRo: <TArgs extends unknown[], TData = unknown>(sha1: string, keys: string[], args: TArgs) => Promise<TData>;
     /**
      * @see https://redis.io/commands/evalsha
      */
     evalsha: <TArgs extends unknown[], TData = unknown>(sha1: string, keys: string[], args: TArgs) => Promise<TData>;
+    /**
+     * Generic method to execute any Redis command.
+     */
+    exec: <TResult>(args: [command: string, ...args: (string | number | boolean)[]]) => Promise<TResult>;
     /**
      * @see https://redis.io/commands/exists
      */
@@ -2617,11 +3259,11 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/expire
      */
-    expire: (key: string, seconds: number) => Promise<0 | 1>;
+    expire: (key: string, seconds: number, option?: ExpireOption | undefined) => Promise<0 | 1>;
     /**
      * @see https://redis.io/commands/expireat
      */
-    expireat: (key: string, unix: number) => Promise<0 | 1>;
+    expireat: (key: string, unix: number, option?: ExpireOption | undefined) => Promise<0 | 1>;
     /**
      * @see https://redis.io/commands/flushall
      */
@@ -2630,8 +3272,98 @@ declare class Redis {
      * @see https://redis.io/commands/flushdb
      */
     flushdb: (opts?: {
-        async?: boolean | undefined;
+        async?: boolean;
     } | undefined) => Promise<"OK">;
+    /**
+     * @see https://redis.io/commands/geoadd
+     */
+    geoadd: <TData>(args_0: string, args_1: GeoAddCommandOptions | GeoMember<TData>, ...args_2: GeoMember<TData>[]) => Promise<number | null>;
+    /**
+     * @see https://redis.io/commands/geopos
+     */
+    geopos: <TData>(args_0: string, ...args_1: TData[]) => Promise<{
+        lng: number;
+        lat: number;
+    }[]>;
+    /**
+     * @see https://redis.io/commands/geodist
+     */
+    geodist: <TData>(key: string, member1: TData, member2: TData, unit?: "M" | "KM" | "FT" | "MI" | undefined) => Promise<number | null>;
+    /**
+     * @see https://redis.io/commands/geohash
+     */
+    geohash: <TData>(args_0: string, ...args_1: TData[]) => Promise<(string | null)[]>;
+    /**
+     * @see https://redis.io/commands/geosearch
+     */
+    geosearch: <TData>(key: string, centerPoint: {
+        type: "FROMLONLAT" | "fromlonlat";
+        coordinate: {
+            lon: number;
+            lat: number;
+        };
+    } | {
+        type: "FROMMEMBER" | "frommember";
+        member: TData;
+    }, shape: {
+        type: "BYRADIUS" | "byradius";
+        radius: number;
+        radiusType: "M" | "KM" | "FT" | "MI";
+    } | {
+        type: "BYBOX" | "bybox";
+        rect: {
+            width: number;
+            height: number;
+        };
+        rectType: "M" | "KM" | "FT" | "MI";
+    }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
+        count?: {
+            limit: number;
+            any?: boolean;
+        };
+        withCoord?: boolean;
+        withDist?: boolean;
+        withHash?: boolean;
+    } | undefined) => Promise<({
+        member: TData;
+    } & {
+        coord?: {
+            long: number;
+            lat: number;
+        } | undefined;
+        dist?: number | undefined;
+        hash?: string | undefined;
+    })[]>;
+    /**
+     * @see https://redis.io/commands/geosearchstore
+     */
+    geosearchstore: <TData>(destination: string, key: string, centerPoint: {
+        type: "FROMLONLAT" | "fromlonlat";
+        coordinate: {
+            lon: number;
+            lat: number;
+        };
+    } | {
+        type: "FROMMEMBER" | "frommember";
+        member: TData;
+    }, shape: {
+        type: "BYRADIUS" | "byradius";
+        radius: number;
+        radiusType: "M" | "KM" | "FT" | "MI";
+    } | {
+        type: "BYBOX" | "bybox";
+        rect: {
+            width: number;
+            height: number;
+        };
+        rectType: "M" | "KM" | "FT" | "MI";
+    }, order: "ASC" | "DESC" | "asc" | "desc", opts?: {
+        count?: {
+            limit: number;
+            any?: boolean;
+        };
+        storeDist?: boolean;
+    } | undefined) => Promise<number>;
     /**
      * @see https://redis.io/commands/get
      */
@@ -2644,6 +3376,46 @@ declare class Redis {
      * @see https://redis.io/commands/getdel
      */
     getdel: <TData>(key: string) => Promise<TData | null>;
+    /**
+     * @see https://redis.io/commands/getex
+     */
+    getex: <TData>(key: string, opts?: ({
+        ex: number;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px: number;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat: number;
+        pxat?: never;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat: number;
+        persist?: never;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist: true;
+    } | {
+        ex?: never;
+        px?: never;
+        exat?: never;
+        pxat?: never;
+        persist?: never;
+    }) | undefined) => Promise<TData | null>;
     /**
      * @see https://redis.io/commands/getrange
      */
@@ -2660,6 +3432,42 @@ declare class Redis {
      * @see https://redis.io/commands/hexists
      */
     hexists: (key: string, field: string) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/hexpire
+     */
+    hexpire: (key: string, fields: string | number | (string | number)[], seconds: number, option?: ExpireOption | undefined) => Promise<(0 | 1 | 2 | -2)[]>;
+    /**
+     * @see https://redis.io/commands/hexpireat
+     */
+    hexpireat: (key: string, fields: string | number | (string | number)[], timestamp: number, option?: ExpireOption | undefined) => Promise<(0 | 1 | 2 | -2)[]>;
+    /**
+     * @see https://redis.io/commands/hexpiretime
+     */
+    hexpiretime: (key: string, fields: string | number | (string | number)[]) => Promise<number[]>;
+    /**
+     * @see https://redis.io/commands/httl
+     */
+    httl: (key: string, fields: string | number | (string | number)[]) => Promise<number[]>;
+    /**
+     * @see https://redis.io/commands/hpexpire
+     */
+    hpexpire: (key: string, fields: string | number | (string | number)[], milliseconds: number, option?: ExpireOption | undefined) => Promise<(0 | 1 | 2 | -2)[]>;
+    /**
+     * @see https://redis.io/commands/hpexpireat
+     */
+    hpexpireat: (key: string, fields: string | number | (string | number)[], timestamp: number, option?: ExpireOption | undefined) => Promise<(0 | 1 | 2 | -2)[]>;
+    /**
+     * @see https://redis.io/commands/hpexpiretime
+     */
+    hpexpiretime: (key: string, fields: string | number | (string | number)[]) => Promise<number[]>;
+    /**
+     * @see https://redis.io/commands/hpttl
+     */
+    hpttl: (key: string, fields: string | number | (string | number)[]) => Promise<number[]>;
+    /**
+     * @see https://redis.io/commands/hpersist
+     */
+    hpersist: (key: string, fields: string | number | (string | number)[]) => Promise<(1 | -2 | -1)[]>;
     /**
      * @see https://redis.io/commands/hget
      */
@@ -2691,27 +3499,23 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/hmset
      */
-    hmset: <TData>(key: string, kv: {
-        [field: string]: TData;
-    }) => Promise<"OK">;
+    hmset: <TData>(key: string, kv: Record<string, TData>) => Promise<"OK">;
     /**
      * @see https://redis.io/commands/hrandfield
      */
     hrandfield: {
-        (key: string): Promise<string>;
+        (key: string): Promise<string | null>;
         (key: string, count: number): Promise<string[]>;
         <TData extends Record<string, unknown>>(key: string, count: number, withValues: boolean): Promise<Partial<TData>>;
     };
     /**
      * @see https://redis.io/commands/hscan
      */
-    hscan: (key: string, cursor: number, cmdOpts?: ScanCommandOptions | undefined) => Promise<[number, (string | number)[]]>;
+    hscan: (key: string, cursor: string | number, cmdOpts?: ScanCommandOptions | undefined) => Promise<[string, (string | number)[]]>;
     /**
      * @see https://redis.io/commands/hset
      */
-    hset: <TData>(key: string, kv: {
-        [field: string]: TData;
-    }) => Promise<number>;
+    hset: <TData>(key: string, kv: Record<string, TData>) => Promise<number>;
     /**
      * @see https://redis.io/commands/hsetnx
      */
@@ -2760,13 +3564,17 @@ declare class Redis {
      * @see https://redis.io/commands/lpop
      */
     lpop: <TData>(key: string, count?: number | undefined) => Promise<TData | null>;
+    /**
+     * @see https://redis.io/commands/lmpop
+     */
+    lmpop: <TData>(numkeys: number, keys: string[], args_2: "LEFT" | "RIGHT", count?: number | undefined) => Promise<[string, TData[]] | null>;
     /**
      * @see https://redis.io/commands/lpos
      */
     lpos: <TData = number>(key: string, element: unknown, opts?: {
-        rank?: number | undefined;
-        count?: number | undefined;
-        maxLen?: number | undefined;
+        rank?: number;
+        count?: number;
+        maxLen?: number;
     } | undefined) => Promise<TData>;
     /**
      * @see https://redis.io/commands/lpush
@@ -2799,15 +3607,11 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/mset
      */
-    mset: <TData>(kv: {
-        [key: string]: TData;
-    }) => Promise<"OK">;
+    mset: <TData>(kv: Record<string, TData>) => Promise<"OK">;
     /**
      * @see https://redis.io/commands/msetnx
      */
-    msetnx: <TData>(kv: {
-        [key: string]: TData;
-    }) => Promise<number>;
+    msetnx: <TData>(kv: Record<string, TData>) => Promise<number>;
     /**
      * @see https://redis.io/commands/persist
      */
@@ -2815,11 +3619,23 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/pexpire
      */
-    pexpire: (key: string, milliseconds: number) => Promise<0 | 1>;
+    pexpire: (key: string, milliseconds: number, option?: ExpireOption | undefined) => Promise<0 | 1>;
     /**
      * @see https://redis.io/commands/pexpireat
      */
-    pexpireat: (key: string, unix: number) => Promise<0 | 1>;
+    pexpireat: (key: string, unix: number, option?: ExpireOption | undefined) => Promise<0 | 1>;
+    /**
+     * @see https://redis.io/commands/pfadd
+     */
+    pfadd: (args_0: string, ...args_1: unknown[]) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/pfcount
+     */
+    pfcount: (args_0: string, ...args_1: string[]) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/pfmerge
+     */
+    pfmerge: (destination_key: string, ...args_1: string[]) => Promise<"OK">;
     /**
      * @see https://redis.io/commands/ping
      */
@@ -2828,6 +3644,10 @@ declare class Redis {
      * @see https://redis.io/commands/psetex
      */
     psetex: <TData>(key: string, ttl: number, value: TData) => Promise<string>;
+    /**
+     * @see https://redis.io/commands/psubscribe
+     */
+    psubscribe: <TMessage>(patterns: string | string[]) => Subscriber<TMessage>;
     /**
      * @see https://redis.io/commands/pttl
      */
@@ -2863,11 +3683,14 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/sadd
      */
-    sadd: <TData>(key: string, ...members: TData[]) => Promise<number>;
+    sadd: <TData>(key: string, member: TData, ...members: TData[]) => Promise<number>;
     /**
      * @see https://redis.io/commands/scan
      */
-    scan: (cursor: number, opts?: ScanCommandOptions | undefined) => Promise<[number, string[]]>;
+    scan(cursor: string | number): Promise<ScanResultStandard>;
+    scan<TOptions extends ScanCommandOptions>(cursor: string | number, opts: TOptions): Promise<TOptions extends {
+        withType: true;
+    } ? ScanResultWithType : ScanResultStandard>;
     /**
      * @see https://redis.io/commands/scard
      */
@@ -2951,11 +3774,15 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/sscan
      */
-    sscan: (key: string, cursor: number, opts?: ScanCommandOptions | undefined) => Promise<[number, (string | number)[]]>;
+    sscan: (key: string, cursor: string | number, opts?: ScanCommandOptions | undefined) => Promise<[string, (string | number)[]]>;
     /**
      * @see https://redis.io/commands/strlen
      */
     strlen: (key: string) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/subscribe
+     */
+    subscribe: <TMessage>(channels: string | string[]) => Subscriber<TMessage>;
     /**
      * @see https://redis.io/commands/sunion
      */
@@ -2987,11 +3814,9 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/xadd
      */
-    xadd: (key: string, id: string, entries: {
-        [field: string]: unknown;
-    }, opts?: {
-        nomkStream?: boolean | undefined;
-        trim?: (({
+    xadd: (key: string, id: string, entries: Record<string, unknown>, opts?: {
+        nomkStream?: boolean;
+        trim?: ({
             type: "MAXLEN" | "maxlen";
             threshold: number;
         } | {
@@ -2999,20 +3824,117 @@ declare class Redis {
             threshold: string;
         }) & ({
             comparison: "~";
-            limit?: number | undefined;
+            limit?: number;
         } | {
             comparison: "=";
-            limit?: undefined;
-        })) | undefined;
+            limit?: never;
+        });
     } | undefined) => Promise<string>;
+    /**
+     * @see https://redis.io/commands/xack
+     */
+    xack: (key: string, group: string, id: string | string[]) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/xdel
+     */
+    xdel: (key: string, ids: string | string[]) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/xgroup
+     */
+    xgroup: (key: string, opts: {
+        type: "CREATE";
+        group: string;
+        id: `$` | string;
+        options?: {
+            MKSTREAM?: boolean;
+            ENTRIESREAD?: number;
+        };
+    } | {
+        type: "CREATECONSUMER";
+        group: string;
+        consumer: string;
+    } | {
+        type: "DELCONSUMER";
+        group: string;
+        consumer: string;
+    } | {
+        type: "DESTROY";
+        group: string;
+    } | {
+        type: "SETID";
+        group: string;
+        id: `$` | string;
+        options?: {
+            ENTRIESREAD?: number;
+        };
+    }) => Promise<never>;
+    /**
+     * @see https://redis.io/commands/xread
+     */
+    xread: (...args: CommandArgs<typeof XReadCommand>) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xreadgroup
+     */
+    xreadgroup: (...args: CommandArgs<typeof XReadGroupCommand>) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xinfo
+     */
+    xinfo: (key: string, options: {
+        type: "CONSUMERS";
+        group: string;
+    } | {
+        type: "GROUPS";
+    }) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xlen
+     */
+    xlen: (key: string) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/xpending
+     */
+    xpending: (key: string, group: string, start: string, end: string, count: number, options?: {
+        idleTime?: number;
+        consumer?: string | string[];
+    } | undefined) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xclaim
+     */
+    xclaim: (key: string, group: string, consumer: string, minIdleTime: number, id: string | string[], options?: {
+        idleMS?: number;
+        timeMS?: number;
+        retryCount?: number;
+        force?: boolean;
+        justId?: boolean;
+        lastId?: number;
+    } | undefined) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xautoclaim
+     */
+    xautoclaim: (key: string, group: string, consumer: string, minIdleTime: number, start: string, options?: {
+        count?: number;
+        justId?: boolean;
+    } | undefined) => Promise<unknown[]>;
+    /**
+     * @see https://redis.io/commands/xtrim
+     */
+    xtrim: (key: string, options: {
+        strategy: "MAXLEN" | "MINID";
+        exactness?: "~" | "=";
+        threshold: number | string;
+        limit?: number;
+    }) => Promise<number>;
     /**
      * @see https://redis.io/commands/xrange
      */
     xrange: (key: string, start: string, end: string, count?: number | undefined) => Promise<Record<string, Record<string, unknown>>>;
+    /**
+     * @see https://redis.io/commands/xrevrange
+     */
+    xrevrange: (key: string, end: string, start: string, count?: number | undefined) => Promise<Record<string, Record<string, unknown>>>;
     /**
      * @see https://redis.io/commands/zadd
      */
-    zadd: <TData>(...args: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]] | [key: string, opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr, ScoreMember<TData>, ...ScoreMember<TData>[]]) => Promise<number | null>;
+    zadd: <TData>(...args: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]] | [key: string, opts: ZAddCommandOptions, ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]]) => Promise<number | null>;
     /**
      * @see https://redis.io/commands/zcard
      */
@@ -3052,21 +3974,11 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/zrange
      */
-    zrange: <TData extends unknown[]>(...args: [key: string, min: number, max: number, opts?: ZRangeCommandOptions] | [
-        key: string,
-        min: `(${string}` | `[${string}` | "-" | "+",
-        max: `(${string}` | `[${string}` | "-" | "+",
-        opts: {
-            byLex: true;
-        } & ZRangeCommandOptions
-    ] | [
-        key: string,
-        min: number | `(${number}` | "-inf" | "+inf",
-        max: number | `(${number}` | "-inf" | "+inf",
-        opts: {
-            byScore: true;
-        } & ZRangeCommandOptions
-    ]) => Promise<TData>;
+    zrange: <TData extends unknown[]>(...args: [key: string, min: number, max: number, opts?: ZRangeCommandOptions] | [key: string, min: `(${string}` | `[${string}` | "-" | "+", max: `(${string}` | `[${string}` | "-" | "+", opts: {
+        byLex: true;
+    } & ZRangeCommandOptions] | [key: string, min: number | `(${number}` | "-inf" | "+inf", max: number | `(${number}` | "-inf" | "+inf", opts: {
+        byScore: true;
+    } & ZRangeCommandOptions]) => Promise<TData>;
     /**
      * @see https://redis.io/commands/zrank
      */
@@ -3086,7 +3998,7 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/zremrangebyscore
      */
-    zremrangebyscore: (key: string, min: number, max: number) => Promise<number>;
+    zremrangebyscore: (key: string, min: number | `(${number}` | "-inf" | "+inf", max: number | `(${number}` | "-inf" | "+inf") => Promise<number>;
     /**
      * @see https://redis.io/commands/zrevrank
      */
@@ -3094,7 +4006,7 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/zscan
      */
-    zscan: (key: string, cursor: number, opts?: ScanCommandOptions | undefined) => Promise<[number, (string | number)[]]>;
+    zscan: (key: string, cursor: string | number, opts?: ScanCommandOptions | undefined) => Promise<[string, (string | number)[]]>;
     /**
      * @see https://redis.io/commands/zscore
      */
@@ -3109,6 +4021,30 @@ declare class Redis {
     zunionstore: (destination: string, numKeys: number, keys: string[], opts?: ZUnionStoreCommandOptions | undefined) => Promise<number>;
 }
 
+type UpstashErrorOptions = Pick<NonNullable<ConstructorParameters<typeof Error>[1]>, "cause">;
+/**
+ * Result of a bad request to upstash
+ */
+declare class UpstashError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+declare class UrlError extends Error {
+    constructor(url: string);
+}
+declare class UpstashJSONParseError extends UpstashError {
+    constructor(body: string, options?: UpstashErrorOptions);
+}
+
+type error_UpstashError = UpstashError;
+declare const error_UpstashError: typeof UpstashError;
+type error_UpstashJSONParseError = UpstashJSONParseError;
+declare const error_UpstashJSONParseError: typeof UpstashJSONParseError;
+type error_UrlError = UrlError;
+declare const error_UrlError: typeof UrlError;
+declare namespace error {
+  export { error_UpstashError as UpstashError, error_UpstashJSONParseError as UpstashJSONParseError, error_UrlError as UrlError };
+}
+
 /**
  * @see https://redis.io/commands/zdiffstore
  */
@@ -3123,4 +4059,4 @@ declare class ZMScoreCommand<TData> extends Command<string[] | null, number[] |
     constructor(cmd: [key: string, members: TData[]], opts?: CommandOptions<string[] | null, number[] | null>);
 }
 
-export { IncrByCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, GetSetCommand as H, HDelCommand as I, HExistsCommand as J, HGetCommand as K, HGetAllCommand as L, HIncrByCommand as M, HIncrByFloatCommand as N, HKeysCommand as O, HLenCommand as P, HMGetCommand as Q, RedisOptions as R, HMSetCommand as S, HRandFieldCommand as T, UpstashRequest as U, HScanCommand as V, HSetCommand as W, HSetNXCommand as X, HStrLenCommand as Y, HValsCommand as Z, IncrCommand as _, RequesterConfig as a, SetNxCommand as a$, IncrByFloatCommand as a0, JsonArrAppendCommand as a1, JsonArrIndexCommand as a2, JsonArrInsertCommand as a3, JsonArrLenCommand as a4, JsonArrPopCommand as a5, JsonArrTrimCommand as a6, JsonClearCommand as a7, JsonDelCommand as a8, JsonForgetCommand as a9, MSetNXCommand as aA, PersistCommand as aB, PExpireCommand as aC, PExpireAtCommand as aD, PingCommand as aE, PSetEXCommand as aF, PTtlCommand as aG, PublishCommand as aH, RandomKeyCommand as aI, RenameCommand as aJ, RenameNXCommand as aK, RPopCommand as aL, RPushCommand as aM, RPushXCommand as aN, SAddCommand as aO, ScanCommand as aP, ScanCommandOptions as aQ, SCardCommand as aR, ScriptExistsCommand as aS, ScriptFlushCommand as aT, ScriptLoadCommand as aU, SDiffCommand as aV, SDiffStoreCommand as aW, SetCommand as aX, SetCommandOptions as aY, SetBitCommand as aZ, SetExCommand as a_, JsonGetCommand as aa, JsonMGetCommand as ab, JsonNumIncrByCommand as ac, JsonNumMultByCommand as ad, JsonObjKeysCommand as ae, JsonObjLenCommand as af, JsonRespCommand as ag, JsonSetCommand as ah, JsonStrAppendCommand as ai, JsonStrLenCommand as aj, JsonToggleCommand as ak, JsonTypeCommand as al, KeysCommand as am, LIndexCommand as an, LInsertCommand as ao, LLenCommand as ap, LMoveCommand as aq, LPopCommand as ar, LPushCommand as as, LPushXCommand as at, LRangeCommand as au, LRemCommand as av, LSetCommand as aw, LTrimCommand as ax, MGetCommand as ay, MSetCommand as az, Redis as b, SetRangeCommand as b0, SInterCommand as b1, SInterStoreCommand as b2, SIsMemberCommand as b3, SMembersCommand as b4, SMIsMemberCommand as b5, SMoveCommand as b6, SPopCommand as b7, SRandMemberCommand as b8, SRemCommand as b9, ZRangeCommand as bA, ZRangeCommandOptions as bB, ZRankCommand as bC, ZRemCommand as bD, ZRemRangeByLexCommand as bE, ZRemRangeByRankCommand as bF, ZRemRangeByScoreCommand as bG, ZRevRankCommand as bH, ZScanCommand as bI, ZScoreCommand as bJ, ZUnionCommand as bK, ZUnionCommandOptions as bL, ZUnionStoreCommand as bM, ZUnionStoreCommandOptions as bN, SScanCommand as ba, StrLenCommand as bb, SUnionCommand as bc, SUnionStoreCommand as bd, TimeCommand as be, TouchCommand as bf, TtlCommand as bg, Type as bh, TypeCommand as bi, UnlinkCommand as bj, XAddCommand as bk, XRangeCommand as bl, ScoreMember as bm, ZAddCommandOptions as bn, ZAddCommandOptionsWithIncr as bo, ZAddCommand as bp, ZCardCommand as bq, ZCountCommand as br, ZDiffStoreCommand as bs, ZIncrByCommand as bt, ZInterStoreCommand as bu, ZInterStoreCommandOptions as bv, ZLexCountCommand as bw, ZMScoreCommand as bx, ZPopMaxCommand as by, ZPopMinCommand as bz, Requester as c, UpstashResponse as d, BitOpCommand as e, BitPosCommand as f, DecrCommand as g, DecrByCommand as h, DelCommand as i, EvalCommand as j, EvalshaCommand as k, ExistsCommand as l, ExpireCommand as m, ExpireAtCommand as n, FlushDBCommand as o, GeoAddCommandOptions as p, GeoMember as q, GeoDistCommand as r, GeoHashCommand as s, GeoPosCommand as t, GeoSearchCommand as u, GeoSearchStoreCommand as v, GetCommand as w, GetBitCommand as x, GetDelCommand as y, GetRangeCommand as z };
+export { HPersistCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, type HttpClientConfig as H, GetCommand as I, GetBitCommand as J, GetDelCommand as K, GetExCommand as L, GetRangeCommand as M, GetSetCommand as N, HDelCommand as O, Pipeline as P, HExistsCommand as Q, type RedisOptions as R, HExpireCommand as S, HExpireAtCommand as T, type UpstashRequest as U, HExpireTimeCommand as V, HTtlCommand as W, HPExpireCommand as X, HPExpireAtCommand as Y, HPExpireTimeCommand as Z, HPTtlCommand as _, type RequesterConfig as a, RenameNXCommand as a$, HGetCommand as a0, HGetAllCommand as a1, HIncrByCommand as a2, HIncrByFloatCommand as a3, HKeysCommand as a4, HLenCommand as a5, HMGetCommand as a6, HMSetCommand as a7, HRandFieldCommand as a8, HScanCommand as a9, JsonStrLenCommand as aA, JsonToggleCommand as aB, JsonTypeCommand as aC, KeysCommand as aD, LIndexCommand as aE, LInsertCommand as aF, LLenCommand as aG, LMoveCommand as aH, LPopCommand as aI, LPushCommand as aJ, LPushXCommand as aK, LRangeCommand as aL, LRemCommand as aM, LSetCommand as aN, LTrimCommand as aO, MGetCommand as aP, MSetCommand as aQ, MSetNXCommand as aR, PersistCommand as aS, PExpireCommand as aT, PExpireAtCommand as aU, PingCommand as aV, PSetEXCommand as aW, PTtlCommand as aX, PublishCommand as aY, RandomKeyCommand as aZ, RenameCommand as a_, HSetCommand as aa, HSetNXCommand as ab, HStrLenCommand as ac, HValsCommand as ad, IncrCommand as ae, IncrByCommand as af, IncrByFloatCommand as ag, JsonArrAppendCommand as ah, JsonArrIndexCommand as ai, JsonArrInsertCommand as aj, JsonArrLenCommand as ak, JsonArrPopCommand as al, JsonArrTrimCommand as am, JsonClearCommand as an, JsonDelCommand as ao, JsonForgetCommand as ap, JsonGetCommand as aq, JsonMergeCommand as ar, JsonMGetCommand as as, JsonNumIncrByCommand as at, JsonNumMultByCommand as au, JsonObjKeysCommand as av, JsonObjLenCommand as aw, JsonRespCommand as ax, JsonSetCommand as ay, JsonStrAppendCommand as az, Redis as b, type ZUnionCommandOptions as b$, RPopCommand as b0, RPushCommand as b1, RPushXCommand as b2, SAddCommand as b3, ScanCommand as b4, type ScanCommandOptions as b5, SCardCommand as b6, ScriptExistsCommand as b7, ScriptFlushCommand as b8, ScriptLoadCommand as b9, UnlinkCommand as bA, XAddCommand as bB, XRangeCommand as bC, type ScoreMember as bD, type ZAddCommandOptions as bE, ZAddCommand as bF, ZCardCommand as bG, ZCountCommand as bH, ZDiffStoreCommand as bI, ZIncrByCommand as bJ, ZInterStoreCommand as bK, type ZInterStoreCommandOptions as bL, ZLexCountCommand as bM, ZMScoreCommand as bN, ZPopMaxCommand as bO, ZPopMinCommand as bP, ZRangeCommand as bQ, type ZRangeCommandOptions as bR, ZRankCommand as bS, ZRemCommand as bT, ZRemRangeByLexCommand as bU, ZRemRangeByRankCommand as bV, ZRemRangeByScoreCommand as bW, ZRevRankCommand as bX, ZScanCommand as bY, ZScoreCommand as bZ, ZUnionCommand as b_, SDiffCommand as ba, SDiffStoreCommand as bb, SetCommand as bc, type SetCommandOptions as bd, SetBitCommand as be, SetExCommand as bf, SetNxCommand as bg, SetRangeCommand as bh, SInterCommand as bi, SInterStoreCommand as bj, SIsMemberCommand as bk, SMembersCommand as bl, SMIsMemberCommand as bm, SMoveCommand as bn, SPopCommand as bo, SRandMemberCommand as bp, SRemCommand as bq, SScanCommand as br, StrLenCommand as bs, SUnionCommand as bt, SUnionStoreCommand as bu, TimeCommand as bv, TouchCommand as bw, TtlCommand as bx, type Type as by, TypeCommand as bz, type Requester as c, ZUnionStoreCommand as c0, type ZUnionStoreCommandOptions as c1, type UpstashResponse as d, error as e, BitOpCommand as f, BitPosCommand as g, DecrCommand as h, DecrByCommand as i, DelCommand as j, EvalROCommand as k, EvalCommand as l, EvalshaROCommand as m, EvalshaCommand as n, ExistsCommand as o, ExpireCommand as p, type ExpireOption as q, ExpireAtCommand as r, FlushDBCommand as s, type GeoAddCommandOptions as t, type GeoMember as u, GeoDistCommand as v, GeoHashCommand as w, GeoPosCommand as x, GeoSearchCommand as y, GeoSearchStoreCommand as z };