orcaq 1.0.33 → 1.1.2

package/.output/server/node_modules/@redis/search/dist/lib/commands/CURSOR_READ.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AGGREGATE_WITHCURSOR_1 = __importDefault(require("./AGGREGATE_WITHCURSOR"));
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Reads from an existing cursor to get more results from an index.
+     * @param parser - The command parser
+     * @param index - The index name that contains the cursor
+     * @param cursor - The cursor ID to read from
+     * @param options - Optional parameters:
+     *   - COUNT: Maximum number of results to return
+     */
+    parseCommand(parser, index, cursor, options) {
+        parser.push('FT.CURSOR', 'READ', index, cursor.toString());
+        if (options?.COUNT !== undefined) {
+            parser.push('COUNT', options.COUNT.toString());
+        }
+    },
+    transformReply: AGGREGATE_WITHCURSOR_1.default.transformReply,
+    unstableResp3: true
+};
+//# sourceMappingURL=CURSOR_READ.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/DICTADD.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Adds terms to a dictionary.
+     * @param parser - The command parser
+     * @param dictionary - Name of the dictionary to add terms to
+     * @param term - One or more terms to add to the dictionary
+     */
+    parseCommand(parser, dictionary, term) {
+        parser.push('FT.DICTADD', dictionary);
+        parser.pushVariadic(term);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DICTADD.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/DICTDEL.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Deletes terms from a dictionary.
+     * @param parser - The command parser
+     * @param dictionary - Name of the dictionary to remove terms from
+     * @param term - One or more terms to delete from the dictionary
+     */
+    parseCommand(parser, dictionary, term) {
+        parser.push('FT.DICTDEL', dictionary);
+        parser.pushVariadic(term);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DICTDEL.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/DICTDUMP.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns all terms in a dictionary.
+     * @param parser - The command parser
+     * @param dictionary - Name of the dictionary to dump
+     */
+    parseCommand(parser, dictionary) {
+        parser.push('FT.DICTDUMP', dictionary);
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=DICTDUMP.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/DROPINDEX.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Deletes an index and all associated documents.
+     * @param parser - The command parser
+     * @param index - Name of the index to delete
+     * @param options - Optional parameters:
+     *   - DD: Also delete the indexed documents themselves
+     */
+    parseCommand(parser, index, options) {
+        parser.push('FT.DROPINDEX', index);
+        if (options?.DD) {
+            parser.push('DD');
+        }
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=DROPINDEX.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/EXPLAIN.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SEARCH_1 = require("./SEARCH");
+const default_1 = require("../dialect/default");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the execution plan for a complex query.
+     * @param parser - The command parser
+     * @param index - Name of the index to explain query against
+     * @param query - The query string to explain
+     * @param options - Optional parameters:
+     *   - PARAMS: Named parameters to use in the query
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.EXPLAIN', index, query);
+        (0, SEARCH_1.parseParamsArgument)(parser, options?.PARAMS);
+        if (options?.DIALECT) {
+            parser.push('DIALECT', options.DIALECT.toString());
+        }
+        else {
+            parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=EXPLAIN.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/EXPLAINCLI.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = require("../dialect/default");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the execution plan for a complex query in a more verbose format than FT.EXPLAIN.
+     * @param parser - The command parser
+     * @param index - Name of the index to explain query against
+     * @param query - The query string to explain
+     * @param options - Optional parameters:
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.EXPLAINCLI', index, query);
+        if (options?.DIALECT) {
+            parser.push('DIALECT', options.DIALECT.toString());
+        }
+        else {
+            parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=EXPLAINCLI.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/HYBRID.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FT_HYBRID_COMBINE_METHOD = exports.FT_HYBRID_VECTOR_METHOD = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SEARCH_1 = require("./SEARCH");
+const AGGREGATE_1 = require("./AGGREGATE");
+/**
+ * Vector search method configuration - either KNN or RANGE.
+ */
+exports.FT_HYBRID_VECTOR_METHOD = {
+    /** K-Nearest Neighbors search configuration */
+    KNN: "KNN",
+    /** Range-based vector search configuration */
+    RANGE: "RANGE",
+};
+/**
+ * Score fusion method type constants for combining search results.
+ */
+exports.FT_HYBRID_COMBINE_METHOD = {
+    /** Reciprocal Rank Fusion */
+    RRF: "RRF",
+    /** Linear combination with ALPHA and BETA weights */
+    LINEAR: "LINEAR",
+};
+function parseSearchExpression(parser, search) {
+    parser.push("SEARCH", search.query);
+    if (search.SCORER) {
+        parser.push("SCORER", search.SCORER);
+    }
+    if (search.YIELD_SCORE_AS) {
+        parser.push("YIELD_SCORE_AS", search.YIELD_SCORE_AS);
+    }
+}
+function parseVectorExpression(parser, vsim) {
+    parser.push("VSIM", vsim.field, vsim.vector);
+    if (vsim.method) {
+        if (vsim.method.type === exports.FT_HYBRID_VECTOR_METHOD.KNN) {
+            let argsCount = 2;
+            if (vsim.method.EF_RUNTIME !== undefined) {
+                argsCount += 2;
+            }
+            parser.push("KNN", argsCount.toString(), "K", vsim.method.K.toString());
+            if (vsim.method.EF_RUNTIME !== undefined) {
+                parser.push("EF_RUNTIME", vsim.method.EF_RUNTIME.toString());
+            }
+        }
+        if (vsim.method.type === exports.FT_HYBRID_VECTOR_METHOD.RANGE) {
+            let argsCount = 2;
+            if (vsim.method.EPSILON !== undefined) {
+                argsCount += 2;
+            }
+            parser.push("RANGE", argsCount.toString(), "RADIUS", vsim.method.RADIUS.toString());
+            if (vsim.method.EPSILON !== undefined) {
+                parser.push("EPSILON", vsim.method.EPSILON.toString());
+            }
+        }
+    }
+    if (vsim.FILTER) {
+        parser.push("FILTER", vsim.FILTER);
+    }
+    if (vsim.YIELD_SCORE_AS) {
+        parser.push("YIELD_SCORE_AS", vsim.YIELD_SCORE_AS);
+    }
+}
+function parseCombineMethod(parser, combine) {
+    if (!combine)
+        return;
+    parser.push("COMBINE");
+    if (combine.method.type === exports.FT_HYBRID_COMBINE_METHOD.RRF) {
+        // Calculate argsCount: 2 per optional (WINDOW, CONSTANT, YIELD_SCORE_AS)
+        let argsCount = 0;
+        if (combine.method.WINDOW !== undefined) {
+            argsCount += 2;
+        }
+        if (combine.method.CONSTANT !== undefined) {
+            argsCount += 2;
+        }
+        if (combine.YIELD_SCORE_AS) {
+            argsCount += 2;
+        }
+        parser.push("RRF", argsCount.toString());
+        if (combine.method.WINDOW !== undefined) {
+            parser.push("WINDOW", combine.method.WINDOW.toString());
+        }
+        if (combine.method.CONSTANT !== undefined) {
+            parser.push("CONSTANT", combine.method.CONSTANT.toString());
+        }
+    }
+    if (combine.method.type === exports.FT_HYBRID_COMBINE_METHOD.LINEAR) {
+        // Calculate argsCount: 2 per optional (ALPHA, BETA, WINDOW, YIELD_SCORE_AS)
+        let argsCount = 0;
+        if (combine.method.ALPHA !== undefined) {
+            argsCount += 2;
+        }
+        if (combine.method.BETA !== undefined) {
+            argsCount += 2;
+        }
+        if (combine.method.WINDOW !== undefined) {
+            argsCount += 2;
+        }
+        if (combine.YIELD_SCORE_AS) {
+            argsCount += 2;
+        }
+        parser.push("LINEAR", argsCount.toString());
+        if (combine.method.ALPHA !== undefined) {
+            parser.push("ALPHA", combine.method.ALPHA.toString());
+        }
+        if (combine.method.BETA !== undefined) {
+            parser.push("BETA", combine.method.BETA.toString());
+        }
+        if (combine.method.WINDOW !== undefined) {
+            parser.push("WINDOW", combine.method.WINDOW.toString());
+        }
+    }
+    if (combine.YIELD_SCORE_AS) {
+        parser.push("YIELD_SCORE_AS", combine.YIELD_SCORE_AS);
+    }
+}
+function parseApply(parser, apply) {
+    parser.push("APPLY", apply.expression);
+    if (apply.AS) {
+        parser.push("AS", apply.AS);
+    }
+}
+function parseHybridOptions(parser, options) {
+    parseSearchExpression(parser, options.SEARCH);
+    parseVectorExpression(parser, options.VSIM);
+    if (options.COMBINE) {
+        parseCombineMethod(parser, options.COMBINE);
+    }
+    if (options.LOAD) {
+        if (options.LOAD === "*") {
+            parser.push("LOAD", "*");
+        }
+        else {
+            (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, "LOAD", options.LOAD);
+        }
+    }
+    if (options.GROUPBY) {
+        (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, "GROUPBY", options.GROUPBY.fields);
+        if (options.GROUPBY.REDUCE) {
+            const reducers = Array.isArray(options.GROUPBY.REDUCE)
+                ? options.GROUPBY.REDUCE
+                : [options.GROUPBY.REDUCE];
+            for (const reducer of reducers) {
+                (0, AGGREGATE_1.parseGroupByReducer)(parser, reducer);
+            }
+        }
+    }
+    if (options.APPLY) {
+        const applies = Array.isArray(options.APPLY)
+            ? options.APPLY
+            : [options.APPLY];
+        for (const apply of applies) {
+            parseApply(parser, apply);
+        }
+    }
+    if (options.SORTBY) {
+        const sortByArgsCount = options.SORTBY.fields.reduce((acc, field) => {
+            if (field.direction) {
+                return acc + 2;
+            }
+            return acc + 1;
+        }, 0);
+        parser.push("SORTBY", sortByArgsCount.toString());
+        for (const sortField of options.SORTBY.fields) {
+            parser.push(sortField.field);
+            if (sortField.direction) {
+                parser.push(sortField.direction);
+            }
+        }
+    }
+    if (options.NOSORT) {
+        parser.push("NOSORT");
+    }
+    if (options.FILTER) {
+        parser.push("FILTER", options.FILTER);
+    }
+    if (options.LIMIT) {
+        parser.push("LIMIT", options.LIMIT.offset.toString(), options.LIMIT.count.toString());
+    }
+    const hasParams = options.PARAMS && Object.keys(options.PARAMS).length > 0;
+    (0, SEARCH_1.parseParamsArgument)(parser, hasParams ? options.PARAMS : undefined);
+    if (options.TIMEOUT !== undefined) {
+        parser.push("TIMEOUT", options.TIMEOUT.toString());
+    }
+}
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Performs a hybrid search combining multiple search expressions.
+     * Supports multiple SEARCH and VECTOR expressions with various fusion methods.
+     *
+     * @experimental
+     * NOTE: FT.Hybrid is still in experimental state
+     * It's behaviour and function signature may change
+     *
+     * @param parser - The command parser
+     * @param index - The index name to search
+     * @param options - Hybrid search options including:
+     *   - SEARCH: Text search expression with optional scoring
+     *   - VSIM: Vector similarity expression with KNN/RANGE methods
+     *   - COMBINE: Fusion method (RRF, LINEAR)
+     *   - Post-processing operations: LOAD, GROUPBY, APPLY, SORTBY, FILTER
+     *   - Tunable options: LIMIT, PARAMS, TIMEOUT
+     */
+    parseCommand(parser, index, options) {
+        parser.push("FT.HYBRID", index);
+        parseHybridOptions(parser, options);
+    },
+    transformReply: {
+        2: (reply) => {
+            return transformHybridSearchResults(reply);
+        },
+        3: undefined,
+    },
+    unstableResp3: true,
+};
+function transformHybridSearchResults(reply) {
+    // FT.HYBRID returns a map-like structure as flat array:
+    // ['total_results', N, 'results', [...], 'warnings', [...], 'execution_time', 'X.XXX']
+    const replyMap = parseReplyMap(reply);
+    const totalResults = replyMap["total_results"] ?? 0;
+    const rawResults = replyMap["results"] ?? [];
+    const warnings = replyMap["warnings"] ?? [];
+    const executionTime = replyMap["execution_time"]
+        ? Number.parseFloat(replyMap["execution_time"])
+        : 0;
+    const results = [];
+    for (const result of rawResults) {
+        // Each result is a flat key-value array like FT.AGGREGATE: ['field1', 'value1', 'field2', 'value2', ...]
+        const resultMap = parseReplyMap(result);
+        const doc = Object.create(null);
+        // Add all other fields from the result
+        for (const [key, value] of Object.entries(resultMap)) {
+            if (key === "$") {
+                // JSON document - parse and merge
+                try {
+                    Object.assign(doc, JSON.parse(value));
+                }
+                catch {
+                    doc[key] = value;
+                }
+            }
+            else {
+                doc[key] = value;
+            }
+        }
+        results.push(doc);
+    }
+    return {
+        totalResults,
+        executionTime,
+        warnings,
+        results,
+    };
+}
+function parseReplyMap(reply) {
+    const map = {};
+    if (!Array.isArray(reply)) {
+        return map;
+    }
+    for (let i = 0; i < reply.length; i += 2) {
+        const key = reply[i];
+        const value = reply[i + 1];
+        if (typeof key === "string") {
+            map[key] = value;
+        }
+    }
+    return map;
+}
+//# sourceMappingURL=HYBRID.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/INFO.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns information and statistics about an index.
+     * @param parser - The command parser
+     * @param index - Name of the index to get information about
+     */
+    parseCommand(parser, index) {
+        parser.push('FT.INFO', index);
+    },
+    transformReply: {
+        2: transformV2Reply,
+        3: undefined
+    },
+    unstableResp3: true
+};
+function transformV2Reply(reply, preserve, typeMapping) {
+    const myTransformFunc = (0, generic_transformers_1.createTransformTuplesReplyFunc)(preserve, typeMapping);
+    const ret = {};
+    for (let i = 0; i < reply.length; i += 2) {
+        const key = reply[i].toString();
+        switch (key) {
+            case 'index_name':
+            case 'index_options':
+            case 'num_docs':
+            case 'max_doc_id':
+            case 'num_terms':
+            case 'num_records':
+            case 'total_inverted_index_blocks':
+            case 'hash_indexing_failures':
+            case 'indexing':
+            case 'number_of_uses':
+            case 'cleaning':
+            case 'stopwords_list':
+                ret[key] = reply[i + 1];
+                break;
+            case 'inverted_sz_mb':
+            case 'vector_index_sz_mb':
+            case 'offset_vectors_sz_mb':
+            case 'doc_table_size_mb':
+            case 'sortable_values_size_mb':
+            case 'key_table_size_mb':
+            case 'text_overhead_sz_mb':
+            case 'tag_overhead_sz_mb':
+            case 'total_index_memory_sz_mb':
+            case 'geoshapes_sz_mb':
+            case 'records_per_doc_avg':
+            case 'bytes_per_record_avg':
+            case 'offsets_per_term_avg':
+            case 'offset_bits_per_record_avg':
+            case 'total_indexing_time':
+            case 'percent_indexed':
+                ret[key] = generic_transformers_1.transformDoubleReply[2](reply[i + 1], undefined, typeMapping);
+                break;
+            case 'index_definition':
+                ret[key] = myTransformFunc(reply[i + 1]);
+                break;
+            case 'attributes':
+                ret[key] = reply[i + 1].map(attribute => myTransformFunc(attribute));
+                break;
+            case 'gc_stats': {
+                const innerRet = {};
+                const array = reply[i + 1];
+                for (let i = 0; i < array.length; i += 2) {
+                    const innerKey = array[i].toString();
+                    switch (innerKey) {
+                        case 'bytes_collected':
+                        case 'total_ms_run':
+                        case 'total_cycles':
+                        case 'average_cycle_time_ms':
+                        case 'last_run_time_ms':
+                        case 'gc_numeric_trees_missed':
+                        case 'gc_blocks_denied':
+                            innerRet[innerKey] = generic_transformers_1.transformDoubleReply[2](array[i + 1], undefined, typeMapping);
+                            break;
+                    }
+                }
+                ret[key] = innerRet;
+                break;
+            }
+            case 'cursor_stats': {
+                const innerRet = {};
+                const array = reply[i + 1];
+                for (let i = 0; i < array.length; i += 2) {
+                    const innerKey = array[i].toString();
+                    switch (innerKey) {
+                        case 'global_idle':
+                        case 'global_total':
+                        case 'index_capacity':
+                        case 'index_total':
+                            innerRet[innerKey] = array[i + 1];
+                            break;
+                    }
+                }
+                ret[key] = innerRet;
+                break;
+            }
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=INFO.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/PROFILE_AGGREGATE.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AGGREGATE_1 = __importStar(require("./AGGREGATE"));
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Profiles the execution of an aggregation query for performance analysis.
+     * @param parser - The command parser
+     * @param index - Name of the index to profile query against
+     * @param query - The aggregation query to profile
+     * @param options - Optional parameters:
+     *   - LIMITED: Collect limited timing information only
+     *   - All options supported by FT.AGGREGATE command
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.PROFILE', index, 'AGGREGATE');
+        if (options?.LIMITED) {
+            parser.push('LIMITED');
+        }
+        parser.push('QUERY', query);
+        (0, AGGREGATE_1.parseAggregateOptions)(parser, options);
+    },
+    transformReply: {
+        2: (reply) => {
+            return {
+                results: AGGREGATE_1.default.transformReply[2](reply[0]),
+                profile: reply[1]
+            };
+        },
+        3: (reply) => reply
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=PROFILE_AGGREGATE.js.map

package/.output/server/node_modules/@redis/search/dist/lib/commands/PROFILE_SEARCH.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SEARCH_1 = __importStar(require("./SEARCH"));
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Profiles the execution of a search query for performance analysis.
+     * @param parser - The command parser
+     * @param index - Name of the index to profile query against
+     * @param query - The search query to profile
+     * @param options - Optional parameters:
+     *   - LIMITED: Collect limited timing information only
+     *   - All options supported by FT.SEARCH command
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.PROFILE', index, 'SEARCH');
+        if (options?.LIMITED) {
+            parser.push('LIMITED');
+        }
+        parser.push('QUERY', query);
+        (0, SEARCH_1.parseSearchOptions)(parser, options);
+    },
+    transformReply: {
+        2: (reply) => {
+            return {
+                results: SEARCH_1.default.transformReply[2](reply[0]),
+                profile: reply[1]
+            };
+        },
+        3: (reply) => reply
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=PROFILE_SEARCH.js.map