@upstash/redis 1.36.1 → 1.37.0-rc.1

package/{chunk-LLI2WIYN.mjs → chunk-PDHDP2I5.mjs}

@@ -77,18 +77,8 @@ function mergeHeaders(...headers) {
   }
   return merged;
 }
-function kvArrayToObject(v) {
-  if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
-  if (!Array.isArray(v)) return {};
-  const obj = {};
-  for (let i = 0; i < v.length; i += 2) {
-    if (typeof v[i] === "string") obj[v[i]] = v[i + 1];
-  }
-  return obj;
-}
 
 // pkg/http.ts
-var MAX_BUFFER_SIZE = 1024 * 1024;
 var HttpClient = class {
   baseUrl;
   headers;
@@ -212,16 +202,11 @@ var HttpClient = class {
       const decoder = new TextDecoder();
       (async () => {
         try {
-          let buffer = "";
           while (true) {
             const { value, done } = await reader.read();
             if (done) break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            if (buffer.length > MAX_BUFFER_SIZE) {
-              throw new Error("Buffer size exceeded (1MB)");
-            }
+            const chunk = decoder.decode(value);
+            const lines = chunk.split("\n");
             for (const line of lines) {
               if (line.startsWith("data: ")) {
                 const data = line.slice(6);
@@ -600,23 +585,6 @@ var ExpireAtCommand = class extends Command {
   }
 };
 
-// pkg/commands/fcall.ts
-var FCallCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(["fcall", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
-  }
-};
-
-// pkg/commands/fcall_ro.ts
-var FCallRoCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(
-      ["fcall_ro", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []],
-      opts
-    );
-  }
-};
-
 // pkg/commands/flushall.ts
 var FlushAllCommand = class extends Command {
   constructor(args, opts) {
@@ -639,85 +607,6 @@ var FlushDBCommand = class extends Command {
   }
 };
 
-// pkg/commands/function_delete.ts
-var FunctionDeleteCommand = class extends Command {
-  constructor([libraryName], opts) {
-    super(["function", "delete", libraryName], opts);
-  }
-};
-
-// pkg/commands/function_flush.ts
-var FunctionFlushCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "flush"], opts);
-  }
-};
-
-// pkg/commands/function_list.ts
-var FunctionListCommand = class extends Command {
-  constructor([args], opts) {
-    const command = ["function", "list"];
-    if (args?.libraryName) {
-      command.push("libraryname", args.libraryName);
-    }
-    if (args?.withCode) {
-      command.push("withcode");
-    }
-    super(command, { deserialize: deserialize2, ...opts });
-  }
-};
-function deserialize2(result) {
-  if (!Array.isArray(result)) return [];
-  return result.map((libRaw) => {
-    const lib = kvArrayToObject(libRaw);
-    const functionsParsed = lib.functions.map(
-      (fnRaw) => kvArrayToObject(fnRaw)
-    );
-    return {
-      libraryName: lib.library_name,
-      engine: lib.engine,
-      functions: functionsParsed.map((fn) => ({
-        name: fn.name,
-        description: fn.description ?? void 0,
-        flags: fn.flags
-      })),
-      libraryCode: lib.library_code
-    };
-  });
-}
-
-// pkg/commands/function_load.ts
-var FunctionLoadCommand = class extends Command {
-  constructor([args], opts) {
-    super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
-  }
-};
-
-// pkg/commands/function_stats.ts
-var FunctionStatsCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "stats"], { deserialize: deserialize3, ...opts });
-  }
-};
-function deserialize3(result) {
-  const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
-  const parsedEngines = Object.fromEntries(
-    Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)])
-  );
-  const final = {
-    engines: Object.fromEntries(
-      Object.entries(parsedEngines).map(([key, value]) => [
-        key,
-        {
-          librariesCount: value.libraries_count,
-          functionsCount: value.functions_count
-        }
-      ])
-    )
-  };
-  return final;
-}
-
 // pkg/commands/geo_add.ts
 var GeoAddCommand = class extends Command {
   constructor([key, arg1, ...arg2], opts) {
@@ -1064,7 +953,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize4(result) {
+function deserialize2(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1084,7 +973,7 @@ function deserialize4(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize4(result),
+      deserialize: (result) => deserialize2(result),
       ...opts
     });
   }
@@ -1119,7 +1008,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize5(fields, result) {
+function deserialize3(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -1136,7 +1025,7 @@ function deserialize5(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize5(fields, result),
+      deserialize: (result) => deserialize3(fields, result),
       ...opts
     });
   }
@@ -2113,7 +2002,7 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize6(result) {
+function deserialize4(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2142,7 +2031,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize6(result),
+      deserialize: (result) => deserialize4(result),
       ...opts
     });
   }
@@ -2205,12 +2094,12 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize7(result),
+      deserialize: (result) => deserialize5(result),
       ...opts
     });
   }
 };
-function deserialize7(result) {
+function deserialize5(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -3319,38 +3208,6 @@ var Pipeline = class {
       type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       */
-      stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
-    };
-  }
 };
 
 // pkg/auto-pipeline.ts
@@ -3372,7 +3229,7 @@ var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
   "zrange",
   "exec"
 ]);
-function createAutoPipelineProxy(_redis, namespace = "root") {
+function createAutoPipelineProxy(_redis, json) {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -3382,31 +3239,29 @@ function createAutoPipelineProxy(_redis, namespace = "root") {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (namespace === "root" && command === "json") {
-        return createAutoPipelineProxy(redis2, "json");
-      }
-      if (namespace === "root" && command === "functions") {
-        return createAutoPipelineProxy(redis2, "functions");
+      if (command === "json") {
+        return createAutoPipelineProxy(redis2, true);
       }
-      if (namespace === "root") {
-        const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-        const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-        if (commandInRedisButNotPipeline || isCommandExcluded) {
-          return redis2[command];
-        }
+      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
+      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
+      if (commandInRedisButNotPipeline || isCommandExcluded) {
+        return redis2[command];
       }
-      const pipeline = redis2.autoPipelineExecutor.pipeline;
-      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
-      const isFunction = typeof targetFunction === "function";
+      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
       if (isFunction) {
         return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
-            const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
-            targetFunction2(...args);
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
+            if (json) {
+              pipeline.json[command](
+                ...args
+              );
+            } else {
+              pipeline[command](...args);
+            }
           });
         };
       }
-      return targetFunction;
+      return redis2.autoPipelineExecutor.pipeline[command];
     }
   });
 }
@@ -3453,6 +3308,265 @@ var AutoPipelineExecutor = class {
   }
 };
 
+// pkg/commands/search/types.ts
+var FIELD_TYPES = ["TEXT", "U64", "I64", "F64", "BOOL", "DATE"];
+
+// pkg/commands/search/utils.ts
+function isFieldType(value) {
+  return typeof value === "string" && FIELD_TYPES.includes(value);
+}
+function isDetailedField(value) {
+  return typeof value === "object" && value !== null && "type" in value && isFieldType(value.type);
+}
+function isNestedSchema(value) {
+  return typeof value === "object" && value !== null && !isDetailedField(value);
+}
+function flattenSchema(schema, pathPrefix = []) {
+  const fields = [];
+  for (const [key, value] of Object.entries(schema)) {
+    const currentPath = [...pathPrefix, key];
+    const pathString = currentPath.join(".");
+    if (isFieldType(value)) {
+      fields.push({
+        path: pathString,
+        type: value
+      });
+    } else if (isDetailedField(value)) {
+      fields.push({
+        path: pathString,
+        type: value.type,
+        fast: "fast" in value ? value.fast : void 0,
+        noTokenize: "noTokenize" in value ? value.noTokenize : void 0,
+        noStem: "noStem" in value ? value.noStem : void 0,
+        from: "from" in value ? value.from : void 0
+      });
+    } else if (isNestedSchema(value)) {
+      const nestedFields = flattenSchema(value, currentPath);
+      fields.push(...nestedFields);
+    }
+  }
+  return fields;
+}
+function deserializeQueryResponse(rawResponse) {
+  return rawResponse.map((itemRaw) => {
+    const raw = itemRaw;
+    const key = raw[0];
+    const score = raw[1];
+    const rawFields = raw[2];
+    if (rawFields === void 0) {
+      return { key, score };
+    }
+    if (!Array.isArray(rawFields) || rawFields.length === 0) {
+      return { key, score, data: {} };
+    }
+    let data = {};
+    for (const fieldRaw of rawFields) {
+      const key2 = fieldRaw[0];
+      const value = fieldRaw[1];
+      const pathParts = key2.split(".");
+      if (pathParts.length == 1) {
+        data[key2] = value;
+      } else {
+        let currentObj = data;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+          const pathPart = pathParts[i];
+          if (!(pathPart in currentObj)) {
+            currentObj[pathPart] = {};
+          }
+          currentObj = currentObj[pathPart];
+        }
+        currentObj[pathParts.at(-1)] = value;
+      }
+    }
+    if ("$" in data) {
+      data = data["$"];
+    }
+    return { key, score, data };
+  });
+}
+function deserializeDescribeResponse(rawResponse) {
+  const description = {};
+  for (let i = 0; i < rawResponse.length; i += 2) {
+    const descriptor = rawResponse[i];
+    switch (descriptor) {
+      case "name": {
+        description["name"] = rawResponse[i + 1];
+        break;
+      }
+      case "type": {
+        description["dataType"] = rawResponse[i + 1].toLowerCase();
+        break;
+      }
+      case "prefixes": {
+        description["prefixes"] = rawResponse[i + 1];
+        break;
+      }
+      case "language": {
+        description["language"] = rawResponse[i + 1];
+        break;
+      }
+      case "schema": {
+        const schema = {};
+        for (const fieldDescription of rawResponse[i + 1]) {
+          const fieldName = fieldDescription[0];
+          const fieldInfo = { type: fieldDescription[1] };
+          if (fieldDescription.length > 2) {
+            for (let j = 2; j < fieldDescription.length; j++) {
+              const fieldOption = fieldDescription[j];
+              switch (fieldOption) {
+                case "NOSTEM": {
+                  fieldInfo.noStem = true;
+                  break;
+                }
+                case "NOTOKENIZE": {
+                  fieldInfo.noTokenize = true;
+                  break;
+                }
+                case "FAST": {
+                  fieldInfo.fast = true;
+                  break;
+                }
+              }
+            }
+          }
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+  return description;
+}
+function parseCountResponse(rawResponse) {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+
+// pkg/commands/search/command-builder.ts
+function buildQueryCommand(redisCommand, name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const command = [redisCommand, name, query];
+  if (options?.limit !== void 0) {
+    command.push("LIMIT", options.limit.toString());
+  }
+  if (options?.offset !== void 0) {
+    command.push("OFFSET", options.offset.toString());
+  }
+  if (options?.select && Object.keys(options.select).length === 0) {
+    command.push("NOCONTENT");
+  }
+  if (options?.orderBy) {
+    command.push("ORDERBY");
+    for (const [field, direction] of Object.entries(options.orderBy)) {
+      command.push(field, direction);
+    }
+  }
+  if (options?.highlight) {
+    command.push(
+      "HIGHLIGHT",
+      "FIELDS",
+      options.highlight.fields.length.toString(),
+      ...options.highlight.fields
+    );
+    if (options.highlight.preTag && options.highlight.postTag) {
+      command.push("TAGS", options.highlight.preTag, options.highlight.postTag);
+    }
+  }
+  if (options?.select && Object.keys(options.select).length > 0) {
+    command.push(
+      "SELECT",
+      Object.keys(options.select).length.toString(),
+      ...Object.keys(options.select)
+    );
+  }
+  return command;
+}
+function buildCreateIndexCommand(params) {
+  const { name, schema, dataType, prefix, language, skipInitialScan, existsOk } = params;
+  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
+  const payload = [
+    name,
+    ...skipInitialScan ? ["SKIPINITIALSCAN"] : [],
+    ...existsOk ? ["EXISTSOK"] : [],
+    "ON",
+    dataType.toUpperCase(),
+    "PREFIX",
+    prefixArray.length.toString(),
+    ...prefixArray,
+    ...language ? ["LANGUAGE", language] : [],
+    "SCHEMA"
+  ];
+  const fields = flattenSchema(schema);
+  for (const field of fields) {
+    payload.push(field.path, field.type);
+    if (field.fast) {
+      payload.push("FAST");
+    }
+    if (field.noTokenize) {
+      payload.push("NOTOKENIZE");
+    }
+    if (field.noStem) {
+      payload.push("NOSTEM");
+    }
+    if (field.from) {
+      payload.push("FROM", field.from);
+    }
+  }
+  return ["SEARCH.CREATE", ...payload];
+}
+
+// pkg/commands/search/search.ts
+var SearchIndex = class {
+  name;
+  schema;
+  client;
+  constructor({ name, schema, client }) {
+    this.name = name;
+    this.schema = schema;
+    this.client = client;
+  }
+  async waitIndexing() {
+    const command = ["SEARCH.WAITINDEXING", this.name];
+    await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeQueryResponse(rawResult);
+  }
+  async count({ filter }) {
+    const command = buildQueryCommand("SEARCH.COUNT", this.name, { filter });
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return { count: parseCountResponse(rawResult) };
+  }
+  async drop() {
+    const command = ["SEARCH.DROP", this.name];
+    const result = await new ExecCommand(command).exec(this.client);
+    return result;
+  }
+};
+async function createIndex(client, params) {
+  const { name, schema } = params;
+  const createIndexCommand = buildCreateIndexCommand(params);
+  await new ExecCommand(createIndexCommand).exec(client);
+  return initIndex(client, { name, schema });
+}
+function initIndex(client, params) {
+  const { name, schema } = params;
+  return new SearchIndex({ name, schema, client });
+}
+
 // pkg/commands/psubscribe.ts
 var PSubscribeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -3898,40 +4012,6 @@ var Redis = class {
       type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       *
-       * Note: `running_script` field is not supported and therefore not included in the type.
-       */
-      stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
-    };
-  }
   /**
    * Wrap a new middleware around the HTTP client.
    */
@@ -3982,6 +4062,16 @@ var Redis = class {
   createScript(script, opts) {
     return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
+  get search() {
+    return {
+      createIndex: (params) => {
+        return createIndex(this.client, params);
+      },
+      index: (params) => {
+        return initIndex(this.client, params);
+      }
+    };
+  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4689,7 +4779,7 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.1";
+var VERSION = "v1.37.0-rc.1";
 
 export {
   error_exports,

package/cloudflare.d.mts

@@ -1,5 +1,5 @@
-import { H as HttpClientConfig, R as RedisOptions, a as RequesterConfig, b as Redis$1 } from './zmscore-0SAuWM0q.mjs';
-export { A as AppendCommand, B as BitCountCommand, f as BitOpCommand, g as BitPosCommand, C as CopyCommand, D as DBSizeCommand, i as DecrByCommand, h as DecrCommand, j as DelCommand, E as EchoCommand, l as EvalCommand, k as EvalROCommand, n as EvalshaCommand, m as EvalshaROCommand, o as ExistsCommand, r as ExpireAtCommand, p as ExpireCommand, q as ExpireOption, F as FlushAllCommand, s as FlushDBCommand, G as GeoAddCommand, t as GeoAddCommandOptions, v as GeoDistCommand, w as GeoHashCommand, u as GeoMember, x as GeoPosCommand, y as GeoSearchCommand, z as GeoSearchStoreCommand, J as GetBitCommand, I as GetCommand, K as GetDelCommand, L as GetExCommand, M as GetRangeCommand, N as GetSetCommand, O as HDelCommand, Q as HExistsCommand, T as HExpireAtCommand, S as HExpireCommand, V as HExpireTimeCommand, a1 as HGetAllCommand, a0 as HGetCommand, a2 as HIncrByCommand, a3 as HIncrByFloatCommand, a4 as HKeysCommand, a5 as HLenCommand, a6 as HMGetCommand, a7 as HMSetCommand, Y as HPExpireAtCommand, X as HPExpireCommand, Z as HPExpireTimeCommand, _ as HPTtlCommand, $ as HPersistCommand, a8 as HRandFieldCommand, a9 as HScanCommand, aa as HSetCommand, ab as HSetNXCommand, ac as HStrLenCommand, W as HTtlCommand, ad as HValsCommand, af as IncrByCommand, ag as IncrByFloatCommand, ae as IncrCommand, ah as JsonArrAppendCommand, ai as JsonArrIndexCommand, aj as JsonArrInsertCommand, ak as JsonArrLenCommand, al as JsonArrPopCommand, am as JsonArrTrimCommand, an as JsonClearCommand, ao as JsonDelCommand, ap as JsonForgetCommand, aq as JsonGetCommand, as as JsonMGetCommand, ar as JsonMergeCommand, at as JsonNumIncrByCommand, au as JsonNumMultByCommand, av as JsonObjKeysCommand, aw as JsonObjLenCommand, ax as JsonRespCommand, ay as JsonSetCommand, az as JsonStrAppendCommand, aA as JsonStrLenCommand, aB as JsonToggleCommand, aC as JsonTypeCommand, aD as KeysCommand, aE as LIndexCommand, aF as LInsertCommand, aG as LLenCommand, aH as LMoveCommand, aI as LPopCommand, aJ as LPushCommand, aK as LPushXCommand, aL as LRangeCommand, aM as LRemCommand, aN as LSetCommand, aO as LTrimCommand, aP as MGetCommand, aQ as MSetCommand, aR as MSetNXCommand, aU as PExpireAtCommand, aT as PExpireCommand, aW as PSetEXCommand, aX as PTtlCommand, aS as PersistCommand, aV as PingCommand, P as Pipeline, aY as PublishCommand, b0 as RPopCommand, b1 as RPushCommand, b2 as RPushXCommand, aZ as RandomKeyCommand, a_ as RenameCommand, a$ as RenameNXCommand, c as Requester, b3 as SAddCommand, b6 as SCardCommand, ba as SDiffCommand, bb as SDiffStoreCommand, bi as SInterCommand, bj as SInterStoreCommand, bk as SIsMemberCommand, bm as SMIsMemberCommand, bl as SMembersCommand, bn as SMoveCommand, bo as SPopCommand, bp as SRandMemberCommand, bq as SRemCommand, br as SScanCommand, bt as SUnionCommand, bu as SUnionStoreCommand, b4 as ScanCommand, b5 as ScanCommandOptions, bD as ScoreMember, b7 as ScriptExistsCommand, b8 as ScriptFlushCommand, b9 as ScriptLoadCommand, be as SetBitCommand, bc as SetCommand, bd as SetCommandOptions, bf as SetExCommand, bg as SetNxCommand, bh as SetRangeCommand, bs as StrLenCommand, bv as TimeCommand, bw as TouchCommand, bx as TtlCommand, by as Type, bz as TypeCommand, bA as UnlinkCommand, U as UpstashRequest, d as UpstashResponse, bB as XAddCommand, bC as XRangeCommand, bF as ZAddCommand, bE as ZAddCommandOptions, bG as ZCardCommand, bH as ZCountCommand, bI as ZDiffStoreCommand, bJ as ZIncrByCommand, bK as ZInterStoreCommand, bL as ZInterStoreCommandOptions, bM as ZLexCountCommand, bN as ZMScoreCommand, bO as ZPopMaxCommand, bP as ZPopMinCommand, bQ as ZRangeCommand, bR as ZRangeCommandOptions, bS as ZRankCommand, bT as ZRemCommand, bU as ZRemRangeByLexCommand, bV as ZRemRangeByRankCommand, bW as ZRemRangeByScoreCommand, bX as ZRevRankCommand, bY as ZScanCommand, bZ as ZScoreCommand, b_ as ZUnionCommand, b$ as ZUnionCommandOptions, c0 as ZUnionStoreCommand, c1 as ZUnionStoreCommandOptions, e as errors } from './zmscore-0SAuWM0q.mjs';
+import { H as HttpClientConfig, R as RedisOptions, b as RequesterConfig, c as Redis$1 } from './zmscore-BpOSd5F5.mjs';
+export { A as AppendCommand, B as BitCountCommand, g as BitOpCommand, h as BitPosCommand, C as CopyCommand, D as DBSizeCommand, j as DecrByCommand, i as DecrCommand, k as DelCommand, E as EchoCommand, m as EvalCommand, l as EvalROCommand, o as EvalshaCommand, n as EvalshaROCommand, p as ExistsCommand, s as ExpireAtCommand, q as ExpireCommand, r as ExpireOption, F as FlushAllCommand, t as FlushDBCommand, G as GeoAddCommand, u as GeoAddCommandOptions, w as GeoDistCommand, x as GeoHashCommand, v as GeoMember, y as GeoPosCommand, z as GeoSearchCommand, I as GeoSearchStoreCommand, K as GetBitCommand, J as GetCommand, L as GetDelCommand, M as GetExCommand, O as GetRangeCommand, Q as GetSetCommand, S as HDelCommand, T as HExistsCommand, W as HExpireAtCommand, V as HExpireCommand, X as HExpireTimeCommand, a3 as HGetAllCommand, a2 as HGetCommand, a4 as HIncrByCommand, a5 as HIncrByFloatCommand, a6 as HKeysCommand, a7 as HLenCommand, a8 as HMGetCommand, a9 as HMSetCommand, _ as HPExpireAtCommand, Z as HPExpireCommand, $ as HPExpireTimeCommand, a0 as HPTtlCommand, a1 as HPersistCommand, aa as HRandFieldCommand, ab as HScanCommand, ac as HSetCommand, ad as HSetNXCommand, ae as HStrLenCommand, Y as HTtlCommand, af as HValsCommand, ah as IncrByCommand, ai as IncrByFloatCommand, ag as IncrCommand, aj as JsonArrAppendCommand, ak as JsonArrIndexCommand, al as JsonArrInsertCommand, am as JsonArrLenCommand, an as JsonArrPopCommand, ao as JsonArrTrimCommand, ap as JsonClearCommand, aq as JsonDelCommand, ar as JsonForgetCommand, as as JsonGetCommand, au as JsonMGetCommand, at as JsonMergeCommand, av as JsonNumIncrByCommand, aw as JsonNumMultByCommand, ax as JsonObjKeysCommand, ay as JsonObjLenCommand, az as JsonRespCommand, aA as JsonSetCommand, aB as JsonStrAppendCommand, aC as JsonStrLenCommand, aD as JsonToggleCommand, aE as JsonTypeCommand, aF as KeysCommand, aG as LIndexCommand, aH as LInsertCommand, aI as LLenCommand, aJ as LMoveCommand, aK as LPopCommand, aL as LPushCommand, aM as LPushXCommand, aN as LRangeCommand, aO as LRemCommand, aP as LSetCommand, aQ as LTrimCommand, aR as MGetCommand, aS as MSetCommand, aT as MSetNXCommand, aW as PExpireAtCommand, aV as PExpireCommand, aY as PSetEXCommand, aZ as PTtlCommand, aU as PersistCommand, aX as PingCommand, P as Pipeline, a_ as PublishCommand, b2 as RPopCommand, b3 as RPushCommand, b4 as RPushXCommand, a$ as RandomKeyCommand, b0 as RenameCommand, b1 as RenameNXCommand, d as Requester, b5 as SAddCommand, b8 as SCardCommand, bc as SDiffCommand, bd as SDiffStoreCommand, bk as SInterCommand, bl as SInterStoreCommand, bm as SIsMemberCommand, bo as SMIsMemberCommand, bn as SMembersCommand, bp as SMoveCommand, bq as SPopCommand, br as SRandMemberCommand, bs as SRemCommand, bt as SScanCommand, bv as SUnionCommand, bw as SUnionStoreCommand, b6 as ScanCommand, b7 as ScanCommandOptions, bF as ScoreMember, b9 as ScriptExistsCommand, ba as ScriptFlushCommand, bb as ScriptLoadCommand, bg as SetBitCommand, be as SetCommand, bf as SetCommandOptions, bh as SetExCommand, bi as SetNxCommand, bj as SetRangeCommand, bu as StrLenCommand, bx as TimeCommand, by as TouchCommand, bz as TtlCommand, bA as Type, bB as TypeCommand, bC as UnlinkCommand, U as UpstashRequest, f as UpstashResponse, bD as XAddCommand, bE as XRangeCommand, bH as ZAddCommand, bG as ZAddCommandOptions, bI as ZCardCommand, bJ as ZCountCommand, bK as ZDiffStoreCommand, bL as ZIncrByCommand, bM as ZInterStoreCommand, bN as ZInterStoreCommandOptions, bO as ZLexCountCommand, bP as ZMScoreCommand, bQ as ZPopMaxCommand, bR as ZPopMinCommand, bS as ZRangeCommand, bT as ZRangeCommandOptions, bU as ZRankCommand, bV as ZRemCommand, bW as ZRemRangeByLexCommand, bX as ZRemRangeByRankCommand, bY as ZRemRangeByScoreCommand, bZ as ZRevRankCommand, b_ as ZScanCommand, b$ as ZScoreCommand, c0 as ZUnionCommand, c1 as ZUnionCommandOptions, c2 as ZUnionStoreCommand, c3 as ZUnionStoreCommandOptions, e as errors } from './zmscore-BpOSd5F5.mjs';
 
 type Env = {
     UPSTASH_DISABLE_TELEMETRY?: string;