Class VercelKV

Serverless redis client for upstash.

Hierarchy

Redis
- VercelKV

Index

Accessors

json

get json(): {
    arrappend: ((key, path, ...values) => Promise<number[]>);
    arrindex: ((key, path, value, start?, stop?) => Promise<number[]>);
    arrinsert: ((key, path, index, ...values) => Promise<number[]>);
    arrlen: ((key, path?) => Promise<number[]>);
    arrpop: ((key, path?, index?) => Promise<unknown[]>);
    arrtrim: ((key, path?, start?, stop?) => Promise<number[]>);
    clear: ((key, path?) => Promise<number>);
    del: ((key, path?) => Promise<number>);
    forget: ((key, path?) => Promise<number>);
    geoadd: ((args_0, args_1, ...args_2) => Promise<number>);
    geodist: ((key, member1, member2, unit?) => Promise<number>);
    geohash: ((args_0, ...args_1) => Promise<string[]>);
    geopos: ((args_0, ...args_1) => Promise<{
        lat: number;
        lng: number;
    }[]>);
    geosearch: ((key, centerPoint, shape, order, opts?) => Promise<({
        member: unknown;
    } & {
        coord?: {
            lat: number;
            long: number;
        };
        dist?: number;
        hash?: string;
    })[]>);
    geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Promise<number>);
    get: ((...args) => Promise<any>);
    mget: ((keys, path) => Promise<any>);
    numincrby: ((key, path, value) => Promise<number[]>);
    nummultby: ((key, path, value) => Promise<number[]>);
    objkeys: ((key, path?) => Promise<string[][]>);
    objlen: ((key, path?) => Promise<number[]>);
    resp: ((key, path?) => Promise<any>);
    set: ((key, path, value, opts?) => Promise<"OK">);
    strappend: ((key, path, value) => Promise<number[]>);
    strlen: ((key, path?) => Promise<number[]>);
    toggle: ((key, path) => Promise<number[]>);
    type: ((key, path?) => Promise<string[]>);
}
Returns {
    arrappend: ((key, path, ...values) => Promise<number[]>);
    arrindex: ((key, path, value, start?, stop?) => Promise<number[]>);
    arrinsert: ((key, path, index, ...values) => Promise<number[]>);
    arrlen: ((key, path?) => Promise<number[]>);
    arrpop: ((key, path?, index?) => Promise<unknown[]>);
    arrtrim: ((key, path?, start?, stop?) => Promise<number[]>);
    clear: ((key, path?) => Promise<number>);
    del: ((key, path?) => Promise<number>);
    forget: ((key, path?) => Promise<number>);
    geoadd: ((args_0, args_1, ...args_2) => Promise<number>);
    geodist: ((key, member1, member2, unit?) => Promise<number>);
    geohash: ((args_0, ...args_1) => Promise<string[]>);
    geopos: ((args_0, ...args_1) => Promise<{
        lat: number;
        lng: number;
    }[]>);
    geosearch: ((key, centerPoint, shape, order, opts?) => Promise<({
        member: unknown;
    } & {
        coord?: {
            lat: number;
            long: number;
        };
        dist?: number;
        hash?: string;
    })[]>);
    geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Promise<number>);
    get: ((...args) => Promise<any>);
    mget: ((keys, path) => Promise<any>);
    numincrby: ((key, path, value) => Promise<number[]>);
    nummultby: ((key, path, value) => Promise<number[]>);
    objkeys: ((key, path?) => Promise<string[][]>);
    objlen: ((key, path?) => Promise<number[]>);
    resp: ((key, path?) => Promise<any>);
    set: ((key, path, value, opts?) => Promise<"OK">);
    strappend: ((key, path, value) => Promise<number[]>);
    strlen: ((key, path?) => Promise<number[]>);
    toggle: ((key, path) => Promise<number[]>);
    type: ((key, path?) => Promise<string[]>);
}
- arrappend: ((key, path, ...values) => Promise<number[]>)
  - - (key, path, ...values): Promise<number[]>
    - Parameters
      key: string
      path: string
      Rest ...values: unknown[]
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.arrappend
- arrindex: ((key, path, value, start?, stop?) => Promise<number[]>)
  - - (key, path, value, start?, stop?): Promise<number[]>
    - Parameters
      key: string
      path: string
      value: unknown
      Optional start: number
      Optional stop: number
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.arrindex
- arrinsert: ((key, path, index, ...values) => Promise<number[]>)
  - - (key, path, index, ...values): Promise<number[]>
    - Parameters
      key: string
      path: string
      index: number
      Rest ...values: unknown[]
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.arrinsert
- arrlen: ((key, path?) => Promise<number[]>)
  - - (key, path?): Promise<number[]>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.arrlen
- arrpop: ((key, path?, index?) => Promise<unknown[]>)
  - - (key, path?, index?): Promise<unknown[]>
    - Parameters
      key: string
      Optional path: string
      Optional index: number
      Returns Promise<unknown[]>
      See
      https://redis.io/commands/json.arrpop
- arrtrim: ((key, path?, start?, stop?) => Promise<number[]>)
  - - (key, path?, start?, stop?): Promise<number[]>
    - Parameters
      key: string
      Optional path: string
      Optional start: number
      Optional stop: number
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.arrtrim
- clear: ((key, path?) => Promise<number>)
  - - (key, path?): Promise<number>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number>
      See
      https://redis.io/commands/json.clear
- del: ((key, path?) => Promise<number>)
  - - (key, path?): Promise<number>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number>
      See
      https://redis.io/commands/json.del
- forget: ((key, path?) => Promise<number>)
  - - (key, path?): Promise<number>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number>
      See
      https://redis.io/commands/json.forget
- geoadd: ((args_0, args_1, ...args_2) => Promise<number>)
  - - (args_0, args_1, ...args_2): Promise<number>
    - Parameters
      args_0: string
      args_1: GeoMember<unknown> | GeoAddCommandOptions
      Rest ...args_2: GeoMember<unknown>[]
      Returns Promise<number>
      See
      https://redis.io/commands/geoadd
- geodist: ((key, member1, member2, unit?) => Promise<number>)
  - - (key, member1, member2, unit?): Promise<number>
    - Parameters
      key: string
      member1: unknown
      member2: unknown
      Optional unit: "M" | "KM" | "FT" | "MI"
      Returns Promise<number>
      See
      https://redis.io/commands/geodist
- geohash: ((args_0, ...args_1) => Promise<string[]>)
  - - (args_0, ...args_1): Promise<string[]>
    - Parameters
      args_0: string
      Rest ...args_1: unknown[]
      Returns Promise<string[]>
      See
      https://redis.io/commands/geohash
- geopos: ((args_0, ...args_1) => Promise<{
  lat: number;
  lng: number;
  }[]>)
  - - (args_0, ...args_1): Promise<{
      lat: number;
      lng: number;
      }[]>
    - Parameters
      args_0: string
      Rest ...args_1: unknown[]
      Returns Promise<{
      lat: number;
      lng: number;
      }[]>
      See
      https://redis.io/commands/geopos
- geosearch: ((key, centerPoint, shape, order, opts?) => Promise<({
      member: unknown;
  } & {
      coord?: {
          lat: number;
          long: number;
      };
      dist?: number;
      hash?: string;
  })[]>)
  - - (key, centerPoint, shape, order, opts?): Promise<({
          member: unknown;
      } & {
          coord?: {
              lat: number;
              long: number;
          };
          dist?: number;
          hash?: string;
      })[]>
    - Parameters
      key: string
      centerPoint: {
          coordinate: {
              lat: number;
              lon: number;
          };
          type: "FROMLONLAT" | "fromlonlat";
      } | {
          member: unknown;
          type: "FROMMEMBER" | "frommember";
      }
      shape: {
          radius: number;
          radiusType: "M" | "KM" | "FT" | "MI";
          type: "BYRADIUS" | "byradius";
      } | {
          rect: {
              height: number;
              width: number;
          };
          rectType: "M" | "KM" | "FT" | "MI";
          type: "BYBOX" | "bybox";
      }
      order: "ASC" | "DESC" | "asc" | "desc"
      Optional opts: {
          count?: {
              any?: boolean;
              limit: number;
          };
          withCoord?: boolean;
          withDist?: boolean;
          withHash?: boolean;
      }
      Optional count?: {
          any?: boolean;
          limit: number;
      }
      Optional any?: boolean
      limit: number
      Optional withCoord?: boolean
      Optional withDist?: boolean
      Optional withHash?: boolean
      Returns Promise<({
          member: unknown;
      } & {
          coord?: {
              lat: number;
              long: number;
          };
          dist?: number;
          hash?: string;
      })[]>
      See
      https://redis.io/commands/geosearch
- geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Promise<number>)
  - - (destination, key, centerPoint, shape, order, opts?): Promise<number>
    - Parameters
      destination: string
      key: string
      centerPoint: {
          coordinate: {
              lat: number;
              lon: number;
          };
          type: "FROMLONLAT" | "fromlonlat";
      } | {
          member: unknown;
          type: "FROMMEMBER" | "frommember";
      }
      shape: {
          radius: number;
          radiusType: "M" | "KM" | "FT" | "MI";
          type: "BYRADIUS" | "byradius";
      } | {
          rect: {
              height: number;
              width: number;
          };
          rectType: "M" | "KM" | "FT" | "MI";
          type: "BYBOX" | "bybox";
      }
      order: "ASC" | "DESC" | "asc" | "desc"
      Optional opts: {
          count?: {
              any?: boolean;
              limit: number;
          };
          storeDist?: boolean;
      }
      Optional count?: {
          any?: boolean;
          limit: number;
      }
      Optional any?: boolean
      limit: number
      Optional storeDist?: boolean
      Returns Promise<number>
      See
      https://redis.io/commands/geosearchstore
- get: ((...args) => Promise<any>)
  - - (...args): Promise<any>
    - Parameters
      Rest ...args: [key: string, opts?: {
          indent?: string;
          newline?: string;
          space?: string;
      }, ...path: string[]] | [key: string, ...path: string[]]
      Returns Promise<any>
      See
      https://redis.io/commands/json.get
- mget: ((keys, path) => Promise<any>)
  - - (keys, path): Promise<any>
    - Parameters
      keys: string[]
      path: string
      Returns Promise<any>
      See
      https://redis.io/commands/json.mget
- numincrby: ((key, path, value) => Promise<number[]>)
  - - (key, path, value): Promise<number[]>
    - Parameters
      key: string
      path: string
      value: number
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.numincrby
- nummultby: ((key, path, value) => Promise<number[]>)
  - - (key, path, value): Promise<number[]>
    - Parameters
      key: string
      path: string
      value: number
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.nummultby
- objkeys: ((key, path?) => Promise<string[][]>)
  - - (key, path?): Promise<string[][]>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<string[][]>
      See
      https://redis.io/commands/json.objkeys
- objlen: ((key, path?) => Promise<number[]>)
  - - (key, path?): Promise<number[]>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.objlen
- resp: ((key, path?) => Promise<any>)
  - - (key, path?): Promise<any>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<any>
      See
      https://redis.io/commands/json.resp
- set: ((key, path, value, opts?) => Promise<"OK">)
  - - (key, path, value, opts?): Promise<"OK">
    - Parameters
      key: string
      path: string
      value: string | number | boolean | Record<string, unknown> | (string | number | boolean | Record<string, unknown>)[]
      Optional opts: {
          nx: true;
          xx?: undefined;
      } | {
          nx?: undefined;
          xx: true;
      }
      Returns Promise<"OK">
      See
      https://redis.io/commands/json.set
- strappend: ((key, path, value) => Promise<number[]>)
  - - (key, path, value): Promise<number[]>
    - Parameters
      key: string
      path: string
      value: string
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.strappend
- strlen: ((key, path?) => Promise<number[]>)
  - - (key, path?): Promise<number[]>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.strlen
- toggle: ((key, path) => Promise<number[]>)
  - - (key, path): Promise<number[]>
    - Parameters
      key: string
      path: string
      Returns Promise<number[]>
      See
      https://redis.io/commands/json.toggle
- type: ((key, path?) => Promise<string[]>)
  - - (key, path?): Promise<string[]>
    - Parameters
      key: string
      Optional path: string
      Returns Promise<string[]>
      See
      https://redis.io/commands/json.type
Inherited from Redis.json

Constructors

constructor

new VercelKV(config): VercelKV
Create a new redis client by providing the url and token
Parameters
- config: RedisConfigNodejs
Returns VercelKV
Example
```
const redis = new Redis({
 url: "<UPSTASH_REDIS_REST_URL>",
 token: "<UPSTASH_REDIS_REST_TOKEN>",
});
```
Inherited from Redis.constructor
new VercelKV(requesters): VercelKV

Create a new redis client by providing a custom Requester implementation

Parameters

requesters: Requester

Returns VercelKV

Example


import { UpstashRequest, Requester, UpstashResponse, Redis } from "@upstash/redis"

 const requester: Requester = {
   request: <TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>> => {
     // ...
   }
 }

const redis = new Redis(requester)

Methods

createScript

createScript(script): Script<unknown>
Parameters
- script: string
Returns Script<unknown>
Inherited from Redis.createScript

hscanIterator

hscanIterator(key, options?): AsyncIterable<string | number>
Same as hscan but returns an AsyncIterator to allow iteration via for await.
Parameters
- key: string
- Optional options: ScanCommandOptions
Returns AsyncIterable<string | number>

scanIterator

scanIterator(options?): AsyncIterable<string>
Same as scan but returns an AsyncIterator to allow iteration via for await.
Parameters
- Optional options: ScanCommandOptions
Returns AsyncIterable<string>

sscanIterator

sscanIterator(key, options?): AsyncIterable<string | number>
Same as sscan but returns an AsyncIterator to allow iteration via for await.
Parameters
- key: string
- Optional options: ScanCommandOptions
Returns AsyncIterable<string | number>

zscanIterator

zscanIterator(key, options?): AsyncIterable<string | number>
Same as zscan but returns an AsyncIterator to allow iteration via for await.
Parameters
- key: string
- Optional options: ScanCommandOptions
Returns AsyncIterable<string | number>

`Static` fromEnv

fromEnv(config?): Redis
Create a new Upstash Redis instance from environment variables.

Use this to automatically load connection secrets from your environment variables. For instance when using the Vercel integration.

This tries to load UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN from your environment using process.env.
Parameters
- Optional config: Omit<RedisConfigNodejs, "url" | "token">
Returns Redis
Inherited from Redis.fromEnv

Properties

`Protected` addTelemetry

addTelemetry: ((telemetry) => void)

Type declaration

- (telemetry): void
- Technically this is not private, we can hide it from intellisense by doing this
  Parameters
  - telemetry: Telemetry
  Returns void

append

append: ((key, value) => Promise<number>)

Type declaration

- (key, value): Promise<number>
- Parameters
  - key: string
  - value: string
  Returns Promise<number>
  See
  https://redis.io/commands/append

bitcount

bitcount: ((key, start, end) => Promise<number>)

Type declaration

- (key, start, end): Promise<number>
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Promise<number>
  See
  https://redis.io/commands/bitcount

bitop

bitop: {
(op, destinationKey, sourceKey, ...sourceKeys): Promise<number>;
(op, destinationKey, sourceKey): Promise<number>;
}

Type declaration

- (op, destinationKey, sourceKey, ...sourceKeys): Promise<number>
- Parameters
  - op: "and" | "or" | "xor"
  - destinationKey: string
  - sourceKey: string
  - Rest ...sourceKeys: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/bitop
- (op, destinationKey, sourceKey): Promise<number>
- Parameters
  - op: "not"
  - destinationKey: string
  - sourceKey: string
  Returns Promise<number>
  See
  https://redis.io/commands/bitop

bitpos

bitpos: ((key, bit, start?, end?) => Promise<number>)

Type declaration

- (key, bit, start?, end?): Promise<number>
- Parameters
  - key: string
  - bit: 0 | 1
  - Optional start: number
  - Optional end: number
  Returns Promise<number>
  See
  https://redis.io/commands/bitpos

`Protected` client

client: Requester

copy

copy: ((key, destinationKey, opts?) => Promise<"COPIED" | "NOT_COPIED">)

Type declaration

- (key, destinationKey, opts?): Promise<"COPIED" | "NOT_COPIED">
- Parameters
  - key: string
  - destinationKey: string
  - Optional opts: {
    replace: boolean;
    }
    - replace: boolean
  Returns Promise<"COPIED" | "NOT_COPIED">
  See
  https://redis.io/commands/copy

dbsize

dbsize: (() => Promise<number>)

Type declaration

- (): Promise<number>
- Returns Promise<number>
  See
  https://redis.io/commands/dbsize

decr

decr: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/decr

decrby

decrby: ((key, decrement) => Promise<number>)

Type declaration

- (key, decrement): Promise<number>
- Parameters
  - key: string
  - decrement: number
  Returns Promise<number>
  See
  https://redis.io/commands/decrby

del

del: ((...args) => Promise<number>)

Type declaration

- (...args): Promise<number>
- Parameters
  - Rest ...args: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/del

echo

echo: ((message) => Promise<string>)

Type declaration

- (message): Promise<string>
- Parameters
  - message: string
  Returns Promise<string>
  See
  https://redis.io/commands/echo

`Protected` enableTelemetry

enableTelemetry: boolean

eval

eval: (<TArgs, TData>(script, keys, args) => Promise<TData>)

Type declaration

- <TArgs, TData>(script, keys, args): Promise<TData>
- Type Parameters
  - TArgs extends unknown[]
  - TData = unknown
  Parameters
  - script: string
  - keys: string[]
  - args: TArgs
  Returns Promise<TData>
  See
  https://redis.io/commands/eval

evalsha

evalsha: (<TArgs, TData>(sha1, keys, args) => Promise<TData>)

Type declaration

- <TArgs, TData>(sha1, keys, args): Promise<TData>
- Type Parameters
  - TArgs extends unknown[]
  - TData = unknown
  Parameters
  - sha1: string
  - keys: string[]
  - args: TArgs
  Returns Promise<TData>
  See
  https://redis.io/commands/evalsha

exists

exists: ((...args) => Promise<number>)

Type declaration

- (...args): Promise<number>
- Parameters
  - Rest ...args: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/exists

expire

expire: ((key, seconds) => Promise<0 | 1>)

Type declaration

- (key, seconds): Promise<0 | 1>
- Parameters
  - key: string
  - seconds: number
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/expire

expireat

expireat: ((key, unix) => Promise<0 | 1>)

Type declaration

- (key, unix): Promise<0 | 1>
- Parameters
  - key: string
  - unix: number
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/expireat

flushall

flushall: ((args?) => Promise<"OK">)

Type declaration

- (args?): Promise<"OK">
- Parameters
  - Optional args: [{
    async?: boolean;
    }]
  Returns Promise<"OK">
  See
  https://redis.io/commands/flushall

flushdb

flushdb: ((opts?) => Promise<"OK">)

Type declaration

- (opts?): Promise<"OK">
- Parameters
  - Optional opts: {
    async?: boolean;
    }
    - Optional async?: boolean
  Returns Promise<"OK">
  See
  https://redis.io/commands/flushdb

get

get: (<TData>(key) => Promise<TData>)

Type declaration

- <TData>(key): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  Returns Promise<TData>
  See
  https://redis.io/commands/get

getbit

getbit: ((key, offset) => Promise<0 | 1>)

Type declaration

- (key, offset): Promise<0 | 1>
- Parameters
  - key: string
  - offset: number
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/getbit

getdel

getdel: (<TData>(key) => Promise<TData>)

Type declaration

- <TData>(key): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  Returns Promise<TData>
  See
  https://redis.io/commands/getdel

getrange

getrange: ((key, start, end) => Promise<string>)

Type declaration

- (key, start, end): Promise<string>
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Promise<string>
  See
  https://redis.io/commands/getrange

getset

getset: (<TData>(key, value) => Promise<TData>)

Type declaration

- <TData>(key, value): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - value: TData
  Returns Promise<TData>
  See
  https://redis.io/commands/getset

hdel

hdel: ((key, ...fields) => Promise<0 | 1>)

Type declaration

- (key, ...fields): Promise<0 | 1>
- Parameters
  - key: string
  - Rest ...fields: string[]
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/hdel

hexists

hexists: ((key, field) => Promise<number>)

Type declaration

- (key, field): Promise<number>
- Parameters
  - key: string
  - field: string
  Returns Promise<number>
  See
  https://redis.io/commands/hexists

hget

hget: (<TData>(key, field) => Promise<TData>)

Type declaration

- <TData>(key, field): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - field: string
  Returns Promise<TData>
  See
  https://redis.io/commands/hget

hgetall

hgetall: (<TData>(key) => Promise<TData>)

Type declaration

- <TData>(key): Promise<TData>
- Type Parameters
  - TData extends Record<string, unknown>
  Parameters
  - key: string
  Returns Promise<TData>
  See
  https://redis.io/commands/hgetall

hincrby

hincrby: ((key, field, increment) => Promise<number>)

Type declaration

- (key, field, increment): Promise<number>
- Parameters
  - key: string
  - field: string
  - increment: number
  Returns Promise<number>
  See
  https://redis.io/commands/hincrby

hincrbyfloat

hincrbyfloat: ((key, field, increment) => Promise<number>)

Type declaration

- (key, field, increment): Promise<number>
- Parameters
  - key: string
  - field: string
  - increment: number
  Returns Promise<number>
  See
  https://redis.io/commands/hincrbyfloat

hkeys

hkeys: ((key) => Promise<string[]>)

Type declaration

- (key): Promise<string[]>
- Parameters
  - key: string
  Returns Promise<string[]>
  See
  https://redis.io/commands/hkeys

hlen

hlen: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/hlen

hmget

hmget: (<TData>(key, ...fields) => Promise<TData>)

Type declaration

- <TData>(key, ...fields): Promise<TData>
- Type Parameters
  - TData extends Record<string, unknown>
  Parameters
  - key: string
  - Rest ...fields: string[]
  Returns Promise<TData>
  See
  https://redis.io/commands/hmget

hmset

hmset: (<TData>(key, kv) => Promise<"OK">)

Type declaration

- <TData>(key, kv): Promise<"OK">
- Type Parameters
  - TData
  Parameters
  - key: string
  - kv: {
    [field: string]: TData;
    }
    - [field: string]: TData
  Returns Promise<"OK">
  See
  https://redis.io/commands/hmset

hrandfield

hrandfield: {
    (key): Promise<string>;
    (key, count): Promise<string[]>;
    <TData>(key, count, withValues): Promise<Partial<TData>>;
}

Type declaration

- (key): Promise<string>
- Parameters
  - key: string
  Returns Promise<string>
  See
  https://redis.io/commands/hrandfield
- (key, count): Promise<string[]>
- Parameters
  - key: string
  - count: number
  Returns Promise<string[]>
  See
  https://redis.io/commands/hrandfield
- <TData>(key, count, withValues): Promise<Partial<TData>>
- Type Parameters
  - TData extends Record<string, unknown>
  Parameters
  - key: string
  - count: number
  - withValues: boolean
  Returns Promise<Partial<TData>>
  See
  https://redis.io/commands/hrandfield

hscan

hscan: ((key, cursor, cmdOpts?) => Promise<[number, (string | number)[]]>)

Type declaration

- (key, cursor, cmdOpts?): Promise<[number, (string | number)[]]>
- Parameters
  - key: string
  - cursor: number
  - Optional cmdOpts: ScanCommandOptions
  Returns Promise<[number, (string | number)[]]>
  See
  https://redis.io/commands/hscan

hset

hset: (<TData>(key, kv) => Promise<number>)

Type declaration

- <TData>(key, kv): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - kv: {
    [field: string]: TData;
    }
    - [field: string]: TData
  Returns Promise<number>
  See
  https://redis.io/commands/hset

hsetnx

hsetnx: (<TData>(key, field, value) => Promise<0 | 1>)

Type declaration

- <TData>(key, field, value): Promise<0 | 1>
- Type Parameters
  - TData
  Parameters
  - key: string
  - field: string
  - value: TData
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/hsetnx

hstrlen

hstrlen: ((key, field) => Promise<number>)

Type declaration

- (key, field): Promise<number>
- Parameters
  - key: string
  - field: string
  Returns Promise<number>
  See
  https://redis.io/commands/hstrlen

hvals

hvals: ((key) => Promise<any>)

Type declaration

- (key): Promise<any>
- Parameters
  - key: string
  Returns Promise<any>
  See
  https://redis.io/commands/hvals

incr

incr: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/incr

incrby

incrby: ((key, value) => Promise<number>)

Type declaration

- (key, value): Promise<number>
- Parameters
  - key: string
  - value: number
  Returns Promise<number>
  See
  https://redis.io/commands/incrby

incrbyfloat

incrbyfloat: ((key, value) => Promise<number>)

Type declaration

- (key, value): Promise<number>
- Parameters
  - key: string
  - value: number
  Returns Promise<number>
  See
  https://redis.io/commands/incrbyfloat

keys

keys: ((pattern) => Promise<string[]>)

Type declaration

- (pattern): Promise<string[]>
- Parameters
  - pattern: string
  Returns Promise<string[]>
  See
  https://redis.io/commands/keys

lindex

lindex: ((key, index) => Promise<any>)

Type declaration

- (key, index): Promise<any>
- Parameters
  - key: string
  - index: number
  Returns Promise<any>
  See
  https://redis.io/commands/lindex

linsert

linsert: (<TData>(key, direction, pivot, value) => Promise<number>)

Type declaration

- <TData>(key, direction, pivot, value): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - direction: "before" | "after"
  - pivot: TData
  - value: TData
  Returns Promise<number>
  See
  https://redis.io/commands/linsert

llen

llen: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/llen

lmove

lmove: (<TData>(source, destination, whereFrom, whereTo) => Promise<TData>)

Type declaration

- <TData>(source, destination, whereFrom, whereTo): Promise<TData>
- Type Parameters
  - TData = string
  Parameters
  - source: string
  - destination: string
  - whereFrom: "left" | "right"
  - whereTo: "left" | "right"
  Returns Promise<TData>
  See
  https://redis.io/commands/lmove

lpop

lpop: (<TData>(key, count?) => Promise<TData>)

Type declaration

- <TData>(key, count?): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData>
  See
  https://redis.io/commands/lpop

lpos

lpos: (<TData>(key, element, opts?) => Promise<TData>)

Type declaration

- <TData>(key, element, opts?): Promise<TData>
- Type Parameters
  - TData = number
  Parameters
  - key: string
  - element: unknown
  - Optional opts: {
        count?: number;
        maxLen?: number;
        rank?: number;
    }
    - Optional count?: number
    - Optional maxLen?: number
    - Optional rank?: number
  Returns Promise<TData>
  See
  https://redis.io/commands/lpos

lpush

lpush: (<TData>(key, ...elements) => Promise<number>)

Type declaration

- <TData>(key, ...elements): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...elements: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/lpush

lpushx

lpushx: (<TData>(key, ...elements) => Promise<number>)

Type declaration

- <TData>(key, ...elements): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...elements: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/lpushx

lrange

lrange: (<TResult>(key, start, end) => Promise<TResult[]>)

Type declaration

- <TResult>(key, start, end): Promise<TResult[]>
- Type Parameters
  - TResult = string
  Parameters
  - key: string
  - start: number
  - end: number
  Returns Promise<TResult[]>
  See
  https://redis.io/commands/lrange

lrem

lrem: (<TData>(key, count, value) => Promise<number>)

Type declaration

- <TData>(key, count, value): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - count: number
  - value: TData
  Returns Promise<number>
  See
  https://redis.io/commands/lrem

lset

lset: (<TData>(key, index, value) => Promise<"OK">)

Type declaration

- <TData>(key, index, value): Promise<"OK">
- Type Parameters
  - TData
  Parameters
  - key: string
  - index: number
  - value: TData
  Returns Promise<"OK">
  See
  https://redis.io/commands/lset

ltrim

ltrim: ((key, start, end) => Promise<"OK">)

Type declaration

- (key, start, end): Promise<"OK">
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Promise<"OK">
  See
  https://redis.io/commands/ltrim

mget

mget: (<TData>(...args) => Promise<TData>)

Type declaration

- <TData>(...args): Promise<TData>
- Type Parameters
  - TData extends unknown[]
  Parameters
  - Rest ...args: string[] | [string[]]
  Returns Promise<TData>
  See
  https://redis.io/commands/mget

mset

mset: (<TData>(kv) => Promise<"OK">)

Type declaration

- <TData>(kv): Promise<"OK">
- Type Parameters
  - TData
  Parameters
  - kv: {
    [key: string]: TData;
    }
    - [key: string]: TData
  Returns Promise<"OK">
  See
  https://redis.io/commands/mset

msetnx

msetnx: (<TData>(kv) => Promise<number>)

Type declaration

- <TData>(kv): Promise<number>
- Type Parameters
  - TData
  Parameters
  - kv: {
    [key: string]: TData;
    }
    - [key: string]: TData
  Returns Promise<number>
  See
  https://redis.io/commands/msetnx

multi

multi: (() => Pipeline<[]>)

Type declaration

- (): 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.
  
  Returns Pipeline<[]>
  See
  Pipeline

`Protected` `Optional` opts

opts?: CommandOptions<any, any>

persist

persist: ((key) => Promise<0 | 1>)

Type declaration

- (key): Promise<0 | 1>
- Parameters
  - key: string
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/persist

pexpire

pexpire: ((key, milliseconds) => Promise<0 | 1>)

Type declaration

- (key, milliseconds): Promise<0 | 1>
- Parameters
  - key: string
  - milliseconds: number
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/pexpire

pexpireat

pexpireat: ((key, unix) => Promise<0 | 1>)

Type declaration

- (key, unix): Promise<0 | 1>
- Parameters
  - key: string
  - unix: number
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/pexpireat

pfadd

pfadd: ((args_0, ...args_1) => Promise<number>)

Type declaration

- (args_0, ...args_1): Promise<number>
- Parameters
  - args_0: string
  - Rest ...args_1: unknown[]
  Returns Promise<number>
  See
  https://redis.io/commands/pfadd

pfcount

pfcount: ((args_0, ...args_1) => Promise<number>)

Type declaration

- (args_0, ...args_1): Promise<number>
- Parameters
  - args_0: string
  - Rest ...args_1: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/pfcount

pfmerge

pfmerge: ((destination_key, ...args_1) => Promise<"OK">)

Type declaration

- (destination_key, ...args_1): Promise<"OK">
- Parameters
  - destination_key: string
  - Rest ...args_1: string[]
  Returns Promise<"OK">
  See
  https://redis.io/commands/pfmerge

ping

ping: ((args?) => Promise<string>)

Type declaration

- (args?): Promise<string>
- Parameters
  - Optional args: [message?: string]
  Returns Promise<string>
  See
  https://redis.io/commands/ping

pipeline

pipeline: (() => Pipeline<[]>)

Type declaration

- (): Pipeline<[]>
- Create a new pipeline that allows you to send requests in bulk.
  
  Returns Pipeline<[]>
  See
  Pipeline

psetex

psetex: (<TData>(key, ttl, value) => Promise<string>)

Type declaration

- <TData>(key, ttl, value): Promise<string>
- Type Parameters
  - TData
  Parameters
  - key: string
  - ttl: number
  - value: TData
  Returns Promise<string>
  See
  https://redis.io/commands/psetex

pttl

pttl: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/pttl

publish

publish: ((channel, message) => Promise<number>)

Type declaration

- (channel, message): Promise<number>
- Parameters
  - channel: string
  - message: unknown
  Returns Promise<number>
  See
  https://redis.io/commands/publish

randomkey

randomkey: (() => Promise<string>)

Type declaration

- (): Promise<string>
- Returns Promise<string>
  See
  https://redis.io/commands/randomkey

rename

rename: ((source, destination) => Promise<"OK">)

Type declaration

- (source, destination): Promise<"OK">
- Parameters
  - source: string
  - destination: string
  Returns Promise<"OK">
  See
  https://redis.io/commands/rename

renamenx

renamenx: ((source, destination) => Promise<0 | 1>)

Type declaration

- (source, destination): Promise<0 | 1>
- Parameters
  - source: string
  - destination: string
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/renamenx

rpop

rpop: (<TData>(key, count?) => Promise<TData>)

Type declaration

- <TData>(key, count?): Promise<TData>
- Type Parameters
  - TData = string
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData>
  See
  https://redis.io/commands/rpop

rpush

rpush: (<TData>(key, ...elements) => Promise<number>)

Type declaration

- <TData>(key, ...elements): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...elements: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/rpush

rpushx

rpushx: (<TData>(key, ...elements) => Promise<number>)

Type declaration

- <TData>(key, ...elements): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...elements: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/rpushx

sadd

sadd: (<TData>(key, ...members) => Promise<number>)

Type declaration

- <TData>(key, ...members): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...members: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/sadd

scan

scan: ((cursor, opts?) => Promise<[number, string[]]>)

Type declaration

- (cursor, opts?): Promise<[number, string[]]>
- Parameters
  - cursor: number
  - Optional opts: ScanCommandOptions
  Returns Promise<[number, string[]]>
  See
  https://redis.io/commands/scan

scard

scard: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/scard

scriptExists

scriptExists: ((...args) => Promise<number[]>)

Type declaration

- (...args): Promise<number[]>
- Parameters
  - Rest ...args: string[]
  Returns Promise<number[]>
  See
  https://redis.io/commands/script-exists

scriptFlush

scriptFlush: ((opts?) => Promise<"OK">)

Type declaration

- (opts?): Promise<"OK">
- Parameters
  - Optional opts: ScriptFlushCommandOptions
  Returns Promise<"OK">
  See
  https://redis.io/commands/script-flush

scriptLoad

scriptLoad: ((script) => Promise<string>)

Type declaration

- (script): Promise<string>
- Parameters
  - script: string
  Returns Promise<string>
  See
  https://redis.io/commands/script-load

sdiff

sdiff: ((key, ...keys) => Promise<unknown[]>)

Type declaration

- (key, ...keys): Promise<unknown[]>
- Parameters
  - key: string
  - Rest ...keys: string[]
  Returns Promise<unknown[]>
  See
  https://redis.io/commands/sdiff

sdiffstore

sdiffstore: ((destination, ...keys) => Promise<number>)

Type declaration

- (destination, ...keys): Promise<number>
- Parameters
  - destination: string
  - Rest ...keys: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/sdiffstore

set

set: (<TData>(key, value, opts?) => Promise<"OK" | TData>)

Type declaration

- <TData>(key, value, opts?): Promise<"OK" | TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - value: TData
  - Optional opts: SetCommandOptions
  Returns Promise<"OK" | TData>
  See
  https://redis.io/commands/set

setbit

setbit: ((key, offset, value) => Promise<0 | 1>)

Type declaration

- (key, offset, value): Promise<0 | 1>
- Parameters
  - key: string
  - offset: number
  - value: 0 | 1
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/setbit

setex

setex: (<TData>(key, ttl, value) => Promise<"OK">)

Type declaration

- <TData>(key, ttl, value): Promise<"OK">
- Type Parameters
  - TData
  Parameters
  - key: string
  - ttl: number
  - value: TData
  Returns Promise<"OK">
  See
  https://redis.io/commands/setex

setnx

setnx: (<TData>(key, value) => Promise<number>)

Type declaration

- <TData>(key, value): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - value: TData
  Returns Promise<number>
  See
  https://redis.io/commands/setnx

setrange

setrange: ((key, offset, value) => Promise<number>)

Type declaration

- (key, offset, value): Promise<number>
- Parameters
  - key: string
  - offset: number
  - value: string
  Returns Promise<number>
  See
  https://redis.io/commands/setrange

sinter

sinter: ((key, ...keys) => Promise<string[]>)

Type declaration

- (key, ...keys): Promise<string[]>
- Parameters
  - key: string
  - Rest ...keys: string[]
  Returns Promise<string[]>
  See
  https://redis.io/commands/sinter

sinterstore

sinterstore: ((destination, key, ...keys) => Promise<number>)

Type declaration

- (destination, key, ...keys): Promise<number>
- Parameters
  - destination: string
  - key: string
  - Rest ...keys: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/sinterstore

sismember

sismember: (<TData>(key, member) => Promise<0 | 1>)

Type declaration

- <TData>(key, member): Promise<0 | 1>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/sismember

smembers

smembers: (<TData>(key) => Promise<TData>)

Type declaration

- <TData>(key): Promise<TData>
- Type Parameters
  - TData extends unknown[] = string[]
  Parameters
  - key: string
  Returns Promise<TData>
  See
  https://redis.io/commands/smembers

smismember

smismember: (<TMembers>(key, members) => Promise<(0 | 1)[]>)

Type declaration

- <TMembers>(key, members): Promise<(0 | 1)[]>
- Type Parameters
  - TMembers extends unknown[]
  Parameters
  - key: string
  - members: TMembers
  Returns Promise<(0 | 1)[]>
  See
  https://redis.io/commands/smismember

smove

smove: (<TData>(source, destination, member) => Promise<0 | 1>)

Type declaration

- <TData>(source, destination, member): Promise<0 | 1>
- Type Parameters
  - TData
  Parameters
  - source: string
  - destination: string
  - member: TData
  Returns Promise<0 | 1>
  See
  https://redis.io/commands/smove

spop

spop: (<TData>(key, count?) => Promise<TData>)

Type declaration

- <TData>(key, count?): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData>
  See
  https://redis.io/commands/spop

srandmember

srandmember: (<TData>(key, count?) => Promise<TData>)

Type declaration

- <TData>(key, count?): Promise<TData>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData>
  See
  https://redis.io/commands/srandmember

srem

srem: (<TData>(key, ...members) => Promise<number>)

Type declaration

- <TData>(key, ...members): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...members: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/srem

sscan

sscan: ((key, cursor, opts?) => Promise<[number, (string | number)[]]>)

Type declaration

- (key, cursor, opts?): Promise<[number, (string | number)[]]>
- Parameters
  - key: string
  - cursor: number
  - Optional opts: ScanCommandOptions
  Returns Promise<[number, (string | number)[]]>
  See
  https://redis.io/commands/sscan

strlen

strlen: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/strlen

sunion

sunion: ((key, ...keys) => Promise<unknown[]>)

Type declaration

- (key, ...keys): Promise<unknown[]>
- Parameters
  - key: string
  - Rest ...keys: string[]
  Returns Promise<unknown[]>
  See
  https://redis.io/commands/sunion

sunionstore

sunionstore: ((destination, key, ...keys) => Promise<number>)

Type declaration

- (destination, key, ...keys): Promise<number>
- Parameters
  - destination: string
  - key: string
  - Rest ...keys: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/sunionstore

time

time: (() => Promise<[number, number]>)

Type declaration

- (): Promise<[number, number]>
- Returns Promise<[number, number]>
  See
  https://redis.io/commands/time

touch

touch: ((...args) => Promise<number>)

Type declaration

- (...args): Promise<number>
- Parameters
  - Rest ...args: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/touch

ttl

ttl: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/ttl

type

type: ((key) => Promise<Type>)

Type declaration

- (key): Promise<Type>
- Parameters
  - key: string
  Returns Promise<Type>
  See
  https://redis.io/commands/type

unlink

unlink: ((...args) => Promise<number>)

Type declaration

- (...args): Promise<number>
- Parameters
  - Rest ...args: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/unlink

use

use: (<TResult>(middleware) => void)

Type declaration

- <TResult>(middleware): void
- Wrap a new middleware around the HTTP client.
  Type Parameters
  - TResult = unknown
  Parameters
  - middleware: ((r, next) => Promise<UpstashResponse<TResult>>)
    - (r, next): Promise<UpstashResponse<TResult>>
      Parameters
      r: UpstashRequest
      next: (<TResult_1>(req) => Promise<UpstashResponse<TResult_1>>)
      <TResult_1>(req): Promise<UpstashResponse<TResult_1>>
      Type Parameters
      TResult_1 = unknown
      Parameters
      req: UpstashRequest
      Returns Promise<UpstashResponse<TResult_1>>
      Returns Promise<UpstashResponse<TResult>>
  Returns void

xadd

xadd: ((key, id, entries, opts?) => Promise<string>)

Type declaration

- (key, id, entries, opts?): Promise<string>
- Parameters
  - key: string
  - id: string
  - entries: {
    [field: string]: unknown;
    }
    - [field: string]: unknown
  - Optional opts: {
        nomkStream?: boolean;
        trim?: {
            comparison: "~" | "=";
            limit?: number;
            threshold: string | number;
            type: "MAXLEN" | "maxlen" | "MINID" | "minid";
        };
    }
    - Optional nomkStream?: boolean
    - Optional trim?: {
          comparison: "~" | "=";
          limit?: number;
          threshold: string | number;
          type: "MAXLEN" | "maxlen" | "MINID" | "minid";
      }
      comparison: "~" | "="
      Optional limit?: number
      threshold: string | number
      type: "MAXLEN" | "maxlen" | "MINID" | "minid"
  Returns Promise<string>
  See
  https://redis.io/commands/xadd

xrange

xrange: ((key, start, end, count?) => Promise<Record<string, Record<string, unknown>>>)

Type declaration

- (key, start, end, count?): Promise<Record<string, Record<string, unknown>>>
- Parameters
  - key: string
  - start: string
  - end: string
  - Optional count: number
  Returns Promise<Record<string, Record<string, unknown>>>
  See
  https://redis.io/commands/xrange

zadd

zadd: (<TData>(...args) => Promise<number>)

Type declaration

- <TData>(...args): Promise<number>
- Type Parameters
  - TData
  Parameters
  - Rest ...args: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]] | [key: string, opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr, ScoreMember<TData>, ...ScoreMember<TData>[]]
  Returns Promise<number>
  See
  https://redis.io/commands/zadd

zcard

zcard: ((key) => Promise<number>)

Type declaration

- (key): Promise<number>
- Parameters
  - key: string
  Returns Promise<number>
  See
  https://redis.io/commands/zcard

zcount

zcount: ((key, min, max) => Promise<number>)

Type declaration

- (key, min, max): Promise<number>
- Parameters
  - key: string
  - min: string | number
  - max: string | number
  Returns Promise<number>
  See
  https://redis.io/commands/zcount

zdiffstore

zdiffstore: ((destination, numkeys, ...keys) => Promise<number>)

Type declaration

- (destination, numkeys, ...keys): Promise<number>
- Parameters
  - destination: string
  - numkeys: number
  - Rest ...keys: string[]
  Returns Promise<number>
  See
  https://redis.io/commands/zdiffstore

zincrby

zincrby: (<TData>(key, increment, member) => Promise<number>)

Type declaration

- <TData>(key, increment, member): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - increment: number
  - member: TData
  Returns Promise<number>
  See
  https://redis.io/commands/zincrby

zinterstore

zinterstore: ((destination, numKeys, keys, opts?) => Promise<number>)

Type declaration

- (destination, numKeys, keys, opts?): Promise<number>
- Parameters
  - destination: string
  - numKeys: number
  - keys: string[]
  - Optional opts: ZInterStoreCommandOptions
  Returns Promise<number>
  See
  https://redis.io/commands/zinterstore

zlexcount

zlexcount: ((key, min, max) => Promise<number>)

Type declaration

- (key, min, max): Promise<number>
- Parameters
  - key: string
  - min: string
  - max: string
  Returns Promise<number>
  See
  https://redis.io/commands/zlexcount

zmscore

zmscore: ((key, members) => Promise<number[]>)

Type declaration

- (key, members): Promise<number[]>
- Parameters
  - key: string
  - members: unknown[]
  Returns Promise<number[]>
  See
  https://redis.io/commands/zmscore

zpopmax

zpopmax: (<TData>(key, count?) => Promise<TData[]>)

Type declaration

- <TData>(key, count?): Promise<TData[]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData[]>
  See
  https://redis.io/commands/zpopmax

zpopmin

zpopmin: (<TData>(key, count?) => Promise<TData[]>)

Type declaration

- <TData>(key, count?): Promise<TData[]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Promise<TData[]>
  See
  https://redis.io/commands/zpopmin

zrange

zrange: (<TData>(...args) => Promise<TData>)

Type declaration

- <TData>(...args): Promise<TData>
- Type Parameters
  - TData extends unknown[]
  Parameters
  - Rest ...args: [key: string, min: number, max: number, opts?: ZRangeCommandOptions] | [key: string, min: `(${string}` | `[${string}` | "-" | "+", max: `(${string}` | `[${string}` | "-" | "+", opts: {
        byLex: true;
        byScore?: true;
        count?: number;
        offset?: number;
        rev?: boolean;
        withScores?: boolean;
    }] | [key: string, min: number | `(${number}` | "-inf" | "+inf", max: number | `(${number}` | "-inf" | "+inf", opts: {
        byLex?: true;
        byScore: true;
        count?: number;
        offset?: number;
        rev?: boolean;
        withScores?: boolean;
    }]
  Returns Promise<TData>
  See
  https://redis.io/commands/zrange

zrank

zrank: (<TData>(key, member) => Promise<number>)

Type declaration

- <TData>(key, member): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Promise<number>
  See
  https://redis.io/commands/zrank

zrem

zrem: (<TData>(key, ...members) => Promise<number>)

Type declaration

- <TData>(key, ...members): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Rest ...members: TData[]
  Returns Promise<number>
  See
  https://redis.io/commands/zrem

zremrangebylex

zremrangebylex: ((key, min, max) => Promise<number>)

Type declaration

- (key, min, max): Promise<number>
- Parameters
  - key: string
  - min: string
  - max: string
  Returns Promise<number>
  See
  https://redis.io/commands/zremrangebylex

zremrangebyrank

zremrangebyrank: ((key, start, stop) => Promise<number>)

Type declaration

- (key, start, stop): Promise<number>
- Parameters
  - key: string
  - start: number
  - stop: number
  Returns Promise<number>
  See
  https://redis.io/commands/zremrangebyrank

zremrangebyscore

zremrangebyscore: ((key, min, max) => Promise<number>)

Type declaration

- (key, min, max): Promise<number>
- Parameters
  - key: string
  - min: number
  - max: number
  Returns Promise<number>
  See
  https://redis.io/commands/zremrangebyscore

zrevrank

zrevrank: (<TData>(key, member) => Promise<number>)

Type declaration

- <TData>(key, member): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Promise<number>
  See
  https://redis.io/commands/zrevrank

zscan

zscan: ((key, cursor, opts?) => Promise<[number, (string | number)[]]>)

Type declaration

- (key, cursor, opts?): Promise<[number, (string | number)[]]>
- Parameters
  - key: string
  - cursor: number
  - Optional opts: ScanCommandOptions
  Returns Promise<[number, (string | number)[]]>
  See
  https://redis.io/commands/zscan

zscore

zscore: (<TData>(key, member) => Promise<number>)

Type declaration

- <TData>(key, member): Promise<number>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Promise<number>
  See
  https://redis.io/commands/zscore

zunion

zunion: ((numKeys, keys, opts?) => Promise<any>)

Type declaration

- (numKeys, keys, opts?): Promise<any>
- Parameters
  - numKeys: number
  - keys: string[]
  - Optional opts: ZUnionCommandOptions
  Returns Promise<any>
  See
  https://redis.io/commands/zunion

zunionstore

zunionstore: ((destination, numKeys, keys, opts?) => Promise<number>)

Type declaration

- (destination, numKeys, keys, opts?): Promise<number>
- Parameters
  - destination: string
  - numKeys: number
  - keys: string[]
  - Optional opts: ZUnionStoreCommandOptions
  Returns Promise<number>
  See
  https://redis.io/commands/zunionstore

Class VercelKV

Hierarchy

Index

Accessors

Constructors

Methods

Properties

Accessors

json

arrappend: ((key, path, ...values) => Promise<number[]>)

Parameters

key: string

path: string

Rest ...values: unknown[]

Returns Promise<number[]>

See

arrindex: ((key, path, value, start?, stop?) => Promise<number[]>)

Parameters

key: string

path: string

value: unknown

Optional start: number

Optional stop: number

Returns Promise<number[]>

See

arrinsert: ((key, path, index, ...values) => Promise<number[]>)

Parameters

key: string

path: string

index: number

Rest ...values: unknown[]

Returns Promise<number[]>

See

arrlen: ((key, path?) => Promise<number[]>)

Parameters

key: string

Optional path: string

Returns Promise<number[]>

See

arrpop: ((key, path?, index?) => Promise<unknown[]>)

Parameters

key: string

Optional path: string

Optional index: number

Returns Promise<unknown[]>

See

arrtrim: ((key, path?, start?, stop?) => Promise<number[]>)

Parameters

key: string

Optional path: string

Optional start: number

Optional stop: number

Returns Promise<number[]>

See

clear: ((key, path?) => Promise<number>)

Parameters

key: string

Optional path: string

Returns Promise<number>

See

del: ((key, path?) => Promise<number>)

Parameters

key: string

Optional path: string

Returns Promise<number>

See

forget: ((key, path?) => Promise<number>)

Parameters

key: string

Optional path: string

Returns Promise<number>

See

geoadd: ((args_0, args_1, ...args_2) => Promise<number>)

Parameters

args_0: string

args_1: GeoMember<unknown> | GeoAddCommandOptions

Rest ...args_2: GeoMember<unknown>[]

Returns Promise<number>

See

geodist: ((key, member1, member2, unit?) => Promise<number>)

`Rest` ...values: unknown[]

`Optional` start: number

`Optional` stop: number

`Rest` ...values: unknown[]

`Optional` path: string

`Optional` path: string

`Optional` index: number

`Optional` path: string

`Optional` start: number

`Optional` stop: number

`Optional` path: string

`Optional` path: string

`Optional` path: string

`Rest` ...args_2: GeoMember<unknown>[]

`Optional` unit: "M" | "KM" | "FT" | "MI"

`Rest` ...args_1: unknown[]

geopos: ((args_0, ...args_1) => Promise<{
lat: number;
lng: number;
}[]>)

`Rest` ...args_1: unknown[]

Returns Promise<{
lat: number;
lng: number;
}[]>

geosearch: ((key, centerPoint, shape, order, opts?) => Promise<({
member: unknown;
} & {
coord?: {
lat: number;
long: number;
};
dist?: number;
hash?: string;
})[]>)

centerPoint: {
coordinate: {
lat: number;
lon: number;
};
type: "FROMLONLAT" | "fromlonlat";
} | {
member: unknown;
type: "FROMMEMBER" | "frommember";
}

shape: {
radius: number;
radiusType: "M" | "KM" | "FT" | "MI";
type: "BYRADIUS" | "byradius";
} | {
rect: {
height: number;
width: number;
};
rectType: "M" | "KM" | "FT" | "MI";
type: "BYBOX" | "bybox";
}

`Optional` opts: {
count?: {
any?: boolean;
limit: number;
};
withCoord?: boolean;
withDist?: boolean;
withHash?: boolean;
}

`Optional` count?: {
any?: boolean;
limit: number;
}

`Optional` any?: boolean

`Optional` withCoord?: boolean

`Optional` withDist?: boolean

`Optional` withHash?: boolean

Returns Promise<({
member: unknown;
} & {
coord?: {
lat: number;
long: number;
};
dist?: number;
hash?: string;
})[]>

centerPoint: {
coordinate: {
lat: number;
lon: number;
};
type: "FROMLONLAT" | "fromlonlat";
} | {
member: unknown;
type: "FROMMEMBER" | "frommember";
}

shape: {
radius: number;
radiusType: "M" | "KM" | "FT" | "MI";
type: "BYRADIUS" | "byradius";
} | {
rect: {
height: number;
width: number;
};
rectType: "M" | "KM" | "FT" | "MI";
type: "BYBOX" | "bybox";
}

`Optional` opts: {
count?: {
any?: boolean;
limit: number;
};
storeDist?: boolean;
}

`Optional` count?: {
any?: boolean;
limit: number;
}

`Optional` any?: boolean

`Optional` storeDist?: boolean

`Rest` ...args: [key: string, opts?: {
indent?: string;
newline?: string;
space?: string;
}, ...path: string[]] | [key: string, ...path: string[]]