@upstash/redis 1.36.0-rc.7 → 1.36.1

package/{chunk-YYS6F6RP.mjs → chunk-LLI2WIYN.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,362 +393,6 @@ 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"];
-
-// 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
-      });
-    } 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("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)
-    );
-  }
-  return command;
-}
-function buildCreateIndexCommand(props) {
-  const { name, schema, dataType, prefix, language } = props;
-  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
-  const payload = [
-    name,
-    "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");
-    }
-  }
-  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];
-    const result = await new ExecCommand(command).exec(
-      this.client
-    );
-    return result;
-  }
-  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(props) {
-  const { name, schema, client } = props;
-  const createIndexCommand = buildCreateIndexCommand(props);
-  await new ExecCommand(createIndexCommand).exec(client);
-  return index(client, name, schema);
-}
-function index(client, name, schema) {
-  return new SearchIndex({ name, schema, client });
-}
-
-// pkg/commands/search/schema-builder.ts
-var BUILD = Symbol("build");
-var TextFieldBuilder = class _TextFieldBuilder {
-  _noTokenize;
-  _noStem;
-  constructor(noTokenize = { noTokenize: false }, noStem = { noStem: false }) {
-    this._noTokenize = noTokenize;
-    this._noStem = noStem;
-  }
-  noTokenize() {
-    return new _TextFieldBuilder({ noTokenize: true }, this._noStem);
-  }
-  noStem() {
-    return new _TextFieldBuilder(this._noTokenize, { noStem: true });
-  }
-  [BUILD]() {
-    return this._noTokenize.noTokenize || this._noStem.noStem ? {
-      type: "TEXT",
-      ...this._noTokenize.noTokenize ? { noTokenize: true } : {},
-      ...this._noStem.noStem ? { noStem: true } : {}
-    } : "TEXT";
-  }
-};
-var NumericFieldBuilder = class {
-  type;
-  constructor(type) {
-    this.type = type;
-  }
-  [BUILD]() {
-    return {
-      type: this.type,
-      fast: true
-    };
-  }
-};
-var BoolFieldBuilder = class _BoolFieldBuilder {
-  _fast;
-  constructor(fast = { fast: false }) {
-    this._fast = fast;
-  }
-  fast() {
-    return new _BoolFieldBuilder({ fast: true });
-  }
-  [BUILD]() {
-    return this._fast.fast ? {
-      type: "BOOL",
-      fast: true
-    } : "BOOL";
-  }
-};
-var DateFieldBuilder = class _DateFieldBuilder {
-  _fast;
-  constructor(fast = { fast: false }) {
-    this._fast = fast;
-  }
-  fast() {
-    return new _DateFieldBuilder({ fast: true });
-  }
-  [BUILD]() {
-    return this._fast.fast ? {
-      type: "DATE",
-      fast: true
-    } : "DATE";
-  }
-};
-var s = {
-  string() {
-    return new TextFieldBuilder();
-  },
-  number(type = "F64") {
-    return new NumericFieldBuilder(type);
-  },
-  boolean() {
-    return new BoolFieldBuilder();
-  },
-  date() {
-    return new DateFieldBuilder();
-  },
-  object(fields) {
-    const result = {};
-    for (const [key, value] of Object.entries(fields)) {
-      if (value && typeof value === "object" && BUILD in value) {
-        result[key] = value[BUILD]();
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
-};
-
 // pkg/commands/hrandfield.ts
 function deserialize(result) {
   if (result.length === 0) {
@@ -912,6 +571,14 @@ 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) {
@@ -933,6 +600,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) {
@@ -955,6 +639,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) {
@@ -1301,7 +1064,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize2(result) {
+function deserialize4(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1321,7 +1084,7 @@ function deserialize2(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize2(result),
+      deserialize: (result) => deserialize4(result),
       ...opts
     });
   }
@@ -1356,7 +1119,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize3(fields, result) {
+function deserialize5(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -1373,7 +1136,7 @@ function deserialize3(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize3(fields, result),
+      deserialize: (result) => deserialize5(fields, result),
       ...opts
     });
   }
@@ -2350,7 +2113,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) {
@@ -2379,7 +2142,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize4(result),
+      deserialize: (result) => deserialize6(result),
       ...opts
     });
   }
@@ -2442,12 +2205,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) {
@@ -3104,7 +2867,7 @@ var Pipeline = class {
   /**
    * @see https://redis.io/commands/lset
    */
-  lset = (key, index2, value) => this.chain(new LSetCommand([key, index2, value], this.commandOptions));
+  lset = (key, index, value) => this.chain(new LSetCommand([key, index, value], this.commandOptions));
   /**
    * @see https://redis.io/commands/ltrim
    */
@@ -3556,6 +3319,38 @@ 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
@@ -3577,7 +3372,7 @@ var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
   "zrange",
   "exec"
 ]);
-function createAutoPipelineProxy(_redis, json) {
+function createAutoPipelineProxy(_redis, namespace = "root") {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -3587,29 +3382,31 @@ function createAutoPipelineProxy(_redis, json) {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (command === "json") {
-        return createAutoPipelineProxy(redis2, true);
+      if (namespace === "root" && command === "json") {
+        return createAutoPipelineProxy(redis2, "json");
       }
-      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-      if (commandInRedisButNotPipeline || isCommandExcluded) {
-        return redis2[command];
+      if (namespace === "root" && command === "functions") {
+        return createAutoPipelineProxy(redis2, "functions");
       }
-      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
+      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 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((pipeline) => {
-            if (json) {
-              pipeline.json[command](
-                ...args
-              );
-            } else {
-              pipeline[command](...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.pipeline[command];
+      return targetFunction;
     }
   });
 }
@@ -3632,7 +3429,7 @@ var AutoPipelineExecutor = class {
       this.activePipeline = pipeline;
       this.indexInCurrentPipeline = 0;
     }
-    const index2 = this.indexInCurrentPipeline++;
+    const index = this.indexInCurrentPipeline++;
     executeWithPipeline(pipeline);
     const pipelineDone = this.deferExecution().then(() => {
       if (!this.pipelinePromises.has(pipeline)) {
@@ -3644,7 +3441,7 @@ var AutoPipelineExecutor = class {
       return this.pipelinePromises.get(pipeline);
     });
     const results = await pipelineDone;
-    const commandResult = results[index2];
+    const commandResult = results[index];
     if (commandResult.error) {
       throw new UpstashError(`Command failed: ${commandResult.error}`);
     }
@@ -3901,8 +3698,8 @@ var Script = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s2) {
-    const data = new TextEncoder().encode(s2);
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
     const hashBuffer = await subtle.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -3965,8 +3762,8 @@ var ScriptRO = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s2) {
-    const data = new TextEncoder().encode(s2);
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
     const hashBuffer = await subtle2.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -4101,6 +3898,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.
    */
@@ -4151,19 +3982,6 @@ var Redis = class {
   createScript(script, opts) {
     return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
-  get search() {
-    return {
-      createIndex: (props) => {
-        return createIndex({
-          ...props,
-          client: this.client
-        });
-      },
-      index: (name, schema) => {
-        return index(this.client, name, schema);
-      }
-    };
-  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4500,7 +4318,7 @@ var Redis = class {
   /**
    * @see https://redis.io/commands/lset
    */
-  lset = (key, index2, value) => new LSetCommand([key, index2, value], this.opts).exec(this.client);
+  lset = (key, index, value) => new LSetCommand([key, index, value], this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/ltrim
    */
@@ -4871,14 +4689,11 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.0-rc.7";
+var VERSION = "v1.36.1";
 
 export {
   error_exports,
   HttpClient,
-  createIndex,
-  index,
-  s,
   Redis,
   VERSION
 };