Class Pipeline<TCommands>

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. When using pipelines, several commands are sent using a single HTTP request, and a single JSON array response is returned. Each item in the response array corresponds to the command in the same order within the pipeline.

NOTE:

Execution of the pipeline is not atomic. Even though each command in the pipeline will be executed in order, commands sent by other clients can interleave with the pipeline.

Examples:

 const p = redis.pipeline() // or redis.multi()
p.set("key","value")
p.get("key")
const res = await p.exec()

You can also chain commands together

const p = redis.pipeline()
const res = await p.set("key","value").get("key").exec()

Return types are inferred if all commands are chained, but you can still override the response type manually:

 redis.pipeline()
  .set("key", { greeting: "hello"})
  .get("key")
  .exec<["OK", { greeting: string } ]>()

Type Parameters

TCommands extends Command<any, any>[] = []

Index

Accessors

json

get json(): {
    arrappend: ((key, path, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrindex: ((key, path, value, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrinsert: ((key, path, index, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrpop: ((key, path?, index?) => Pipeline<[...TCommands[], Command<any, unknown[]>]>);
    arrtrim: ((key, path?, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    clear: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    del: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    forget: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    geoadd: ((args_0, args_1, ...args_2) => Pipeline<[...TCommands[], Command<any, number>]>);
    geodist: ((key, member1, member2, unit?) => Pipeline<[...TCommands[], Command<any, number>]>);
    geohash: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, string[]>]>);
    geopos: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, {
        lat: number;
        lng: number;
    }[]>]>);
    geosearch: ((key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, ({
        member: unknown;
    } & {
        coord?: {
            lat: number;
            long: number;
        };
        dist?: number;
        hash?: string;
    })[]>]>);
    geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, number>]>);
    get: ((...args) => Pipeline<[...TCommands[], Command<any, any>]>);
    mget: ((keys, path) => Pipeline<[...TCommands[], Command<any, any>]>);
    numincrby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    nummultby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    objkeys: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[][]>]>);
    objlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    resp: ((key, path?) => Pipeline<[...TCommands[], Command<any, any>]>);
    set: ((key, path, value, opts?) => Pipeline<[...TCommands[], Command<any, "OK">]>);
    strappend: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    strlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    toggle: ((key, path) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    type: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[]>]>);
}
Returns {
    arrappend: ((key, path, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrindex: ((key, path, value, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrinsert: ((key, path, index, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    arrpop: ((key, path?, index?) => Pipeline<[...TCommands[], Command<any, unknown[]>]>);
    arrtrim: ((key, path?, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    clear: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    del: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    forget: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>);
    geoadd: ((args_0, args_1, ...args_2) => Pipeline<[...TCommands[], Command<any, number>]>);
    geodist: ((key, member1, member2, unit?) => Pipeline<[...TCommands[], Command<any, number>]>);
    geohash: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, string[]>]>);
    geopos: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, {
        lat: number;
        lng: number;
    }[]>]>);
    geosearch: ((key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, ({
        member: unknown;
    } & {
        coord?: {
            lat: number;
            long: number;
        };
        dist?: number;
        hash?: string;
    })[]>]>);
    geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, number>]>);
    get: ((...args) => Pipeline<[...TCommands[], Command<any, any>]>);
    mget: ((keys, path) => Pipeline<[...TCommands[], Command<any, any>]>);
    numincrby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    nummultby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    objkeys: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[][]>]>);
    objlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    resp: ((key, path?) => Pipeline<[...TCommands[], Command<any, any>]>);
    set: ((key, path, value, opts?) => Pipeline<[...TCommands[], Command<any, "OK">]>);
    strappend: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    strlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    toggle: ((key, path) => Pipeline<[...TCommands[], Command<any, number[]>]>);
    type: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[]>]>);
}
- arrappend: ((key, path, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, ...values): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      Rest ...values: unknown[]
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.arrappend
- arrindex: ((key, path, value, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, value, start?, stop?): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      value: unknown
      Optional start: number
      Optional stop: number
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.arrindex
- arrinsert: ((key, path, index, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, index, ...values): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      index: number
      Rest ...values: unknown[]
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.arrinsert
- arrlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.arrlen
- arrpop: ((key, path?, index?) => Pipeline<[...TCommands[], Command<any, unknown[]>]>)
  - - (key, path?, index?): Pipeline<[...TCommands[], Command<any, unknown[]>]>
    - Parameters
      key: string
      Optional path: string
      Optional index: number
      Returns Pipeline<[...TCommands[], Command<any, unknown[]>]>
      See
      https://redis.io/commands/json.arrpop
- arrtrim: ((key, path?, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path?, start?, stop?): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      Optional path: string
      Optional start: number
      Optional stop: number
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.arrtrim
- clear: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/json.clear
- del: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/json.del
- forget: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/json.forget
- geoadd: ((args_0, args_1, ...args_2) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (args_0, args_1, ...args_2): Pipeline<[...TCommands[], Command<any, number>]>
    - Parameters
      args_0: string
      args_1: GeoMember<unknown> | GeoAddCommandOptions
      Rest ...args_2: GeoMember<unknown>[]
      Returns Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/geoadd
- geodist: ((key, member1, member2, unit?) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (key, member1, member2, unit?): Pipeline<[...TCommands[], Command<any, number>]>
    - Parameters
      key: string
      member1: unknown
      member2: unknown
      Optional unit: "M" | "KM" | "FT" | "MI"
      Returns Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/geodist
- geohash: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, string[]>]>)
  - - (args_0, ...args_1): Pipeline<[...TCommands[], Command<any, string[]>]>
    - Parameters
      args_0: string
      Rest ...args_1: unknown[]
      Returns Pipeline<[...TCommands[], Command<any, string[]>]>
      See
      https://redis.io/commands/geohash
- geopos: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, {
  lat: number;
  lng: number;
  }[]>]>)
  - - (args_0, ...args_1): Pipeline<[...TCommands[], Command<any, {
      lat: number;
      lng: number;
      }[]>]>
    - Parameters
      args_0: string
      Rest ...args_1: unknown[]
      Returns Pipeline<[...TCommands[], Command<any, {
      lat: number;
      lng: number;
      }[]>]>
      See
      https://redis.io/commands/geopos
- geosearch: ((key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, ({
      member: unknown;
  } & {
      coord?: {
          lat: number;
          long: number;
      };
      dist?: number;
      hash?: string;
  })[]>]>)
  - - (key, centerPoint, shape, order, opts?): Pipeline<[...TCommands[], Command<any, ({
          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 Pipeline<[...TCommands[], Command<any, ({
          member: unknown;
      } & {
          coord?: {
              lat: number;
              long: number;
          };
          dist?: number;
          hash?: string;
      })[]>]>
      See
      https://redis.io/commands/geosearch
- geosearchstore: ((destination, key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, number>]>)
  - - (destination, key, centerPoint, shape, order, opts?): Pipeline<[...TCommands[], Command<any, 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 Pipeline<[...TCommands[], Command<any, number>]>
      See
      https://redis.io/commands/geosearchstore
- get: ((...args) => Pipeline<[...TCommands[], Command<any, any>]>)
  - - (...args): Pipeline<[...TCommands[], Command<any, any>]>
    - Parameters
      Rest ...args: [key: string, opts?: {
          indent?: string;
          newline?: string;
          space?: string;
      }, ...path: string[]] | [key: string, ...path: string[]]
      Returns Pipeline<[...TCommands[], Command<any, any>]>
      See
      https://redis.io/commands/json.get
- mget: ((keys, path) => Pipeline<[...TCommands[], Command<any, any>]>)
  - - (keys, path): Pipeline<[...TCommands[], Command<any, any>]>
    - Parameters
      keys: string[]
      path: string
      Returns Pipeline<[...TCommands[], Command<any, any>]>
      See
      https://redis.io/commands/json.mget
- numincrby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, value): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      value: number
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.numincrby
- nummultby: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, value): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      value: number
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.nummultby
- objkeys: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[][]>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, string[][]>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, string[][]>]>
      See
      https://redis.io/commands/json.objkeys
- objlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.objlen
- resp: ((key, path?) => Pipeline<[...TCommands[], Command<any, any>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, any>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, any>]>
      See
      https://redis.io/commands/json.resp
- set: ((key, path, value, opts?) => Pipeline<[...TCommands[], Command<any, "OK">]>)
  - - (key, path, value, opts?): Pipeline<[...TCommands[], Command<any, "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 Pipeline<[...TCommands[], Command<any, "OK">]>
      See
      https://redis.io/commands/json.set
- strappend: ((key, path, value) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path, value): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      value: string
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.strappend
- strlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.strlen
- toggle: ((key, path) => Pipeline<[...TCommands[], Command<any, number[]>]>)
  - - (key, path): Pipeline<[...TCommands[], Command<any, number[]>]>
    - Parameters
      key: string
      path: string
      Returns Pipeline<[...TCommands[], Command<any, number[]>]>
      See
      https://redis.io/commands/json.toggle
- type: ((key, path?) => Pipeline<[...TCommands[], Command<any, string[]>]>)
  - - (key, path?): Pipeline<[...TCommands[], Command<any, string[]>]>
    - Parameters
      key: string
      Optional path: string
      Returns Pipeline<[...TCommands[], Command<any, string[]>]>
      See
      https://redis.io/commands/json.type
See
https://redis.io/commands/?group=json

Constructors

constructor

new Pipeline<TCommands>(opts): Pipeline<TCommands>
Type Parameters
- TCommands extends Command<any, any>[] = []
Parameters
- opts: {
      client: Requester;
      commandOptions?: CommandOptions<any, any>;
      multiExec?: boolean;
  }
  - client: Requester
  - Optional commandOptions?: CommandOptions<any, any>
  - Optional multiExec?: boolean
Returns Pipeline<TCommands>

Methods

length

length(): number
Returns the length of pipeline before the execution

Returns number

Properties

append

append: ((key, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, value): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - value: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/append

bitcount

bitcount: ((key, start, end) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, start, end): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/bitcount

bitop

bitop: {
(op, destinationKey, sourceKey, ...sourceKeys): Pipeline<[...TCommands[], BitOpCommand]>;
(op, destinationKey, sourceKey): Pipeline<[...TCommands[], BitOpCommand]>;
}

Type declaration

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

bitpos

bitpos: ((key, bit, start?, end?) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

`Private` chain

chain: any

Pushes a command into the pipeline and returns a chainable instance of the pipeline

`Private` client

client: any

`Private` `Optional` commandOptions

commandOptions?: any

`Private` commands

commands: any

copy

copy: ((key, destinationKey, opts?) => Pipeline<[...TCommands[], Command<any, "COPIED" | "NOT_COPIED">]>)

Type declaration

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

dbsize

dbsize: (() => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (): Pipeline<[...TCommands[], Command<any, number>]>
- Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/dbsize

decr

decr: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/decr

decrby

decrby: ((key, decrement) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, decrement): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - decrement: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/decrby

del

del: ((...args) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (...args): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - Rest ...args: string[]
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/del

echo

echo: ((message) => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- (message): Pipeline<[...TCommands[], Command<any, string>]>
- Parameters
  - message: string
  Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/echo

eval

eval: (<TArgs, TData>(script, keys, args) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

evalsha

evalsha: (<TArgs, TData>(sha1, keys, args) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

exec

exec: (<TCommandResults>() => Promise<TCommandResults>)

Type declaration

- <TCommandResults>(): Promise<TCommandResults>
- 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:
```
const p = redis.pipeline()
p.get("key")
const result = p.exec<[{ greeting: string }]>()
```
  Type Parameters
  - TCommandResults extends unknown[] = [] extends TCommands
    ? unknown[]
    : InferResponseData<TCommands>
  Returns Promise<TCommandResults>

exists

exists: ((...args) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (...args): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - Rest ...args: string[]
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/exists

expire

expire: ((key, seconds) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, seconds): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - seconds: number
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/expire

expireat

expireat: ((key, unix) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, unix): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - unix: number
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/expireat

flushall

flushall: ((args?) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

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

flushdb

flushdb: ((opts?) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- (opts?): Pipeline<[...TCommands[], Command<any, "OK">]>
- Parameters
  - Optional opts: {
    async?: boolean;
    }
    - Optional async?: boolean
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/flushdb

get

get: (<TData>(key) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/get

getbit

getbit: ((key, offset) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, offset): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - offset: number
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/getbit

getdel

getdel: (<TData>(key) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/getdel

getrange

getrange: ((key, start, end) => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- (key, start, end): Pipeline<[...TCommands[], Command<any, string>]>
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/getrange

getset

getset: (<TData>(key, value) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, value): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/getset

hdel

hdel: ((key, ...fields) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

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

hexists

hexists: ((key, field) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, field): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - field: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/hexists

hget

hget: (<TData>(key, field) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, field): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - field: string
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/hget

hgetall

hgetall: (<TData>(key) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData extends Record<string, unknown>
  Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/hgetall

hincrby

hincrby: ((key, field, increment) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, field, increment): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - field: string
  - increment: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/hincrby

hincrbyfloat

hincrbyfloat: ((key, field, increment) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, field, increment): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - field: string
  - increment: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/hincrbyfloat

hkeys

hkeys: ((key) => Pipeline<[...TCommands[], Command<any, string[]>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, string[]>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, string[]>]>
  See
  https://redis.io/commands/hkeys

hlen

hlen: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/hlen

hmget

hmget: (<TData>(key, ...fields) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

hmset

hmset: (<TData>(key, kv) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

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

hrandfield

hrandfield: (<TData>(key, count?, withValues?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, count?, withValues?): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData extends string | string[] | Record<string, unknown>
  Parameters
  - key: string
  - Optional count: number
  - Optional withValues: boolean
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/hrandfield

hscan

hscan: ((key, cursor, cmdOpts?) => Pipeline<[...TCommands[], Command<any, [number, (string | number)[]]>]>)

Type declaration

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

hset

hset: (<TData>(key, kv) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

hsetnx

hsetnx: (<TData>(key, field, value) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- <TData>(key, field, value): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - field: string
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/hsetnx

hstrlen

hstrlen: ((key, field) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, field): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - field: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/hstrlen

hvals

hvals: ((key) => Pipeline<[...TCommands[], Command<any, any>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, any>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, any>]>
  See
  https://redis.io/commands/hvals

incr

incr: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/incr

incrby

incrby: ((key, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, value): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - value: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/incrby

incrbyfloat

incrbyfloat: ((key, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, value): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - value: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/incrbyfloat

keys

keys: ((pattern) => Pipeline<[...TCommands[], Command<any, string[]>]>)

Type declaration

- (pattern): Pipeline<[...TCommands[], Command<any, string[]>]>
- Parameters
  - pattern: string
  Returns Pipeline<[...TCommands[], Command<any, string[]>]>
  See
  https://redis.io/commands/keys

lindex

lindex: ((key, index) => Pipeline<[...TCommands[], Command<any, any>]>)

Type declaration

- (key, index): Pipeline<[...TCommands[], Command<any, any>]>
- Parameters
  - key: string
  - index: number
  Returns Pipeline<[...TCommands[], Command<any, any>]>
  See
  https://redis.io/commands/lindex

linsert

linsert: (<TData>(key, direction, pivot, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

llen

llen: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/llen

lmove

lmove: (<TData>(source, destination, whereFrom, whereTo) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

lpop

lpop: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, count?): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/lpop

lpos

lpos: (<TData>(key, element, opts?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

lpush

lpush: (<TData>(key, ...elements) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

lpushx

lpushx: (<TData>(key, ...elements) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

lrange

lrange: (<TResult>(key, start, end) => Pipeline<[...TCommands[], Command<any, TResult[]>]>)

Type declaration

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

lrem

lrem: (<TData>(key, count, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, count, value): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - count: number
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/lrem

lset

lset: (<TData>(key, index, value) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- <TData>(key, index, value): Pipeline<[...TCommands[], Command<any, "OK">]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - index: number
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/lset

ltrim

ltrim: ((key, start, end) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- (key, start, end): Pipeline<[...TCommands[], Command<any, "OK">]>
- Parameters
  - key: string
  - start: number
  - end: number
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/ltrim

mget

mget: (<TData>(...args) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

mset

mset: (<TData>(kv) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

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

msetnx

msetnx: (<TData>(kv) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

`Private` multiExec

multiExec: any

persist

persist: ((key) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/persist

pexpire

pexpire: ((key, milliseconds) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, milliseconds): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - milliseconds: number
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/pexpire

pexpireat

pexpireat: ((key, unix) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, unix): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - unix: number
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/pexpireat

pfadd

pfadd: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

pfcount

pfcount: ((args_0, ...args_1) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

pfmerge

pfmerge: ((destination_key, ...args_1) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

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

ping

ping: ((args?) => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- (args?): Pipeline<[...TCommands[], Command<any, string>]>
- Parameters
  - Optional args: [message?: string]
  Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/ping

psetex

psetex: (<TData>(key, ttl, value) => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- <TData>(key, ttl, value): Pipeline<[...TCommands[], Command<any, string>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - ttl: number
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/psetex

pttl

pttl: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/pttl

publish

publish: ((channel, message) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (channel, message): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - channel: string
  - message: unknown
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/publish

randomkey

randomkey: (() => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- (): Pipeline<[...TCommands[], Command<any, string>]>
- Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/randomkey

rename

rename: ((source, destination) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- (source, destination): Pipeline<[...TCommands[], Command<any, "OK">]>
- Parameters
  - source: string
  - destination: string
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/rename

renamenx

renamenx: ((source, destination) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (source, destination): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - source: string
  - destination: string
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/renamenx

rpop

rpop: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, count?): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData = string
  Parameters
  - key: string
  - Optional count: number
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/rpop

rpush

rpush: (<TData>(key, ...elements) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

rpushx

rpushx: (<TData>(key, ...elements) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

sadd

sadd: (<TData>(key, ...members) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

scan

scan: ((cursor, opts?) => Pipeline<[...TCommands[], Command<any, [number, string[]]>]>)

Type declaration

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

scard

scard: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/scard

scriptExists

scriptExists: ((...args) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Type declaration

- (...args): Pipeline<[...TCommands[], Command<any, number[]>]>
- Parameters
  - Rest ...args: string[]
  Returns Pipeline<[...TCommands[], Command<any, number[]>]>
  See
  https://redis.io/commands/script-exists

scriptFlush

scriptFlush: ((opts?) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- (opts?): Pipeline<[...TCommands[], Command<any, "OK">]>
- Parameters
  - Optional opts: ScriptFlushCommandOptions
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/script-flush

scriptLoad

scriptLoad: ((script) => Pipeline<[...TCommands[], Command<any, string>]>)

Type declaration

- (script): Pipeline<[...TCommands[], Command<any, string>]>
- Parameters
  - script: string
  Returns Pipeline<[...TCommands[], Command<any, string>]>
  See
  https://redis.io/commands/script-load

sdiff

sdiff: ((key, ...keys) => Pipeline<[...TCommands[], Command<any, unknown[]>]>)

Type declaration

- (key, ...keys): Pipeline<[...TCommands[], Command<any, unknown[]>]>
- Parameters
  - key: string
  - Rest ...keys: string[]
  Returns Pipeline<[...TCommands[], Command<any, unknown[]>]>

sdiffstore

sdiffstore: ((destination, ...keys) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

set

set: (<TData>(key, value, opts?) => Pipeline<[...TCommands[], Command<any, "OK" | TData>]>)

Type declaration

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

setbit

setbit: ((key, offset, value) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- (key, offset, value): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Parameters
  - key: string
  - offset: number
  - value: 0 | 1
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/setbit

setex

setex: (<TData>(key, ttl, value) => Pipeline<[...TCommands[], Command<any, "OK">]>)

Type declaration

- <TData>(key, ttl, value): Pipeline<[...TCommands[], Command<any, "OK">]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - ttl: number
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, "OK">]>
  See
  https://redis.io/commands/setex

setnx

setnx: (<TData>(key, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, value): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - value: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/setnx

setrange

setrange: ((key, offset, value) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, offset, value): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - offset: number
  - value: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/setrange

sinter

sinter: ((key, ...keys) => Pipeline<[...TCommands[], Command<any, string[]>]>)

Type declaration

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

sinterstore

sinterstore: ((destination, key, ...keys) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

sismember

sismember: (<TData>(key, member) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- <TData>(key, member): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/sismember

smembers

smembers: (<TData>(key) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

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

smismember

smismember: (<TMembers>(key, members) => Pipeline<[...TCommands[], Command<any, (0 | 1)[]>]>)

Type declaration

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

smove

smove: (<TData>(source, destination, member) => Pipeline<[...TCommands[], Command<any, 0 | 1>]>)

Type declaration

- <TData>(source, destination, member): Pipeline<[...TCommands[], Command<any, 0 | 1>]>
- Type Parameters
  - TData
  Parameters
  - source: string
  - destination: string
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, 0 | 1>]>
  See
  https://redis.io/commands/smove

spop

spop: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, count?): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/spop

srandmember

srandmember: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(key, count?): Pipeline<[...TCommands[], Command<any, TData>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - Optional count: number
  Returns Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/srandmember

srem

srem: (<TData>(key, ...members) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

sscan

sscan: ((key, cursor, opts?) => Pipeline<[...TCommands[], Command<any, [number, (string | number)[]]>]>)

Type declaration

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

strlen

strlen: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/strlen

sunion

sunion: ((key, ...keys) => Pipeline<[...TCommands[], Command<any, unknown[]>]>)

Type declaration

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

sunionstore

sunionstore: ((destination, key, ...keys) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

time

time: (() => Pipeline<[...TCommands[], Command<any, [number, number]>]>)

Type declaration

- (): Pipeline<[...TCommands[], Command<any, [number, number]>]>
- Returns Pipeline<[...TCommands[], Command<any, [number, number]>]>
  See
  https://redis.io/commands/time

touch

touch: ((...args) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (...args): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - Rest ...args: string[]
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/touch

ttl

ttl: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/ttl

type

type: ((key) => Pipeline<[...TCommands[], Command<any, Type>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, Type>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, Type>]>
  See
  https://redis.io/commands/type

unlink

unlink: ((...args) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (...args): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - Rest ...args: string[]
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/unlink

zadd

zadd: (<TData>(...args) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(...args): Pipeline<[...TCommands[], Command<any, 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 Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zadd

zcard

zcard: ((key) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zcard

zcount

zcount: ((key, min, max) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, min, max): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - min: string | number
  - max: string | number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zcount

zdiffstore

zdiffstore: ((destination, numkeys, ...keys) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

zincrby

zincrby: (<TData>(key, increment, member) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, increment, member): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - increment: number
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zincrby

zinterstore

zinterstore: ((destination, numKeys, keys, opts?) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

zlexcount

zlexcount: ((key, min, max) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, min, max): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - min: string
  - max: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zlexcount

zmscore

zmscore: ((key, members) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Type declaration

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

zpopmax

zpopmax: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData[]>]>)

Type declaration

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

zpopmin

zpopmin: (<TData>(key, count?) => Pipeline<[...TCommands[], Command<any, TData[]>]>)

Type declaration

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

zrange

zrange: (<TData>(...args) => Pipeline<[...TCommands[], Command<any, TData>]>)

Type declaration

- <TData>(...args): Pipeline<[...TCommands[], Command<any, 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 Pipeline<[...TCommands[], Command<any, TData>]>
  See
  https://redis.io/commands/zrange

zrank

zrank: (<TData>(key, member) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, member): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zrank

zrem

zrem: (<TData>(key, ...members) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

zremrangebylex

zremrangebylex: ((key, min, max) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, min, max): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - min: string
  - max: string
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zremrangebylex

zremrangebyrank

zremrangebyrank: ((key, start, stop) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, start, stop): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - start: number
  - stop: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zremrangebyrank

zremrangebyscore

zremrangebyscore: ((key, min, max) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- (key, min, max): Pipeline<[...TCommands[], Command<any, number>]>
- Parameters
  - key: string
  - min: number
  - max: number
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zremrangebyscore

zrevrank

zrevrank: (<TData>(key, member) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, member): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zrevrank

zscan

zscan: ((key, cursor, opts?) => Pipeline<[...TCommands[], Command<any, [number, (string | number)[]]>]>)

Type declaration

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

zscore

zscore: (<TData>(key, member) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

- <TData>(key, member): Pipeline<[...TCommands[], Command<any, number>]>
- Type Parameters
  - TData
  Parameters
  - key: string
  - member: TData
  Returns Pipeline<[...TCommands[], Command<any, number>]>
  See
  https://redis.io/commands/zscore

zunion

zunion: ((numKeys, keys, opts?) => Pipeline<[...TCommands[], Command<any, any>]>)

Type declaration

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

zunionstore

zunionstore: ((destination, numKeys, keys, opts?) => Pipeline<[...TCommands[], Command<any, number>]>)

Type declaration

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

Class Pipeline<TCommands>

Type Parameters

TCommands extends Command<any, any>[] = []

Index

Accessors

Constructors

Methods

Properties

Accessors

json

arrappend: ((key, path, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Parameters

key: string

path: string

Rest ...values: unknown[]

Returns Pipeline<[...TCommands[], Command<any, number[]>]>

See

arrindex: ((key, path, value, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Parameters

key: string

path: string

value: unknown

Optional start: number

Optional stop: number

Returns Pipeline<[...TCommands[], Command<any, number[]>]>

See

arrinsert: ((key, path, index, ...values) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Parameters

key: string

path: string

index: number

Rest ...values: unknown[]

Returns Pipeline<[...TCommands[], Command<any, number[]>]>

See

arrlen: ((key, path?) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Parameters

key: string

Optional path: string

Returns Pipeline<[...TCommands[], Command<any, number[]>]>

See

arrpop: ((key, path?, index?) => Pipeline<[...TCommands[], Command<any, unknown[]>]>)

Parameters

key: string

Optional path: string

Optional index: number

Returns Pipeline<[...TCommands[], Command<any, unknown[]>]>

See

arrtrim: ((key, path?, start?, stop?) => Pipeline<[...TCommands[], Command<any, number[]>]>)

Parameters

key: string

Optional path: string

Optional start: number

Optional stop: number

Returns Pipeline<[...TCommands[], Command<any, number[]>]>

See

clear: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)

Parameters

key: string

Optional path: string

Returns Pipeline<[...TCommands[], Command<any, number>]>

See

del: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)

Parameters

key: string

Optional path: string

Returns Pipeline<[...TCommands[], Command<any, number>]>

See

forget: ((key, path?) => Pipeline<[...TCommands[], Command<any, number>]>)

Parameters

key: string

Optional path: string

Returns Pipeline<[...TCommands[], Command<any, number>]>

See

geoadd: ((args_0, args_1, ...args_2) => Pipeline<[...TCommands[], Command<any, number>]>)

Parameters

args_0: string

args_1: GeoMember<unknown> | GeoAddCommandOptions

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

Returns Pipeline<[...TCommands[], Command<any, number>]>

See

`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) => Pipeline<[...TCommands[], Command<any, {
lat: number;
lng: number;
}[]>]>)

`Rest` ...args_1: unknown[]

Returns Pipeline<[...TCommands[], Command<any, {
lat: number;
lng: number;
}[]>]>

geosearch: ((key, centerPoint, shape, order, opts?) => Pipeline<[...TCommands[], Command<any, ({
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 Pipeline<[...TCommands[], Command<any, ({
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[]]