@upstash/redis 0.0.0-ci.e9b0c868305a820aaed7d68c8407b277da5a093e-20241008121230 → 0.0.0-ci.ea9f0853d6a86e6b7809a21bff609de1b6e9291d-20250414063537

package/{zmscore-BLgYk16R.d.ts → zmscore-CjoCv9kz.d.ts}

@@ -36,7 +36,23 @@ 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;
@@ -119,6 +135,31 @@ type CommandOptions<TResult, TData> = {
      */
     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.
@@ -130,6 +171,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.
      *
@@ -262,6 +308,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
  */
@@ -358,6 +409,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
  */
@@ -365,6 +423,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
  */
@@ -379,16 +444,11 @@ declare class ExistsCommand extends Command<number, number> {
     constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>);
 }
 
-type ExpireOptions = "NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt";
-declare class ExpireCommand extends Command<"0" | "1", 0 | 1> {
-    constructor(cmd: [key: string, seconds: number, option?: ExpireOptions], 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>);
 }
 
 /**
@@ -563,6 +623,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
  */
@@ -591,6 +695,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
  */
@@ -698,6 +854,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
  */
@@ -804,6 +964,13 @@ 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
  */
@@ -1006,14 +1173,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>);
 }
 
 /**
@@ -1599,9 +1766,78 @@ 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;
+    constructor(client: Requester, channels: string[], isPattern?: boolean);
+    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.
@@ -1650,19 +1886,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
      */
@@ -1738,10 +1962,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
      */
@@ -1753,11 +1985,11 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
     /**
      * @see https://redis.io/commands/expire
      */
-    expire: (key: string, seconds: number, option?: ("NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt") | undefined) => 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
      */
@@ -1870,6 +2102,46 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @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
      */
@@ -1886,6 +2158,42 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
      * @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
      */
@@ -2033,11 +2341,11 @@ 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
      */
@@ -2459,6 +2767,10 @@ declare class Pipeline<TCommands extends Command<any, any>[] = []> {
          * @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
          */
@@ -2558,6 +2870,48 @@ 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;
+    readonly sha1: string;
+    private readonly redis;
+    constructor(redis: Redis, script: string);
+    /**
+     * 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.
  */
@@ -2621,6 +2975,10 @@ declare class Redis {
          * @see https://redis.io/commands/json.get
          */
         get: <TData>(...args: CommandArgs<typeof JsonGetCommand>) => Promise<TData | null>;
+        /**
+         * @see https://redis.io/commands/json.merge
+         */
+        merge: (key: string, path: string, value: string | number | unknown[] | Record<string, unknown>) => Promise<"OK" | null>;
         /**
          * @see https://redis.io/commands/json.mget
          */
@@ -2684,7 +3042,37 @@ 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.
      *
@@ -2763,14 +3151,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
      */
@@ -2778,11 +3178,11 @@ declare class Redis {
     /**
      * @see https://redis.io/commands/expire
      */
-    expire: (key: string, seconds: number, option?: ("NX" | "nx" | "XX" | "xx" | "GT" | "gt" | "LT" | "lt") | undefined) => 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
      */
@@ -2895,6 +3295,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
      */
@@ -2911,6 +3351,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
      */
@@ -3062,11 +3538,11 @@ 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
      */
@@ -3087,6 +3563,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
      */
@@ -3215,6 +3695,10 @@ declare class Redis {
      * @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
      */
@@ -3485,4 +3969,4 @@ declare class ZMScoreCommand<TData> extends Command<string[] | null, number[] |
     constructor(cmd: [key: string, members: TData[]], opts?: CommandOptions<string[] | null, number[] | null>);
 }
 
-export { HValsCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, GetRangeCommand as H, GetSetCommand as I, HDelCommand as J, HExistsCommand as K, HGetCommand as L, HGetAllCommand as M, HIncrByCommand as N, HIncrByFloatCommand as O, Pipeline as P, HKeysCommand as Q, type RedisOptions as R, HLenCommand as S, HMGetCommand as T, type UpstashRequest as U, HMSetCommand as V, HRandFieldCommand as W, HScanCommand as X, HSetCommand as Y, HSetNXCommand as Z, HStrLenCommand as _, type RequesterConfig as a, SetBitCommand as a$, IncrCommand as a0, IncrByCommand as a1, IncrByFloatCommand as a2, JsonArrAppendCommand as a3, JsonArrIndexCommand as a4, JsonArrInsertCommand as a5, JsonArrLenCommand as a6, JsonArrPopCommand as a7, JsonArrTrimCommand as a8, JsonClearCommand as a9, MGetCommand as aA, MSetCommand as aB, MSetNXCommand as aC, PersistCommand as aD, PExpireCommand as aE, PExpireAtCommand as aF, PingCommand as aG, PSetEXCommand as aH, PTtlCommand as aI, PublishCommand as aJ, RandomKeyCommand as aK, RenameCommand as aL, RenameNXCommand as aM, RPopCommand as aN, RPushCommand as aO, RPushXCommand as aP, SAddCommand as aQ, ScanCommand as aR, type ScanCommandOptions as aS, SCardCommand as aT, ScriptExistsCommand as aU, ScriptFlushCommand as aV, ScriptLoadCommand as aW, SDiffCommand as aX, SDiffStoreCommand as aY, SetCommand as aZ, type SetCommandOptions as a_, JsonDelCommand as aa, JsonForgetCommand as ab, JsonGetCommand as ac, JsonMGetCommand as ad, JsonNumIncrByCommand as ae, JsonNumMultByCommand as af, JsonObjKeysCommand as ag, JsonObjLenCommand as ah, JsonRespCommand as ai, JsonSetCommand as aj, JsonStrAppendCommand as ak, JsonStrLenCommand as al, JsonToggleCommand as am, JsonTypeCommand as an, KeysCommand as ao, LIndexCommand as ap, LInsertCommand as aq, LLenCommand as ar, LMoveCommand as as, LPopCommand as at, LPushCommand as au, LPushXCommand as av, LRangeCommand as aw, LRemCommand as ax, LSetCommand as ay, LTrimCommand as az, Redis as b, SetExCommand as b0, SetNxCommand as b1, SetRangeCommand as b2, SInterCommand as b3, SInterStoreCommand as b4, SIsMemberCommand as b5, SMembersCommand as b6, SMIsMemberCommand as b7, SMoveCommand as b8, SPopCommand as b9, ZPopMinCommand as bA, ZRangeCommand as bB, type ZRangeCommandOptions as bC, ZRankCommand as bD, ZRemCommand as bE, ZRemRangeByLexCommand as bF, ZRemRangeByRankCommand as bG, ZRemRangeByScoreCommand as bH, ZRevRankCommand as bI, ZScanCommand as bJ, ZScoreCommand as bK, ZUnionCommand as bL, type ZUnionCommandOptions as bM, ZUnionStoreCommand as bN, type ZUnionStoreCommandOptions as bO, SRandMemberCommand as ba, SRemCommand as bb, SScanCommand as bc, StrLenCommand as bd, SUnionCommand as be, SUnionStoreCommand as bf, TimeCommand as bg, TouchCommand as bh, TtlCommand as bi, type Type as bj, TypeCommand as bk, UnlinkCommand as bl, XAddCommand as bm, XRangeCommand as bn, type ScoreMember as bo, type ZAddCommandOptions as bp, ZAddCommand as bq, ZCardCommand as br, ZCountCommand as bs, ZDiffStoreCommand as bt, ZIncrByCommand as bu, ZInterStoreCommand as bv, type ZInterStoreCommandOptions as bw, ZLexCountCommand as bx, ZMScoreCommand as by, ZPopMaxCommand as bz, type UpstashResponse as c, type Requester as d, error as e, BitOpCommand as f, BitPosCommand as g, DecrCommand as h, DecrByCommand as i, DelCommand as j, EvalCommand as k, EvalshaCommand as l, ExistsCommand as m, ExpireCommand as n, ExpireAtCommand as o, FlushDBCommand as p, type GeoAddCommandOptions as q, type GeoMember as r, GeoDistCommand as s, GeoHashCommand as t, GeoPosCommand as u, GeoSearchCommand as v, GeoSearchStoreCommand as w, GetCommand as x, GetBitCommand as y, GetDelCommand as z };
+export { HGetCommand as $, AppendCommand as A, BitCountCommand as B, CopyCommand as C, DBSizeCommand as D, EchoCommand as E, FlushAllCommand as F, GeoAddCommand as G, GetCommand as H, GetBitCommand as I, GetDelCommand as J, GetExCommand as K, GetRangeCommand as L, GetSetCommand as M, HDelCommand as N, HExistsCommand as O, Pipeline as P, HExpireCommand as Q, type RedisOptions as R, HExpireAtCommand as S, HExpireTimeCommand as T, type UpstashRequest as U, HTtlCommand as V, HPExpireCommand as W, HPExpireAtCommand as X, HPExpireTimeCommand as Y, HPTtlCommand as Z, HPersistCommand as _, type RequesterConfig as a, RPopCommand as a$, HGetAllCommand as a0, HIncrByCommand as a1, HIncrByFloatCommand as a2, HKeysCommand as a3, HLenCommand as a4, HMGetCommand as a5, HMSetCommand as a6, HRandFieldCommand as a7, HScanCommand as a8, HSetCommand as a9, JsonToggleCommand as aA, JsonTypeCommand as aB, KeysCommand as aC, LIndexCommand as aD, LInsertCommand as aE, LLenCommand as aF, LMoveCommand as aG, LPopCommand as aH, LPushCommand as aI, LPushXCommand as aJ, LRangeCommand as aK, LRemCommand as aL, LSetCommand as aM, LTrimCommand as aN, MGetCommand as aO, MSetCommand as aP, MSetNXCommand as aQ, PersistCommand as aR, PExpireCommand as aS, PExpireAtCommand as aT, PingCommand as aU, PSetEXCommand as aV, PTtlCommand as aW, PublishCommand as aX, RandomKeyCommand as aY, RenameCommand as aZ, RenameNXCommand as a_, HSetNXCommand as aa, HStrLenCommand as ab, HValsCommand as ac, IncrCommand as ad, IncrByCommand as ae, IncrByFloatCommand as af, JsonArrAppendCommand as ag, JsonArrIndexCommand as ah, JsonArrInsertCommand as ai, JsonArrLenCommand as aj, JsonArrPopCommand as ak, JsonArrTrimCommand as al, JsonClearCommand as am, JsonDelCommand as an, JsonForgetCommand as ao, JsonGetCommand as ap, JsonMergeCommand as aq, JsonMGetCommand as ar, JsonNumIncrByCommand as as, JsonNumMultByCommand as at, JsonObjKeysCommand as au, JsonObjLenCommand as av, JsonRespCommand as aw, JsonSetCommand as ax, JsonStrAppendCommand as ay, JsonStrLenCommand as az, Redis as b, ZUnionStoreCommand as b$, RPushCommand as b0, RPushXCommand as b1, SAddCommand as b2, ScanCommand as b3, type ScanCommandOptions as b4, SCardCommand as b5, ScriptExistsCommand as b6, ScriptFlushCommand as b7, ScriptLoadCommand as b8, SDiffCommand as b9, XAddCommand as bA, XRangeCommand as bB, type ScoreMember as bC, type ZAddCommandOptions as bD, ZAddCommand as bE, ZCardCommand as bF, ZCountCommand as bG, ZDiffStoreCommand as bH, ZIncrByCommand as bI, ZInterStoreCommand as bJ, type ZInterStoreCommandOptions as bK, ZLexCountCommand as bL, ZMScoreCommand as bM, ZPopMaxCommand as bN, ZPopMinCommand as bO, ZRangeCommand as bP, type ZRangeCommandOptions as bQ, ZRankCommand as bR, ZRemCommand as bS, ZRemRangeByLexCommand as bT, ZRemRangeByRankCommand as bU, ZRemRangeByScoreCommand as bV, ZRevRankCommand as bW, ZScanCommand as bX, ZScoreCommand as bY, ZUnionCommand as bZ, type ZUnionCommandOptions as b_, SDiffStoreCommand as ba, SetCommand as bb, type SetCommandOptions as bc, SetBitCommand as bd, SetExCommand as be, SetNxCommand as bf, SetRangeCommand as bg, SInterCommand as bh, SInterStoreCommand as bi, SIsMemberCommand as bj, SMembersCommand as bk, SMIsMemberCommand as bl, SMoveCommand as bm, SPopCommand as bn, SRandMemberCommand as bo, SRemCommand as bp, SScanCommand as bq, StrLenCommand as br, SUnionCommand as bs, SUnionStoreCommand as bt, TimeCommand as bu, TouchCommand as bv, TtlCommand as bw, type Type as bx, TypeCommand as by, UnlinkCommand as bz, type UpstashResponse as c, type ZUnionStoreCommandOptions as c0, type Requester 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 };