orcaq 1.1.1 → 1.1.2

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGroupByReducer = exports.parseAggregateOptions = exports.FT_AGGREGATE_GROUP_BY_REDUCERS = exports.FT_AGGREGATE_STEPS = void 0;
+const SEARCH_1 = require("./SEARCH");
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const default_1 = require("../dialect/default");
+exports.FT_AGGREGATE_STEPS = {
+    GROUPBY: 'GROUPBY',
+    SORTBY: 'SORTBY',
+    APPLY: 'APPLY',
+    LIMIT: 'LIMIT',
+    FILTER: 'FILTER'
+};
+exports.FT_AGGREGATE_GROUP_BY_REDUCERS = {
+    COUNT: 'COUNT',
+    COUNT_DISTINCT: 'COUNT_DISTINCT',
+    COUNT_DISTINCTISH: 'COUNT_DISTINCTISH',
+    SUM: 'SUM',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    AVG: 'AVG',
+    STDDEV: 'STDDEV',
+    QUANTILE: 'QUANTILE',
+    TOLIST: 'TOLIST',
+    FIRST_VALUE: 'FIRST_VALUE',
+    RANDOM_SAMPLE: 'RANDOM_SAMPLE'
+};
+;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: false,
+    /**
+     * Performs an aggregation query on a RediSearch index.
+     * @param parser - The command parser
+     * @param index - The index name to query
+     * @param query - The text query to use as filter, use * to indicate no filtering
+     * @param options - Optional parameters for aggregation:
+     *   - VERBATIM: disable stemming in query evaluation
+     *   - LOAD: specify fields to load from documents
+     *   - STEPS: sequence of aggregation steps (GROUPBY, SORTBY, APPLY, LIMIT, FILTER)
+     *   - PARAMS: bind parameters for query evaluation
+     *   - TIMEOUT: maximum time to run the query
+     */
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.AGGREGATE', index, query);
+        return parseAggregateOptions(parser, options);
+    },
+    transformReply: {
+        2: (rawReply, preserve, typeMapping) => {
+            const results = [];
+            for (let i = 1; i < rawReply.length; i++) {
+                results.push((0, generic_transformers_1.transformTuplesReply)(rawReply[i], preserve, typeMapping));
+            }
+            return {
+                //  https://redis.io/docs/latest/commands/ft.aggregate/#return
+                //  FT.AGGREGATE returns an array reply where each row is an array reply and represents a single aggregate result.
+                // The integer reply at position 1 does not represent a valid value.
+                total: Number(rawReply[0]),
+                results
+            };
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+function parseAggregateOptions(parser, options) {
+    if (options?.VERBATIM) {
+        parser.push('VERBATIM');
+    }
+    if (options?.ADDSCORES) {
+        parser.push('ADDSCORES');
+    }
+    if (options?.LOAD) {
+        const args = [];
+        if (Array.isArray(options.LOAD)) {
+            for (const load of options.LOAD) {
+                pushLoadField(args, load);
+            }
+        }
+        else {
+            pushLoadField(args, options.LOAD);
+        }
+        parser.push('LOAD');
+        parser.pushVariadicWithLength(args);
+    }
+    if (options?.TIMEOUT !== undefined) {
+        parser.push('TIMEOUT', options.TIMEOUT.toString());
+    }
+    if (options?.STEPS) {
+        for (const step of options.STEPS) {
+            parser.push(step.type);
+            switch (step.type) {
+                case exports.FT_AGGREGATE_STEPS.GROUPBY:
+                    if (!step.properties) {
+                        parser.push('0');
+                    }
+                    else {
+                        parser.pushVariadicWithLength(step.properties);
+                    }
+                    if (Array.isArray(step.REDUCE)) {
+                        for (const reducer of step.REDUCE) {
+                            parseGroupByReducer(parser, reducer);
+                        }
+                    }
+                    else {
+                        parseGroupByReducer(parser, step.REDUCE);
+                    }
+                    break;
+                case exports.FT_AGGREGATE_STEPS.SORTBY:
+                    const args = [];
+                    if (Array.isArray(step.BY)) {
+                        for (const by of step.BY) {
+                            pushSortByProperty(args, by);
+                        }
+                    }
+                    else {
+                        pushSortByProperty(args, step.BY);
+                    }
+                    if (step.MAX) {
+                        args.push('MAX', step.MAX.toString());
+                    }
+                    parser.pushVariadicWithLength(args);
+                    break;
+                case exports.FT_AGGREGATE_STEPS.APPLY:
+                    parser.push(step.expression, 'AS', step.AS);
+                    break;
+                case exports.FT_AGGREGATE_STEPS.LIMIT:
+                    parser.push(step.from.toString(), step.size.toString());
+                    break;
+                case exports.FT_AGGREGATE_STEPS.FILTER:
+                    parser.push(step.expression);
+                    break;
+            }
+        }
+    }
+    (0, SEARCH_1.parseParamsArgument)(parser, options?.PARAMS);
+    if (options?.DIALECT) {
+        parser.push('DIALECT', options.DIALECT.toString());
+    }
+    else {
+        parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+    }
+}
+exports.parseAggregateOptions = parseAggregateOptions;
+function pushLoadField(args, toLoad) {
+    if (typeof toLoad === 'string' || toLoad instanceof Buffer) {
+        args.push(toLoad);
+    }
+    else {
+        args.push(toLoad.identifier);
+        if (toLoad.AS) {
+            args.push('AS', toLoad.AS);
+        }
+    }
+}
+function parseGroupByReducer(parser, reducer) {
+    parser.push('REDUCE', reducer.type);
+    switch (reducer.type) {
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.COUNT:
+            parser.push('0');
+            break;
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.COUNT_DISTINCT:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.COUNT_DISTINCTISH:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.SUM:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.MIN:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.MAX:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.AVG:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.STDDEV:
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.TOLIST:
+            parser.push('1', reducer.property);
+            break;
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.QUANTILE:
+            parser.push('2', reducer.property, reducer.quantile.toString());
+            break;
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.FIRST_VALUE: {
+            const args = [reducer.property];
+            if (reducer.BY) {
+                args.push('BY');
+                if (typeof reducer.BY === 'string' || reducer.BY instanceof Buffer) {
+                    args.push(reducer.BY);
+                }
+                else {
+                    args.push(reducer.BY.property);
+                    if (reducer.BY.direction) {
+                        args.push(reducer.BY.direction);
+                    }
+                }
+            }
+            parser.pushVariadicWithLength(args);
+            break;
+        }
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.RANDOM_SAMPLE:
+            parser.push('2', reducer.property, reducer.sampleSize.toString());
+            break;
+    }
+    if (reducer.AS) {
+        parser.push('AS', reducer.AS);
+    }
+}
+exports.parseGroupByReducer = parseGroupByReducer;
+function pushSortByProperty(args, sortBy) {
+    if (typeof sortBy === 'string' || sortBy instanceof Buffer) {
+        args.push(sortBy);
+    }
+    else {
+        args.push(sortBy.BY);
+        if (sortBy.DIRECTION) {
+            args.push(sortBy.DIRECTION);
+        }
+    }
+}
+//# sourceMappingURL=AGGREGATE.js.map

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AGGREGATE_1 = __importDefault(require("./AGGREGATE"));
+exports.default = {
+    IS_READ_ONLY: AGGREGATE_1.default.IS_READ_ONLY,
+    /**
+     * Performs an aggregation with a cursor for retrieving large result sets.
+     * @param parser - The command parser
+     * @param index - Name of the index to query
+     * @param query - The aggregation query
+     * @param options - Optional parameters:
+     *   - All options supported by FT.AGGREGATE
+     *   - COUNT: Number of results to return per cursor fetch
+     *   - MAXIDLE: Maximum idle time for cursor in milliseconds
+     */
+    parseCommand(parser, index, query, options) {
+        AGGREGATE_1.default.parseCommand(parser, index, query, options);
+        parser.push('WITHCURSOR');
+        if (options?.COUNT !== undefined) {
+            parser.push('COUNT', options.COUNT.toString());
+        }
+        if (options?.MAXIDLE !== undefined) {
+            parser.push('MAXIDLE', options.MAXIDLE.toString());
+        }
+    },
+    transformReply: {
+        2: (reply) => {
+            return {
+                ...AGGREGATE_1.default.transformReply[2](reply[0]),
+                cursor: reply[1]
+            };
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=AGGREGATE_WITHCURSOR.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Adds an alias to a RediSearch index.
+     * @param parser - The command parser
+     * @param alias - The alias to add
+     * @param index - The index name to alias
+     */
+    parseCommand(parser, alias, index) {
+        parser.push('FT.ALIASADD', alias, index);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASADD.js.map

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Removes an existing alias from a RediSearch index.
+     * @param parser - The command parser
+     * @param alias - The alias to remove
+     */
+    parseCommand(parser, alias) {
+        parser.push('FT.ALIASDEL', alias);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASDEL.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Updates the index pointed to by an existing alias.
+     * @param parser - The command parser
+     * @param alias - The existing alias to update
+     * @param index - The new index name that the alias should point to
+     */
+    parseCommand(parser, alias, index) {
+        parser.push('FT.ALIASUPDATE', alias, index);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASUPDATE.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CREATE_1 = require("./CREATE");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Alters an existing RediSearch index schema by adding new fields.
+     * @param parser - The command parser
+     * @param index - The index to alter
+     * @param schema - The schema definition containing new fields to add
+     */
+    parseCommand(parser, index, schema) {
+        parser.push('FT.ALTER', index, 'SCHEMA', 'ADD');
+        (0, CREATE_1.parseSchema)(parser, schema);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALTER.js.map

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets a RediSearch configuration option value.
+     * @param parser - The command parser
+     * @param option - The name of the configuration option to retrieve
+     */
+    parseCommand(parser, option) {
+        parser.push('FT.CONFIG', 'GET', option);
+    },
+    transformReply(reply) {
+        const transformedReply = Object.create(null);
+        for (const item of reply) {
+            const [key, value] = item;
+            transformedReply[key.toString()] = value;
+        }
+        return transformedReply;
+    }
+};
+//# sourceMappingURL=CONFIG_GET.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Sets a RediSearch configuration option value.
+     * @param parser - The command parser
+     * @param property - The name of the configuration option to set
+     * @param value - The value to set for the configuration option
+     */
+    parseCommand(parser, property, value) {
+        parser.push('FT.CONFIG', 'SET', property, value);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CONFIG_SET.js.map

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

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDISEARCH_LANGUAGE = exports.parseSchema = exports.SCHEMA_GEO_SHAPE_COORD_SYSTEM = exports.VAMANA_COMPRESSION_ALGORITHM = exports.SCHEMA_VECTOR_FIELD_ALGORITHM = exports.SCHEMA_TEXT_FIELD_PHONETIC = exports.SCHEMA_FIELD_TYPE = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.SCHEMA_FIELD_TYPE = {
+    TEXT: 'TEXT',
+    NUMERIC: 'NUMERIC',
+    GEO: 'GEO',
+    TAG: 'TAG',
+    VECTOR: 'VECTOR',
+    GEOSHAPE: 'GEOSHAPE'
+};
+exports.SCHEMA_TEXT_FIELD_PHONETIC = {
+    DM_EN: 'dm:en',
+    DM_FR: 'dm:fr',
+    DM_PT: 'dm:pt',
+    DM_ES: 'dm:es'
+};
+exports.SCHEMA_VECTOR_FIELD_ALGORITHM = {
+    FLAT: 'FLAT',
+    HNSW: 'HNSW',
+    /**
+     * available since 8.2
+    */
+    VAMANA: 'SVS-VAMANA'
+};
+exports.VAMANA_COMPRESSION_ALGORITHM = {
+    LVQ4: 'LVQ4',
+    LVQ8: 'LVQ8',
+    LVQ4x4: 'LVQ4x4',
+    LVQ4x8: 'LVQ4x8',
+    LeanVec4x8: 'LeanVec4x8',
+    LeanVec8x8: 'LeanVec8x8'
+};
+exports.SCHEMA_GEO_SHAPE_COORD_SYSTEM = {
+    SPHERICAL: 'SPHERICAL',
+    FLAT: 'FLAT'
+};
+function parseCommonSchemaFieldOptions(parser, fieldOptions) {
+    if (fieldOptions.SORTABLE) {
+        parser.push('SORTABLE');
+        if (fieldOptions.SORTABLE === 'UNF') {
+            parser.push('UNF');
+        }
+    }
+    if (fieldOptions.NOINDEX) {
+        parser.push('NOINDEX');
+    }
+}
+function parseSchema(parser, schema) {
+    for (const [field, fieldOptionsOrArray] of Object.entries(schema)) {
+        // Normalize to array for uniform processing
+        const fieldOptionsList = Array.isArray(fieldOptionsOrArray)
+            ? fieldOptionsOrArray
+            : [fieldOptionsOrArray];
+        for (const fieldOptions of fieldOptionsList) {
+            parser.push(field);
+            if (typeof fieldOptions === 'string') {
+                parser.push(fieldOptions);
+                continue;
+            }
+            if (fieldOptions.AS) {
+                parser.push('AS', fieldOptions.AS);
+            }
+            parser.push(fieldOptions.type);
+            switch (fieldOptions.type) {
+                case exports.SCHEMA_FIELD_TYPE.TEXT:
+                    if (fieldOptions.INDEXMISSING) {
+                        parser.push('INDEXMISSING');
+                    }
+                    if (fieldOptions.NOSTEM) {
+                        parser.push('NOSTEM');
+                    }
+                    if (fieldOptions.WEIGHT !== undefined) {
+                        parser.push('WEIGHT', fieldOptions.WEIGHT.toString());
+                    }
+                    if (fieldOptions.PHONETIC) {
+                        parser.push('PHONETIC', fieldOptions.PHONETIC);
+                    }
+                    if (fieldOptions.WITHSUFFIXTRIE) {
+                        parser.push('WITHSUFFIXTRIE');
+                    }
+                    if (fieldOptions.INDEXEMPTY) {
+                        parser.push('INDEXEMPTY');
+                    }
+                    parseCommonSchemaFieldOptions(parser, fieldOptions);
+                    break;
+                case exports.SCHEMA_FIELD_TYPE.NUMERIC:
+                case exports.SCHEMA_FIELD_TYPE.GEO:
+                    if (fieldOptions.INDEXMISSING) {
+                        parser.push('INDEXMISSING');
+                    }
+                    parseCommonSchemaFieldOptions(parser, fieldOptions);
+                    break;
+                case exports.SCHEMA_FIELD_TYPE.TAG:
+                    if (fieldOptions.INDEXMISSING) {
+                        parser.push('INDEXMISSING');
+                    }
+                    if (fieldOptions.SEPARATOR) {
+                        parser.push('SEPARATOR', fieldOptions.SEPARATOR);
+                    }
+                    if (fieldOptions.CASESENSITIVE) {
+                        parser.push('CASESENSITIVE');
+                    }
+                    if (fieldOptions.WITHSUFFIXTRIE) {
+                        parser.push('WITHSUFFIXTRIE');
+                    }
+                    if (fieldOptions.INDEXEMPTY) {
+                        parser.push('INDEXEMPTY');
+                    }
+                    parseCommonSchemaFieldOptions(parser, fieldOptions);
+                    break;
+                case exports.SCHEMA_FIELD_TYPE.VECTOR:
+                    parser.push(fieldOptions.ALGORITHM);
+                    const args = [];
+                    args.push('TYPE', fieldOptions.TYPE, 'DIM', fieldOptions.DIM.toString(), 'DISTANCE_METRIC', fieldOptions.DISTANCE_METRIC);
+                    if (fieldOptions.INITIAL_CAP !== undefined) {
+                        args.push('INITIAL_CAP', fieldOptions.INITIAL_CAP.toString());
+                    }
+                    switch (fieldOptions.ALGORITHM) {
+                        case exports.SCHEMA_VECTOR_FIELD_ALGORITHM.FLAT:
+                            if (fieldOptions.BLOCK_SIZE !== undefined) {
+                                args.push('BLOCK_SIZE', fieldOptions.BLOCK_SIZE.toString());
+                            }
+                            break;
+                        case exports.SCHEMA_VECTOR_FIELD_ALGORITHM.HNSW:
+                            if (fieldOptions.M !== undefined) {
+                                args.push('M', fieldOptions.M.toString());
+                            }
+                            if (fieldOptions.EF_CONSTRUCTION !== undefined) {
+                                args.push('EF_CONSTRUCTION', fieldOptions.EF_CONSTRUCTION.toString());
+                            }
+                            if (fieldOptions.EF_RUNTIME !== undefined) {
+                                args.push('EF_RUNTIME', fieldOptions.EF_RUNTIME.toString());
+                            }
+                            break;
+                        case exports.SCHEMA_VECTOR_FIELD_ALGORITHM['VAMANA']:
+                            if (fieldOptions.COMPRESSION) {
+                                args.push('COMPRESSION', fieldOptions.COMPRESSION);
+                            }
+                            if (fieldOptions.CONSTRUCTION_WINDOW_SIZE !== undefined) {
+                                args.push('CONSTRUCTION_WINDOW_SIZE', fieldOptions.CONSTRUCTION_WINDOW_SIZE.toString());
+                            }
+                            if (fieldOptions.GRAPH_MAX_DEGREE !== undefined) {
+                                args.push('GRAPH_MAX_DEGREE', fieldOptions.GRAPH_MAX_DEGREE.toString());
+                            }
+                            if (fieldOptions.SEARCH_WINDOW_SIZE !== undefined) {
+                                args.push('SEARCH_WINDOW_SIZE', fieldOptions.SEARCH_WINDOW_SIZE.toString());
+                            }
+                            if (fieldOptions.EPSILON !== undefined) {
+                                args.push('EPSILON', fieldOptions.EPSILON.toString());
+                            }
+                            if (fieldOptions.TRAINING_THRESHOLD !== undefined) {
+                                args.push('TRAINING_THRESHOLD', fieldOptions.TRAINING_THRESHOLD.toString());
+                            }
+                            if (fieldOptions.REDUCE !== undefined) {
+                                args.push('REDUCE', fieldOptions.REDUCE.toString());
+                            }
+                            break;
+                    }
+                    parser.pushVariadicWithLength(args);
+                    if (fieldOptions.INDEXMISSING) {
+                        parser.push('INDEXMISSING');
+                    }
+                    break;
+                case exports.SCHEMA_FIELD_TYPE.GEOSHAPE:
+                    if (fieldOptions.COORD_SYSTEM !== undefined) {
+                        parser.push('COORD_SYSTEM', fieldOptions.COORD_SYSTEM);
+                    }
+                    if (fieldOptions.INDEXMISSING) {
+                        parser.push('INDEXMISSING');
+                    }
+                    break;
+            }
+        }
+    }
+}
+exports.parseSchema = parseSchema;
+exports.REDISEARCH_LANGUAGE = {
+    ARABIC: 'Arabic',
+    BASQUE: 'Basque',
+    CATALANA: 'Catalan',
+    DANISH: 'Danish',
+    DUTCH: 'Dutch',
+    ENGLISH: 'English',
+    FINNISH: 'Finnish',
+    FRENCH: 'French',
+    GERMAN: 'German',
+    GREEK: 'Greek',
+    HUNGARIAN: 'Hungarian',
+    INDONESAIN: 'Indonesian',
+    IRISH: 'Irish',
+    ITALIAN: 'Italian',
+    LITHUANIAN: 'Lithuanian',
+    NEPALI: 'Nepali',
+    NORWEIGAN: 'Norwegian',
+    PORTUGUESE: 'Portuguese',
+    ROMANIAN: 'Romanian',
+    RUSSIAN: 'Russian',
+    SPANISH: 'Spanish',
+    SWEDISH: 'Swedish',
+    TAMIL: 'Tamil',
+    TURKISH: 'Turkish',
+    CHINESE: 'Chinese'
+};
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Creates a new search index with the given schema and options.
+     * @param parser - The command parser
+     * @param index - Name of the index to create
+     * @param schema - Index schema defining field names and types (TEXT, NUMERIC, GEO, TAG, VECTOR, GEOSHAPE).
+     *   Each field can be a single definition or an array to index the same field multiple times with different configurations.
+     * @param options - Optional parameters:
+     *   - ON: Type of container to index (HASH or JSON)
+     *   - PREFIX: Prefixes for document keys to index
+     *   - FILTER: Expression that filters indexed documents
+     *   - LANGUAGE/LANGUAGE_FIELD: Default language for indexing
+     *   - SCORE/SCORE_FIELD: Document ranking parameters
+     *   - MAXTEXTFIELDS: Index all text fields without specifying them
+     *   - TEMPORARY: Create a temporary index
+     *   - NOOFFSETS/NOHL/NOFIELDS/NOFREQS: Index optimization flags
+     *   - STOPWORDS: Custom stopword list
+     */
+    parseCommand(parser, index, schema, options) {
+        parser.push('FT.CREATE', index);
+        if (options?.ON) {
+            parser.push('ON', options.ON);
+        }
+        (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'PREFIX', options?.PREFIX);
+        if (options?.FILTER) {
+            parser.push('FILTER', options.FILTER);
+        }
+        if (options?.LANGUAGE) {
+            parser.push('LANGUAGE', options.LANGUAGE);
+        }
+        if (options?.LANGUAGE_FIELD) {
+            parser.push('LANGUAGE_FIELD', options.LANGUAGE_FIELD);
+        }
+        if (options?.SCORE) {
+            parser.push('SCORE', options.SCORE.toString());
+        }
+        if (options?.SCORE_FIELD) {
+            parser.push('SCORE_FIELD', options.SCORE_FIELD);
+        }
+        // if (options?.PAYLOAD_FIELD) {
+        //     parser.push('PAYLOAD_FIELD', options.PAYLOAD_FIELD);
+        // }
+        if (options?.MAXTEXTFIELDS) {
+            parser.push('MAXTEXTFIELDS');
+        }
+        if (options?.TEMPORARY) {
+            parser.push('TEMPORARY', options.TEMPORARY.toString());
+        }
+        if (options?.NOOFFSETS) {
+            parser.push('NOOFFSETS');
+        }
+        if (options?.NOHL) {
+            parser.push('NOHL');
+        }
+        if (options?.NOFIELDS) {
+            parser.push('NOFIELDS');
+        }
+        if (options?.NOFREQS) {
+            parser.push('NOFREQS');
+        }
+        if (options?.SKIPINITIALSCAN) {
+            parser.push('SKIPINITIALSCAN');
+        }
+        (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'STOPWORDS', options?.STOPWORDS);
+        parser.push('SCHEMA');
+        parseSchema(parser, schema);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CREATE.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Deletes a cursor from an index.
+     * @param parser - The command parser
+     * @param index - The index name that contains the cursor
+     * @param cursorId - The cursor ID to delete
+     */
+    parseCommand(parser, index, cursorId) {
+        parser.push('FT.CURSOR', 'DEL', index, cursorId.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CURSOR_DEL.js.map