SYMBOL INDEX (662 symbols across 60 files)

FILE: backoff.ts
  type Backoff (line 1) | interface Backoff {
  type ExponentialBackoffOptions (line 8) | interface ExponentialBackoffOptions {
  function exponentialBackoff (line 25) | function exponentialBackoff({

FILE: benchmark/benchmark.js
  function run (line 4) | function run({

FILE: client.ts
  type Client (line 13) | interface Client {

FILE: command.ts
  type ACLLogMode (line 42) | type ACLLogMode = "RESET";
  type BitopOperation (line 43) | type BitopOperation = "AND" | "OR" | "XOR" | "NOT";
  type BitfieldOpts (line 45) | interface BitfieldOpts {
  type BitfieldWithOverflowOpts (line 51) | interface BitfieldWithOverflowOpts extends BitfieldOpts {
  type ClientCachingMode (line 55) | type ClientCachingMode = "YES" | "NO";
  type ClientKillOpts (line 57) | interface ClientKillOpts {
  type ClientListOpts (line 66) | interface ClientListOpts {
  type ClientPauseMode (line 71) | type ClientPauseMode = "WRITE" | "ALL";
  type ClientTrackingOpts (line 73) | interface ClientTrackingOpts {
  type ClientType (line 83) | type ClientType = "NORMAL" | "MASTER" | "REPLICA" | "PUBSUB";
  type ClientUnblockingBehaviour (line 84) | type ClientUnblockingBehaviour = "TIMEOUT" | "ERROR";
  type ClusterFailoverMode (line 86) | type ClusterFailoverMode = "FORCE" | "TAKEOVER";
  type ClusterResetMode (line 87) | type ClusterResetMode = "HARD" | "SOFT";
  type ClusterSetSlotSubcommand (line 88) | type ClusterSetSlotSubcommand =
  type MigrateOpts (line 94) | interface MigrateOpts {
  type RestoreOpts (line 101) | interface RestoreOpts {
  type HelloOpts (line 108) | interface HelloOpts {
  type StralgoOpts (line 117) | interface StralgoOpts {
  type StralgoAlgorithm (line 124) | type StralgoAlgorithm = "LCS";
  type StralgoTarget (line 125) | type StralgoTarget = "KEYS" | "STRINGS";
  type SetOpts (line 127) | interface SetOpts {
  type SetReply (line 155) | type SetReply<T extends SetOpts | SetWithModeOpts> = T extends
  type SetWithModeOpts (line 165) | interface SetWithModeOpts extends SetOpts {
  type GeoRadiusOpts (line 172) | interface GeoRadiusOpts {
  type GeoUnit (line 182) | type GeoUnit = "m" | "km" | "ft" | "mi";
  type BaseScanOpts (line 184) | interface BaseScanOpts {
  type ScanOpts (line 189) | interface ScanOpts extends BaseScanOpts {
  type HScanOpts (line 193) | type HScanOpts = BaseScanOpts;
  type SScanOpts (line 194) | type SScanOpts = BaseScanOpts;
  type ZScanOpts (line 195) | type ZScanOpts = BaseScanOpts;
  type ZAddOpts (line 197) | interface ZAddOpts {
  type ZAddReply (line 207) | type ZAddReply<T extends ZAddOpts> =
  type ZStoreOpts (line 216) | interface ZStoreOpts {
  type ZInterstoreOpts (line 220) | type ZInterstoreOpts = ZStoreOpts;
  type ZUnionstoreOpts (line 221) | type ZUnionstoreOpts = ZStoreOpts;
  type ZRangeOpts (line 223) | interface ZRangeOpts {
  type ZInterOpts (line 227) | type ZInterOpts = {
  type ZRangeByLexOpts (line 231) | interface ZRangeByLexOpts {
  type ZRangeByScoreOpts (line 235) | interface ZRangeByScoreOpts {
  type BaseLPosOpts (line 240) | interface BaseLPosOpts {
  type LPosOpts (line 245) | interface LPosOpts extends BaseLPosOpts {
  type LPosWithCountOpts (line 249) | interface LPosWithCountOpts extends BaseLPosOpts {
  type LInsertLocation (line 253) | type LInsertLocation = "BEFORE" | "AFTER";
  type MemoryUsageOpts (line 255) | interface MemoryUsageOpts {
  type RoleReply (line 259) | type RoleReply =
  type ScriptDebugMode (line 264) | type ScriptDebugMode = "YES" | "SYNC" | "NO";
  type SortOpts (line 266) | interface SortOpts {
  type SortWithDestinationOpts (line 274) | interface SortWithDestinationOpts extends SortOpts {
  type ShutdownMode (line 278) | type ShutdownMode = "NOSAVE" | "SAVE";
  type RedisCommands (line 280) | interface RedisCommands {

FILE: connection.ts
  type SendCommandOptions (line 20) | interface SendCommandOptions {
  type Connection (line 29) | interface Connection extends TypedEventTarget<ConnectionEventMap> {
  type RedisConnectionOptions (line 65) | interface RedisConnectionOptions {

FILE: default_client.ts
  function createDefaultClient (line 12) | function createDefaultClient(connection: Connection): Client {
  class DefaultClient (line 16) | class DefaultClient implements Client {
    method constructor (line 17) | constructor(readonly connection: Connection) {}
    method exec (line 19) | exec(
    method sendCommand (line 26) | sendCommand(
    method subscribe (line 34) | async subscribe<
    method close (line 54) | close(): void {

FILE: default_connection.ts
  function createRedisConnection (line 33) | function createRedisConnection(
  type PendingCommand (line 41) | interface PendingCommand {
  class RedisConnection (line 47) | class RedisConnection
    method isClosed (line 64) | get isClosed(): boolean {
    method isConnected (line 68) | get isConnected(): boolean {
    method isRetriable (line 72) | get isRetriable(): boolean {
    method constructor (line 76) | constructor(
    method authenticate (line 92) | private async authenticate(
    method selectDb (line 115) | private async selectDb(
    method enqueueCommand (line 122) | private enqueueCommand(
    method sendCommand (line 132) | sendCommand(
    method #sendCommandImmediately (line 152) | #sendCommandImmediately(
    method addEventListener (line 170) | addEventListener<K extends keyof ConnectionEventMap>(
    method removeEventListener (line 182) | removeEventListener<K extends keyof ConnectionEventMap>(
    method [kUnstableReadReply] (line 194) | [kUnstableReadReply](returnsUint8Arrays?: boolean): Promise<RedisReply> {
    method [kUnstablePipeline] (line 198) | [kUnstablePipeline](commands: Array<Command>): Promise<RedisReply[]> {
    method [kUnstableWriteCommand] (line 207) | [kUnstableWriteCommand](command: Command): Promise<void> {
    method [kUnstableStartReadLoop] (line 211) | async *[kUnstableStartReadLoop](
    method connect (line 244) | connect(): Promise<void> {
    method #connect (line 263) | async #connect(retryCount: number) {
    method close (line 330) | close() {
    method #close (line 338) | #close(canReconnect = false) {
    method reconnect (line 361) | async reconnect(): Promise<void> {
    method processCommandQueue (line 374) | private async processCommandQueue() {
    method isManuallyClosedByUser (line 417) | private isManuallyClosedByUser(): boolean {
    method #enableHealthCheckIfNeeded (line 421) | #enableHealthCheckIfNeeded() {
  method [Symbol.dispose] (line 334) | [Symbol.dispose](): void {
  class AuthenticationError (line 447) | class AuthenticationError extends Error {}
  function parsePortLike (line 449) | function parsePortLike(port: string | number | undefined): number {

FILE: default_subscription.ts
  class DefaultRedisSubscription (line 15) | class DefaultRedisSubscription<
    method isConnected (line 18) | get isConnected(): boolean {
    method isClosed (line 22) | get isClosed(): boolean {
    method constructor (line 29) | constructor(private readonly connection: Connection) {}
    method psubscribe (line 31) | async psubscribe(...patterns: string[]) {
    method punsubscribe (line 38) | async punsubscribe(...patterns: string[]) {
    method subscribe (line 45) | async subscribe(...channels: string[]) {
    method unsubscribe (line 52) | async unsubscribe(...channels: string[]) {
    method receive (line 59) | receive(): AsyncIterableIterator<RedisPubSubMessage<TMessage>> {
    method receiveBuffers (line 63) | receiveBuffers(): AsyncIterableIterator<RedisPubSubMessage<Binary>> {
    method #receive (line 67) | async *#receive<
    method close (line 127) | close() {
    method #writeCommand (line 131) | async #writeCommand(command: string, args: Array<string>): Promise<voi...

FILE: errors.ts
  class EOFError (line 1) | class EOFError extends Error {}
  class ConnectionClosedError (line 3) | class ConnectionClosedError extends Error {}
  class SubscriptionClosedError (line 5) | class SubscriptionClosedError extends Error {}
  class ErrorReplyError (line 7) | class ErrorReplyError extends Error {}
  class NotImplementedError (line 8) | class NotImplementedError extends Error {
    method constructor (line 9) | constructor(message?: string) {
  class InvalidStateError (line 14) | class InvalidStateError extends Error {
    method constructor (line 15) | constructor(message?: string) {
  function isRetriableError (line 21) | function isRetriableError(error: unknown): boolean {

FILE: events.ts
  type ConnectionEvent (line 1) | type ConnectionEvent = Record<string, unknown>;
  type ConnectionErrorEventDetails (line 3) | type ConnectionErrorEventDetails = {
  type ConnectionReconnectingEventDetails (line 7) | type ConnectionReconnectingEventDetails = {
  type ConnectionEventMap (line 11) | type ConnectionEventMap = {
  type ConnectionEventType (line 20) | type ConnectionEventType =

FILE: executor.ts
  type CommandExecutor (line 4) | type CommandExecutor = Client;

FILE: experimental/cluster/mod.ts
  type ClusterConnectOptions (line 47) | interface ClusterConnectOptions {
  type NodeOptions (line 53) | interface NodeOptions {
  type SlotMap (line 58) | interface SlotMap {
  class ClusterNode (line 62) | class ClusterNode {
    method constructor (line 65) | constructor(readonly hostname: string, readonly port: number) {
    method parseIPAndPort (line 69) | static parseIPAndPort(ipAndPort: string): ClusterNode {
  class ClusterError (line 81) | class ClusterError extends Error {}
  class ClusterClient (line 83) | class ClusterClient implements Client {
    method constructor (line 91) | constructor(opts: ClusterConnectOptions) {
    method connection (line 99) | get connection(): Connection {
    method exec (line 103) | exec(command: string, ...args: RedisValue[]): Promise<RedisReply> {
    method sendCommand (line 107) | async sendCommand(
    method subscribe (line 194) | subscribe<TMessage extends PubSubMessageType = DefaultPubSubMessageType>(
    method close (line 201) | close(): void {
    method initializeSlotsCache (line 213) | async initializeSlotsCache(): Promise<void> {
    method #populateStartupNodes (line 245) | #populateStartupNodes(nodes: ClusterNode[]) {
    method #getRandomConnection (line 256) | async #getRandomConnection(): Promise<Redis> {
    method #getConnectionBySlot (line 287) | #getConnectionBySlot(slot: number): Promise<Redis> {
    method #getConnectionByNode (line 296) | async #getConnectionByNode(node: ClusterNode): Promise<Redis> {
    method #closeExistingConnection (line 312) | async #closeExistingConnection() {
    method #getRedisLink (line 327) | #getRedisLink(node: ClusterNode): Promise<Redis> {
  function getKeyFromCommand (line 333) | function getKeyFromCommand(command: string, args: RedisValue[]): string ...
  function connectToCluster (line 353) | async function connectToCluster(opts: ClusterConnectOptions): Promise<Re...

FILE: experimental/web_streams_connection/mod.ts
  function createProtocol (line 10) | function createProtocol(conn: Deno.Conn) {
  function connect (line 14) | function connect(options: RedisConnectOptions): Promise<Redis> {

FILE: internal/buffered_readable_stream.ts
  class BufferedReadableStream (line 9) | class BufferedReadableStream {
    method constructor (line 12) | constructor(readable: ReadableStream<Uint8Array>) {
    method readLine (line 17) | async readLine(): Promise<Uint8Array> {
    method readN (line 29) | async readN(n: number): Promise<Uint8Array> {
    method #consume (line 63) | #consume(n: number): Uint8Array {
    method #fill (line 69) | async #fill() {

FILE: internal/buffered_readable_stream_test.ts
  method start (line 62) | start(controller) {
  function createReadableStreamFromString (line 88) | function createReadableStreamFromString(s: string): ReadableStream<Uint8...

FILE: internal/concate_bytes.ts
  function concateBytes (line 1) | function concateBytes(a: Uint8Array, b: Uint8Array) {

FILE: internal/delegate.ts
  type Delegate (line 1) | type Delegate<TObject, TMethods extends keyof TObject> =
  function delegate (line 9) | function delegate<

FILE: internal/delegate_test.ts
  class Connection (line 12) | class Connection {
    method connect (line 14) | connect(): void {
    method close (line 17) | close(): void {
    method isConnected (line 20) | isConnected(): boolean {
    method isClosed (line 23) | isClosed(): boolean {

FILE: internal/on.ts
  type Options (line 1) | interface Options {
  function on (line 7) | function on(

FILE: internal/typed_event_target.ts
  type TypedEventTarget (line 1) | interface TypedEventTarget<TEventMap extends Record<string, unknown>>
  function createTypedEventTarget (line 24) | function createTypedEventTarget<
  function dispatchEvent (line 30) | function dispatchEvent<

FILE: pipeline.ts
  type RedisPipeline (line 20) | interface RedisPipeline extends Redis {
  function createRedisPipeline (line 24) | function createRedisPipeline(
  class PipelineClient (line 36) | class PipelineClient implements Client {
    method constructor (line 52) | constructor(
    method exec (line 58) | exec(
    method sendCommand (line 65) | sendCommand(
    method close (line 78) | close(): void {
    method subscribe (line 82) | subscribe<TMessage extends PubSubMessageType = DefaultPubSubMessageType>(
    method flush (line 89) | flush(): Promise<RawOrError[]> {
    method dequeue (line 103) | private dequeue(): void {

FILE: pool/client.ts
  function createPoolClient (line 20) | function createPoolClient(pool: Pool<Connection>): Client {
  class PoolClient (line 24) | class PoolClient implements Client {
    method constructor (line 26) | constructor(pool: Pool<Connection>) {
    method connection (line 30) | get connection(): Connection {
    method exec (line 34) | async exec(
    method sendCommand (line 47) | async sendCommand(
    method subscribe (line 61) | async subscribe<
    method close (line 83) | close(): void {
  function createPoolConnection (line 88) | function createPoolConnection(

FILE: pool/default_pool.ts
  class AlreadyRemovedFromPoolError (line 3) | class AlreadyRemovedFromPoolError extends Error {
    method constructor (line 4) | constructor() {
  class DefaultPool (line 10) | class DefaultPool<T extends Disposable> implements Pool<T> {
    method constructor (line 17) | constructor(
    method acquire (line 29) | async acquire(signal?: AbortSignal): Promise<T> {
    method #has (line 62) | #has(conn: T): boolean {
    method release (line 66) | release(conn: T): void {
    method close (line 77) | close() {
  type PoolOptions (line 94) | interface PoolOptions<T extends Disposable> {
  function createDefaultPool (line 99) | function createDefaultPool<T extends Disposable>(

FILE: pool/default_pool_test.ts
  class FakeConnection (line 4) | class FakeConnection implements Disposable {
    method isClosed (line 6) | isClosed() {
  method [Symbol.dispose] (line 9) | [Symbol.dispose]() {

FILE: pool/mod.ts
  type CreatePoolClientOptions (line 8) | interface CreatePoolClientOptions {
  function createPoolClient (line 13) | function createPoolClient(

FILE: pool/pool.ts
  type Pool (line 1) | interface Pool<T extends Disposable> {

FILE: protocol/deno_streams/command.ts
  function writeCommand (line 8) | async function writeCommand(
  function sendCommand (line 17) | async function sendCommand(
  function sendCommands (line 29) | async function sendCommands(

FILE: protocol/deno_streams/mod.ts
  class Protocol (line 9) | class Protocol implements BaseProtocol {
    method constructor (line 13) | constructor(conn: Deno.Conn) {
    method sendCommand (line 18) | sendCommand(
    method readReply (line 32) | readReply(returnsUint8Arrays?: boolean): Promise<RedisReply> {
    method writeCommand (line 36) | async writeCommand(command: Command): Promise<void> {
    method pipeline (line 41) | pipeline(commands: Command[]): Promise<Array<RedisReply | ErrorReplyEr...

FILE: protocol/deno_streams/reply.ts
  function readReply (line 23) | async function readReply(
  function readIntegerReply (line 76) | async function readIntegerReply(
  function readBulkReply (line 87) | function readBulkReply(
  function readVerbatimStringReply (line 94) | function readVerbatimStringReply(
  function readSimpleStringReply (line 101) | function readSimpleStringReply(
  function readArrayReply (line 108) | function readArrayReply(
  function readPushReply (line 115) | function readPushReply(
  function readArrayLikeReply (line 122) | async function readArrayLikeReply(
  function readSetReply (line 147) | async function readSetReply(
  function readMapReply (line 172) | async function readMapReply(
  function readAttributeReply (line 196) | async function readAttributeReply(
  function readBooleanReply (line 214) | async function readBooleanReply(reader: BufReader): Promise<1 | 0> {
  function readDoubleReply (line 225) | function readDoubleReply(
  function readBigNumberReply (line 232) | function readBigNumberReply(
  function readNullReply (line 239) | async function readNullReply(reader: BufReader): Promise<null> {
  function readSingleLineReply (line 245) | async function readSingleLineReply(
  type BlobLikeReply (line 262) | type BlobLikeReply = string | types.Binary | null;
  function readBlobReply (line 263) | async function readBlobReply(
  function parseErrorReplyOrFail (line 288) | function parseErrorReplyOrFail(line: Uint8Array): never {
  function readErrorReplyOrFail (line 296) | async function readErrorReplyOrFail(reader: BufReader): Promise<never> {
  function readLine (line 304) | async function readLine(reader: BufReader): Promise<Uint8Array> {
  function parseSize (line 325) | function parseSize(line: Uint8Array): number {

FILE: protocol/shared/command.ts
  constant CRLF (line 6) | const CRLF = encoder.encode("\r\n");
  function encodeCommand (line 13) | function encodeCommand(
  function writeFrom (line 70) | function writeFrom(
  function encodeCommands (line 79) | function encodeCommands(commands: Array<Command>): Uint8Array {

FILE: protocol/shared/protocol.ts
  type Command (line 4) | interface Command {
  type Protocol (line 10) | interface Protocol {

FILE: protocol/shared/types.ts
  type RedisValue (line 7) | type RedisValue = string | number | Uint8Array;
  type SimpleString (line 12) | type SimpleString = string;
  type Integer (line 17) | type Integer = number;
  type Bulk (line 22) | type Bulk = BulkString | BulkNil;
  type BulkString (line 27) | type BulkString = string;
  type BulkNil (line 32) | type BulkNil = null;
  type Raw (line 37) | type Raw = SimpleString | Integer | Bulk | ConditionalArray | Binary;
  type Binary (line 39) | type Binary = Uint8Array;
  type ConditionalArray (line 44) | type ConditionalArray = Raw[];
  type RedisReply (line 46) | type RedisReply = Raw | ConditionalArray;
  type RawOrError (line 48) | type RawOrError = Raw | ErrorReplyError;
  type Protover (line 52) | type Protover = 2 | 3;

FILE: protocol/web_streams/command.ts
  function writeCommand (line 7) | async function writeCommand(
  function sendCommand (line 21) | async function sendCommand(
  type Command (line 32) | interface Command {
  function sendCommands (line 38) | async function sendCommands(

FILE: protocol/web_streams/mod.ts
  class Protocol (line 8) | class Protocol implements BaseProtocol {
    method constructor (line 11) | constructor(conn: Deno.Conn) {
    method sendCommand (line 15) | sendCommand(
    method readReply (line 29) | readReply(returnsUint8Arrays?: boolean): Promise<RedisReply> {
    method writeCommand (line 33) | writeCommand(command: Command): Promise<void> {
    method pipeline (line 37) | pipeline(commands: Command[]): Promise<Array<RedisReply | ErrorReplyEr...

FILE: protocol/web_streams/reply.ts
  function readReply (line 23) | async function readReply(

FILE: protocol/web_streams/reply_test.ts
  function createReadableByteStream (line 99) | function createReadableByteStream(payload: string): ReadableStream<Uint8...

FILE: redis.ts
  type Redis (line 112) | interface Redis
  class RedisImpl (line 131) | class RedisImpl implements Redis {
    method isClosed (line 134) | get isClosed() {
    method isConnected (line 138) | get isConnected() {
    method constructor (line 142) | constructor(client: Client) {
    method addEventListener (line 146) | addEventListener<K extends ConnectionEventType>(
    method removeEventListener (line 158) | removeEventListener<K extends ConnectionEventType>(
    method sendCommand (line 170) | sendCommand(
    method connect (line 178) | connect(): Promise<void> {
    method close (line 182) | close(): void {
    method execReply (line 190) | async execReply<T extends Raw = Raw>(
    method execStatusReply (line 201) | async execStatusReply(
    method execIntegerReply (line 209) | async execIntegerReply(
    method execBinaryReply (line 217) | async execBinaryReply(
    method execBulkReply (line 229) | async execBulkReply<T extends Bulk = Bulk>(
    method execArrayReply (line 237) | async execArrayReply<T extends Raw = Raw>(
    method execIntegerOrNilReply (line 245) | async execIntegerOrNilReply(
    method execStatusOrNilReply (line 253) | async execStatusOrNilReply(
    method aclCat (line 261) | aclCat(categoryname?: string) {
    method aclDelUser (line 268) | aclDelUser(...usernames: string[]) {
    method aclGenPass (line 272) | aclGenPass(bits?: number) {
    method aclGetUser (line 279) | aclGetUser(username: string) {
    method aclHelp (line 287) | aclHelp() {
    method aclList (line 291) | aclList() {
    method aclLoad (line 295) | aclLoad() {
    method aclLog (line 301) | aclLog(param: number | ACLLogMode) {
    method aclSave (line 308) | aclSave() {
    method aclSetUser (line 312) | aclSetUser(username: string, ...rules: string[]) {
    method aclUsers (line 316) | aclUsers() {
    method aclWhoami (line 320) | aclWhoami() {
    method append (line 324) | append(key: string, value: RedisValue) {
    method auth (line 328) | auth(param1: RedisValue, param2?: RedisValue) {
    method bgrewriteaof (line 335) | bgrewriteaof() {
    method bgsave (line 339) | bgsave() {
    method bitcount (line 343) | bitcount(key: string, start?: number, end?: number) {
    method bitfield (line 350) | bitfield(
    method bitop (line 373) | bitop(operation: string, destkey: string, ...keys: string[]) {
    method bitpos (line 377) | bitpos(key: string, bit: number, start?: number, end?: number) {
    method blpop (line 387) | blpop(timeout: number, ...keys: string[]) {
    method brpop (line 393) | brpop(timeout: number, ...keys: string[]) {
    method brpoplpush (line 399) | brpoplpush(source: string, destination: string, timeout: number) {
    method bzpopmin (line 403) | bzpopmin(timeout: number, ...keys: string[]) {
    method bzpopmax (line 409) | bzpopmax(timeout: number, ...keys: string[]) {
    method clientCaching (line 415) | clientCaching(mode: ClientCachingMode) {
    method clientGetName (line 419) | clientGetName() {
    method clientGetRedir (line 423) | clientGetRedir() {
    method clientID (line 427) | clientID() {
    method clientInfo (line 431) | clientInfo() {
    method clientKill (line 435) | clientKill(opts: ClientKillOpts) {
    method clientList (line 458) | clientList(opts?: ClientListOpts) {
    method clientPause (line 471) | clientPause(timeout: number, mode?: ClientPauseMode) {
    method clientSetName (line 478) | clientSetName(connectionName: string) {
    method clientTracking (line 482) | clientTracking(opts: ClientTrackingOpts) {
    method clientTrackingInfo (line 508) | clientTrackingInfo() {
    method clientUnblock (line 512) | clientUnblock(
    method clientUnpause (line 522) | clientUnpause(): Promise<SimpleString> {
    method asking (line 526) | asking() {
    method clusterAddSlots (line 530) | clusterAddSlots(...slots: number[]) {
    method clusterCountFailureReports (line 534) | clusterCountFailureReports(nodeId: string) {
    method clusterCountKeysInSlot (line 538) | clusterCountKeysInSlot(slot: number) {
    method clusterDelSlots (line 542) | clusterDelSlots(...slots: number[]) {
    method clusterFailover (line 546) | clusterFailover(mode?: ClusterFailoverMode) {
    method clusterFlushSlots (line 553) | clusterFlushSlots() {
    method clusterForget (line 557) | clusterForget(nodeId: string) {
    method clusterGetKeysInSlot (line 561) | clusterGetKeysInSlot(slot: number, count: number) {
    method clusterInfo (line 570) | clusterInfo() {
    method clusterKeySlot (line 574) | clusterKeySlot(key: string) {
    method clusterMeet (line 578) | clusterMeet(ip: string, port: number) {
    method clusterMyID (line 582) | clusterMyID() {
    method clusterNodes (line 586) | clusterNodes() {
    method clusterReplicas (line 590) | clusterReplicas(nodeId: string) {
    method clusterReplicate (line 594) | clusterReplicate(nodeId: string) {
    method clusterReset (line 598) | clusterReset(mode?: ClusterResetMode) {
    method clusterSaveConfig (line 605) | clusterSaveConfig() {
    method clusterSetSlot (line 609) | clusterSetSlot(
    method clusterSlaves (line 626) | clusterSlaves(nodeId: string) {
    method clusterSlots (line 630) | clusterSlots() {
    method command (line 634) | command() {
    method commandCount (line 640) | commandCount() {
    method commandGetKeys (line 644) | commandGetKeys() {
    method commandInfo (line 648) | commandInfo(...commandNames: string[]) {
    method configGet (line 657) | configGet(parameter: string) {
    method configResetStat (line 661) | configResetStat() {
    method configRewrite (line 665) | configRewrite() {
    method configSet (line 669) | configSet(parameter: string, value: string | number) {
    method dbsize (line 673) | dbsize() {
    method debugObject (line 677) | debugObject(key: string) {
    method debugSegfault (line 681) | debugSegfault() {
    method decr (line 685) | decr(key: string) {
    method decrby (line 689) | decrby(key: string, decrement: number) {
    method del (line 693) | del(...keys: string[]) {
    method discard (line 697) | discard() {
    method dump (line 701) | dump(key: string) {
    method echo (line 705) | echo(message: RedisValue) {
    method eval (line 709) | eval(script: string, keys: string[], args: string[]) {
    method evalsha (line 719) | evalsha(sha1: string, keys: string[], args: string[]) {
    method exec (line 729) | exec() {
    method exists (line 733) | exists(...keys: string[]) {
    method expire (line 737) | expire(key: string, seconds: number) {
    method expireat (line 741) | expireat(key: string, timestamp: string) {
    method flushall (line 745) | flushall(async?: boolean) {
    method flushdb (line 752) | flushdb(async?: boolean) {
    method geoadd (line 760) | geoadd(key: string, ...params: any[]) {
    method geohash (line 774) | geohash(key: string, ...members: string[]) {
    method geopos (line 778) | geopos(key: string, ...members: string[]) {
    method geodist (line 784) | geodist(
    method georadius (line 796) | georadius(
    method georadiusbymember (line 811) | georadiusbymember(
    method pushGeoRadiusOpts (line 822) | private pushGeoRadiusOpts(
    method get (line 850) | get(key: string) {
    method getbit (line 854) | getbit(key: string, offset: number) {
    method getrange (line 858) | getrange(key: string, start: number, end: number) {
    method getset (line 862) | getset(key: string, value: RedisValue) {
    method hdel (line 866) | hdel(key: string, ...fields: string[]) {
    method hexists (line 870) | hexists(key: string, field: string) {
    method hget (line 874) | hget(key: string, field: string) {
    method hgetall (line 878) | hgetall(key: string) {
    method hincrby (line 882) | hincrby(key: string, field: string, increment: number) {
    method hincrbyfloat (line 886) | hincrbyfloat(key: string, field: string, increment: number) {
    method hkeys (line 895) | hkeys(key: string) {
    method hlen (line 899) | hlen(key: string) {
    method hmget (line 903) | hmget(key: string, ...fields: string[]) {
    method hmset (line 908) | hmset(key: string, ...params: any[]) {
    method hset (line 923) | hset(key: string, ...params: any[]) {
    method hsetnx (line 937) | hsetnx(key: string, field: string, value: RedisValue) {
    method hstrlen (line 941) | hstrlen(key: string, field: string) {
    method hvals (line 945) | hvals(key: string) {
    method incr (line 949) | incr(key: string) {
    method incrby (line 953) | incrby(key: string, increment: number) {
    method incrbyfloat (line 957) | incrbyfloat(key: string, increment: number) {
    method info (line 961) | info(section?: string) {
    method keys (line 968) | keys(pattern: string) {
    method lastsave (line 972) | lastsave() {
    method lindex (line 976) | lindex(key: string, index: number) {
    method linsert (line 980) | linsert(key: string, loc: LInsertLocation, pivot: string, value: Redis...
    method llen (line 984) | llen(key: string) {
    method lpop (line 990) | lpop(key: string, count?: number): Promise<Bulk | Array<BulkString>> {
    method lpos (line 1010) | lpos(
    method lpush (line 1033) | lpush(key: string, ...elements: RedisValue[]) {
    method lpushx (line 1037) | lpushx(key: string, ...elements: RedisValue[]) {
    method lrange (line 1041) | lrange(key: string, start: number, stop: number) {
    method lrem (line 1045) | lrem(key: string, count: number, element: string | number) {
    method lset (line 1049) | lset(key: string, index: number, element: string | number) {
    method ltrim (line 1053) | ltrim(key: string, start: number, stop: number) {
    method memoryDoctor (line 1057) | memoryDoctor() {
    method memoryHelp (line 1061) | memoryHelp() {
    method memoryMallocStats (line 1065) | memoryMallocStats() {
    method memoryPurge (line 1069) | memoryPurge() {
    method memoryStats (line 1073) | memoryStats() {
    method memoryUsage (line 1077) | memoryUsage(key: string, opts?: MemoryUsageOpts) {
    method mget (line 1085) | mget(...keys: string[]) {
    method migrate (line 1089) | migrate(
    method moduleList (line 1113) | moduleList() {
    method moduleLoad (line 1117) | moduleLoad(path: string, ...args: string[]) {
    method moduleUnload (line 1121) | moduleUnload(name: string) {
    method monitor (line 1125) | monitor() {
    method move (line 1129) | move(key: string, db: string) {
    method mset (line 1134) | mset(...params: any[]) {
    method msetnx (line 1149) | msetnx(...params: any[]) {
    method multi (line 1163) | multi() {
    method objectEncoding (line 1167) | objectEncoding(key: string) {
    method objectFreq (line 1171) | objectFreq(key: string) {
    method objectHelp (line 1175) | objectHelp() {
    method objectIdletime (line 1179) | objectIdletime(key: string) {
    method objectRefCount (line 1183) | objectRefCount(key: string) {
    method persist (line 1187) | persist(key: string) {
    method pexpire (line 1191) | pexpire(key: string, milliseconds: number) {
    method pexpireat (line 1195) | pexpireat(key: string, millisecondsTimestamp: number) {
    method pfadd (line 1199) | pfadd(key: string, ...elements: string[]) {
    method pfcount (line 1203) | pfcount(...keys: string[]) {
    method pfmerge (line 1207) | pfmerge(destkey: string, ...sourcekeys: string[]) {
    method ping (line 1211) | ping(message?: RedisValue) {
    method psetex (line 1218) | psetex(key: string, milliseconds: number, value: RedisValue) {
    method publish (line 1222) | publish(channel: string, message: string) {
    method subscribe (line 1228) | async subscribe<TMessage extends string | string[] = string>(
    method psubscribe (line 1243) | async psubscribe<TMessage extends string | string[] = string>(
    method pubsubChannels (line 1258) | pubsubChannels(pattern?: string) {
    method pubsubNumpat (line 1265) | pubsubNumpat() {
    method pubsubNumsub (line 1269) | pubsubNumsub(...channels: string[]) {
    method pttl (line 1277) | pttl(key: string) {
    method quit (line 1281) | quit() {
    method randomkey (line 1285) | randomkey() {
    method readonly (line 1289) | readonly() {
    method readwrite (line 1293) | readwrite() {
    method rename (line 1297) | rename(key: string, newkey: string) {
    method renamenx (line 1301) | renamenx(key: string, newkey: string) {
    method restore (line 1305) | restore(
    method role (line 1327) | role() {
    method rpop (line 1335) | rpop(key: string) {
    method rpoplpush (line 1339) | rpoplpush(source: string, destination: string) {
    method rpush (line 1343) | rpush(key: string, ...elements: RedisValue[]) {
    method rpushx (line 1347) | rpushx(key: string, ...elements: RedisValue[]) {
    method sadd (line 1351) | sadd(key: string, ...members: string[]) {
    method save (line 1355) | save() {
    method scard (line 1359) | scard(key: string) {
    method scriptDebug (line 1363) | scriptDebug(mode: ScriptDebugMode) {
    method scriptExists (line 1367) | scriptExists(...sha1s: string[]) {
    method scriptFlush (line 1371) | scriptFlush() {
    method scriptKill (line 1375) | scriptKill() {
    method scriptLoad (line 1379) | scriptLoad(script: string) {
    method sdiff (line 1383) | sdiff(...keys: string[]) {
    method sdiffstore (line 1387) | sdiffstore(destination: string, ...keys: string[]) {
    method select (line 1391) | select(index: number) {
    method hello (line 1395) | hello(opts?: HelloOpts): Promise<ConditionalArray> {
    method set (line 1409) | set<TSetOpts extends SetOpts | SetWithModeOpts = SetOpts>(
    method setbit (line 1449) | setbit(key: string, offset: number, value: RedisValue) {
    method setex (line 1453) | setex(key: string, seconds: number, value: RedisValue) {
    method setnx (line 1457) | setnx(key: string, value: RedisValue) {
    method setrange (line 1461) | setrange(key: string, offset: number, value: RedisValue) {
    method shutdown (line 1465) | shutdown(mode?: ShutdownMode) {
    method sinter (line 1472) | sinter(...keys: string[]) {
    method sinterstore (line 1476) | sinterstore(destination: string, ...keys: string[]) {
    method sismember (line 1480) | sismember(key: string, member: string) {
    method slaveof (line 1484) | slaveof(host: string, port: number) {
    method slaveofNoOne (line 1488) | slaveofNoOne() {
    method replicaof (line 1492) | replicaof(host: string, port: number) {
    method replicaofNoOne (line 1496) | replicaofNoOne() {
    method slowlog (line 1500) | slowlog(subcommand: string, ...args: string[]) {
    method smembers (line 1504) | smembers(key: string) {
    method smove (line 1508) | smove(source: string, destination: string, member: string) {
    method sort (line 1520) | sort(
    method spop (line 1549) | spop(key: string, count?: number) {
    method srandmember (line 1558) | srandmember(key: string, count?: number) {
    method srem (line 1565) | srem(key: string, ...members: string[]) {
    method stralgo (line 1614) | stralgo(
    method strlen (line 1645) | strlen(key: string) {
    method sunion (line 1649) | sunion(...keys: string[]) {
    method sunionstore (line 1653) | sunionstore(destination: string, ...keys: string[]) {
    method swapdb (line 1657) | swapdb(index1: number, index2: number) {
    method sync (line 1661) | sync() {
    method time (line 1665) | time() {
    method touch (line 1669) | touch(...keys: string[]) {
    method ttl (line 1673) | ttl(key: string) {
    method type (line 1677) | type(key: string) {
    method unlink (line 1681) | unlink(...keys: string[]) {
    method unwatch (line 1685) | unwatch() {
    method wait (line 1689) | wait(numreplicas: number, timeout: number) {
    method watch (line 1693) | watch(...keys: string[]) {
    method xack (line 1697) | xack(key: string, group: string, ...xids: XIdInput[]) {
    method xadd (line 1706) | xadd(
    method xclaim (line 1742) | xclaim(key: string, opts: XClaimOpts, ...xids: XIdInput[]) {
    method xdel (line 1798) | xdel(key: string, ...xids: XIdInput[]) {
    method xlen (line 1806) | xlen(key: string) {
    method xgroupCreate (line 1810) | xgroupCreate(
    method xgroupDelConsumer (line 1831) | xgroupDelConsumer(
    method xgroupDestroy (line 1845) | xgroupDestroy(key: string, groupName: string) {
    method xgroupHelp (line 1849) | xgroupHelp() {
    method xgroupSetID (line 1853) | xgroupSetID(
    method xinfoStream (line 1867) | xinfoStream(key: string) {
    method xinfoStreamFull (line 1897) | xinfoStreamFull(key: string, count?: number) {
    method xinfoGroups (line 1931) | xinfoGroups(key: string) {
    method xinfoConsumers (line 1948) | xinfoConsumers(key: string, group: string) {
    method xpending (line 1967) | xpending(
    method xpendingCount (line 1989) | xpendingCount(
    method xrange (line 2008) | xrange(
    method xrevrange (line 2024) | xrevrange(
    method xread (line 2040) | xread(
    method xreadgroup (line 2078) | xreadgroup(
    method xtrim (line 2120) | xtrim(key: string, maxlen: XMaxlen) {
    method zadd (line 2147) | zadd(
    method pushZAddOpts (line 2173) | private pushZAddOpts(
    method zaddIncr (line 2194) | zaddIncr(
    method zcard (line 2206) | zcard(key: string) {
    method zcount (line 2210) | zcount(key: string, min: number, max: number) {
    method zincrby (line 2214) | zincrby(key: string, increment: number, member: string) {
    method zinter (line 2218) | zinter(
    method zinterstore (line 2229) | zinterstore(
    method zunionstore (line 2238) | zunionstore(
    method pushZStoreArgs (line 2247) | private pushZStoreArgs(
    method zlexcount (line 2274) | zlexcount(key: string, min: string, max: string) {
    method zpopmax (line 2278) | zpopmax(key: string, count?: number) {
    method zpopmin (line 2285) | zpopmin(key: string, count?: number) {
    method zrange (line 2292) | zrange(
    method zrangebylex (line 2302) | zrangebylex(
    method zrangebyscore (line 2312) | zrangebyscore(
    method zrank (line 2322) | zrank(key: string, member: string) {
    method zrem (line 2326) | zrem(key: string, ...members: string[]) {
    method zremrangebylex (line 2330) | zremrangebylex(key: string, min: string, max: string) {
    method zremrangebyrank (line 2334) | zremrangebyrank(key: string, start: number, stop: number) {
    method zremrangebyscore (line 2338) | zremrangebyscore(key: string, min: number | string, max: number | stri...
    method zrevrange (line 2342) | zrevrange(
    method zrevrangebylex (line 2352) | zrevrangebylex(
    method zrevrangebyscore (line 2362) | zrevrangebyscore(
    method pushZRangeOpts (line 2372) | private pushZRangeOpts(
    method zrevrank (line 2389) | zrevrank(key: string, member: string) {
    method zscore (line 2393) | zscore(key: string, member: string) {
    method scan (line 2397) | scan(
    method sscan (line 2407) | sscan(
    method hscan (line 2418) | hscan(
    method zscan (line 2429) | zscan(
    method pushScanOpts (line 2440) | private pushScanOpts(
    method latencyDoctor (line 2456) | latencyDoctor() {
    method tx (line 2460) | tx() {
    method pipeline (line 2464) | pipeline() {
  method [Symbol.dispose] (line 186) | [Symbol.dispose](): void {
  type RedisConnectOptions (line 2469) | interface RedisConnectOptions extends RedisConnectionOptions {
  function connect (line 2484) | async function connect(options: RedisConnectOptions): Promise<Redis> {
  function createLazyClient (line 2504) | function createLazyClient(options: RedisConnectOptions): Redis {
  function create (line 2516) | function create(client: Client): Redis {
  function parseURL (line 2531) | function parseURL(url: string): RedisConnectOptions {
  function createBaseLazyClient (line 2556) | function createBaseLazyClient(connection: Connection): Client {

FILE: stream.ts
  type XId (line 7) | interface XId {
  type XMessage (line 12) | interface XMessage {
  type XKeyId (line 17) | interface XKeyId {
  type XKeyIdLike (line 22) | type XKeyIdLike = [string, XIdInput];
  type XKeyIdGroup (line 24) | interface XKeyIdGroup {
  type XKeyIdGroupLike (line 29) | type XKeyIdGroupLike = [string, XIdGroupRead];
  type XReadStream (line 31) | type XReadStream = { key: string; messages: XMessage[] };
  type XReadReply (line 32) | type XReadReply = XReadStream[];
  type XReadIdData (line 35) | type XReadIdData = [string, string[]];
  type XReadStreamRaw (line 36) | type XReadStreamRaw = [string, XReadIdData[]];
  type XReadReplyRaw (line 37) | type XReadReplyRaw = XReadStreamRaw[];
  type XIdInput (line 50) | type XIdInput = XId | [number, number] | number | string;
  type XIdAdd (line 54) | type XIdAdd = XIdInput | "*";
  type XIdGroupRead (line 60) | type XIdGroupRead = XIdInput | ">";
  type XIdPos (line 63) | type XIdPos = XIdInput | "+";
  type XIdNeg (line 65) | type XIdNeg = XIdInput | "-";
  type XIdCreateGroup (line 67) | type XIdCreateGroup = XIdInput | "$";
  type XAddFieldValues (line 69) | type XAddFieldValues =
  type XReadOpts (line 73) | interface XReadOpts {
  type XReadGroupOpts (line 78) | interface XReadGroupOpts {
  type XMaxlen (line 85) | interface XMaxlen {
  type XClaimReply (line 90) | type XClaimReply = XClaimMessages | XClaimJustXId;
  type XClaimMessages (line 91) | interface XClaimMessages {
  type XClaimJustXId (line 95) | interface XClaimJustXId {
  type XPendingReply (line 108) | interface XPendingReply {
  type XPendingConsumer (line 114) | interface XPendingConsumer {
  type XPendingCount (line 130) | interface XPendingCount {
  type StartEndCount (line 139) | interface StartEndCount {
  type XInfoStreamReply (line 145) | interface XInfoStreamReply {
  type XInfoStreamFullReply (line 155) | interface XInfoStreamFullReply {
  type XGroupDetail (line 167) | interface XGroupDetail {
  type XConsumerDetail (line 175) | interface XConsumerDetail {
  type XInfoConsumersReply (line 182) | type XInfoConsumersReply = XInfoConsumer[];
  type XInfoConsumer (line 190) | interface XInfoConsumer {
  type XInfoGroupsReply (line 197) | type XInfoGroupsReply = XInfoGroup[];
  type XInfoGroup (line 198) | interface XInfoGroup {
  type XClaimOpts (line 205) | interface XClaimOpts {
  function parseXMessage (line 216) | function parseXMessage(raw: XReadIdData): XMessage {
  function convertMap (line 233) | function convertMap(raw: ConditionalArray): Map<string, Raw> {
  function parseXReadReply (line 250) | function parseXReadReply(raw: XReadReplyRaw): XReadReply {
  function parseXId (line 263) | function parseXId(raw: string): XId {
  function parseXPendingConsumers (line 268) | function parseXPendingConsumers(
  function parseXPendingCounts (line 282) | function parseXPendingCounts(raw: ConditionalArray): XPendingCount[] {
  function parseXGroupDetail (line 304) | function parseXGroupDetail(rawGroups: ConditionalArray): XGroupDetail[] {
  function parseXConsumerDetail (line 329) | function parseXConsumerDetail(nestedRaws: Raw[][]): XConsumerDetail[] {
  function xidstr (line 358) | function xidstr(
  function rawnum (line 368) | function rawnum(raw: Raw): number {
  function rawstr (line 371) | function rawstr(raw: Raw): string {
  function isString (line 375) | function isString(x: any): x is string {
  function isNumber (line 380) | function isNumber(x: any): x is number {
  function isCondArray (line 384) | function isCondArray(x: Raw): x is ConditionalArray {
  function isXId (line 390) | function isXId(xid: XIdAdd): xid is XId {

FILE: subscription.ts
  type DefaultPubSubMessageType (line 2) | type DefaultPubSubMessageType = string;
  type PubSubMessageType (line 3) | type PubSubMessageType = string | string[];
  type SubscribeCommand (line 4) | type SubscribeCommand = "SUBSCRIBE" | "PSUBSCRIBE";
  type RedisPubSubMessage (line 6) | interface RedisPubSubMessage<TMessage = DefaultPubSubMessageType> {
  type RedisSubscription (line 12) | interface RedisSubscription<

FILE: tests/cluster/test.ts
  method newRedis (line 70) | async newRedis(opts) {
  method newRedis (line 128) | async newRedis(opts) {
  method newRedis (line 183) | async newRedis(opts) {

FILE: tests/cluster/test_util.ts
  type TestCluster (line 11) | interface TestCluster {
  function startRedisCluster (line 15) | async function startRedisCluster(ports: number[]): Promise<TestCluster> {
  function stopRedisCluster (line 56) | async function stopRedisCluster(cluster: TestCluster): Promise<void> {
  function nextPorts (line 62) | function nextPorts(n: number): Array<number> {

FILE: tests/commands/acl.ts
  function aclTests (line 11) | function aclTests(

FILE: tests/commands/connection.ts
  function connectionTests (line 15) | function connectionTests(
  function parseCommandStats (line 253) | function parseCommandStats(

FILE: tests/commands/general.ts
  function generalTests (line 13) | function generalTests(

FILE: tests/commands/geo.ts
  function geoTests (line 7) | function geoTests(

FILE: tests/commands/hash.ts
  function hashTests (line 6) | function hashTests(

FILE: tests/commands/hyper_loglog.ts
  function hyperloglogTests (line 6) | function hyperloglogTests(

FILE: tests/commands/key.ts
  function keyTests (line 10) | function keyTests(

FILE: tests/commands/latency.ts
  function latencyTests (line 6) | function latencyTests(

FILE: tests/commands/list.ts
  function listTests (line 12) | function listTests(

FILE: tests/commands/pipeline.ts
  function pipelineTests (line 7) | function pipelineTests(

FILE: tests/commands/pubsub.ts
  function pubsubTests (line 7) | function pubsubTests(

FILE: tests/commands/resp3.ts
  function resp3Tests (line 12) | function resp3Tests(

FILE: tests/commands/script.ts
  function scriptTests (line 6) | function scriptTests(

FILE: tests/commands/set.ts
  function setTests (line 10) | function setTests(

FILE: tests/commands/sorted_set.ts
  function zsetTests (line 14) | function zsetTests(

FILE: tests/commands/stream.ts
  function streamTests (line 14) | function streamTests(

FILE: tests/commands/string.ts
  function stringTests (line 22) | function stringTests(

FILE: tests/test_util.ts
  type Connector (line 5) | type Connector = typeof connect;
  type Logger (line 6) | interface Logger {
  type TestServer (line 9) | interface TestServer {
  function startRedis (line 19) | async function startRedis({
  function stopRedis (line 65) | async function stopRedis(server: TestServer): Promise<void> {
  function ensureTerminated (line 78) | async function ensureTerminated(
  function newClient (line 95) | function newClient(opt: RedisConnectOptions): Promise<Redis> {
  function exists (line 99) | async function exists(path: string): Promise<boolean> {
  function nextPort (line 112) | function nextPort(): number {
  function waitForPort (line 116) | async function waitForPort(port: number): Promise<void> {
  function tempPath (line 134) | function tempPath(fileName: string): string {
  function usesRedisVersion (line 139) | function usesRedisVersion(version: "6" | "7" | "8"): boolean {
  function withTimeout (line 145) | function withTimeout(

FILE: tools/format-benchmark-results.js
  function formatResultsAsMarkdown (line 4) | function formatResultsAsMarkdown({ name, results }) {
  function makeTableRow (line 27) | function makeTableRow(columns) {