diff --git a/pkg/commands/types.ts b/pkg/commands/types.ts
index 546c990a..c1309108 100644
--- a/pkg/commands/types.ts
+++ b/pkg/commands/types.ts
@@ -127,17 +127,15 @@ export { Type, type TypeCommand } from "./type";
 export { type UnlinkCommand } from "./unlink";
 export { type XAddCommand } from "./xadd";
 export { type XRangeCommand } from "./xrange";
-export {
-  ScoreMember,
-  ZAddCommandOptions,
-  ZAddCommandOptionsWithIncr,
-  type ZAddCommand,
-} from "./zadd";
+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 ZInterStoreCommand,
+  ZInterStoreCommandOptions,
+} from "./zinterstore";
 export { type ZLexCountCommand } from "./zlexcount";
 export { type ZMScoreCommand } from "./zmscore";
 export { type ZPopMaxCommand } from "./zpopmax";
@@ -152,4 +150,7 @@ 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";
+export {
+  type ZUnionStoreCommand,
+  ZUnionStoreCommandOptions,
+} from "./zunionstore";
diff --git a/pkg/commands/zadd.test.ts b/pkg/commands/zadd.test.ts
index 6f4de162..88f15fad 100644
--- a/pkg/commands/zadd.test.ts
+++ b/pkg/commands/zadd.test.ts
@@ -2,6 +2,7 @@ import { keygen, newHttpClient, randomID } from "../test-utils";
 
 import { afterAll, describe, expect, test } from "bun:test";
 import { ZAddCommand } from "./zadd";
+import { ZRangeCommand } from "./zrange";
 import { ZScoreCommand } from "./zscore";
 
 const client = newHttpClient();
@@ -12,19 +13,17 @@ afterAll(cleanup);
 describe("command format", () => {
   describe("without options", () => {
     test("build the correct command", () => {
-      expect(new ZAddCommand(["key", { score: 0, member: "member" }]).command).toEqual([
-        "zadd",
-        "key",
-        0,
-        "member",
-      ]);
+      expect(
+        new ZAddCommand(["key", { score: 0, member: "member" }]).command
+      ).toEqual(["zadd", "key", 0, "member"]);
     });
   });
 
   describe("with nx", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { nx: true }, { score: 0, member: "member" }]).command,
+        new ZAddCommand(["key", { nx: true }, { score: 0, member: "member" }])
+          .command
       ).toEqual(["zadd", "key", "nx", 0, "member"]);
     });
   });
@@ -32,7 +31,8 @@ describe("command format", () => {
   describe("with xx", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { xx: true }, { score: 0, member: "member" }]).command,
+        new ZAddCommand(["key", { xx: true }, { score: 0, member: "member" }])
+          .command
       ).toEqual(["zadd", "key", "xx", 0, "member"]);
     });
   });
@@ -40,7 +40,8 @@ describe("command format", () => {
   describe("with ch", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { ch: true }, { score: 0, member: "member" }]).command,
+        new ZAddCommand(["key", { ch: true }, { score: 0, member: "member" }])
+          .command
       ).toEqual(["zadd", "key", "ch", 0, "member"]);
     });
   });
@@ -48,7 +49,8 @@ describe("command format", () => {
   describe("with incr", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { incr: true }, { score: 0, member: "member" }]).command,
+        new ZAddCommand(["key", { incr: true }, { score: 0, member: "member" }])
+          .command
       ).toEqual(["zadd", "key", "incr", 0, "member"]);
     });
   });
@@ -56,7 +58,11 @@ describe("command format", () => {
   describe("with nx and ch", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { nx: true, ch: true }, { score: 0, member: "member" }]).command,
+        new ZAddCommand([
+          "key",
+          { nx: true, ch: true },
+          { score: 0, member: "member" },
+        ]).command
       ).toEqual(["zadd", "key", "nx", "ch", 0, "member"]);
     });
   });
@@ -64,8 +70,11 @@ describe("command format", () => {
   describe("with nx,ch and incr", () => {
     test("build the correct command", () => {
       expect(
-        new ZAddCommand(["key", { nx: true, ch: true, incr: true }, { score: 0, member: "member" }])
-          .command,
+        new ZAddCommand([
+          "key",
+          { nx: true, ch: true, incr: true },
+          { score: 0, member: "member" },
+        ]).command
       ).toEqual(["zadd", "key", "nx", "ch", "incr", 0, "member"]);
     });
   });
@@ -78,7 +87,7 @@ describe("command format", () => {
           { nx: true },
           { score: 0, member: "member" },
           { score: 1, member: "member1" },
-        ]).command,
+        ]).command
       ).toEqual(["zadd", "key", "nx", 0, "member", 1, "member1"]);
     });
   });
@@ -102,9 +111,11 @@ describe("xx", () => {
       const score = Math.floor(Math.random() * 10);
       await new ZAddCommand([key, { score, member }]).exec(client);
       const newScore = score + 1;
-      const res = await new ZAddCommand([key, { xx: true }, { score: newScore, member }]).exec(
-        client,
-      );
+      const res = await new ZAddCommand([
+        key,
+        { xx: true },
+        { score: newScore, member },
+      ]).exec(client);
       expect(res).toEqual(0);
 
       const res2 = await new ZScoreCommand([key, member]).exec(client);
@@ -118,9 +129,11 @@ describe("xx", () => {
       const score = Math.floor(Math.random() * 10);
       await new ZAddCommand([key, { score, member }]).exec(client);
       const newScore = score + 1;
-      const res = await new ZAddCommand([key, { xx: true }, { score: newScore, member }]).exec(
-        client,
-      );
+      const res = await new ZAddCommand([
+        key,
+        { xx: true },
+        { score: newScore, member },
+      ]).exec(client);
       expect(res).toEqual(0);
     });
   });
@@ -134,9 +147,11 @@ describe("nx", () => {
       const score = Math.floor(Math.random() * 10);
       await new ZAddCommand([key, { score, member }]).exec(client);
       const newScore = score + 1;
-      const res = await new ZAddCommand([key, { nx: true }, { score: newScore, member }]).exec(
-        client,
-      );
+      const res = await new ZAddCommand([
+        key,
+        { nx: true },
+        { score: newScore, member },
+      ]).exec(client);
       expect(res).toEqual(0);
 
       const res2 = await new ZScoreCommand([key, member]).exec(client);
@@ -148,7 +163,11 @@ describe("nx", () => {
       const key = newKey();
       const member = randomID();
       const score = Math.floor(Math.random() * 10);
-      const res = await new ZAddCommand([key, { nx: true }, { score, member }]).exec(client);
+      const res = await new ZAddCommand([
+        key,
+        { nx: true },
+        { score, member },
+      ]).exec(client);
       expect(res).toEqual(1);
     });
   });
@@ -161,9 +180,11 @@ describe("ch", () => {
     const score = Math.floor(Math.random() * 10);
     await new ZAddCommand([key, { score, member }]).exec(client);
     const newScore = score + 1;
-    const res = await new ZAddCommand([key, { ch: true }, { score: newScore, member }]).exec(
-      client,
-    );
+    const res = await new ZAddCommand([
+      key,
+      { ch: true },
+      { score: newScore, member },
+    ]).exec(client);
     expect(res).toEqual(1);
   });
 });
@@ -174,8 +195,108 @@ describe("incr", () => {
     const member = randomID();
     const score = Math.floor(Math.random() * 10);
     await new ZAddCommand([key, { score, member }]).exec(client);
-    const res = await new ZAddCommand([key, { incr: true }, { score: 1, member }]).exec(client);
+    const res = await new ZAddCommand([
+      key,
+      { incr: true },
+      { score: 1, member },
+    ]).exec(client);
     expect(typeof res).toBe("number");
     expect(res).toEqual(score + 1);
   });
 });
+
+describe("LT and GT", () => {
+  describe("GT", () => {
+    test("should replace successfully if greater than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([
+        key,
+        { gt: true },
+        { score: 4, member: "two" },
+      ]).exec(client);
+
+      const res2 = await new ZRangeCommand([
+        key,
+        0,
+        -1,
+        { withScores: true },
+      ]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "three", 3, "two", 4]);
+    });
+
+    test("should fail to replace if its not greater than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([
+        key,
+        { gt: true },
+        { score: 1, member: "two" },
+      ]).exec(client);
+
+      const res2 = await new ZRangeCommand([
+        key,
+        0,
+        -1,
+        { withScores: true },
+      ]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "two", 2, "three", 3]);
+    });
+  });
+
+  describe("LT", () => {
+    test("should replace successfully if less than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+      await new ZAddCommand([
+        key,
+        { lt: true },
+        { score: 2, member: "three" },
+      ]).exec(client);
+
+      const res2 = await new ZRangeCommand([
+        key,
+        0,
+        -1,
+        { withScores: true },
+      ]).exec(client);
+      expect(res2).toEqual(["one", 1, "three", 2, "two", 2]);
+    });
+
+    test("should fail to replace if its not less than", async () => {
+      const key = newKey();
+
+      await new ZAddCommand([key, { score: 1, member: "one" }]).exec(client);
+      await new ZAddCommand([key, { score: 2, member: "two" }]).exec(client);
+      await new ZAddCommand([key, { score: 3, member: "three" }]).exec(client);
+
+      await new ZAddCommand([
+        key,
+        { lt: true },
+        { score: 6, member: "two" },
+      ]).exec(client);
+
+      const res2 = await new ZRangeCommand([
+        key,
+        0,
+        -1,
+        { withScores: true },
+      ]).exec(client);
+
+      expect(res2).toEqual(["one", 1, "two", 2, "three", 3]);
+    });
+  });
+});
diff --git a/pkg/commands/zadd.ts b/pkg/commands/zadd.ts
index 416f641b..404bc247 100644
--- a/pkg/commands/zadd.ts
+++ b/pkg/commands/zadd.ts
@@ -1,42 +1,32 @@
 import { Command, CommandOptions } from "./command";
 
-export type ZAddCommandOptions = (
+type NXAndXXOptions =
   | { nx: true; xx?: never }
   | { nx?: never; xx: true }
-  | { nx?: never; xx?: never }
-) & { ch?: true };
+  | { nx?: never; xx?: never };
 
-export type ZAddCommandOptionsWithIncr = ZAddCommandOptions & { incr: true };
+type LTAndGTOptions =
+  | { lt: true; gt?: never }
+  | { lt?: never; gt: true }
+  | { lt?: never; gt?: never };
 
-/**
- * This type is defiend up here because otherwise it would be automatically formatted into
- * multiple lines by Deno. As a result of that, Deno will add a comma to the end and then
- * complain about the comma being there...
- */
-type Arg2<TData> = ScoreMember<TData> | ZAddCommandOptions | ZAddCommandOptionsWithIncr;
+export type ZAddCommandOptions = NXAndXXOptions &
+  LTAndGTOptions & { ch?: true } & { incr?: true };
+
+type Arg2<TData> = ScoreMember<TData> | ZAddCommandOptions;
 export type ScoreMember<TData> = { score: number; member: TData };
 /**
  * @see https://redis.io/commands/zadd
  */
-export class ZAddCommand<TData = string> extends Command<number | null, number | null> {
-  constructor(
-    cmd: [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]],
-    opts?: CommandOptions<number | null, number | null>,
-  );
-  constructor(
-    cmd: [
-      key: string,
-      opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
-      ...scoreMemberPairs: ScoreMember<TData>[],
-    ],
-    opts?: CommandOptions<number | null, number | null>,
-  );
+export class ZAddCommand<TData = string> extends Command<
+  number | null,
+  number | null
+> {
   constructor(
     [key, arg1, ...arg2]: [string, Arg2<TData>, ...ScoreMember<TData>[]],
-    opts?: CommandOptions<number | null, number | null>,
+    opts?: CommandOptions<number | null, number | null>
   ) {
     const command: unknown[] = ["zadd", key];
-
     if ("nx" in arg1 && arg1.nx) {
       command.push("nx");
     } else if ("xx" in arg1 && arg1.xx) {
@@ -49,6 +39,12 @@ export class ZAddCommand<TData = string> extends Command<number | null, number |
       command.push("incr");
     }
 
+    if ("lt" in arg1 && arg1.lt) {
+      command.push("lt");
+    } else if ("gt" in arg1 && arg1.gt) {
+      command.push("gt");
+    }
+
     if ("score" in arg1 && "member" in arg1) {
       command.push(arg1.score, arg1.member);
     }
diff --git a/pkg/pipeline.ts b/pkg/pipeline.ts
index 841b4fd9..3e65f355 100644
--- a/pkg/pipeline.ts
+++ b/pkg/pipeline.ts
@@ -88,10 +88,10 @@ import {
   PExpireCommand,
   PSetEXCommand,
   PTtlCommand,
+  PersistCommand,
   PfAddCommand,
   PfCountCommand,
   PfMergeCommand,
-  PersistCommand,
   PingCommand,
   PublishCommand,
   RPopCommand,
@@ -135,7 +135,6 @@ import {
   UnlinkCommand,
   ZAddCommand,
   ZAddCommandOptions,
-  ZAddCommandOptionsWithIncr,
   ZCardCommand,
   ZCountCommand,
   ZIncrByCommand,
@@ -159,8 +158,7 @@ import {
 import { ZDiffStoreCommand } from "./commands/zdiffstore";
 import { ZMScoreCommand } from "./commands/zmscore";
 import { UpstashError } from "./error";
-import { Requester } from "./http";
-import { UpstashResponse } from "./http";
+import { Requester, UpstashResponse } from "./http";
 import { CommandArgs } from "./types";
 
 // Given a tuple of commands, returns a tuple of the response data of each command
@@ -238,7 +236,7 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   exec = async <
     TCommandResults extends unknown[] = [] extends TCommands
       ? unknown[]
-      : InferResponseData<TCommands>,
+      : InferResponseData<TCommands>
   >(): Promise<TCommandResults> => {
     if (this.commands.length === 0) {
       throw new Error("Pipeline is empty");
@@ -252,7 +250,7 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
     return res.map(({ error, result }, i) => {
       if (error) {
         throw new UpstashError(
-          `Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`,
+          `Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`
         );
       }
 
@@ -271,7 +269,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    * Pushes a command into the pipeline and returns a chainable instance of the
    * pipeline
    */
-  private chain<T>(command: Command<any, T>): Pipeline<[...TCommands, Command<any, T>]> {
+  private chain<T>(
+    command: Command<any, T>
+  ): Pipeline<[...TCommands, Command<any, T>]> {
     this.commands.push(command);
     return this as any; // TS thinks we're returning Pipeline<[]> here, because we're not creating a new instance of the class, hence the cast
   }
@@ -298,7 +298,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
       sourceKey: string,
       ...sourceKeys: string[]
     ): Pipeline<[...TCommands, BitOpCommand]>;
-    (op: "not", destinationKey: string, sourceKey: string): Pipeline<[...TCommands, BitOpCommand]>;
+    (op: "not", destinationKey: string, sourceKey: string): Pipeline<
+      [...TCommands, BitOpCommand]
+    >;
   } = (
     op: "and" | "or" | "xor" | "not",
     destinationKey: string,
@@ -306,7 +308,10 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
     ...sourceKeys: string[]
   ) =>
     this.chain(
-      new BitOpCommand([op as any, destinationKey, sourceKey, ...sourceKeys], this.commandOptions),
+      new BitOpCommand(
+        [op as any, destinationKey, sourceKey, ...sourceKeys],
+        this.commandOptions
+      )
     );
 
   /**
@@ -449,8 +454,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   /**
    * @see https://redis.io/commands/hgetall
    */
-  hgetall = <TData extends Record<string, unknown>>(...args: CommandArgs<typeof HGetAllCommand>) =>
-    this.chain(new HGetAllCommand<TData>(args, this.commandOptions));
+  hgetall = <TData extends Record<string, unknown>>(
+    ...args: CommandArgs<typeof HGetAllCommand>
+  ) => this.chain(new HGetAllCommand<TData>(args, this.commandOptions));
 
   /**
    * @see https://redis.io/commands/hincrby
@@ -479,8 +485,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   /**
    * @see https://redis.io/commands/hmget
    */
-  hmget = <TData extends Record<string, unknown>>(...args: CommandArgs<typeof HMGetCommand>) =>
-    this.chain(new HMGetCommand<TData>(args, this.commandOptions));
+  hmget = <TData extends Record<string, unknown>>(
+    ...args: CommandArgs<typeof HMGetCommand>
+  ) => this.chain(new HMGetCommand<TData>(args, this.commandOptions));
 
   /**
    * @see https://redis.io/commands/hmset
@@ -494,9 +501,14 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   hrandfield = <TData extends string | string[] | Record<string, unknown>>(
     key: string,
     count?: number,
-    withValues?: boolean,
+    withValues?: boolean
   ) =>
-    this.chain(new HRandFieldCommand<TData>([key, count, withValues] as any, this.commandOptions));
+    this.chain(
+      new HRandFieldCommand<TData>(
+        [key, count, withValues] as any,
+        this.commandOptions
+      )
+    );
 
   /**
    * @see https://redis.io/commands/hscan
@@ -514,7 +526,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    * @see https://redis.io/commands/hsetnx
    */
   hsetnx = <TData>(key: string, field: string, value: TData) =>
-    this.chain(new HSetNXCommand<TData>([key, field, value], this.commandOptions));
+    this.chain(
+      new HSetNXCommand<TData>([key, field, value], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/hstrlen
@@ -561,8 +575,18 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   /**
    * @see https://redis.io/commands/linsert
    */
-  linsert = <TData>(key: string, direction: "before" | "after", pivot: TData, value: TData) =>
-    this.chain(new LInsertCommand<TData>([key, direction, pivot, value], this.commandOptions));
+  linsert = <TData>(
+    key: string,
+    direction: "before" | "after",
+    pivot: TData,
+    value: TData
+  ) =>
+    this.chain(
+      new LInsertCommand<TData>(
+        [key, direction, pivot, value],
+        this.commandOptions
+      )
+    );
 
   /**
    * @see https://redis.io/commands/llen
@@ -592,13 +616,17 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    * @see https://redis.io/commands/lpush
    */
   lpush = <TData>(key: string, ...elements: TData[]) =>
-    this.chain(new LPushCommand<TData>([key, ...elements], this.commandOptions));
+    this.chain(
+      new LPushCommand<TData>([key, ...elements], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/lpushx
    */
   lpushx = <TData>(key: string, ...elements: TData[]) =>
-    this.chain(new LPushXCommand<TData>([key, ...elements], this.commandOptions));
+    this.chain(
+      new LPushXCommand<TData>([key, ...elements], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/lrange
@@ -660,7 +688,7 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   pexpireat = (...args: CommandArgs<typeof PExpireAtCommand>) =>
     this.chain(new PExpireAtCommand(args, this.commandOptions));
 
-    /**
+  /**
    * @see https://redis.io/commands/pfadd
    */
   pfadd = (...args: CommandArgs<typeof PfAddCommand>) =>
@@ -688,7 +716,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    * @see https://redis.io/commands/psetex
    */
   psetex = <TData>(key: string, ttl: number, value: TData) =>
-    this.chain(new PSetEXCommand<TData>([key, ttl, value], this.commandOptions));
+    this.chain(
+      new PSetEXCommand<TData>([key, ttl, value], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/pttl
@@ -835,20 +865,28 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   /**
    * @see https://redis.io/commands/smembers
    */
-  smembers = <TData extends unknown[] = string[]>(...args: CommandArgs<typeof SMembersCommand>) =>
-    this.chain(new SMembersCommand<TData>(args, this.commandOptions));
+  smembers = <TData extends unknown[] = string[]>(
+    ...args: CommandArgs<typeof SMembersCommand>
+  ) => this.chain(new SMembersCommand<TData>(args, this.commandOptions));
 
   /**
    * @see https://redis.io/commands/smismember
    */
   smismember = <TMembers extends unknown[]>(key: string, members: TMembers) =>
-    this.chain(new SMIsMemberCommand<TMembers>([key, members], this.commandOptions));
+    this.chain(
+      new SMIsMemberCommand<TMembers>([key, members], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/smove
    */
   smove = <TData>(source: string, destination: string, member: TData) =>
-    this.chain(new SMoveCommand<TData>([source, destination, member], this.commandOptions));
+    this.chain(
+      new SMoveCommand<TData>(
+        [source, destination, member],
+        this.commandOptions
+      )
+    );
 
   /**
    * @see https://redis.io/commands/spop
@@ -926,27 +964,31 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    */
   zadd = <TData>(
     ...args:
-      | [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]]
       | [
           key: string,
-          opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
-          ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]],
+          scoreMember: ScoreMember<TData>,
+          ...scoreMemberPairs: ScoreMember<TData>[]
+        ]
+      | [
+          key: string,
+          opts: ZAddCommandOptions,
+          ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]
         ]
   ) => {
     if ("score" in args[1]) {
       return this.chain(
         new ZAddCommand<TData>(
           [args[0], args[1] as ScoreMember<TData>, ...(args.slice(2) as any)],
-          this.commandOptions,
-        ),
+          this.commandOptions
+        )
       );
     }
 
     return this.chain(
       new ZAddCommand<TData>(
         [args[0], args[1] as any, ...(args.slice(2) as any)],
-        this.commandOptions,
-      ),
+        this.commandOptions
+      )
     );
   };
 
@@ -966,7 +1008,9 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
    * @see https://redis.io/commands/zincrby
    */
   zincrby = <TData>(key: string, increment: number, member: TData) =>
-    this.chain(new ZIncrByCommand<TData>([key, increment, member], this.commandOptions));
+    this.chain(
+      new ZIncrByCommand<TData>([key, increment, member], this.commandOptions)
+    );
 
   /**
    * @see https://redis.io/commands/zinterstore
@@ -1008,13 +1052,13 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
           key: string,
           min: `(${string}` | `[${string}` | "-" | "+",
           max: `(${string}` | `[${string}` | "-" | "+",
-          opts: { byLex: true } & ZRangeCommandOptions,
+          opts: { byLex: true } & ZRangeCommandOptions
         ]
       | [
           key: string,
           min: number | `(${number}` | "-inf" | "+inf",
           max: number | `(${number}` | "-inf" | "+inf",
-          opts: { byScore: true } & ZRangeCommandOptions,
+          opts: { byScore: true } & ZRangeCommandOptions
         ]
   ) => this.chain(new ZRangeCommand<TData>(args as any, this.commandOptions));
 
diff --git a/pkg/redis.ts b/pkg/redis.ts
index 17403770..8c297464 100644
--- a/pkg/redis.ts
+++ b/pkg/redis.ts
@@ -137,7 +137,6 @@ import {
   XRangeCommand,
   ZAddCommand,
   ZAddCommandOptions,
-  ZAddCommandOptionsWithIncr,
   ZCardCommand,
   ZCountCommand,
   ZIncrByCommand,
@@ -366,11 +365,14 @@ export class Redis {
   use = <TResult = unknown>(
     middleware: (
       r: UpstashRequest,
-      next: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>,
-    ) => Promise<UpstashResponse<TResult>>,
+      next: <TResult = unknown>(
+        req: UpstashRequest
+      ) => Promise<UpstashResponse<TResult>>
+    ) => Promise<UpstashResponse<TResult>>
   ) => {
     const makeRequest = this.client.request.bind(this.client);
-    this.client.request = (req: UpstashRequest) => middleware(req, makeRequest) as any;
+    this.client.request = (req: UpstashRequest) =>
+      middleware(req, makeRequest) as any;
   };
 
   /**
@@ -449,9 +451,10 @@ export class Redis {
     sourceKey: string,
     ...sourceKeys: string[]
   ) =>
-    new BitOpCommand([op as any, destinationKey, sourceKey, ...sourceKeys], this.opts).exec(
-      this.client,
-    );
+    new BitOpCommand(
+      [op as any, destinationKey, sourceKey, ...sourceKeys],
+      this.opts
+    ).exec(this.client);
 
   /**
    * @see https://redis.io/commands/bitpos
@@ -588,8 +591,9 @@ export class Redis {
   /**
    * @see https://redis.io/commands/hgetall
    */
-  hgetall = <TData extends Record<string, unknown>>(...args: CommandArgs<typeof HGetAllCommand>) =>
-    new HGetAllCommand<TData>(args, this.opts).exec(this.client);
+  hgetall = <TData extends Record<string, unknown>>(
+    ...args: CommandArgs<typeof HGetAllCommand>
+  ) => new HGetAllCommand<TData>(args, this.opts).exec(this.client);
 
   /**
    * @see https://redis.io/commands/hincrby
@@ -618,8 +622,9 @@ export class Redis {
   /**
    * @see https://redis.io/commands/hmget
    */
-  hmget = <TData extends Record<string, unknown>>(...args: CommandArgs<typeof HMGetCommand>) =>
-    new HMGetCommand<TData>(args, this.opts).exec(this.client);
+  hmget = <TData extends Record<string, unknown>>(
+    ...args: CommandArgs<typeof HMGetCommand>
+  ) => new HMGetCommand<TData>(args, this.opts).exec(this.client);
 
   /**
    * @see https://redis.io/commands/hmset
@@ -636,13 +641,17 @@ export class Redis {
     <TData extends Record<string, unknown>>(
       key: string,
       count: number,
-      withValues: boolean,
+      withValues: boolean
     ): Promise<Partial<TData>>;
   } = <TData extends string | string[] | Record<string, unknown>>(
     key: string,
     count?: number,
-    withValues?: boolean,
-  ) => new HRandFieldCommand<TData>([key, count, withValues] as any, this.opts).exec(this.client);
+    withValues?: boolean
+  ) =>
+    new HRandFieldCommand<TData>(
+      [key, count, withValues] as any,
+      this.opts
+    ).exec(this.client);
 
   /**
    * @see https://redis.io/commands/hscan
@@ -707,8 +716,15 @@ export class Redis {
   /**
    * @see https://redis.io/commands/linsert
    */
-  linsert = <TData>(key: string, direction: "before" | "after", pivot: TData, value: TData) =>
-    new LInsertCommand<TData>([key, direction, pivot, value], this.opts).exec(this.client);
+  linsert = <TData>(
+    key: string,
+    direction: "before" | "after",
+    pivot: TData,
+    value: TData
+  ) =>
+    new LInsertCommand<TData>([key, direction, pivot, value], this.opts).exec(
+      this.client
+    );
 
   /**
    * @see https://redis.io/commands/llen
@@ -806,10 +822,10 @@ export class Redis {
   pexpireat = (...args: CommandArgs<typeof PExpireAtCommand>) =>
     new PExpireAtCommand(args, this.opts).exec(this.client);
 
-    /**
+  /**
    * @see https://redis.io/commands/pfadd
    */
-    pfadd = (...args: CommandArgs<typeof PfAddCommand>) =>
+  pfadd = (...args: CommandArgs<typeof PfAddCommand>) =>
     new PfAddCommand(args, this.opts).exec(this.client);
 
   /**
@@ -982,19 +998,24 @@ export class Redis {
    * @see https://redis.io/commands/smismember
    */
   smismember = <TMembers extends unknown[]>(key: string, members: TMembers) =>
-    new SMIsMemberCommand<TMembers>([key, members], this.opts).exec(this.client);
+    new SMIsMemberCommand<TMembers>([key, members], this.opts).exec(
+      this.client
+    );
 
   /**
    * @see https://redis.io/commands/smembers
    */
-  smembers = <TData extends unknown[] = string[]>(...args: CommandArgs<typeof SMembersCommand>) =>
-    new SMembersCommand<TData>(args, this.opts).exec(this.client);
+  smembers = <TData extends unknown[] = string[]>(
+    ...args: CommandArgs<typeof SMembersCommand>
+  ) => new SMembersCommand<TData>(args, this.opts).exec(this.client);
 
   /**
    * @see https://redis.io/commands/smove
    */
   smove = <TData>(source: string, destination: string, member: TData) =>
-    new SMoveCommand<TData>([source, destination, member], this.opts).exec(this.client);
+    new SMoveCommand<TData>([source, destination, member], this.opts).exec(
+      this.client
+    );
 
   /**
    * @see https://redis.io/commands/spop
@@ -1084,23 +1105,27 @@ export class Redis {
    */
   zadd = <TData>(
     ...args:
-      | [key: string, scoreMember: ScoreMember<TData>, ...scoreMemberPairs: ScoreMember<TData>[]]
       | [
           key: string,
-          opts: ZAddCommandOptions | ZAddCommandOptionsWithIncr,
-          ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]],
+          scoreMember: ScoreMember<TData>,
+          ...scoreMemberPairs: ScoreMember<TData>[]
+        ]
+      | [
+          key: string,
+          opts: ZAddCommandOptions,
+          ...scoreMemberPairs: [ScoreMember<TData>, ...ScoreMember<TData>[]]
         ]
   ) => {
     if ("score" in args[1]) {
       return new ZAddCommand<TData>(
         [args[0], args[1] as ScoreMember<TData>, ...(args.slice(2) as any)],
-        this.opts,
+        this.opts
       ).exec(this.client);
     }
 
     return new ZAddCommand<TData>(
       [args[0], args[1] as any, ...(args.slice(2) as any)],
-      this.opts,
+      this.opts
     ).exec(this.client);
   };
   /**
@@ -1125,7 +1150,9 @@ export class Redis {
    * @see https://redis.io/commands/zincrby
    */
   zincrby = <TData>(key: string, increment: number, member: TData) =>
-    new ZIncrByCommand<TData>([key, increment, member], this.opts).exec(this.client);
+    new ZIncrByCommand<TData>([key, increment, member], this.opts).exec(
+      this.client
+    );
 
   /**
    * @see https://redis.io/commands/zinterstore
@@ -1167,13 +1194,13 @@ export class Redis {
           key: string,
           min: `(${string}` | `[${string}` | "-" | "+",
           max: `(${string}` | `[${string}` | "-" | "+",
-          opts: { byLex: true } & ZRangeCommandOptions,
+          opts: { byLex: true } & ZRangeCommandOptions
         ]
       | [
           key: string,
           min: number | `(${number}` | "-inf" | "+inf",
           max: number | `(${number}` | "-inf" | "+inf",
-          opts: { byScore: true } & ZRangeCommandOptions,
+          opts: { byScore: true } & ZRangeCommandOptions
         ]
   ) => new ZRangeCommand<TData>(args as any, this.opts).exec(this.client);