@upstash/redis 0.0.0-ci.babdc47f97e036e2863dfed16300cda2b97bf6ad-20240322001434 → 0.0.0-ci.bb93ac2803c2e927dc8bf1a1b3c5aa2a14034eb6-20240930061920

package/pkg/commands/spop.test.ts

@@ -0,0 +1,36 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SPopCommand } from "./spop";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("without count", () => {
+  test("returns the first element", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new SAddCommand([key, member]).exec(client);
+    const res = await new SPopCommand([key]).exec(client);
+    expect(res).toEqual(member);
+  });
+});
+
+describe("with count", () => {
+  test("returns n elements", async () => {
+    const key = newKey();
+    const member1 = randomID();
+    const member2 = randomID();
+    const member3 = randomID();
+    const member4 = randomID();
+    await new SAddCommand([key, member1, member2, member3, member4]).exec(client);
+    const res = await new SPopCommand<string[]>([key, 2]).exec(client);
+
+    expect(res?.length).toBe(2);
+    expect([member1, member2, member3, member4].includes(res![0])).toBe(true);
+    expect([member1, member2, member3, member4].includes(res![1])).toBe(true);
+  });
+});

package/pkg/commands/spop.ts

@@ -0,0 +1,17 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/spop
+ */
+export class SPopCommand<TData> extends Command<string | string[] | null, TData | null> {
+  constructor(
+    [key, count]: [key: string, count?: number],
+    opts?: CommandOptions<string | string[] | null, TData | null>
+  ) {
+    const command: unknown[] = ["spop", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+}

package/pkg/commands/srandmember.test.ts

@@ -0,0 +1,31 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SRandMemberCommand } from "./srandmember";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("without opts", () => {
+  test("returns a random key", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new SAddCommand([key, member]).exec(client);
+    const res = await new SRandMemberCommand([key]).exec(client);
+    expect(res).toEqual(member);
+  });
+});
+
+test("with count", () => {
+  test("returns a random key", async () => {
+    const key = newKey();
+    const member1 = randomID();
+    const member2 = randomID();
+    await new SAddCommand([key, member1, member2]).exec(client);
+    const res = await new SRandMemberCommand<unknown[]>([key, 2]).exec(client);
+    expect(res?.length).toBe(2);
+  });
+});

package/pkg/commands/srandmember.ts

@@ -0,0 +1,17 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/srandmember
+ */
+export class SRandMemberCommand<TData> extends Command<string | null, TData | null> {
+  constructor(
+    [key, count]: [key: string, count?: number],
+    opts?: CommandOptions<string | null, TData | null>
+  ) {
+    const command: unknown[] = ["srandmember", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+}

package/pkg/commands/srem.test.ts

@@ -0,0 +1,19 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SRemCommand } from "./srem";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of removed members", async () => {
+  const key = newKey();
+  const value1 = randomID();
+  const value2 = randomID();
+  await new SAddCommand([key, value1, value2]).exec(client);
+  const res = await new SRemCommand([key, value1]).exec(client);
+  expect(res).toEqual(1);
+});

package/pkg/commands/srem.ts

@@ -0,0 +1,10 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/srem
+ */
+export class SRemCommand<TData = string> extends Command<number, number> {
+  constructor(cmd: [key: string, ...members: TData[]], opts?: CommandOptions<number, number>) {
+    super(["srem", ...cmd], opts);
+  }
+}

package/pkg/commands/sscan.test.ts

@@ -0,0 +1,48 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SScanCommand } from "./sscan";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+
+afterAll(cleanup);
+describe("without options", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new SAddCommand([key, member]).exec(client);
+    const res = await new SScanCommand([key, 0]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("string");
+    expect(res[1].length > 0).toBe(true);
+  });
+});
+
+describe("with match", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new SAddCommand([key, member]).exec(client);
+    const res = await new SScanCommand([key, "0", { match: member }]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("string");
+    expect(res[1].length > 0).toBe(true);
+  });
+});
+
+describe("with count", () => {
+  test("returns cursor and members", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new SAddCommand([key, member]).exec(client);
+    const res = await new SScanCommand([key, "0", { count: 1 }]).exec(client);
+
+    expect(res.length).toBe(2);
+    expect(typeof res[0]).toBe("string");
+    expect(res[1].length > 0).toBe(true);
+  });
+});

package/pkg/commands/sscan.ts

@@ -0,0 +1,30 @@
+import { deserializeScanResponse } from "../util";
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+import type { ScanCommandOptions } from "./scan";
+
+/**
+ * @see https://redis.io/commands/sscan
+ */
+export class SScanCommand extends Command<
+  [string, (string | number)[]],
+  [string, (string | number)[]]
+> {
+  constructor(
+    [key, cursor, opts]: [key: string, cursor: string | number, opts?: ScanCommandOptions],
+    cmdOpts?: CommandOptions<[string, (string | number)[]], [string, (string | number)[]]>
+  ) {
+    const command: (number | string)[] = ["sscan", key, cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts,
+    });
+  }
+}

package/pkg/commands/strlen.test.ts

@@ -0,0 +1,17 @@
+import { afterAll, expect, test } from "bun:test";
+import { keygen, newHttpClient } from "../test-utils";
+import { SetCommand } from "./set";
+
+import { StrLenCommand } from "./strlen";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the correct length", async () => {
+  const key = newKey();
+  const value = "abcd";
+  await new SetCommand([key, value]).exec(client);
+  const res = await new StrLenCommand([key]).exec(client);
+  expect(res).toEqual(value.length);
+});

package/pkg/commands/strlen.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/strlen
+ */
+export class StrLenCommand extends Command<number, number> {
+  constructor(cmd: [key: string], opts?: CommandOptions<number, number>) {
+    super(["strlen", ...cmd], opts);
+  }
+}

package/pkg/commands/sunion.test.ts

@@ -0,0 +1,22 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+import { SUnionCommand } from "./sunion";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the union", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+
+  const member1 = randomID();
+  const member2 = randomID();
+
+  await new SAddCommand([key1, member1]).exec(client);
+  await new SAddCommand([key2, member2]).exec(client);
+  const res = await new SUnionCommand([key1, key2]).exec(client);
+  expect(res.sort()).toEqual([member1, member2].sort());
+});

package/pkg/commands/sunion.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/sunion
+ */
+export class SUnionCommand<TData> extends Command<string[], TData[]> {
+  constructor(cmd: [key: string, ...keys: string[]], opts?: CommandOptions<string[], TData[]>) {
+    super(["sunion", ...cmd], opts);
+  }
+}

package/pkg/commands/sunionstore.test.ts

@@ -0,0 +1,30 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SAddCommand } from "./sadd";
+
+import { SMembersCommand } from "./smembers";
+import { SUnionStoreCommand } from "./sunionstore";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("writes the union to destination", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const dest = newKey();
+
+  const member1 = randomID();
+  const member2 = randomID();
+
+  await new SAddCommand([key1, member1]).exec(client);
+  await new SAddCommand([key2, member2]).exec(client);
+  const res = await new SUnionStoreCommand([dest, key1, key2]).exec(client);
+  expect(res).toEqual(2);
+
+  const res2 = await new SMembersCommand([dest]).exec(client);
+
+  expect(res2).toBeTruthy();
+  expect(res2.sort()).toEqual([member1, member2].sort());
+});

package/pkg/commands/sunionstore.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/sunionstore
+ */
+export class SUnionStoreCommand extends Command<number, number> {
+  constructor(
+    cmd: [destination: string, key: string, ...keys: string[]],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["sunionstore", ...cmd], opts);
+  }
+}

package/pkg/commands/time.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "bun:test";
+import { newHttpClient } from "../test-utils";
+
+import { TimeCommand } from "./time";
+const client = newHttpClient();
+
+test("returns the time", async () => {
+  const res = await new TimeCommand().exec(client);
+
+  expect(typeof res[0]).toBe("number");
+  expect(typeof res[1]).toBe("number");
+});

package/pkg/commands/time.ts

@@ -0,0 +1,10 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/time
+ */
+export class TimeCommand extends Command<[number, number], [number, number]> {
+  constructor(opts?: CommandOptions<[number, number], [number, number]>) {
+    super(["time"], opts);
+  }
+}

package/pkg/commands/touch.test.ts

@@ -0,0 +1,21 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { MSetCommand } from "./mset";
+import { TouchCommand } from "./touch";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the number of touched keys", async () => {
+  const key1 = newKey();
+  const key2 = newKey();
+  const kv: Record<string, string> = {};
+  kv[key1] = randomID();
+  kv[key2] = randomID();
+  await new MSetCommand([kv]).exec(client);
+  const res = await new TouchCommand([key1, key2]).exec(client);
+  expect(res).toEqual(2);
+});

package/pkg/commands/touch.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/touch
+ */
+export class TouchCommand extends Command<number, number> {
+  constructor(cmd: [...keys: string[]], opts?: CommandOptions<number, number>) {
+    super(["touch", ...cmd], opts);
+  }
+}

package/pkg/commands/ttl.test.ts

@@ -0,0 +1,17 @@
+import { keygen, newHttpClient } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { SetExCommand } from "./setex";
+import { TtlCommand } from "./ttl";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("returns the ttl on a key", async () => {
+  const key = newKey();
+  const ttl = 60;
+  await new SetExCommand([key, ttl, "value"]).exec(client);
+  const res = await new TtlCommand([key]).exec(client);
+  expect(res).toEqual(ttl);
+});

package/pkg/commands/ttl.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/ttl
+ */
+export class TtlCommand extends Command<number, number> {
+  constructor(cmd: [key: string], opts?: CommandOptions<number, number>) {
+    super(["ttl", ...cmd], opts);
+  }
+}

package/pkg/commands/type.test.ts

@@ -0,0 +1,72 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, expect, test } from "bun:test";
+import { HSetCommand } from "./hset";
+import { LPushCommand } from "./lpush";
+import { SAddCommand } from "./sadd";
+import { SetCommand } from "./set";
+import { TypeCommand } from "./type";
+import { ZAddCommand } from "./zadd";
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+test("string", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SetCommand([key, value]).exec(client);
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("string");
+  });
+});
+
+test("list", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new LPushCommand([key, value]).exec(client);
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("list");
+  });
+});
+
+test("set", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const value = randomID();
+    await new SAddCommand([key, value]).exec(client);
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("set");
+  });
+});
+
+test("hash", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const field = randomID();
+    const value = randomID();
+    await new HSetCommand([key, { [field]: value }]).exec(client);
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("hash");
+  });
+});
+
+test("zset", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const member = randomID();
+    await new ZAddCommand([key, { score: 0, member }]).exec(client);
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("zset");
+  });
+});
+
+test("none", () => {
+  test("returns the correct type", async () => {
+    const key = newKey();
+    const res = await new TypeCommand([key]).exec(client);
+    expect(res).toEqual("none");
+  });
+});

package/pkg/commands/type.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type Type = "string" | "list" | "set" | "zset" | "hash" | "none";
+/**
+ * @see https://redis.io/commands/type
+ */
+export class TypeCommand extends Command<Type, Type> {
+  constructor(cmd: [key: string], opts?: CommandOptions<Type, Type>) {
+    super(["type", ...cmd], opts);
+  }
+}

package/pkg/commands/types.ts

@@ -0,0 +1,150 @@
+export { type AppendCommand } from "./append";
+export { type BitCountCommand } from "./bitcount";
+export { type BitOpCommand } from "./bitop";
+export { type BitPosCommand } from "./bitpos";
+export { type CopyCommand } from "./copy";
+export { type DBSizeCommand } from "./dbsize";
+export { type DecrCommand } from "./decr";
+export { type DecrByCommand } from "./decrby";
+export { type DelCommand } from "./del";
+export { type EchoCommand } from "./echo";
+export { type EvalCommand } from "./eval";
+export { type EvalshaCommand } from "./evalsha";
+export { type ExistsCommand } from "./exists";
+export { type ExpireCommand } from "./expire";
+export { type ExpireAtCommand } from "./expireat";
+export { type FlushAllCommand } from "./flushall";
+export { type FlushDBCommand } from "./flushdb";
+export { type GeoAddCommand, GeoAddCommandOptions, GeoMember } from "./geo_add";
+export { type GeoDistCommand } from "./geo_dist";
+export { type GeoHashCommand } from "./geo_hash";
+export { type GeoPosCommand } from "./geo_pos";
+export { type GeoSearchCommand } from "./geo_search";
+export { type GeoSearchStoreCommand } from "./geo_search_store";
+export { type GetCommand } from "./get";
+export { type GetBitCommand } from "./getbit";
+export { type GetDelCommand } from "./getdel";
+export { type GetRangeCommand } from "./getrange";
+export { type GetSetCommand } from "./getset";
+export { type HDelCommand } from "./hdel";
+export { type HExistsCommand } from "./hexists";
+export { type HGetCommand } from "./hget";
+export { type HGetAllCommand } from "./hgetall";
+export { type HIncrByCommand } from "./hincrby";
+export { type HIncrByFloatCommand } from "./hincrbyfloat";
+export { type HKeysCommand } from "./hkeys";
+export { type HLenCommand } from "./hlen";
+export { type HMGetCommand } from "./hmget";
+export { type HMSetCommand } from "./hmset";
+export { type HRandFieldCommand } from "./hrandfield";
+export { type HScanCommand } from "./hscan";
+export { type HSetCommand } from "./hset";
+export { type HSetNXCommand } from "./hsetnx";
+export { type HStrLenCommand } from "./hstrlen";
+export { type HValsCommand } from "./hvals";
+export { type IncrCommand } from "./incr";
+export { type IncrByCommand } from "./incrby";
+export { type IncrByFloatCommand } from "./incrbyfloat";
+export { type JsonArrAppendCommand } from "./json_arrappend";
+export { type JsonArrIndexCommand } from "./json_arrindex";
+export { type JsonArrInsertCommand } from "./json_arrinsert";
+export { type JsonArrLenCommand } from "./json_arrlen";
+export { type JsonArrPopCommand } from "./json_arrpop";
+export { type JsonArrTrimCommand } from "./json_arrtrim";
+export { type JsonClearCommand } from "./json_clear";
+export { type JsonDelCommand } from "./json_del";
+export { type JsonForgetCommand } from "./json_forget";
+export { type JsonGetCommand } from "./json_get";
+export { type JsonMGetCommand } from "./json_mget";
+export { type JsonNumIncrByCommand } from "./json_numincrby";
+export { type JsonNumMultByCommand } from "./json_nummultby";
+export { type JsonObjKeysCommand } from "./json_objkeys";
+export { type JsonObjLenCommand } from "./json_objlen";
+export { type JsonRespCommand } from "./json_resp";
+export { type JsonSetCommand } from "./json_set";
+export { type JsonStrAppendCommand } from "./json_strappend";
+export { type JsonStrLenCommand } from "./json_strlen";
+export { type JsonToggleCommand } from "./json_toggle";
+export { type JsonTypeCommand } from "./json_type";
+export { type KeysCommand } from "./keys";
+export { type LIndexCommand } from "./lindex";
+export { type LInsertCommand } from "./linsert";
+export { type LLenCommand } from "./llen";
+export { type LMoveCommand } from "./lmove";
+export { type LPopCommand } from "./lpop";
+export { type LPushCommand } from "./lpush";
+export { type LPushXCommand } from "./lpushx";
+export { type LRangeCommand } from "./lrange";
+export { type LRemCommand } from "./lrem";
+export { type LSetCommand } from "./lset";
+export { type LTrimCommand } from "./ltrim";
+export { type MGetCommand } from "./mget";
+export { type MSetCommand } from "./mset";
+export { type MSetNXCommand } from "./msetnx";
+export { type PersistCommand } from "./persist";
+export { type PExpireCommand } from "./pexpire";
+export { type PExpireAtCommand } from "./pexpireat";
+export { type PingCommand } from "./ping";
+export { type PSetEXCommand } from "./psetex";
+export { type PTtlCommand } from "./pttl";
+export { type PublishCommand } from "./publish";
+export { type RandomKeyCommand } from "./randomkey";
+export { type RenameCommand } from "./rename";
+export { type RenameNXCommand } from "./renamenx";
+export { type RPopCommand } from "./rpop";
+export { type RPushCommand } from "./rpush";
+export { type RPushXCommand } from "./rpushx";
+export { type SAddCommand } from "./sadd";
+export { type ScanCommand, ScanCommandOptions } from "./scan";
+export { type SCardCommand } from "./scard";
+export { type ScriptExistsCommand } from "./script_exists";
+export { type ScriptFlushCommand } from "./script_flush";
+export { type ScriptLoadCommand } from "./script_load";
+export { type SDiffCommand } from "./sdiff";
+export { type SDiffStoreCommand } from "./sdiffstore";
+export { type SetCommand, SetCommandOptions } from "./set";
+export { type SetBitCommand } from "./setbit";
+export { type SetExCommand } from "./setex";
+export { type SetNxCommand } from "./setnx";
+export { type SetRangeCommand } from "./setrange";
+export { type SInterCommand } from "./sinter";
+export { type SInterStoreCommand } from "./sinterstore";
+export { type SIsMemberCommand } from "./sismember";
+export { type SMembersCommand } from "./smembers";
+export { type SMIsMemberCommand } from "./smismember";
+export { type SMoveCommand } from "./smove";
+export { type SPopCommand } from "./spop";
+export { type SRandMemberCommand } from "./srandmember";
+export { type SRemCommand } from "./srem";
+export { type SScanCommand } from "./sscan";
+export { type StrLenCommand } from "./strlen";
+export { type SUnionCommand } from "./sunion";
+export { type SUnionStoreCommand } from "./sunionstore";
+export { type TimeCommand } from "./time";
+export { type TouchCommand } from "./touch";
+export { type TtlCommand } from "./ttl";
+export { Type, type TypeCommand } from "./type";
+export { type UnlinkCommand } from "./unlink";
+export { type XAddCommand } from "./xadd";
+export { type XRangeCommand } from "./xrange";
+export { ScoreMember, ZAddCommandOptions, type ZAddCommand } from "./zadd";
+export { type ZCardCommand } from "./zcard";
+export { type ZCountCommand } from "./zcount";
+export { type ZDiffStoreCommand } from "./zdiffstore";
+export { type ZIncrByCommand } from "./zincrby";
+export { type ZInterStoreCommand, ZInterStoreCommandOptions } from "./zinterstore";
+export { type ZLexCountCommand } from "./zlexcount";
+export { type ZMScoreCommand } from "./zmscore";
+export { type ZPopMaxCommand } from "./zpopmax";
+export { type ZPopMinCommand } from "./zpopmin";
+export { type ZRangeCommand, ZRangeCommandOptions } from "./zrange";
+export { type ZRankCommand } from "./zrank";
+export { type ZRemCommand } from "./zrem";
+export { type ZRemRangeByLexCommand } from "./zremrangebylex";
+export { type ZRemRangeByRankCommand } from "./zremrangebyrank";
+export { type ZRemRangeByScoreCommand } from "./zremrangebyscore";
+export { type ZRevRankCommand } from "./zrevrank";
+export { type ZScanCommand } from "./zscan";
+export { type ZScoreCommand } from "./zscore";
+export { type ZUnionCommand, ZUnionCommandOptions } from "./zunion";
+export { type ZUnionStoreCommand, ZUnionStoreCommandOptions } from "./zunionstore";