@upstash/redis 0.0.0-ci.cc4e03b5-20221003 → 0.0.0-ci.cfa9c86e-20230504

package/types/pkg/http.d.ts

@@ -1,18 +1,20 @@
-export declare type UpstashRequest = {
+import { Telemetry } from "./types.js";
+type CacheSetting = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
+export type UpstashRequest = {
     path?: string[];
     /**
      * Request body will be serialized to json
      */
     body?: unknown;
 };
-export declare type UpstashResponse<TResult> = {
+export type UpstashResponse<TResult> = {
     result?: TResult;
     error?: string;
 };
 export interface Requester {
     request: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>;
 }
-export declare type RetryConfig = false | {
+export type RetryConfig = false | {
     /**
      * The number of retries to attempt before giving up.
      *
@@ -29,26 +31,61 @@ export declare type RetryConfig = false | {
      */
     backoff?: (retryCount: number) => number;
 };
-declare type Options = {
+export type Options = {
     backend?: string;
 };
-export declare type HttpClientConfig = {
+export type RequesterConfig = {
+    /**
+     * Configure the retry behaviour in case of network errors
+     */
+    retry?: RetryConfig;
+    /**
+     * Due to the nature of dynamic and custom data, it is possible to write data to redis that is not
+     * valid json and will therefore cause errors when deserializing. This used to happen very
+     * frequently with non-utf8 data, such as emojis.
+     *
+     * By default we will therefore encode the data as base64 on the server, before sending it to the
+     * client. The client will then decode the base64 data and parse it as utf8.
+     *
+     * For very large entries, this can add a few milliseconds, so if you are sure that your data is
+     * valid utf8, you can disable this behaviour by setting this option to false.
+     *
+     * Here's what the response body looks like:
+     *
+     * ```json
+     * {
+     *  result?: "base64-encoded",
+     *  error?: string
+     * }
+     * ```
+     *
+     * @default "base64"
+     */
+    responseEncoding?: false | "base64";
+};
+export type HttpClientConfig = {
     headers?: Record<string, string>;
     baseUrl: string;
     options?: Options;
     retry?: RetryConfig;
-};
+    agent?: any;
+    cache?: CacheSetting;
+} & RequesterConfig;
 export declare class HttpClient implements Requester {
     baseUrl: string;
     headers: Record<string, string>;
-    readonly options?: {
+    readonly options: {
         backend?: string;
+        agent: any;
+        responseEncoding?: false | "base64";
+        cache?: CacheSetting;
     };
     readonly retry: {
         attempts: number;
         backoff: (retryCount: number) => number;
     };
     constructor(config: HttpClientConfig);
+    mergeTelemetry(telemetry: Telemetry): void;
     request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
 }
 export {};

package/types/pkg/pipeline.d.ts

@@ -1,4 +1,4 @@
-import { DelCommand, ExistsCommand, FlushAllCommand, MGetCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
+import { DelCommand, ExistsCommand, FlushAllCommand, JsonArrAppendCommand, JsonArrIndexCommand, JsonArrInsertCommand, JsonArrLenCommand, JsonArrPopCommand, JsonArrTrimCommand, JsonClearCommand, JsonDelCommand, JsonForgetCommand, JsonGetCommand, JsonMGetCommand, JsonNumIncrByCommand, JsonNumMultByCommand, JsonObjKeysCommand, JsonObjLenCommand, JsonRespCommand, JsonSetCommand, JsonStrAppendCommand, JsonStrLenCommand, JsonToggleCommand, JsonTypeCommand, MGetCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
 import { CommandOptions } from "./commands/command.js";
 import { Requester } from "./http.js";
 import { CommandArgs } from "./types.js";
@@ -18,7 +18,7 @@ import { CommandArgs } from "./types.js";
  * **Examples:**
  *
  * ```ts
- *  const p = redis.pipeline()
+ *  const p = redis.pipeline() // or redis.multi()
  * p.set("key","value")
  * p.get("key")
  * const res = await p.exec()
@@ -44,7 +44,12 @@ export declare class Pipeline {
     private client;
     private commands;
     private commandOptions?;
-    constructor(client: Requester, commandOptions?: CommandOptions<any, any>);
+    private multiExec;
+    constructor(opts: {
+        client: Requester;
+        commandOptions?: CommandOptions<any, any>;
+        multiExec?: boolean;
+    });
     /**
      * Send the pipeline request to upstash.
      *
@@ -80,6 +85,10 @@ export declare class Pipeline {
      * @see https://redis.io/commands/bitpos
      */
     bitpos: (key: string, bit: 0 | 1, start?: number | undefined, end?: number | undefined) => this;
+    /**
+     * @see https://redis.io/commands/zdiffstore
+     */
+    zdiffstore: (destination: string, numkeys: number, ...keys: string[]) => this;
     /**
      * @see https://redis.io/commands/dbsize
      */
@@ -138,6 +147,10 @@ export declare class Pipeline {
      * @see https://redis.io/commands/getbit
      */
     getbit: (key: string, offset: number) => this;
+    /**
+     * @see https://redis.io/commands/getdel
+     */
+    getdel: <TData>(key: string) => this;
     /**
      * @see https://redis.io/commands/getrange
      */
@@ -149,7 +162,7 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/hdel
      */
-    hdel: (key: string, field: string) => this;
+    hdel: (key: string, ...fields: string[]) => this;
     /**
      * @see https://redis.io/commands/hexists
      */
@@ -188,6 +201,10 @@ export declare class Pipeline {
     hmset: <TData>(key: string, kv: {
         [field: string]: TData;
     }) => this;
+    /**
+     * @see https://redis.io/commands/hrandfield
+     */
+    hrandfield: <TData extends string | string[] | Record<string, unknown>>(key: string, count?: number, withValues?: boolean) => this;
     /**
      * @see https://redis.io/commands/hscan
      */
@@ -238,6 +255,10 @@ export declare class Pipeline {
      * @see https://redis.io/commands/llen
      */
     llen: (key: string) => this;
+    /**
+     * @see https://redis.io/commands/lmove
+     */
+    lmove: <TData = string>(source: string, destination: string, whereFrom: "left" | "right", whereTo: "left" | "right") => this;
     /**
      * @see https://redis.io/commands/lpop
      */
@@ -406,7 +427,11 @@ export declare class Pipeline {
     /**
      * @see https://redis.io/commands/smembers
      */
-    smembers: (key: string) => this;
+    smembers: <TData extends unknown[] = string[]>(key: string) => this;
+    /**
+     * @see https://redis.io/commands/smismember
+     */
+    smismember: <TMembers extends unknown[]>(key: string, members: TMembers) => this;
     /**
      * @see https://redis.io/commands/smove
      */
@@ -549,4 +574,30 @@ export declare class Pipeline {
      * @see https://redis.io/commands/zunionstore
      */
     zunionstore: (destination: string, numKeys: number, keys: string[], opts?: import("./commands/zunionstore.js").ZUnionStoreCommandOptions | undefined) => this;
+    /**
+     * @see https://redis.io/commands/?group=json
+     */
+    get json(): {
+        arrappend: (...args: CommandArgs<typeof JsonArrAppendCommand>) => Pipeline;
+        arrindex: (...args: CommandArgs<typeof JsonArrIndexCommand>) => Pipeline;
+        arrinsert: (...args: CommandArgs<typeof JsonArrInsertCommand>) => Pipeline;
+        arrlen: (...args: CommandArgs<typeof JsonArrLenCommand>) => Pipeline;
+        arrpop: (...args: CommandArgs<typeof JsonArrPopCommand>) => Pipeline;
+        arrtrim: (...args: CommandArgs<typeof JsonArrTrimCommand>) => Pipeline;
+        clear: (...args: CommandArgs<typeof JsonClearCommand>) => Pipeline;
+        del: (...args: CommandArgs<typeof JsonDelCommand>) => Pipeline;
+        forget: (...args: CommandArgs<typeof JsonForgetCommand>) => Pipeline;
+        get: (...args: CommandArgs<typeof JsonGetCommand>) => Pipeline;
+        mget: (...args: CommandArgs<typeof JsonMGetCommand>) => Pipeline;
+        numincrby: (...args: CommandArgs<typeof JsonNumIncrByCommand>) => Pipeline;
+        nummultby: (...args: CommandArgs<typeof JsonNumMultByCommand>) => Pipeline;
+        objkeys: (...args: CommandArgs<typeof JsonObjKeysCommand>) => Pipeline;
+        objlen: (...args: CommandArgs<typeof JsonObjLenCommand>) => Pipeline;
+        resp: (...args: CommandArgs<typeof JsonRespCommand>) => Pipeline;
+        set: (...args: CommandArgs<typeof JsonSetCommand>) => Pipeline;
+        strappend: (...args: CommandArgs<typeof JsonStrAppendCommand>) => Pipeline;
+        strlen: (...args: CommandArgs<typeof JsonStrLenCommand>) => Pipeline;
+        toggle: (...args: CommandArgs<typeof JsonToggleCommand>) => Pipeline;
+        type: (...args: CommandArgs<typeof JsonTypeCommand>) => Pipeline;
+    };
 }

package/types/pkg/redis.d.ts

@@ -1,22 +1,17 @@
-import { CommandOptions, DelCommand, ExistsCommand, FlushAllCommand, MGetCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
+import { CommandOptions, DelCommand, ExistsCommand, FlushAllCommand, JsonGetCommand, MGetCommand, PingCommand, ScoreMember, ScriptExistsCommand, SetCommandOptions, TouchCommand, UnlinkCommand, ZAddCommandOptions, ZAddCommandOptionsWithIncr, ZRangeCommandOptions } from "./commands/mod.js";
 import { Requester, UpstashRequest, UpstashResponse } from "./http.js";
 import { Pipeline } from "./pipeline.js";
 import type { CommandArgs } from "./types.js";
 import { Script } from "./script.js";
-export declare type RedisOptions = {
-    /**
-     * Automatically try to deserialize the returned data from upstash using `JSON.deserialize`
-     *
-     * @default true
-     */
-    automaticDeserialization?: boolean;
-};
+import type { RedisOptions, Telemetry } from "./types.js";
+export type { RedisOptions } from "./types.js";
 /**
  * Serverless redis client for upstash.
  */
 export declare class Redis {
     protected client: Requester;
     protected opts?: CommandOptions<any, any>;
+    protected enableTelemetry: boolean;
     /**
      * Create a new redis client
      *
@@ -29,10 +24,106 @@ export declare class Redis {
      * ```
      */
     constructor(client: Requester, opts?: RedisOptions);
+    get json(): {
+        /**
+         * @see https://redis.io/commands/json.arrappend
+         */
+        arrappend: (key: string, path: string, ...values: unknown[]) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.arrindex
+         */
+        arrindex: (key: string, path: string, value: unknown, start?: number | undefined, stop?: number | undefined) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.arrinsert
+         */
+        arrinsert: (key: string, path: string, index: number, ...values: unknown[]) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.arrlen
+         */
+        arrlen: (key: string, path?: string | undefined) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.arrpop
+         */
+        arrpop: (key: string, path?: string | undefined, index?: number | undefined) => Promise<unknown[]>;
+        /**
+         * @see https://redis.io/commands/json.arrtrim
+         */
+        arrtrim: (key: string, path?: string | undefined, start?: number | undefined, stop?: number | undefined) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.clear
+         */
+        clear: (key: string, path?: string | undefined) => Promise<number>;
+        /**
+         * @see https://redis.io/commands/json.del
+         */
+        del: (key: string, path?: string | undefined) => Promise<number>;
+        /**
+         * @see https://redis.io/commands/json.forget
+         */
+        forget: (key: string, path?: string | undefined) => Promise<number>;
+        /**
+         * @see https://redis.io/commands/json.get
+         */
+        get: (...args: CommandArgs<typeof JsonGetCommand>) => Promise<any>;
+        /**
+         * @see https://redis.io/commands/json.mget
+         */
+        mget: (keys: string[], path: string) => Promise<any>;
+        /**
+         * @see https://redis.io/commands/json.numincrby
+         */
+        numincrby: (key: string, path: string, value: number) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.nummultby
+         */
+        nummultby: (key: string, path: string, value: number) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.objkeys
+         */
+        objkeys: (key: string, path?: string | undefined) => Promise<(string[] | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.objlen
+         */
+        objlen: (key: string, path?: string | undefined) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.resp
+         */
+        resp: (key: string, path?: string | undefined) => Promise<any>;
+        /**
+         * @see https://redis.io/commands/json.set
+         */
+        set: (key: string, path: string, value: string | number | boolean | Record<string, unknown> | (string | number | boolean | Record<string, unknown>)[], opts?: {
+            nx: true;
+            xx?: undefined;
+        } | {
+            nx?: undefined;
+            xx: true;
+        } | undefined) => Promise<"OK" | null>;
+        /**
+         * @see https://redis.io/commands/json.strappend
+         */
+        strappend: (key: string, path: string, value: string) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.strlen
+         */
+        strlen: (key: string, path?: string | undefined) => Promise<(number | null)[]>;
+        /**
+         * @see https://redis.io/commands/json.toggle
+         */
+        toggle: (key: string, path: string) => Promise<number[]>;
+        /**
+         * @see https://redis.io/commands/json.type
+         */
+        type: (key: string, path?: string | undefined) => Promise<string[]>;
+    };
     /**
      * Wrap a new middleware around the HTTP client.
      */
     use: <TResult = unknown>(middleware: (r: UpstashRequest, next: <TResult_1 = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult_1>>) => Promise<UpstashResponse<TResult>>) => void;
+    /**
+     * Technically this is not private, we can hide it from intellisense by doing this
+     */
+    protected addTelemetry: (telemetry: Telemetry) => void;
     createScript(script: string): Script;
     /**
      * Create a new pipeline that allows you to send requests in bulk.
@@ -40,6 +131,16 @@ export declare class Redis {
      * @see {@link Pipeline}
      */
     pipeline: () => Pipeline;
+    /**
+     * Create a new transaction to allow executing multiple steps atomically.
+     *
+     * All the commands in a transaction are serialized and executed sequentially. A request sent by
+     * another client will never be served in the middle of the execution of a Redis Transaction. This
+     * guarantees that the commands are executed as a single isolated operation.
+     *
+     * @see {@link Pipeline}
+     */
+    multi: () => Pipeline;
     /**
      * @see https://redis.io/commands/append
      */
@@ -117,6 +218,10 @@ export declare class Redis {
      * @see https://redis.io/commands/getbit
      */
     getbit: (key: string, offset: number) => Promise<0 | 1>;
+    /**
+     * @see https://redis.io/commands/getdel
+     */
+    getdel: <TData>(key: string) => Promise<TData | null>;
     /**
      * @see https://redis.io/commands/getrange
      */
@@ -128,7 +233,7 @@ export declare class Redis {
     /**
      * @see https://redis.io/commands/hdel
      */
-    hdel: (key: string, field: string) => Promise<0 | 1>;
+    hdel: (key: string, ...fields: string[]) => Promise<0 | 1>;
     /**
      * @see https://redis.io/commands/hexists
      */
@@ -167,6 +272,14 @@ export declare class Redis {
     hmset: <TData>(key: string, kv: {
         [field: string]: TData;
     }) => Promise<"OK">;
+    /**
+     * @see https://redis.io/commands/hrandfield
+     */
+    hrandfield: {
+        (key: string): Promise<string>;
+        (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
      */
@@ -217,6 +330,10 @@ export declare class Redis {
      * @see https://redis.io/commands/llen
      */
     llen: (key: string) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/lmove
+     */
+    lmove: <TData = string>(source: string, destination: string, whereFrom: "left" | "right", whereTo: "left" | "right") => Promise<TData>;
     /**
      * @see https://redis.io/commands/lpop
      */
@@ -385,10 +502,14 @@ export declare class Redis {
      * @see https://redis.io/commands/sismember
      */
     sismember: <TData>(key: string, member: TData) => Promise<0 | 1>;
+    /**
+     * @see https://redis.io/commands/smismember
+     */
+    smismember: <TMembers extends unknown[]>(key: string, members: TMembers) => Promise<(0 | 1)[]>;
     /**
      * @see https://redis.io/commands/smembers
      */
-    smembers: (key: string) => Promise<string[]>;
+    smembers: <TData extends unknown[] = string[]>(key: string) => Promise<TData>;
     /**
      * @see https://redis.io/commands/smove
      */
@@ -453,6 +574,10 @@ export declare class Redis {
      * @see https://redis.io/commands/zcount
      */
     zcount: (key: string, min: string | number, max: string | number) => Promise<number>;
+    /**
+     * @see https://redis.io/commands/zdiffstore
+     */
+    zdiffstore: (destination: string, numkeys: number, ...keys: string[]) => Promise<number>;
     /**
      * @see https://redis.io/commands/zincrby
      */

package/types/pkg/types.d.ts

@@ -1 +1,27 @@
-export declare type CommandArgs<TCommand extends new (...args: any) => any> = ConstructorParameters<TCommand>[0];
+export type CommandArgs<TCommand extends new (...args: any) => any> = ConstructorParameters<TCommand>[0];
+export type Telemetry = {
+    /**
+     * Upstash-Telemetry-Sdk
+     * @example @upstash/redis@v1.1.1
+     */
+    sdk?: string;
+    /**
+     * Upstash-Telemetry-Platform
+     * @example cloudflare
+     */
+    platform?: string;
+    /**
+     * Upstash-Telemetry-Runtime
+     * @example node@v18
+     */
+    runtime?: string;
+};
+export type RedisOptions = {
+    /**
+     * Automatically try to deserialize the returned data from upstash using `JSON.deserialize`
+     *
+     * @default true
+     */
+    automaticDeserialization?: boolean;
+    enableTelemetry?: boolean;
+};

package/types/platforms/cloudflare.d.ts

@@ -1,11 +1,15 @@
 import * as core from "../pkg/redis.js";
-import type { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import type { Requester, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { RequesterConfig } from "../pkg/http.js";
+type Env = {
+    UPSTASH_DISABLE_TELEMETRY?: string;
+};
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
  * Get them from https://console.upstash.com/redis/<uuid>
  */
-export declare type RedisConfigCloudflare = {
+export type RedisConfigCloudflare = {
     /**
      * UPSTASH_REDIS_REST_URL
      */
@@ -14,11 +18,7 @@ export declare type RedisConfigCloudflare = {
      * UPSTASH_REDIS_REST_TOKEN
      */
     token: string;
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig & Env;
 /**
  * Serverless redis client for upstash.
  */
@@ -34,9 +34,10 @@ export declare class Redis extends core.Redis {
      * });
      * ```
      */
-    constructor(config: RedisConfigCloudflare);
+    constructor(config: RedisConfigCloudflare, env?: Env);
     static fromEnv(env?: {
         UPSTASH_REDIS_REST_URL: string;
         UPSTASH_REDIS_REST_TOKEN: string;
+        UPSTASH_DISABLE_TELEMETRY?: string;
     }, opts?: Omit<RedisConfigCloudflare, "url" | "token">): Redis;
 }

package/types/platforms/fastly.d.ts

@@ -1,11 +1,11 @@
 import * as core from "../pkg/redis.js";
-import type { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import type { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
  * Get them from https://console.upstash.com/redis/<uuid>
  */
-export declare type RedisConfigFastly = {
+export type RedisConfigFastly = {
     /**
      * UPSTASH_REDIS_REST_URL
      */
@@ -20,11 +20,7 @@ export declare type RedisConfigFastly = {
      * referenced by name.
      */
     backend: string;
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/platforms/node_with_fetch.d.ts

@@ -1,12 +1,12 @@
 import * as core from "../pkg/redis.js";
-import { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 import "isomorphic-fetch";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
  * Get them from https://console.upstash.com/redis/<uuid>
  */
-export declare type RedisConfigNodejs = {
+export type RedisConfigNodejs = {
     /**
      * UPSTASH_REDIS_REST_URL
      */
@@ -15,26 +15,7 @@ export declare type RedisConfigNodejs = {
      * UPSTASH_REDIS_REST_TOKEN
      */
     token: string;
-    /**
-     * An agent allows you to reuse connections to reduce latency for multiple sequential requests.
-     *
-     * This is a node specific implementation and is not supported in various runtimes like Vercel
-     * edge functions.
-     *
-     * @example
-     * ```ts
-     * import https from "https"
-     *
-     * const options: RedisConfigNodejs = {
-     *  agent: new https.Agent({ keepAlive: true })
-     * }
-     * ```
-     */
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/platforms/nodejs.d.ts

@@ -1,11 +1,11 @@
 import * as core from "../pkg/redis.js";
-import { Requester, RetryConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
+import { Requester, RequesterConfig, UpstashRequest, UpstashResponse } from "../pkg/http.js";
 export type { Requester, UpstashRequest, UpstashResponse };
 /**
  * Connection credentials for upstash redis.
  * Get them from https://console.upstash.com/redis/<uuid>
  */
-export declare type RedisConfigNodejs = {
+export type RedisConfigNodejs = {
     /**
      * UPSTASH_REDIS_REST_URL
      */
@@ -29,11 +29,8 @@ export declare type RedisConfigNodejs = {
      * }
      * ```
      */
-    /**
-     * Configure the retry behaviour in case of network errors
-     */
-    retry?: RetryConfig;
-} & core.RedisOptions;
+    agent?: any;
+} & core.RedisOptions & RequesterConfig;
 /**
  * Serverless redis client for upstash.
  */

package/types/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "v0.0.0-ci.cfa9c86e-20230504";