@upstash/redis 1.37.0-rc → 1.37.0-rc.10

package/{chunk-D4C7KXWT.mjs → chunk-A4UDH32Y.mjs}

@@ -77,8 +77,18 @@ 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;
@@ -202,11 +212,16 @@ var HttpClient = class {
       const decoder = new TextDecoder();
       (async () => {
         try {
+          let buffer = "";
           while (true) {
             const { value, done } = await reader.read();
             if (done) break;
-            const chunk = decoder.decode(value);
-            const lines = chunk.split("\n");
+            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)");
+            }
             for (const line of lines) {
               if (line.startsWith("data: ")) {
                 const data = line.slice(6);
@@ -378,6 +393,429 @@ var Command = class {
   }
 };
 
+// pkg/commands/exec.ts
+var ExecCommand = class extends Command {
+  constructor(cmd, opts) {
+    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
+    super(normalizedCmd, opts);
+  }
+};
+
+// pkg/commands/search/types.ts
+var FIELD_TYPES = ["TEXT", "U64", "I64", "F64", "BOOL", "DATE", "KEYWORD"];
+
+// 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 = Number(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);
+}
+function deserializeAggregateResponse(rawResponse) {
+  return parseAggregationArray(rawResponse);
+}
+function parseAggregationArray(arr) {
+  const result = {};
+  for (let i = 0; i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+    if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "string") {
+        result[key] = value[0] === "buckets" ? parseBucketsValue(value) : parseStatsValue(value);
+      } else {
+        result[key] = parseAggregationArray(value);
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function coerceNumericString(value) {
+  if (typeof value === "string" && value !== "" && !Number.isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+function parseStatsValue(arr) {
+  const result = {};
+  for (let i = 0; i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+    if (Array.isArray(value) && value.length > 0) {
+      if (typeof value[0] === "string") {
+        result[key] = parseStatsValue(value);
+      } else if (Array.isArray(value[0]) && typeof value[0][0] === "string") {
+        result[key] = value.map((item) => parseStatsValue(item));
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = coerceNumericString(value);
+    }
+  }
+  return result;
+}
+function parseBucketsValue(arr) {
+  if (arr[0] === "buckets" && Array.isArray(arr[1])) {
+    const result = {
+      buckets: arr[1].map((bucket) => {
+        const bucketObj = {};
+        for (let i = 0; i < bucket.length; i += 2) {
+          const key = bucket[i];
+          const value = bucket[i + 1];
+          bucketObj[key] = Array.isArray(value) && value.length > 0 && typeof value[0] === "string" ? parseStatsValue(value) : value;
+        }
+        return bucketObj;
+      })
+    };
+    for (let i = 2; i < arr.length; i += 2) {
+      result[arr[i]] = arr[i + 1];
+    }
+    return result;
+  }
+  return arr;
+}
+
+// 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) {
+    if ("orderBy" in options && options.orderBy) {
+      command.push("ORDERBY");
+      for (const [field, direction] of Object.entries(options.orderBy)) {
+        command.push(field, direction);
+      }
+    } else if ("scoreFunc" in options && options.scoreFunc) {
+      command.push("SCOREFUNC", ...buildScoreFunc(options.scoreFunc));
+    }
+  }
+  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 buildScoreFunc(scoreBy) {
+  const result = [];
+  if (typeof scoreBy === "string") {
+    result.push("FIELDVALUE", scoreBy);
+  } else if ("fields" in scoreBy) {
+    if (scoreBy.combineMode) {
+      result.push("COMBINEMODE", scoreBy.combineMode.toUpperCase());
+    }
+    if (scoreBy.scoreMode) {
+      result.push("SCOREMODE", scoreBy.scoreMode.toUpperCase());
+    }
+    for (const field of scoreBy.fields) {
+      result.push(...buildScoreFuncField(field));
+    }
+  } else {
+    result.push(...buildScoreFuncField(scoreBy));
+  }
+  return result;
+}
+function buildScoreFuncField(field) {
+  const result = [];
+  if (typeof field === "string") {
+    result.push("FIELDVALUE", field);
+  } else {
+    if (field.scoreMode) {
+      result.push("SCOREMODE", field.scoreMode.toUpperCase());
+    }
+    result.push("FIELDVALUE", field.field);
+    if (field.modifier) {
+      result.push("MODIFIER", field.modifier.toUpperCase());
+    }
+    if (field.factor !== void 0) {
+      result.push("FACTOR", field.factor.toString());
+    }
+    if (field.missing !== void 0) {
+      result.push("MISSING", field.missing.toString());
+    }
+  }
+  return result;
+}
+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];
+}
+function buildAggregateCommand(name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const aggregations = JSON.stringify(options.aggregations);
+  return ["SEARCH.AGGREGATE", name, query, aggregations];
+}
+
+// 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];
+    return await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    if (!rawResult) return null;
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    if (!rawResult) return rawResult;
+    return deserializeQueryResponse(rawResult);
+  }
+  async aggregate(options) {
+    const command = buildAggregateCommand(this.name, options);
+    const rawResult = await new ExecCommand(
+      command
+    ).exec(this.client);
+    return deserializeAggregateResponse(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 addAlias({ alias }) {
+    const command = ["SEARCH.ALIASADD", alias, 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 });
+}
+async function listAliases(client) {
+  const command = ["SEARCH.LISTALIASES"];
+  const rawResult = await new ExecCommand(command).exec(client);
+  if (rawResult === 0 || Array.isArray(rawResult) && rawResult.length === 0) {
+    return {};
+  }
+  if (!Array.isArray(rawResult)) {
+    return {};
+  }
+  const aliases = {};
+  for (const pair of rawResult) {
+    if (Array.isArray(pair) && pair.length === 2) {
+      const [alias, index] = pair;
+      aliases[alias] = index;
+    }
+  }
+  return aliases;
+}
+async function addAlias(client, { indexName, alias }) {
+  const command = ["SEARCH.ALIASADD", alias, indexName];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+async function delAlias(client, { alias }) {
+  const command = ["SEARCH.ALIASDEL", alias];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+
 // pkg/commands/hrandfield.ts
 function deserialize(result) {
   if (result.length === 0) {
@@ -478,6 +916,13 @@ var BitPosCommand = class extends Command {
   }
 };
 
+// pkg/commands/client_setinfo.ts
+var ClientSetInfoCommand = class extends Command {
+  constructor([attribute, value], opts) {
+    super(["CLIENT", "SETINFO", attribute.toUpperCase(), value], opts);
+  }
+};
+
 // pkg/commands/copy.ts
 var CopyCommand = class extends Command {
   constructor([key, destinationKey, opts], commandOptions) {
@@ -556,14 +1001,6 @@ var EvalshaCommand = class extends Command {
   }
 };
 
-// pkg/commands/exec.ts
-var ExecCommand = class extends Command {
-  constructor(cmd, opts) {
-    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
-    super(normalizedCmd, opts);
-  }
-};
-
 // pkg/commands/exists.ts
 var ExistsCommand = class extends Command {
   constructor(cmd, opts) {
@@ -585,6 +1022,23 @@ 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) {
@@ -607,6 +1061,85 @@ 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) {
@@ -953,7 +1486,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize2(result) {
+function deserialize4(result) {
   if (result.length === 0) {
     return null;
   }
@@ -970,15 +1503,72 @@ function deserialize2(result) {
   }
   return obj;
 }
-var HGetAllCommand = class extends Command {
-  constructor(cmd, opts) {
-    super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize2(result),
+var HGetAllCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["hgetall", ...cmd], {
+      deserialize: (result) => deserialize4(result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/hmget.ts
+function deserialize5(fields, result) {
+  if (result.every((field) => field === null)) {
+    return null;
+  }
+  const obj = {};
+  for (const [i, field] of fields.entries()) {
+    try {
+      obj[field] = JSON.parse(result[i]);
+    } catch {
+      obj[field] = result[i];
+    }
+  }
+  return obj;
+}
+var HMGetCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hmget", key, ...fields], {
+      deserialize: (result) => deserialize5(fields, result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/hgetdel.ts
+var HGetDelCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hgetdel", key, "FIELDS", fields.length, ...fields], {
+      deserialize: (result) => deserialize5(fields.map(String), result),
       ...opts
     });
   }
 };
 
+// pkg/commands/hgetex.ts
+var HGetExCommand = class extends Command {
+  constructor([key, opts, ...fields], cmdOpts) {
+    const command = ["hgetex", key];
+    if ("ex" in opts && typeof opts.ex === "number") {
+      command.push("EX", opts.ex);
+    } else if ("px" in opts && typeof opts.px === "number") {
+      command.push("PX", opts.px);
+    } else if ("exat" in opts && typeof opts.exat === "number") {
+      command.push("EXAT", opts.exat);
+    } else if ("pxat" in opts && typeof opts.pxat === "number") {
+      command.push("PXAT", opts.pxat);
+    } else if ("persist" in opts && opts.persist) {
+      command.push("PERSIST");
+    }
+    command.push("FIELDS", fields.length, ...fields);
+    super(command, {
+      deserialize: (result) => deserialize5(fields.map(String), result),
+      ...cmdOpts
+    });
+  }
+};
+
 // pkg/commands/hincrby.ts
 var HIncrByCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1007,30 +1597,6 @@ var HLenCommand = class extends Command {
   }
 };
 
-// pkg/commands/hmget.ts
-function deserialize3(fields, result) {
-  if (result.every((field) => field === null)) {
-    return null;
-  }
-  const obj = {};
-  for (const [i, field] of fields.entries()) {
-    try {
-      obj[field] = JSON.parse(result[i]);
-    } catch {
-      obj[field] = result[i];
-    }
-  }
-  return obj;
-}
-var HMGetCommand = class extends Command {
-  constructor([key, ...fields], opts) {
-    super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize3(fields, result),
-      ...opts
-    });
-  }
-};
-
 // pkg/commands/hmset.ts
 var HMSetCommand = class extends Command {
   constructor([key, kv], opts) {
@@ -1062,6 +1628,35 @@ var HSetCommand = class extends Command {
   }
 };
 
+// pkg/commands/hsetex.ts
+var HSetExCommand = class extends Command {
+  constructor([key, opts, kv], cmdOpts) {
+    const command = ["hsetex", key];
+    if (opts.conditional) {
+      command.push(opts.conditional.toUpperCase());
+    }
+    if (opts.expiration) {
+      if ("ex" in opts.expiration && typeof opts.expiration.ex === "number") {
+        command.push("EX", opts.expiration.ex);
+      } else if ("px" in opts.expiration && typeof opts.expiration.px === "number") {
+        command.push("PX", opts.expiration.px);
+      } else if ("exat" in opts.expiration && typeof opts.expiration.exat === "number") {
+        command.push("EXAT", opts.expiration.exat);
+      } else if ("pxat" in opts.expiration && typeof opts.expiration.pxat === "number") {
+        command.push("PXAT", opts.expiration.pxat);
+      } else if ("keepttl" in opts.expiration && opts.expiration.keepttl) {
+        command.push("KEEPTTL");
+      }
+    }
+    const entries = Object.entries(kv);
+    command.push("FIELDS", entries.length);
+    for (const [field, value] of entries) {
+      command.push(field, value);
+    }
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/hsetnx.ts
 var HSetNXCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1845,6 +2440,16 @@ var XAckCommand = class extends Command {
   }
 };
 
+// pkg/commands/xackdel.ts
+var XAckDelCommand = class extends Command {
+  constructor([key, group, opts, ...ids], cmdOpts) {
+    const command = ["XACKDEL", key, group];
+    command.push(opts.toUpperCase());
+    command.push("IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/xadd.ts
 var XAddCommand = class extends Command {
   constructor([key, id, entries, opts], commandOptions) {
@@ -1917,6 +2522,18 @@ var XDelCommand = class extends Command {
   }
 };
 
+// pkg/commands/xdelex.ts
+var XDelExCommand = class extends Command {
+  constructor([key, opts, ...ids], cmdOpts) {
+    const command = ["XDELEX", key];
+    if (opts) {
+      command.push(opts.toUpperCase());
+    }
+    command.push("IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/xgroup.ts
 var XGroupCommand = class extends Command {
   constructor([key, opts], commandOptions) {
@@ -2002,7 +2619,7 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize4(result) {
+function deserialize6(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2031,7 +2648,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize4(result),
+      deserialize: (result) => deserialize6(result),
       ...opts
     });
   }
@@ -2094,12 +2711,12 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize5(result),
+      deserialize: (result) => deserialize7(result),
       ...opts
     });
   }
 };
-function deserialize5(result) {
+function deserialize7(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2481,6 +3098,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => this.chain(new BitPosCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/client-setinfo
+   */
+  clientSetinfo = (...args) => this.chain(new ClientSetInfoCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/copy
    */
@@ -2645,6 +3266,14 @@ var Pipeline = class {
    * @see https://redis.io/commands/hgetall
    */
   hgetall = (...args) => this.chain(new HGetAllCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hgetdel
+   */
+  hgetdel = (...args) => this.chain(new HGetDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hgetex
+   */
+  hgetex = (...args) => this.chain(new HGetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hincrby
    */
@@ -2681,6 +3310,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/hset
    */
   hset = (key, kv) => this.chain(new HSetCommand([key, kv], this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hsetex
+   */
+  hsetex = (...args) => this.chain(new HSetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hsetnx
    */
@@ -2985,10 +3618,18 @@ var Pipeline = class {
    * @see https://redis.io/commands/xack
    */
   xack = (...args) => this.chain(new XAckCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xackdel
+   */
+  xackdel = (...args) => this.chain(new XAckDelCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/xdel
    */
   xdel = (...args) => this.chain(new XDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xdelex
+   */
+  xdelex = (...args) => this.chain(new XDelExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/xgroup
    */
@@ -3208,364 +3849,139 @@ var Pipeline = class {
       type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
     };
   }
-};
-
-// pkg/auto-pipeline.ts
-var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
-  "scan",
-  "keys",
-  "flushdb",
-  "flushall",
-  "dbsize",
-  "hscan",
-  "hgetall",
-  "hkeys",
-  "lrange",
-  "sscan",
-  "smembers",
-  "xrange",
-  "xrevrange",
-  "zscan",
-  "zrange",
-  "exec"
-]);
-function createAutoPipelineProxy(_redis, json) {
-  const redis = _redis;
-  if (!redis.autoPipelineExecutor) {
-    redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
-  }
-  return new Proxy(redis, {
-    get: (redis2, command) => {
-      if (command === "pipelineCounter") {
-        return redis2.autoPipelineExecutor.pipelineCounter;
-      }
-      if (command === "json") {
-        return createAutoPipelineProxy(redis2, true);
-      }
-      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-      if (commandInRedisButNotPipeline || isCommandExcluded) {
-        return redis2[command];
-      }
-      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
-      if (isFunction) {
-        return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
-            if (json) {
-              pipeline.json[command](
-                ...args
-              );
-            } else {
-              pipeline[command](...args);
-            }
-          });
-        };
-      }
-      return redis2.autoPipelineExecutor.pipeline[command];
-    }
-  });
-}
-var AutoPipelineExecutor = class {
-  pipelinePromises = /* @__PURE__ */ new WeakMap();
-  activePipeline = null;
-  indexInCurrentPipeline = 0;
-  redis;
-  pipeline;
-  // only to make sure that proxy can work
-  pipelineCounter = 0;
-  // to keep track of how many times a pipeline was executed
-  constructor(redis) {
-    this.redis = redis;
-    this.pipeline = redis.pipeline();
-  }
-  async withAutoPipeline(executeWithPipeline) {
-    const pipeline = this.activePipeline ?? this.redis.pipeline();
-    if (!this.activePipeline) {
-      this.activePipeline = pipeline;
-      this.indexInCurrentPipeline = 0;
-    }
-    const index = this.indexInCurrentPipeline++;
-    executeWithPipeline(pipeline);
-    const pipelineDone = this.deferExecution().then(() => {
-      if (!this.pipelinePromises.has(pipeline)) {
-        const pipelinePromise = pipeline.exec({ keepErrors: true });
-        this.pipelineCounter += 1;
-        this.pipelinePromises.set(pipeline, pipelinePromise);
-        this.activePipeline = null;
-      }
-      return this.pipelinePromises.get(pipeline);
-    });
-    const results = await pipelineDone;
-    const commandResult = results[index];
-    if (commandResult.error) {
-      throw new UpstashError(`Command failed: ${commandResult.error}`);
-    }
-    return commandResult.result;
-  }
-  async deferExecution() {
-    await Promise.resolve();
-    await Promise.resolve();
-  }
-};
-
-// 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;
+  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
+var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
+  "scan",
+  "keys",
+  "flushdb",
+  "flushall",
+  "dbsize",
+  "hscan",
+  "hgetall",
+  "hkeys",
+  "lrange",
+  "sscan",
+  "smembers",
+  "xrange",
+  "xrevrange",
+  "zscan",
+  "zrange",
+  "exec"
+]);
+function createAutoPipelineProxy(_redis, namespace = "root") {
+  const redis = _redis;
+  if (!redis.autoPipelineExecutor) {
+    redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
+  }
+  return new Proxy(redis, {
+    get: (redis2, command) => {
+      if (command === "pipelineCounter") {
+        return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      case "prefixes": {
-        description["prefixes"] = rawResponse[i + 1];
-        break;
+      if (namespace === "root" && command === "json") {
+        return createAutoPipelineProxy(redis2, "json");
       }
-      case "language": {
-        description["language"] = rawResponse[i + 1];
-        break;
+      if (namespace === "root" && command === "functions") {
+        return createAutoPipelineProxy(redis2, "functions");
       }
-      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;
+      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];
         }
-        description["schema"] = schema;
-        break;
       }
+      const pipeline = redis2.autoPipelineExecutor.pipeline;
+      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
+      const isFunction = typeof targetFunction === "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 targetFunction;
     }
-  }
-  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("SORTBY");
-    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(
-      "RETURN",
-      Object.keys(options.select).length.toString(),
-      ...Object.keys(options.select)
-    );
+var AutoPipelineExecutor = class {
+  pipelinePromises = /* @__PURE__ */ new WeakMap();
+  activePipeline = null;
+  indexInCurrentPipeline = 0;
+  redis;
+  pipeline;
+  // only to make sure that proxy can work
+  pipelineCounter = 0;
+  // to keep track of how many times a pipeline was executed
+  constructor(redis) {
+    this.redis = redis;
+    this.pipeline = redis.pipeline();
   }
-  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");
+  async withAutoPipeline(executeWithPipeline) {
+    const pipeline = this.activePipeline ?? this.redis.pipeline();
+    if (!this.activePipeline) {
+      this.activePipeline = pipeline;
+      this.indexInCurrentPipeline = 0;
     }
-    if (field.from) {
-      payload.push("FROM", field.from);
+    const index = this.indexInCurrentPipeline++;
+    executeWithPipeline(pipeline);
+    const pipelineDone = this.deferExecution().then(() => {
+      if (!this.pipelinePromises.has(pipeline)) {
+        const pipelinePromise = pipeline.exec({ keepErrors: true });
+        this.pipelineCounter += 1;
+        this.pipelinePromises.set(pipeline, pipelinePromise);
+        this.activePipeline = null;
+      }
+      return this.pipelinePromises.get(pipeline);
+    });
+    const results = await pipelineDone;
+    const commandResult = results[index];
+    if (commandResult.error) {
+      throw new UpstashError(`Command failed: ${commandResult.error}`);
     }
+    return commandResult.result;
   }
-  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 deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
   }
 };
-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 {
@@ -4012,6 +4428,40 @@ 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.
    */
@@ -4069,6 +4519,17 @@ var Redis = class {
       },
       index: (params) => {
         return initIndex(this.client, params);
+      },
+      alias: {
+        list: () => {
+          return listAliases(this.client);
+        },
+        add: ({ indexName, alias }) => {
+          return addAlias(this.client, { indexName, alias });
+        },
+        delete: ({ alias }) => {
+          return delAlias(this.client, { alias });
+        }
       }
     };
   }
@@ -4133,6 +4594,10 @@ var Redis = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => new BitPosCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/client-setinfo
+   */
+  clientSetinfo = (...args) => new ClientSetInfoCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/copy
    */
@@ -4297,6 +4762,14 @@ var Redis = class {
    * @see https://redis.io/commands/hgetall
    */
   hgetall = (...args) => new HGetAllCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hgetdel
+   */
+  hgetdel = (...args) => new HGetDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hgetex
+   */
+  hgetex = (...args) => new HGetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hincrby
    */
@@ -4333,6 +4806,10 @@ var Redis = class {
    * @see https://redis.io/commands/hset
    */
   hset = (key, kv) => new HSetCommand([key, kv], this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hsetex
+   */
+  hsetex = (...args) => new HSetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hsetnx
    */
@@ -4634,10 +5111,18 @@ var Redis = class {
    * @see https://redis.io/commands/xack
    */
   xack = (...args) => new XAckCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xackdel
+   */
+  xackdel = (...args) => new XAckDelCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/xdel
    */
   xdel = (...args) => new XDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xdelex
+   */
+  xdelex = (...args) => new XDelExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/xgroup
    */
@@ -4779,11 +5264,12 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.37.0-rc";
+var VERSION = "v1.37.0-rc.10";
 
 export {
   error_exports,
   HttpClient,
+  SearchIndex,
   Redis,
   VERSION
 };