feat: Passwordless cross-device authentication

- Arkitektur: docs/auth/passwordless-architecture.md
- Backend: iom/quixzoom-auth-service/ (FastAPI + Redis)
- Webb: quixzoom-market-pages/se/login/ (QR-kod + polling)
- App: iom/quixzoom-app/src/features/auth/ (push + deep links)

Flöde: QR-kod → app-godkännande → webb-inloggad

landvex-report-system/node_modules/@redis/search/README.md

@@ -0,0 +1,139 @@
+# @redis/search
+
+This package provides support for the [RediSearch](https://redis.io/docs/interact/search-and-query/) module, which adds indexing and querying support for data stored in Redis Hashes or as JSON documents with the [RedisJSON](https://redis.io/docs/data-types/json/) module.
+
+Should be used with [`redis`/`@redis/client`](https://github.com/redis/node-redis).
+
+:warning: To use these extra commands, your Redis server must have the RediSearch module installed. To index and query JSON documents, you'll also need to add the RedisJSON module.
+
+## Usage
+
+For complete examples, see [`search-hashes.js`](https://github.com/redis/node-redis/blob/master/examples/search-hashes.js) and [`search-json.js`](https://github.com/redis/node-redis/blob/master/examples/search-json.js) in the [examples folder](https://github.com/redis/node-redis/tree/master/examples).
+
+### Indexing and Querying Data in Redis Hashes
+
+#### Creating an Index
+
+Before we can perform any searches, we need to tell RediSearch how to index our data, and which Redis keys to find that data in.  The [FT.CREATE](https://redis.io/commands/ft.create) command creates a RediSearch index. Here's how to use it to create an index we'll call `idx:animals` where we want to index hashes containing `name`, `species` and `age` fields, and whose key names in Redis begin with the prefix `noderedis:animals`:
+
+```javascript
+await client.ft.create('idx:animals', {
+  name: {
+    type: SCHEMA_FIELD_TYPE.TEXT,
+    SORTABLE: true
+  },
+  species: SCHEMA_FIELD_TYPE.TAG,
+  age: SCHEMA_FIELD_TYPE.NUMERIC
+}, {
+  ON: 'HASH',
+  PREFIX: 'noderedis:animals'
+});
+```
+
+See the [`FT.CREATE` documentation](https://redis.io/commands/ft.create/#description) for information about the different field types and additional options.
+
+#### Indexing a Field Multiple Times
+
+You can index the same field multiple times with different types or aliases by using an array:
+
+```javascript
+await client.ft.create('idx:products', {
+  sku: [
+    { type: SCHEMA_FIELD_TYPE.TEXT, AS: 'sku_text' },
+    { type: SCHEMA_FIELD_TYPE.TAG, AS: 'sku_tag', SORTABLE: true }
+  ]
+}, {
+  ON: 'HASH',
+  PREFIX: 'product:'
+});
+```
+
+This allows querying the same field using different search strategies.
+
+#### Querying the Index
+
+Once we've created an index, and added some data to Redis hashes whose keys begin with the prefix `noderedis:animals`, we can start writing some search queries.  RediSearch supports a rich query syntax for full-text search, faceted search, aggregation and more.  Check out the [`FT.SEARCH` documentation](https://redis.io/commands/ft.search) and the [query syntax reference](https://redis.io/docs/interact/search-and-query/query) for more information.
+
+Let's write a query to find all the animals where the `species` field has the value `dog`:
+
+```javascript
+const results = await client.ft.search('idx:animals', '@species:{dog}');
+```
+
+`results` looks like this:
+
+```javascript
+{
+  total: 2,
+  documents: [
+    {
+      id: 'noderedis:animals:4',
+      value: {
+        name: 'Fido',
+        species: 'dog',
+        age: '7'
+      }
+    },
+    {
+      id: 'noderedis:animals:3',
+      value: {
+        name: 'Rover',
+        species: 'dog',
+        age: '9'
+      }
+    }
+  ]
+}
+```
+
+### Indexing and Querying Data with RedisJSON
+
+RediSearch can also index and query JSON documents stored in Redis using the RedisJSON module.  The approach is similar to that for indexing and searching data in hashes, but we can now use JSON Path like syntax and the data no longer has to be flat name/value pairs - it can contain nested objects and arrays.
+
+#### Creating an Index
+
+As before, we create an index with the `FT.CREATE` command, this time specifying we want to index JSON documents that look like this:
+
+```javascript
+{
+  name: 'Alice',
+  age: 32,
+  coins: 100
+}
+```
+
+Each document represents a user in some system, and users have name, age and coins properties.
+
+One way we might choose to index these documents is as follows:
+
+```javascript
+await client.ft.create('idx:users', {
+  '$.name': {
+    type: SCHEMA_FIELD_TYPE.TEXT,
+    SORTABLE: 'UNF'
+  },
+  '$.age': {
+    type: SCHEMA_FIELD_TYPE.NUMERIC,
+    AS: 'age'
+  },
+  '$.coins': {
+    type: SCHEMA_FIELD_TYPE.NUMERIC,
+    AS: 'coins'
+  }
+}, {
+  ON: 'JSON',
+  PREFIX: 'noderedis:users'
+});
+```
+
+Note that we're using JSON Path to specify where the fields to index are in our JSON documents, and the `AS` clause to define a name/alias for each field.  We'll use these when writing queries.
+
+#### Querying the Index
+
+Now we have an index and some data stored as JSON documents in Redis (see the [JSON package documentation](https://github.com/redis/node-redis/tree/master/packages/json) for examples of how to store JSON), we can write some queries...
+
+We'll use the [RediSearch query language](https://redis.io/docs/interact/search-and-query/query) and [`FT.SEARCH`](https://redis.io/commands/ft.search) command.  Here's a query to find users under the age of 30:
+
+```javascript
+await client.ft.search('idx:users', '@age:[0 30]');
+```

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE.d.ts

@@ -0,0 +1,120 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, MapReply, NumberReply, RedisArgument, ReplyUnion, TypeMapping, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+import { RediSearchProperty } from './CREATE';
+import { FtSearchParams } from './SEARCH';
+type LoadField = RediSearchProperty | {
+    identifier: RediSearchProperty;
+    AS?: RedisArgument;
+};
+export declare const FT_AGGREGATE_STEPS: {
+    readonly GROUPBY: "GROUPBY";
+    readonly SORTBY: "SORTBY";
+    readonly APPLY: "APPLY";
+    readonly LIMIT: "LIMIT";
+    readonly FILTER: "FILTER";
+};
+type FT_AGGREGATE_STEPS = typeof FT_AGGREGATE_STEPS;
+export type FtAggregateStep = FT_AGGREGATE_STEPS[keyof FT_AGGREGATE_STEPS];
+interface AggregateStep<T extends FtAggregateStep> {
+    type: T;
+}
+export declare const FT_AGGREGATE_GROUP_BY_REDUCERS: {
+    readonly COUNT: "COUNT";
+    readonly COUNT_DISTINCT: "COUNT_DISTINCT";
+    readonly COUNT_DISTINCTISH: "COUNT_DISTINCTISH";
+    readonly SUM: "SUM";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly AVG: "AVG";
+    readonly STDDEV: "STDDEV";
+    readonly QUANTILE: "QUANTILE";
+    readonly TOLIST: "TOLIST";
+    readonly FIRST_VALUE: "FIRST_VALUE";
+    readonly RANDOM_SAMPLE: "RANDOM_SAMPLE";
+};
+type FT_AGGREGATE_GROUP_BY_REDUCERS = typeof FT_AGGREGATE_GROUP_BY_REDUCERS;
+export type FtAggregateGroupByReducer = FT_AGGREGATE_GROUP_BY_REDUCERS[keyof FT_AGGREGATE_GROUP_BY_REDUCERS];
+interface GroupByReducer<T extends FtAggregateGroupByReducer> {
+    type: T;
+    AS?: RedisArgument;
+}
+interface GroupByReducerWithProperty<T extends FtAggregateGroupByReducer> extends GroupByReducer<T> {
+    property: RediSearchProperty;
+}
+type CountReducer = GroupByReducer<FT_AGGREGATE_GROUP_BY_REDUCERS['COUNT']>;
+type CountDistinctReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['COUNT_DISTINCT']>;
+type CountDistinctishReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['COUNT_DISTINCTISH']>;
+type SumReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['SUM']>;
+type MinReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['MIN']>;
+type MaxReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['MAX']>;
+type AvgReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['AVG']>;
+type StdDevReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['STDDEV']>;
+interface QuantileReducer extends GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['QUANTILE']> {
+    quantile: number;
+}
+type ToListReducer = GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['TOLIST']>;
+interface FirstValueReducer extends GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['FIRST_VALUE']> {
+    BY?: RediSearchProperty | {
+        property: RediSearchProperty;
+        direction?: 'ASC' | 'DESC';
+    };
+}
+interface RandomSampleReducer extends GroupByReducerWithProperty<FT_AGGREGATE_GROUP_BY_REDUCERS['RANDOM_SAMPLE']> {
+    sampleSize: number;
+}
+export type GroupByReducers = CountReducer | CountDistinctReducer | CountDistinctishReducer | SumReducer | MinReducer | MaxReducer | AvgReducer | StdDevReducer | QuantileReducer | ToListReducer | FirstValueReducer | RandomSampleReducer;
+interface GroupByStep extends AggregateStep<FT_AGGREGATE_STEPS['GROUPBY']> {
+    properties?: RediSearchProperty | Array<RediSearchProperty>;
+    REDUCE: GroupByReducers | Array<GroupByReducers>;
+}
+type SortByProperty = RedisArgument | {
+    BY: RediSearchProperty;
+    DIRECTION?: 'ASC' | 'DESC';
+};
+interface SortStep extends AggregateStep<FT_AGGREGATE_STEPS['SORTBY']> {
+    BY: SortByProperty | Array<SortByProperty>;
+    MAX?: number;
+}
+interface ApplyStep extends AggregateStep<FT_AGGREGATE_STEPS['APPLY']> {
+    expression: RedisArgument;
+    AS: RedisArgument;
+}
+interface LimitStep extends AggregateStep<FT_AGGREGATE_STEPS['LIMIT']> {
+    from: number;
+    size: number;
+}
+interface FilterStep extends AggregateStep<FT_AGGREGATE_STEPS['FILTER']> {
+    expression: RedisArgument;
+}
+export interface FtAggregateOptions {
+    VERBATIM?: boolean;
+    ADDSCORES?: boolean;
+    LOAD?: '*' | LoadField | Array<LoadField>;
+    TIMEOUT?: number;
+    STEPS?: Array<GroupByStep | SortStep | ApplyStep | LimitStep | FilterStep>;
+    PARAMS?: FtSearchParams;
+    DIALECT?: number;
+}
+export type AggregateRawReply = [
+    total: UnwrapReply<NumberReply>,
+    ...results: UnwrapReply<ArrayReply<ArrayReply<BlobStringReply>>>
+];
+export interface AggregateReply {
+    total: number;
+    results: Array<MapReply<BlobStringReply, BlobStringReply>>;
+}
+declare function transformAggregateReplyResp2(rawReply: AggregateRawReply, preserve?: any, typeMapping?: TypeMapping): AggregateReply;
+declare function transformAggregateReplyResp3(rawReply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping): AggregateReply;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtAggregateOptions) => void;
+    readonly transformReply: {
+        readonly 2: typeof transformAggregateReplyResp2;
+        readonly 3: typeof transformAggregateReplyResp3;
+    };
+};
+export default _default;
+export declare function parseAggregateOptions(parser: CommandParser, options?: FtAggregateOptions): void;
+export declare function parseGroupByReducer(parser: CommandParser, reducer: GroupByReducers): void;
+//# sourceMappingURL=AGGREGATE.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AGGREGATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/AGGREGATE.ts"],"names":[],"mappings":"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"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE.js

@@ -0,0 +1,239 @@
+"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");
+const reply_transformers_1 = require("./reply-transformers");
+const decoder_1 = require("@redis/client/dist/lib/RESP/decoder");
+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'
+};
+;
+function transformAggregateReplyResp2(rawReply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+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
+    };
+}
+function transformAggregateReplyResp3(rawReply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+preserve, typeMapping) {
+    const reply = (0, reply_transformers_1.mapLikeToObject)(rawReply);
+    const total = Number((0, reply_transformers_1.getMapValue)(reply, ['total_results', 'total']) ?? 0);
+    const rawResults = (0, reply_transformers_1.mapLikeValues)((0, reply_transformers_1.getMapValue)(reply, ['results']) ?? []);
+    const results = [];
+    const mapType = typeMapping ? typeMapping[decoder_1.RESP_TYPES.MAP] : undefined;
+    for (const rawResult of rawResults) {
+        const normalized = (0, reply_transformers_1.parseAggregateResultRow)(rawResult);
+        switch (mapType) {
+            case Array: {
+                results.push((0, reply_transformers_1.mapLikeToFlatArray)(normalized));
+                break;
+            }
+            case Map: {
+                results.push(new Map(Object.entries(normalized)));
+                break;
+            }
+            default: {
+                results.push(normalized);
+            }
+        }
+    }
+    return {
+        total,
+        results
+    };
+}
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: false,
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.AGGREGATE', index, query);
+        return parseAggregateOptions(parser, options);
+    },
+    transformReply: {
+        2: transformAggregateReplyResp2,
+        3: transformAggregateReplyResp3
+    },
+};
+function parseAggregateOptions(parser, options) {
+    if (options?.VERBATIM) {
+        parser.push('VERBATIM');
+    }
+    if (options?.ADDSCORES) {
+        parser.push('ADDSCORES');
+    }
+    if (options?.LOAD) {
+        parser.push('LOAD');
+        if (options.LOAD === '*') {
+            parser.push('*');
+        }
+        else {
+            const args = [];
+            if (Array.isArray(options?.LOAD)) {
+                for (const load of options.LOAD) {
+                    pushLoadField(args, load);
+                }
+            }
+            else {
+                pushLoadField(args, options?.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

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE_WITHCURSOR.d.ts

@@ -0,0 +1,25 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ReplyUnion, NumberReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { AggregateRawReply, AggregateReply, FtAggregateOptions } from './AGGREGATE';
+export interface FtAggregateWithCursorOptions extends FtAggregateOptions {
+    COUNT?: number;
+    MAXIDLE?: number;
+}
+type AggregateWithCursorRawReply = [
+    result: AggregateRawReply,
+    cursor: NumberReply
+];
+export interface AggregateWithCursorReply extends AggregateReply {
+    cursor: NumberReply;
+}
+declare function transformAggregateWithCursorReplyResp3(reply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping): AggregateWithCursorReply;
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtAggregateWithCursorOptions) => void;
+    readonly transformReply: {
+        readonly 2: (reply: AggregateWithCursorRawReply, preserve?: any, typeMapping?: TypeMapping) => AggregateWithCursorReply;
+        readonly 3: typeof transformAggregateWithCursorReplyResp3;
+    };
+};
+export default _default;
+//# sourceMappingURL=AGGREGATE_WITHCURSOR.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE_WITHCURSOR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AGGREGATE_WITHCURSOR.d.ts","sourceRoot":"","sources":["../../../lib/commands/AGGREGATE_WITHCURSOR.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACjH,OAAkB,EAAE,iBAAiB,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAG/F,MAAM,WAAW,4BAA6B,SAAQ,kBAAkB;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAGD,KAAK,2BAA2B,GAAG;IACjC,MAAM,EAAE,iBAAiB;IACzB,MAAM,EAAE,WAAW;CACpB,CAAC;AAEF,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC9D,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,iBAAS,sCAAsC,CAC7C,KAAK,EAAE,UAAU,EAEjB,QAAQ,CAAC,EAAE,GAAG,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,wBAAwB,CAe1B;;;gDAIsB,aAAa,SAAS,aAAa,SAAS,aAAa,YAAY,4BAA4B;;oEAgBvG,GAAG,gBACA,WAAW,KACxB,wBAAwB;;;;AApB/B,wBA4B6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE_WITHCURSOR.js

@@ -0,0 +1,48 @@
+"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"));
+const reply_transformers_1 = require("./reply-transformers");
+function transformAggregateWithCursorReplyResp3(reply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+preserve, typeMapping) {
+    if (Array.isArray(reply)) {
+        return {
+            ...AGGREGATE_1.default.transformReply[3](reply[0], preserve, typeMapping),
+            cursor: reply[1]
+        };
+    }
+    const mappedReply = (0, reply_transformers_1.mapLikeToObject)(reply);
+    const rawResult = (0, reply_transformers_1.getMapValue)(mappedReply, ['results', 'result']) ?? mappedReply;
+    return {
+        ...AGGREGATE_1.default.transformReply[3](rawResult, preserve, typeMapping),
+        cursor: ((0, reply_transformers_1.getMapValue)(mappedReply, ['cursor']) ?? 0)
+    };
+}
+exports.default = {
+    IS_READ_ONLY: AGGREGATE_1.default.IS_READ_ONLY,
+    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, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        preserve, typeMapping) => {
+            return {
+                ...AGGREGATE_1.default.transformReply[2](reply[0], preserve, typeMapping),
+                cursor: reply[1]
+            };
+        },
+        3: transformAggregateWithCursorReplyResp3
+    },
+};
+//# sourceMappingURL=AGGREGATE_WITHCURSOR.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/AGGREGATE_WITHCURSOR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AGGREGATE_WITHCURSOR.js","sourceRoot":"","sources":["../../../lib/commands/AGGREGATE_WITHCURSOR.ts"],"names":[],"mappings":";;;;;AAEA,4DAA+F;AAC/F,6DAAoE;AAiBpE,SAAS,sCAAsC,CAC7C,KAAiB;AACjB,iGAAiG;AACjG,QAAc,EACd,WAAyB;IAEzB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;YACL,GAAI,mBAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAe,EAAE,QAAQ,EAAE,WAAW,CAAoB;YACjG,MAAM,EAAE,KAAK,CAAC,CAAC,CAAgB;SAChC,CAAC;IACJ,CAAC;IAED,MAAM,WAAW,GAAG,IAAA,oCAAe,EAAC,KAAK,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,IAAA,gCAAW,EAAC,WAAW,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,IAAI,WAAW,CAAC;IAEjF,OAAO;QACL,GAAI,mBAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,SAAuB,EAAE,QAAQ,EAAE,WAAW,CAAoB;QAClG,MAAM,EAAE,CAAC,IAAA,gCAAW,EAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAgB;KACnE,CAAC;AACJ,CAAC;AAED,kBAAe;IACb,YAAY,EAAE,mBAAS,CAAC,YAAY;IACpC,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,KAAoB,EAAE,OAAsC;QACpH,mBAAS,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACtD,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE1B,IAAI,OAAO,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACjD,CAAC;QAED,IAAG,OAAO,EAAE,OAAO,KAAK,SAAS,EAAE,CAAC;YAClC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CACD,KAAkC;QAClC,iGAAiG;QACjG,QAAc,EACd,WAAyB,EACC,EAAE;YAC5B,OAAO;gBACL,GAAG,mBAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC;gBAC/D,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;aACjB,CAAC;QACJ,CAAC;QACD,CAAC,EAAE,sCAAsC;KAC1C;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, Command, ReplyUnion, NumberReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport AGGREGATE, { AggregateRawReply, AggregateReply, FtAggregateOptions } from './AGGREGATE';\nimport { getMapValue, mapLikeToObject } from './reply-transformers';\n\nexport interface FtAggregateWithCursorOptions extends FtAggregateOptions {\n  COUNT?: number;\n  MAXIDLE?: number;\n}\n\n\ntype AggregateWithCursorRawReply = [\n  result: AggregateRawReply,\n  cursor: NumberReply\n];\n\nexport interface AggregateWithCursorReply extends AggregateReply {\n  cursor: NumberReply;\n}\n\nfunction transformAggregateWithCursorReplyResp3(\n  reply: ReplyUnion,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract\n  preserve?: any,\n  typeMapping?: TypeMapping\n): AggregateWithCursorReply {\n  if (Array.isArray(reply)) {\n    return {\n      ...(AGGREGATE.transformReply[3](reply[0] as ReplyUnion, preserve, typeMapping) as AggregateReply),\n      cursor: reply[1] as NumberReply\n    };\n  }\n\n  const mappedReply = mapLikeToObject(reply);\n  const rawResult = getMapValue(mappedReply, ['results', 'result']) ?? mappedReply;\n\n  return {\n    ...(AGGREGATE.transformReply[3](rawResult as ReplyUnion, preserve, typeMapping) as AggregateReply),\n    cursor: (getMapValue(mappedReply, ['cursor']) ?? 0) as NumberReply\n  };\n}\n\nexport default {\n  IS_READ_ONLY: AGGREGATE.IS_READ_ONLY,\n  parseCommand(parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtAggregateWithCursorOptions) {\n    AGGREGATE.parseCommand(parser, index, query, options);\n    parser.push('WITHCURSOR');\n\n    if (options?.COUNT !== undefined) {\n      parser.push('COUNT', options.COUNT.toString());\n    }\n\n    if(options?.MAXIDLE !== undefined) {\n      parser.push('MAXIDLE', options.MAXIDLE.toString());\n    }\n  },\n  transformReply: {\n    2: (\n      reply: AggregateWithCursorRawReply,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract\n      preserve?: any,\n      typeMapping?: TypeMapping\n    ): AggregateWithCursorReply => {\n      return {\n        ...AGGREGATE.transformReply[2](reply[0], preserve, typeMapping),\n        cursor: reply[1]\n      };\n    },\n    3: transformAggregateWithCursorReplyResp3\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASADD.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, alias: RedisArgument, index: RedisArgument) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=ALIASADD.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASADD.d.ts","sourceRoot":"","sources":["../../../lib/commands/ALIASADD.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;;;;gDAKvE,aAAa,SAAS,aAAa,SAAS,aAAa;mCAGhC,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASADD.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, alias, index) {
+        parser.push('FT.ALIASADD', alias, index);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASADD.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASADD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASADD.js","sourceRoot":"","sources":["../../../lib/commands/ALIASADD.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,KAAoB;QAC5E,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, alias: RedisArgument, index: RedisArgument) {\n    parser.push('FT.ALIASADD', alias, index);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASDEL.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, alias: RedisArgument) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=ALIASDEL.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASDEL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASDEL.d.ts","sourceRoot":"","sources":["../../../lib/commands/ALIASDEL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;;;;gDAKvE,aAAa,SAAS,aAAa;mCAGV,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASDEL.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, alias) {
+        parser.push('FT.ALIASDEL', alias);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASDEL.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASDEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASDEL.js","sourceRoot":"","sources":["../../../lib/commands/ALIASDEL.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB;QACtD,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, alias: RedisArgument) {\n    parser.push('FT.ALIASDEL', alias);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASUPDATE.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { SimpleStringReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, alias: RedisArgument, index: RedisArgument) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=ALIASUPDATE.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASUPDATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASUPDATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/ALIASUPDATE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAW,aAAa,EAAE,MAAM,mCAAmC,CAAC;;;;gDAKvE,aAAa,SAAS,aAAa,SAAS,aAAa;mCAGhC,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASUPDATE.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, alias, index) {
+        parser.push('FT.ALIASUPDATE', alias, index);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALIASUPDATE.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALIASUPDATE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALIASUPDATE.js","sourceRoot":"","sources":["../../../lib/commands/ALIASUPDATE.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,KAAoB;QAC5E,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { SimpleStringReply, Command, RedisArgument } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, alias: RedisArgument, index: RedisArgument) {\n    parser.push('FT.ALIASUPDATE', alias, index);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALTER.d.ts

@@ -0,0 +1,11 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { RediSearchSchema } from './CREATE';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, schema: RediSearchSchema) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=ALTER.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALTER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALTER.d.ts","sourceRoot":"","sources":["../../../lib/commands/ALTER.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAC9F,OAAO,EAAE,gBAAgB,EAAe,MAAM,UAAU,CAAC;;;;gDAKlC,aAAa,SAAS,aAAa,UAAU,gBAAgB;mCAIpC,kBAAkB,IAAI,CAAC;;AAPvE,wBAQ6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALTER.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CREATE_1 = require("./CREATE");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, schema) {
+        parser.push('FT.ALTER', index, 'SCHEMA', 'ADD');
+        (0, CREATE_1.parseSchema)(parser, schema);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALTER.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/ALTER.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALTER.js","sourceRoot":"","sources":["../../../lib/commands/ALTER.ts"],"names":[],"mappings":";;AAEA,qCAAyD;AAEzD,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,MAAwB;QAChF,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChD,IAAA,oBAAW,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { RediSearchSchema, parseSchema } from './CREATE';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument, schema: RediSearchSchema) {\n    parser.push('FT.ALTER', index, 'SCHEMA', 'ADD');\n    parseSchema(parser, schema);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_GET.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, TuplesReply, BlobStringReply, NullReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, option: string) => void;
+    readonly transformReply: (this: void, reply: UnwrapReply<ArrayReply<TuplesReply<[BlobStringReply, BlobStringReply | NullReply]>>>) => Record<string, unknown>;
+};
+export default _default;
+//# sourceMappingURL=CONFIG_GET.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_GET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CONFIG_GET.d.ts","sourceRoot":"","sources":["../../../lib/commands/CONFIG_GET.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;;;;gDAMvG,aAAa,UAAU,MAAM;iDAG5B,YAAY,WAAW,YAAY,CAAC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;;AAN5G,wBAe6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_GET.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reply_transformers_1 = require("./reply-transformers");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, option) {
+        parser.push('FT.CONFIG', 'GET', option);
+    },
+    transformReply(reply) {
+        const transformedReply = {};
+        for (const [key, value] of (0, reply_transformers_1.mapLikeEntries)(reply)) {
+            transformedReply[key] = value;
+        }
+        return (0, reply_transformers_1.toCompatObject)(transformedReply);
+    }
+};
+//# sourceMappingURL=CONFIG_GET.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_GET.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CONFIG_GET.js","sourceRoot":"","sources":["../../../lib/commands/CONFIG_GET.ts"],"names":[],"mappings":";;AAEA,6DAAsE;AAEtE,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,MAAc;QAChD,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IACD,cAAc,CAAC,KAA2F;QACxG,MAAM,gBAAgB,GAAgD,EAAE,CAAC;QAEzE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAA,mCAAc,EAAC,KAAK,CAAC,EAAE,CAAC;YACjD,gBAAgB,CAAC,GAAG,CAAC,GAAG,KAAoC,CAAC;QAC/D,CAAC;QAED,OAAO,IAAA,mCAAc,EAAC,gBAAgB,CAAC,CAAC;IAC1C,CAAC;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { ArrayReply, TuplesReply, BlobStringReply, NullReply, UnwrapReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { mapLikeEntries, toCompatObject } from './reply-transformers';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, option: string) {\n    parser.push('FT.CONFIG', 'GET', option);\n  },\n  transformReply(reply: UnwrapReply<ArrayReply<TuplesReply<[BlobStringReply, BlobStringReply | NullReply]>>>) {\n    const transformedReply: Record<string, BlobStringReply | NullReply> = {};\n\n    for (const [key, value] of mapLikeEntries(reply)) {\n      transformedReply[key] = value as BlobStringReply | NullReply;\n    }\n\n    return toCompatObject(transformedReply);\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_SET.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+type FtConfigProperties = 'a' | 'b' | (string & {}) | Buffer;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, property: FtConfigProperties, value: RedisArgument) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=CONFIG_SET.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_SET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CONFIG_SET.d.ts","sourceRoot":"","sources":["../../../lib/commands/CONFIG_SET.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAI9F,KAAK,kBAAkB,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC;;;;gDAKtC,aAAa,YAAY,kBAAkB,SAAS,aAAa;mCAGxC,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_SET.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, property, value) {
+        parser.push('FT.CONFIG', 'SET', property, value);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CONFIG_SET.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CONFIG_SET.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CONFIG_SET.js","sourceRoot":"","sources":["../../../lib/commands/CONFIG_SET.ts"],"names":[],"mappings":";;AAOA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,QAA4B,EAAE,KAAoB;QACpF,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\n// using `string & {}` to avoid TS widening the type to `string`\n// TODO\ntype FtConfigProperties = 'a' | 'b' | (string & {}) | Buffer;\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, property: FtConfigProperties, value: RedisArgument) {\n    parser.push('FT.CONFIG', 'SET', property, value);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CREATE.d.ts

@@ -0,0 +1,182 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+export declare const SCHEMA_FIELD_TYPE: {
+    readonly TEXT: "TEXT";
+    readonly NUMERIC: "NUMERIC";
+    readonly GEO: "GEO";
+    readonly TAG: "TAG";
+    readonly VECTOR: "VECTOR";
+    readonly GEOSHAPE: "GEOSHAPE";
+};
+export type SchemaFieldType = typeof SCHEMA_FIELD_TYPE[keyof typeof SCHEMA_FIELD_TYPE];
+interface SchemaField<T extends SchemaFieldType = SchemaFieldType> {
+    type: T;
+    AS?: RedisArgument;
+    INDEXMISSING?: boolean;
+}
+interface SchemaCommonField<T extends SchemaFieldType = SchemaFieldType> extends SchemaField<T> {
+    SORTABLE?: boolean | 'UNF';
+    NOINDEX?: boolean;
+}
+export declare const SCHEMA_TEXT_FIELD_PHONETIC: {
+    readonly DM_EN: "dm:en";
+    readonly DM_FR: "dm:fr";
+    readonly DM_PT: "dm:pt";
+    readonly DM_ES: "dm:es";
+};
+export type SchemaTextFieldPhonetic = typeof SCHEMA_TEXT_FIELD_PHONETIC[keyof typeof SCHEMA_TEXT_FIELD_PHONETIC];
+interface SchemaTextField extends SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TEXT']> {
+    NOSTEM?: boolean;
+    WEIGHT?: number;
+    PHONETIC?: SchemaTextFieldPhonetic;
+    WITHSUFFIXTRIE?: boolean;
+    INDEXEMPTY?: boolean;
+}
+type SchemaNumericField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['NUMERIC']>;
+type SchemaGeoField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['GEO']>;
+interface SchemaTagField extends SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TAG']> {
+    SEPARATOR?: RedisArgument;
+    CASESENSITIVE?: boolean;
+    WITHSUFFIXTRIE?: boolean;
+    INDEXEMPTY?: boolean;
+}
+export declare const SCHEMA_VECTOR_FIELD_ALGORITHM: {
+    readonly FLAT: "FLAT";
+    readonly HNSW: "HNSW";
+    /**
+     * available since 8.2
+    */
+    readonly VAMANA: "SVS-VAMANA";
+};
+export type SchemaVectorFieldAlgorithm = typeof SCHEMA_VECTOR_FIELD_ALGORITHM[keyof typeof SCHEMA_VECTOR_FIELD_ALGORITHM];
+interface SchemaVectorField extends SchemaField<typeof SCHEMA_FIELD_TYPE['VECTOR']> {
+    ALGORITHM: SchemaVectorFieldAlgorithm;
+    TYPE: 'FLOAT32' | 'FLOAT64' | 'BFLOAT16' | 'FLOAT16' | 'INT8' | 'UINT8';
+    DIM: number;
+    DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE';
+    INITIAL_CAP?: number;
+}
+interface SchemaFlatVectorField extends SchemaVectorField {
+    ALGORITHM: typeof SCHEMA_VECTOR_FIELD_ALGORITHM['FLAT'];
+    BLOCK_SIZE?: number;
+}
+interface SchemaHNSWVectorField extends SchemaVectorField {
+    ALGORITHM: typeof SCHEMA_VECTOR_FIELD_ALGORITHM['HNSW'];
+    M?: number;
+    EF_CONSTRUCTION?: number;
+    EF_RUNTIME?: number;
+}
+export declare const VAMANA_COMPRESSION_ALGORITHM: {
+    readonly LVQ4: "LVQ4";
+    readonly LVQ8: "LVQ8";
+    readonly LVQ4x4: "LVQ4x4";
+    readonly LVQ4x8: "LVQ4x8";
+    readonly LeanVec4x8: "LeanVec4x8";
+    readonly LeanVec8x8: "LeanVec8x8";
+};
+export type VamanaCompressionAlgorithm = typeof VAMANA_COMPRESSION_ALGORITHM[keyof typeof VAMANA_COMPRESSION_ALGORITHM];
+interface SchemaVAMANAVectorField extends SchemaVectorField {
+    ALGORITHM: typeof SCHEMA_VECTOR_FIELD_ALGORITHM['VAMANA'];
+    TYPE: 'FLOAT16' | 'FLOAT32';
+    COMPRESSION?: VamanaCompressionAlgorithm;
+    CONSTRUCTION_WINDOW_SIZE?: number;
+    GRAPH_MAX_DEGREE?: number;
+    SEARCH_WINDOW_SIZE?: number;
+    EPSILON?: number;
+    /**
+     * applicable only with COMPRESSION
+     */
+    TRAINING_THRESHOLD?: number;
+    /**
+     * applicable only with LeanVec COMPRESSION
+     */
+    REDUCE?: number;
+}
+export declare const SCHEMA_GEO_SHAPE_COORD_SYSTEM: {
+    readonly SPHERICAL: "SPHERICAL";
+    readonly FLAT: "FLAT";
+};
+export type SchemaGeoShapeFieldCoordSystem = typeof SCHEMA_GEO_SHAPE_COORD_SYSTEM[keyof typeof SCHEMA_GEO_SHAPE_COORD_SYSTEM];
+interface SchemaGeoShapeField extends SchemaField<typeof SCHEMA_FIELD_TYPE['GEOSHAPE']> {
+    COORD_SYSTEM?: SchemaGeoShapeFieldCoordSystem;
+}
+/**
+ * Union type representing all possible field definition types for a RediSearch schema.
+ */
+export type SchemaFieldDefinition = SchemaTextField | SchemaNumericField | SchemaGeoField | SchemaTagField | SchemaFlatVectorField | SchemaHNSWVectorField | SchemaVAMANAVectorField | SchemaGeoShapeField | SchemaFieldType;
+/**
+ * Schema definition for a RediSearch index.
+ *
+ * Each field can be either a single field definition or an array of definitions.
+ * Use an array to index the same field multiple times with different types or aliases.
+ *
+ * @example
+ * // Single field definitions
+ * { name: SCHEMA_FIELD_TYPE.TEXT, age: SCHEMA_FIELD_TYPE.NUMERIC }
+ *
+ * @example
+ * // Same field indexed as both TEXT and TAG with different aliases
+ * { sku: [
+ *     { type: SCHEMA_FIELD_TYPE.TEXT, AS: 'sku_text' },
+ *     { type: SCHEMA_FIELD_TYPE.TAG, AS: 'sku_tag', SORTABLE: true }
+ * ]}
+ */
+export interface RediSearchSchema {
+    [field: string]: SchemaFieldDefinition | SchemaFieldDefinition[];
+}
+export declare function parseSchema(parser: CommandParser, schema: RediSearchSchema): void;
+export declare const REDISEARCH_LANGUAGE: {
+    readonly ARABIC: "Arabic";
+    readonly BASQUE: "Basque";
+    readonly CATALANA: "Catalan";
+    readonly DANISH: "Danish";
+    readonly DUTCH: "Dutch";
+    readonly ENGLISH: "English";
+    readonly FINNISH: "Finnish";
+    readonly FRENCH: "French";
+    readonly GERMAN: "German";
+    readonly GREEK: "Greek";
+    readonly HUNGARIAN: "Hungarian";
+    readonly INDONESAIN: "Indonesian";
+    readonly IRISH: "Irish";
+    readonly ITALIAN: "Italian";
+    readonly LITHUANIAN: "Lithuanian";
+    readonly NEPALI: "Nepali";
+    readonly NORWEIGAN: "Norwegian";
+    readonly PORTUGUESE: "Portuguese";
+    readonly ROMANIAN: "Romanian";
+    readonly RUSSIAN: "Russian";
+    readonly SPANISH: "Spanish";
+    readonly SWEDISH: "Swedish";
+    readonly TAMIL: "Tamil";
+    readonly TURKISH: "Turkish";
+    readonly CHINESE: "Chinese";
+};
+export type RediSearchLanguage = typeof REDISEARCH_LANGUAGE[keyof typeof REDISEARCH_LANGUAGE];
+export type RediSearchProperty = `${'@' | '$.'}${string}`;
+export interface CreateOptions {
+    ON?: 'HASH' | 'JSON';
+    PREFIX?: RedisVariadicArgument;
+    FILTER?: RedisArgument;
+    LANGUAGE?: RediSearchLanguage;
+    LANGUAGE_FIELD?: RediSearchProperty;
+    SCORE?: number;
+    SCORE_FIELD?: RediSearchProperty;
+    MAXTEXTFIELDS?: boolean;
+    TEMPORARY?: number;
+    NOOFFSETS?: boolean;
+    NOHL?: boolean;
+    NOFIELDS?: boolean;
+    NOFREQS?: boolean;
+    SKIPINITIALSCAN?: boolean;
+    STOPWORDS?: RedisVariadicArgument;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, schema: RediSearchSchema, options?: CreateOptions) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=CREATE.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CREATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CREATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/CREATE.ts"],"names":[],"mappings":"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"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CREATE.js

@@ -0,0 +1,261 @@
+"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,
+    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

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_DEL.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { SimpleStringReply, RedisArgument, NumberReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, cursorId: UnwrapReply<NumberReply>) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=CURSOR_DEL.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_DEL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CURSOR_DEL.d.ts","sourceRoot":"","sources":["../../../lib/commands/CURSOR_DEL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAW,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;;;;gDAKjG,aAAa,SAAS,aAAa,YAAY,YAAY,WAAW,CAAC;mCAG9C,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_DEL.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, cursorId) {
+        parser.push('FT.CURSOR', 'DEL', index, cursorId.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CURSOR_DEL.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_DEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CURSOR_DEL.js","sourceRoot":"","sources":["../../../lib/commands/CURSOR_DEL.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,QAAkC;QAC1F,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { SimpleStringReply, Command, RedisArgument, NumberReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument, cursorId: UnwrapReply<NumberReply>) {\n    parser.push('FT.CURSOR', 'DEL', index, cursorId.toString());\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_READ.d.ts

@@ -0,0 +1,16 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+export interface FtCursorReadOptions {
+    COUNT?: number;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, cursor: UnwrapReply<NumberReply>, options?: FtCursorReadOptions) => void;
+    readonly transformReply: {
+        readonly 2: (reply: [result: [total: UnwrapReply<NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], cursor: NumberReply<number>], preserve?: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+        readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+    };
+};
+export default _default;
+//# sourceMappingURL=CURSOR_READ.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_READ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CURSOR_READ.d.ts","sourceRoot":"","sources":["../../../lib/commands/CURSOR_READ.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAGrG,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;;;;gDAKsB,aAAa,SAAS,aAAa,UAAU,YAAY,WAAW,CAAC,YAAY,mBAAmB;;;;;;AAH3H,wBAW6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_READ.js

@@ -0,0 +1,18 @@
+"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,
+    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,
+};
+//# sourceMappingURL=CURSOR_READ.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/CURSOR_READ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CURSOR_READ.js","sourceRoot":"","sources":["../../../lib/commands/CURSOR_READ.ts"],"names":[],"mappings":";;;;;AAEA,kFAA0D;AAM1D,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,MAAgC,EAAE,OAA6B;QACvH,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QAE3D,IAAI,OAAO,EAAE,KAAK,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IACD,cAAc,EAAE,8BAAoB,CAAC,cAAc;CACzB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, Command, NumberReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';\nimport AGGREGATE_WITHCURSOR from './AGGREGATE_WITHCURSOR';\n\nexport interface FtCursorReadOptions {\n  COUNT?: number;\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument, cursor: UnwrapReply<NumberReply>, options?: FtCursorReadOptions) {\n    parser.push('FT.CURSOR', 'READ', index, cursor.toString());\n\n    if (options?.COUNT !== undefined) {\n      parser.push('COUNT', options.COUNT.toString());\n    }\n  },\n  transformReply: AGGREGATE_WITHCURSOR.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTADD.d.ts

@@ -0,0 +1,11 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, dictionary: RedisArgument, term: RedisVariadicArgument) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=DICTADD.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTADD.d.ts","sourceRoot":"","sources":["../../../lib/commands/DICTADD.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;;;;gDAKtE,aAAa,cAAc,aAAa,QAAQ,qBAAqB;mCAI5C,WAAW;;AAP3D,wBAQ6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTADD.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, dictionary, term) {
+        parser.push('FT.DICTADD', dictionary);
+        parser.pushVariadic(term);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DICTADD.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTADD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTADD.js","sourceRoot":"","sources":["../../../lib/commands/DICTADD.ts"],"names":[],"mappings":";;AAIA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,UAAyB,EAAE,IAA2B;QACxF,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACtC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, dictionary: RedisArgument, term: RedisVariadicArgument) {\n    parser.push('FT.DICTADD', dictionary);\n    parser.pushVariadic(term);\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDEL.d.ts

@@ -0,0 +1,11 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, dictionary: RedisArgument, term: RedisVariadicArgument) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=DICTDEL.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDEL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTDEL.d.ts","sourceRoot":"","sources":["../../../lib/commands/DICTDEL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;;;;gDAKtE,aAAa,cAAc,aAAa,QAAQ,qBAAqB;mCAI5C,WAAW;;AAP3D,wBAQ6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDEL.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, dictionary, term) {
+        parser.push('FT.DICTDEL', dictionary);
+        parser.pushVariadic(term);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DICTDEL.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTDEL.js","sourceRoot":"","sources":["../../../lib/commands/DICTDEL.ts"],"names":[],"mappings":";;AAIA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,UAAyB,EAAE,IAA2B;QACxF,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QACtC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, dictionary: RedisArgument, term: RedisVariadicArgument) {\n    parser.push('FT.DICTDEL', dictionary);\n    parser.pushVariadic(term);\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDUMP.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ArrayReply, SetReply, BlobStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, dictionary: RedisArgument) => void;
+    readonly transformReply: {
+        readonly 2: () => ArrayReply<BlobStringReply>;
+        readonly 3: () => SetReply<BlobStringReply>;
+    };
+};
+export default _default;
+//# sourceMappingURL=DICTDUMP.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDUMP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTDUMP.d.ts","sourceRoot":"","sources":["../../../lib/commands/DICTDUMP.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAW,MAAM,mCAAmC,CAAC;;;;gDAK3F,aAAa,cAAc,aAAa;;0BAI1B,WAAW,eAAe,CAAC;0BAC3B,SAAS,eAAe,CAAC;;;AAR9D,wBAU6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDUMP.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, dictionary) {
+        parser.push('FT.DICTDUMP', dictionary);
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=DICTDUMP.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DICTDUMP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DICTDUMP.js","sourceRoot":"","sources":["../../../lib/commands/DICTDUMP.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,UAAyB;QAC3D,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACzC,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,SAAyD;QAC5D,CAAC,EAAE,SAAuD;KAC3D;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, ArrayReply, SetReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, dictionary: RedisArgument) {\n    parser.push('FT.DICTDUMP', dictionary);\n  },\n  transformReply: {\n    2: undefined as unknown as () => ArrayReply<BlobStringReply>,\n    3: undefined as unknown as () => SetReply<BlobStringReply>\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DROPINDEX.d.ts

@@ -0,0 +1,16 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply, NumberReply } from '@redis/client/dist/lib/RESP/types';
+export interface FtDropIndexOptions {
+    DD?: true;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, options?: FtDropIndexOptions) => void;
+    readonly transformReply: {
+        readonly 2: () => SimpleStringReply<'OK'>;
+        readonly 3: () => NumberReply;
+    };
+};
+export default _default;
+//# sourceMappingURL=DROPINDEX.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DROPINDEX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DROPINDEX.d.ts","sourceRoot":"","sources":["../../../lib/commands/DROPINDEX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AAE3G,MAAM,WAAW,kBAAkB;IACjC,EAAE,CAAC,EAAE,IAAI,CAAC;CACX;;;;gDAKsB,aAAa,SAAS,aAAa,YAAY,kBAAkB;;0BAQnD,kBAAkB,IAAI,CAAC;0BACvB,WAAW;;;AAZhD,wBAc6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DROPINDEX.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, options) {
+        parser.push('FT.DROPINDEX', index);
+        if (options?.DD) {
+            parser.push('DD');
+        }
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=DROPINDEX.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/DROPINDEX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DROPINDEX.js","sourceRoot":"","sources":["../../../lib/commands/DROPINDEX.ts"],"names":[],"mappings":";;AAOA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,OAA4B;QACpF,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAEnC,IAAI,OAAO,EAAE,EAAE,EAAE,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,SAAqD;QACxD,CAAC,EAAE,SAAyC;KAC7C;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport interface FtDropIndexOptions {\n  DD?: true;\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument, options?: FtDropIndexOptions) {\n    parser.push('FT.DROPINDEX', index);\n\n    if (options?.DD) {\n      parser.push('DD');\n    }\n  },\n  transformReply: {\n    2: undefined as unknown as () => SimpleStringReply<'OK'>,\n    3: undefined as unknown as () => NumberReply\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAIN.d.ts

@@ -0,0 +1,15 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { FtSearchParams } from './SEARCH';
+export interface FtExplainOptions {
+    PARAMS?: FtSearchParams;
+    DIALECT?: number;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtExplainOptions) => void;
+    readonly transformReply: () => SimpleStringReply;
+};
+export default _default;
+//# sourceMappingURL=EXPLAIN.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAIN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXPLAIN.d.ts","sourceRoot":"","sources":["../../../lib/commands/EXPLAIN.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAC9F,OAAO,EAAE,cAAc,EAAuB,MAAM,UAAU,CAAC;AAG/D,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;;;;gDAMW,aAAa,SACd,aAAa,SACb,aAAa,YACV,gBAAgB;mCAYkB,iBAAiB;;AAnBjE,wBAoB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAIN.js

@@ -0,0 +1,20 @@
+"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,
+    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

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAIN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXPLAIN.js","sourceRoot":"","sources":["../../../lib/commands/EXPLAIN.ts"],"names":[],"mappings":";;AAEA,qCAA+D;AAC/D,gDAAqD;AAOrD,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CACV,MAAqB,EACrB,KAAoB,EACpB,KAAoB,EACpB,OAA0B;QAE1B,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAExC,IAAA,4BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAE7C,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,yBAAe,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAA+C;CACrC,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { FtSearchParams, parseParamsArgument } from './SEARCH';\nimport { DEFAULT_DIALECT } from '../dialect/default';\n\nexport interface FtExplainOptions {\n  PARAMS?: FtSearchParams;\n  DIALECT?: number;\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(\n    parser: CommandParser,\n    index: RedisArgument,\n    query: RedisArgument,\n    options?: FtExplainOptions\n  ) {\n    parser.push('FT.EXPLAIN', index, query);\n\n    parseParamsArgument(parser, options?.PARAMS);\n\n    if (options?.DIALECT) {\n      parser.push('DIALECT', options.DIALECT.toString());\n    } else {\n      parser.push('DIALECT', DEFAULT_DIALECT);\n    }\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAINCLI.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ArrayReply, BlobStringReply } from '@redis/client/dist/lib/RESP/types';
+export interface FtExplainCLIOptions {
+    DIALECT?: number;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtExplainCLIOptions) => void;
+    readonly transformReply: () => ArrayReply<BlobStringReply>;
+};
+export default _default;
+//# sourceMappingURL=EXPLAINCLI.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAINCLI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXPLAINCLI.d.ts","sourceRoot":"","sources":["../../../lib/commands/EXPLAINCLI.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAW,MAAM,mCAAmC,CAAC;AAGxG,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;;;;gDAMW,aAAa,SACd,aAAa,SACb,aAAa,YACV,mBAAmB;mCAUe,WAAW,eAAe,CAAC;;AAjB3E,wBAkB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAINCLI.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = require("../dialect/default");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    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

landvex-report-system/node_modules/@redis/search/dist/lib/commands/EXPLAINCLI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXPLAINCLI.js","sourceRoot":"","sources":["../../../lib/commands/EXPLAINCLI.ts"],"names":[],"mappings":";;AAEA,gDAAqD;AAMrD,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CACV,MAAqB,EACrB,KAAoB,EACpB,KAAoB,EACpB,OAA6B;QAE7B,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAE3C,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,yBAAe,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAAyD;CAC/C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, ArrayReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { DEFAULT_DIALECT } from '../dialect/default';\n\nexport interface FtExplainCLIOptions {\n  DIALECT?: number;\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(\n    parser: CommandParser, \n    index: RedisArgument, \n    query: RedisArgument,\n    options?: FtExplainCLIOptions\n  ) {\n    parser.push('FT.EXPLAINCLI', index, query);\n\n    if (options?.DIALECT) {\n      parser.push('DIALECT', options.DIALECT.toString());\n    } else {\n      parser.push('DIALECT', DEFAULT_DIALECT);\n    }\n  },\n  transformReply: undefined as unknown as () => ArrayReply<BlobStringReply>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/HYBRID.d.ts

@@ -0,0 +1,165 @@
+/// <reference types="node" />
+import { CommandParser } from "@redis/client/dist/lib/client/parser";
+import { RedisArgument, TypeMapping } from "@redis/client/dist/lib/RESP/types";
+import { RedisVariadicArgument } from "@redis/client/dist/lib/commands/generic-transformers";
+import { GroupByReducers } from "./AGGREGATE";
+/**
+ * Text search expression configuration for hybrid search.
+ */
+export interface FtHybridSearchExpression {
+    /** Search query string or parameter reference (e.g., "$q") */
+    query: RedisArgument;
+    /** Scoring algorithm configuration */
+    SCORER?: RedisArgument;
+    /** Alias for the text search score in results */
+    YIELD_SCORE_AS?: RedisArgument;
+}
+/**
+ * Vector search method configuration - either KNN or RANGE.
+ */
+export declare const FT_HYBRID_VECTOR_METHOD: {
+    /** K-Nearest Neighbors search configuration */
+    readonly KNN: "KNN";
+    /** Range-based vector search configuration */
+    readonly RANGE: "RANGE";
+};
+/** Vector search method type */
+export type FtHybridVectorMethodType = (typeof FT_HYBRID_VECTOR_METHOD)[keyof typeof FT_HYBRID_VECTOR_METHOD];
+interface FtHybridVectorMethodKNN {
+    type: (typeof FT_HYBRID_VECTOR_METHOD)["KNN"];
+    /** Number of nearest neighbors to find */
+    K: number;
+    /** Controls the search accuracy vs. speed tradeoff */
+    EF_RUNTIME?: number;
+}
+interface FtHybridVectorMethodRange {
+    type: (typeof FT_HYBRID_VECTOR_METHOD)["RANGE"];
+    /** Maximum distance for matches */
+    RADIUS: number;
+    /** Provides additional precision control */
+    EPSILON?: number;
+}
+/**
+ * Vector similarity search expression configuration.
+ */
+export interface FtHybridVectorExpression {
+    /** Vector field name (e.g., "@embedding") */
+    field: RedisArgument;
+    /** Vector parameter reference (e.g., "$v") */
+    vector: string;
+    /** Search method configuration - KNN or RANGE */
+    method?: FtHybridVectorMethodKNN | FtHybridVectorMethodRange;
+    /** Pre-filter expression applied before vector search (e.g., "@tag:{foo}") */
+    FILTER?: RedisArgument;
+    /** Alias for the vector score in results */
+    YIELD_SCORE_AS?: RedisArgument;
+}
+/**
+ * Score fusion method type constants for combining search results.
+ */
+export declare const FT_HYBRID_COMBINE_METHOD: {
+    /** Reciprocal Rank Fusion */
+    readonly RRF: "RRF";
+    /** Linear combination with ALPHA and BETA weights */
+    readonly LINEAR: "LINEAR";
+};
+/** Combine method type */
+export type FtHybridCombineMethodType = (typeof FT_HYBRID_COMBINE_METHOD)[keyof typeof FT_HYBRID_COMBINE_METHOD];
+interface FtHybridCombineMethodRRF {
+    type: (typeof FT_HYBRID_COMBINE_METHOD)["RRF"];
+    /** RRF constant for score calculation */
+    CONSTANT?: number;
+    /** Window size for score normalization */
+    WINDOW?: number;
+}
+interface FtHybridCombineMethodLinear {
+    type: (typeof FT_HYBRID_COMBINE_METHOD)["LINEAR"];
+    /** Weight for text search score */
+    ALPHA?: number;
+    /** Weight for vector search score */
+    BETA?: number;
+    /** Window size for score normalization */
+    WINDOW?: number;
+}
+/**
+ * Apply expression for result transformation.
+ */
+export interface FtHybridApply {
+    /** Transformation expression to apply */
+    expression: RedisArgument;
+    /** Alias for the computed value in output */
+    AS?: RedisArgument;
+}
+/**
+ * Options for the FT.HYBRID command.
+ */
+export interface FtHybridOptions {
+    /** Text search expression configuration */
+    SEARCH: FtHybridSearchExpression;
+    /** Vector similarity search expression configuration */
+    VSIM: FtHybridVectorExpression;
+    /** Score fusion configuration for combining SEARCH and VSIM results */
+    COMBINE?: {
+        /** Fusion method: RRF or LINEAR */
+        method: FtHybridCombineMethodRRF | FtHybridCombineMethodLinear;
+        /** Alias for the combined score in results */
+        YIELD_SCORE_AS?: RedisArgument;
+    };
+    /**
+     * Fields to load and return in results (LOAD clause).
+     * - Use `"*"` to load all fields from documents
+     * - Use a field name or array of field names to load specific fields
+     */
+    LOAD?: RedisVariadicArgument;
+    /** Group by configuration for aggregation */
+    GROUPBY?: {
+        /** Fields to group by */
+        fields: RedisVariadicArgument;
+        /** Reducer(s) to apply to each group */
+        REDUCE?: GroupByReducers | Array<GroupByReducers>;
+    };
+    /** Apply expression(s) for result transformation */
+    APPLY?: FtHybridApply | Array<FtHybridApply>;
+    /** Sort configuration for results */
+    SORTBY?: {
+        /** Fields to sort by with optional direction */
+        fields: Array<{
+            /** Field name to sort by */
+            field: RedisArgument;
+            /** Sort direction: "ASC" (ascending) or "DESC" (descending) */
+            direction?: "ASC" | "DESC";
+        }>;
+    };
+    /** Disable sorting - returns results in arbitrary order */
+    NOSORT?: boolean;
+    /** Post-filter expression applied after scoring */
+    FILTER?: RedisArgument;
+    /** Pagination configuration */
+    LIMIT?: {
+        /** Number of results to skip */
+        offset: number | RedisArgument;
+        /** Number of results to return */
+        count: number | RedisArgument;
+    };
+    /** Query parameters for parameterized queries */
+    PARAMS?: Record<string, string | number | Buffer>;
+    /** Query timeout in milliseconds */
+    TIMEOUT?: number;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, options: FtHybridOptions) => void;
+    readonly transformReply: {
+        readonly 2: (reply: unknown, _preserve?: any, _typeMapping?: TypeMapping) => HybridSearchResult;
+        readonly 3: (reply: unknown, _preserve?: any, _typeMapping?: TypeMapping) => HybridSearchResult;
+    };
+};
+export default _default;
+export interface HybridSearchResult {
+    totalResults: number;
+    executionTime: number;
+    warnings: string[];
+    results: Record<string, any>[];
+}
+//# sourceMappingURL=HYBRID.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/HYBRID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HYBRID.d.ts","sourceRoot":"","sources":["../../../lib/commands/HYBRID.ts"],"names":[],"mappings":"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"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/HYBRID.js

@@ -0,0 +1,268 @@
+"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");
+const reply_transformers_1 = require("./reply-transformers");
+/**
+ * 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,
+    parseCommand(parser, index, options) {
+        parser.push("FT.HYBRID", index);
+        parseHybridOptions(parser, options);
+    },
+    transformReply: {
+        2: (reply, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        _preserve, _typeMapping) => {
+            return transformHybridSearchResults(reply);
+        },
+        3: (reply, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        _preserve, _typeMapping) => {
+            return transformHybridSearchResults(reply);
+        },
+    },
+};
+function transformHybridSearchResults(reply) {
+    const replyMap = parseReplyMap(reply);
+    const totalResults = Number((0, reply_transformers_1.getMapValue)(replyMap, ["total_results", "totalResults"]) ?? 0);
+    const rawResults = (0, reply_transformers_1.mapLikeValues)((0, reply_transformers_1.getMapValue)(replyMap, ["results"]) ?? []);
+    const warnings = (0, reply_transformers_1.mapLikeValues)((0, reply_transformers_1.getMapValue)(replyMap, ["warnings", "warning"]) ?? []);
+    const executionTimeValue = (0, reply_transformers_1.getMapValue)(replyMap, [
+        "execution_time",
+        "executionTime",
+    ]);
+    const executionTime = executionTimeValue === undefined ? 0 : Number(executionTimeValue);
+    const results = [];
+    for (const result of rawResults) {
+        const resultMap = parseReplyMap(result);
+        const doc = {};
+        const id = (0, reply_transformers_1.getMapValue)(resultMap, ["id"]);
+        if (id != null) {
+            doc.id = id.toString();
+        }
+        Object.assign(doc, (0, reply_transformers_1.parseDocumentValue)((0, reply_transformers_1.getMapValue)(resultMap, ["values"])));
+        Object.assign(doc, (0, reply_transformers_1.parseDocumentValue)((0, reply_transformers_1.getMapValue)(resultMap, ["extra_attributes", "extraAttributes"])));
+        for (const [key, value] of Object.entries(resultMap)) {
+            if (key === "id" ||
+                key === "values" ||
+                key.toLowerCase() === "extra_attributes" ||
+                key === "extraAttributes") {
+                continue;
+            }
+            if (!Object.hasOwn(doc, key)) {
+                doc[key] = value;
+            }
+        }
+        results.push(doc);
+    }
+    return {
+        totalResults,
+        executionTime,
+        warnings: warnings.map(toWarningString),
+        results,
+    };
+}
+function parseReplyMap(reply) {
+    return (0, reply_transformers_1.mapLikeToObject)(reply);
+}
+function toWarningString(warning) {
+    if (typeof warning === 'string')
+        return warning;
+    if (warning instanceof Buffer)
+        return warning.toString();
+    if (warning === null || warning === undefined)
+        return '';
+    // Anything else (Map/Array/plain object) would collapse to "[object Object]"
+    // under a naive toString — JSON-serialize instead so the caller can read it.
+    try {
+        return JSON.stringify(warning);
+    }
+    catch {
+        return String(warning);
+    }
+}
+//# sourceMappingURL=HYBRID.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/INFO.d.ts

@@ -0,0 +1,63 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument } from "@redis/client";
+import { ArrayReply, BlobStringReply, DoubleReply, MapReply, NullReply, NumberReply, SimpleStringReply, TypeMapping } from "@redis/client/dist/lib/RESP/types";
+import { TuplesReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument) => void;
+    readonly transformReply: {
+        readonly 2: typeof transformV2Reply;
+        readonly 3: () => InfoReply;
+    };
+};
+export default _default;
+export interface InfoReply {
+    index_name: SimpleStringReply;
+    index_options: ArrayReply<SimpleStringReply>;
+    index_definition: MapReply<SimpleStringReply, SimpleStringReply>;
+    attributes: Array<MapReply<SimpleStringReply, SimpleStringReply>>;
+    num_docs: NumberReply;
+    max_doc_id: NumberReply;
+    num_terms: NumberReply;
+    num_records: NumberReply;
+    inverted_sz_mb: DoubleReply;
+    vector_index_sz_mb: DoubleReply;
+    total_inverted_index_blocks: NumberReply;
+    offset_vectors_sz_mb: DoubleReply;
+    doc_table_size_mb: DoubleReply;
+    sortable_values_size_mb: DoubleReply;
+    key_table_size_mb: DoubleReply;
+    tag_overhead_sz_mb: DoubleReply;
+    text_overhead_sz_mb: DoubleReply;
+    total_index_memory_sz_mb: DoubleReply;
+    geoshapes_sz_mb: DoubleReply;
+    records_per_doc_avg: DoubleReply;
+    bytes_per_record_avg: DoubleReply;
+    offsets_per_term_avg: DoubleReply;
+    offset_bits_per_record_avg: DoubleReply;
+    hash_indexing_failures: NumberReply;
+    total_indexing_time: DoubleReply;
+    indexing: NumberReply;
+    percent_indexed: DoubleReply;
+    number_of_uses: NumberReply;
+    cleaning: NumberReply;
+    gc_stats: {
+        bytes_collected: DoubleReply;
+        total_ms_run: DoubleReply;
+        total_cycles: DoubleReply;
+        average_cycle_time_ms: DoubleReply;
+        last_run_time_ms: DoubleReply;
+        gc_numeric_trees_missed: DoubleReply;
+        gc_blocks_denied: DoubleReply;
+    };
+    cursor_stats: {
+        global_idle: NumberReply;
+        global_total: NumberReply;
+        index_capacity: NumberReply;
+        index_total: NumberReply;
+    };
+    stopwords_list?: ArrayReply<BlobStringReply> | TuplesReply<[NullReply]>;
+}
+declare function transformV2Reply(reply: Array<unknown>, preserve?: unknown, typeMapping?: TypeMapping): InfoReply;
+//# sourceMappingURL=INFO.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/INFO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"INFO.d.ts","sourceRoot":"","sources":["../../../lib/commands/INFO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,eAAe,EAAW,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAExK,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;;;;gDAKzC,aAAa,SAAS,aAAa;;;0BAKrB,SAAS;;;AAR9C,wBAU6B;AAE7B,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;IAC7C,gBAAgB,EAAE,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC;IACjE,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAClE,QAAQ,EAAE,WAAW,CAAA;IACrB,UAAU,EAAE,WAAW,CAAC;IACxB,SAAS,EAAE,WAAW,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,cAAc,EAAE,WAAW,CAAC;IAC5B,kBAAkB,EAAE,WAAW,CAAC;IAChC,2BAA2B,EAAE,WAAW,CAAC;IACzC,oBAAoB,EAAE,WAAW,CAAC;IAClC,iBAAiB,EAAE,WAAW,CAAC;IAC/B,uBAAuB,EAAE,WAAW,CAAC;IACrC,iBAAiB,EAAE,WAAW,CAAC;IAC/B,kBAAkB,EAAE,WAAW,CAAC;IAChC,mBAAmB,EAAE,WAAW,CAAC;IACjC,wBAAwB,EAAE,WAAW,CAAC;IACtC,eAAe,EAAE,WAAW,CAAC;IAC7B,mBAAmB,EAAE,WAAW,CAAC;IACjC,oBAAoB,EAAE,WAAW,CAAC;IAClC,oBAAoB,EAAE,WAAW,CAAC;IAClC,0BAA0B,EAAE,WAAW,CAAC;IACxC,sBAAsB,EAAE,WAAW,CAAC;IACpC,mBAAmB,EAAE,WAAW,CAAC;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,eAAe,EAAE,WAAW,CAAC;IAC7B,cAAc,EAAE,WAAW,CAAC;IAC5B,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE;QACR,eAAe,EAAE,WAAW,CAAC;QAC7B,YAAY,EAAE,WAAW,CAAC;QAC1B,YAAY,EAAE,WAAW,CAAC;QAC1B,qBAAqB,EAAE,WAAW,CAAC;QACnC,gBAAgB,EAAE,WAAW,CAAC;QAC9B,uBAAuB,EAAE,WAAW,CAAC;QACrC,gBAAgB,EAAE,WAAW,CAAC;KAC/B,CAAC;IACF,YAAY,EAAE;QACZ,WAAW,EAAE,WAAW,CAAC;QACzB,YAAY,EAAE,WAAW,CAAC;QAC1B,cAAc,EAAE,WAAW,CAAC;QAC5B,WAAW,EAAE,WAAW,CAAC;KAC1B,CAAC;IACF,cAAc,CAAC,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;CACzE;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CAgGzG"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/INFO.js

@@ -0,0 +1,100 @@
+"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,
+    parseCommand(parser, index) {
+        parser.push('FT.INFO', index);
+    },
+    transformReply: {
+        2: transformV2Reply,
+        3: undefined
+    },
+};
+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

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_AGGREGATE.d.ts

@@ -0,0 +1,15 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ReplyUnion, TypeMapping, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+import { FtAggregateOptions } from './AGGREGATE';
+import { ProfileOptions, ProfileReplyResp2 } from './PROFILE_SEARCH';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: string, query: string, options?: ProfileOptions & FtAggregateOptions) => void;
+    readonly transformReply: {
+        readonly 2: (reply: [[total: UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], import("@redis/client/dist/lib/RESP/types").ArrayReply<ReplyUnion>], preserve?: any, typeMapping?: TypeMapping) => ProfileReplyResp2;
+        readonly 3: (reply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping) => ProfileReplyResp2;
+    };
+};
+export default _default;
+//# sourceMappingURL=PROFILE_AGGREGATE.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_AGGREGATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PROFILE_AGGREGATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/PROFILE_AGGREGATE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAClG,OAAkB,EAAqB,kBAAkB,EAAyB,MAAM,aAAa,CAAC;AACtG,OAAO,EACL,cAAc,EAEd,iBAAiB,EAGlB,MAAM,kBAAkB,CAAC;;;;gDAMd,aAAa,SACd,MAAM,SACN,MAAM,YACH,cAAc,GAAG,kBAAkB;;+UAgBhC,GAAG,gBACA,WAAW,KACxB,iBAAiB;4BAOX,UAAU,aAEN,GAAG,gBACA,WAAW,KACxB,iBAAiB;;;AApCxB,wBA+C6B"}

landvex-report-system/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"));
+const PROFILE_SEARCH_1 = require("./PROFILE_SEARCH");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    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, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        preserve, typeMapping) => {
+            return {
+                results: AGGREGATE_1.default.transformReply[2](reply[0], preserve, typeMapping),
+                profile: reply[1]
+            };
+        },
+        3: (reply, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        preserve, typeMapping) => {
+            return {
+                results: AGGREGATE_1.default.transformReply[3]((0, PROFILE_SEARCH_1.extractProfileResultsReply)(reply), preserve, typeMapping),
+                profile: (0, PROFILE_SEARCH_1.transformProfileReply)(reply)
+            };
+        }
+    },
+};
+//# sourceMappingURL=PROFILE_AGGREGATE.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_AGGREGATE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PROFILE_AGGREGATE.js","sourceRoot":"","sources":["../../../lib/commands/PROFILE_AGGREGATE.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,yDAAsG;AACtG,qDAM0B;AAE1B,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CACV,MAAqB,EACrB,KAAa,EACb,KAAa,EACb,OAA6C;QAE7C,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC;QAE9C,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAE5B,IAAA,iCAAqB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACxC,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CACD,KAA2D;QAC3D,iGAAiG;QACjG,QAAc,EACd,WAAyB,EACN,EAAE;YACrB,OAAO;gBACL,OAAO,EAAE,mBAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC;gBACrE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;aAClB,CAAA;QACH,CAAC;QACD,CAAC,EAAE,CACD,KAAiB;QACjB,iGAAiG;QACjG,QAAc,EACd,WAAyB,EACN,EAAE;YACrB,OAAO;gBACL,OAAO,EAAE,mBAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAClC,IAAA,2CAA0B,EAAC,KAAK,CAAC,EACjC,QAAQ,EACR,WAAW,CACZ;gBACD,OAAO,EAAE,IAAA,sCAAqB,EAAC,KAAK,CAAC;aACtC,CAAC;QACJ,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ReplyUnion, TypeMapping, UnwrapReply } from '@redis/client/dist/lib/RESP/types';\nimport AGGREGATE, { AggregateRawReply, FtAggregateOptions, parseAggregateOptions } from './AGGREGATE';\nimport {\n  ProfileOptions,\n  ProfileRawReplyResp2,\n  ProfileReplyResp2,\n  extractProfileResultsReply,\n  transformProfileReply\n} from './PROFILE_SEARCH';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(\n    parser: CommandParser,\n    index: string,\n    query: string,\n    options?: ProfileOptions & FtAggregateOptions\n  ) {\n    parser.push('FT.PROFILE', index, 'AGGREGATE');\n\n    if (options?.LIMITED) {\n      parser.push('LIMITED');\n    }\n\n    parser.push('QUERY', query);\n\n    parseAggregateOptions(parser, options)\n  },\n  transformReply: {\n    2: (\n      reply: UnwrapReply<ProfileRawReplyResp2<AggregateRawReply>>,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract\n      preserve?: any,\n      typeMapping?: TypeMapping\n    ): ProfileReplyResp2 => {\n      return {\n        results: AGGREGATE.transformReply[2](reply[0], preserve, typeMapping),\n        profile: reply[1]\n      }\n    },\n    3: (\n      reply: ReplyUnion,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract\n      preserve?: any,\n      typeMapping?: TypeMapping\n    ): ProfileReplyResp2 => {\n      return {\n        results: AGGREGATE.transformReply[3](\n          extractProfileResultsReply(reply),\n          preserve,\n          typeMapping\n        ),\n        profile: transformProfileReply(reply)\n      };\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_SEARCH.d.ts

@@ -0,0 +1,29 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, RedisArgument, ReplyUnion, TuplesReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { AggregateReply } from './AGGREGATE';
+import { FtSearchOptions, SearchRawReply, SearchReply } from './SEARCH';
+export type ProfileRawReplyResp2<T> = TuplesReply<[
+    T,
+    ArrayReply<ReplyUnion>
+]>;
+export interface ProfileReplyResp2 {
+    results: SearchReply | AggregateReply;
+    profile: ReplyUnion;
+}
+export interface ProfileOptions {
+    LIMITED?: true;
+}
+export declare function extractProfileResultsReply(reply: ReplyUnion): ReplyUnion;
+export declare function transformProfileReply(reply: ReplyUnion): ReplyUnion;
+declare function transformProfileSearchReplyResp3(reply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping): ProfileReplyResp2;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: ProfileOptions & FtSearchOptions) => void;
+    readonly transformReply: {
+        readonly 2: (reply: [SearchRawReply, ArrayReply<ReplyUnion>], preserve?: any, typeMapping?: TypeMapping) => ProfileReplyResp2;
+        readonly 3: typeof transformProfileSearchReplyResp3;
+    };
+};
+export default _default;
+//# sourceMappingURL=PROFILE_SEARCH.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_SEARCH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PROFILE_SEARCH.d.ts","sourceRoot":"","sources":["../../../lib/commands/PROFILE_SEARCH.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAW,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAe,MAAM,mCAAmC,CAAC;AAC1I,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAe,EAAE,eAAe,EAAE,cAAc,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AAGpG,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,WAAW,CAAC;IAChD,CAAC;IACD,UAAU,CAAC,UAAU,CAAC;CACvB,CAAC,CAAC;AAIH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC;IACtC,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAqBxE;AAiBD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAkBnE;AAED,iBAAS,gCAAgC,CACvC,KAAK,EAAE,UAAU,EAEjB,QAAQ,CAAC,EAAE,GAAG,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,iBAAiB,CASnB;;;;gDAMW,aAAa,SACd,aAAa,SACb,aAAa,YACV,cAAc,GAAG,eAAe;;iFAgB7B,GAAG,gBACA,WAAW,KACxB,iBAAiB;;;;AAzBxB,wBAiC6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/PROFILE_SEARCH.js

@@ -0,0 +1,105 @@
+"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 });
+exports.transformProfileReply = exports.extractProfileResultsReply = void 0;
+const SEARCH_1 = __importStar(require("./SEARCH"));
+const reply_transformers_1 = require("./reply-transformers");
+function extractProfileResultsReply(reply) {
+    const replyObject = (0, reply_transformers_1.mapLikeToObject)(reply);
+    // Redis 8+ wraps results under `Results`.
+    if (Object.hasOwn(replyObject, 'Results')) {
+        return replyObject['Results'];
+    }
+    // Redis 7.4 RESP3 returns search/aggregate payload directly at top-level.
+    if ((Object.hasOwn(replyObject, 'total_results') || Object.hasOwn(replyObject, 'total')) &&
+        Object.hasOwn(replyObject, 'results')) {
+        return reply;
+    }
+    if (Object.hasOwn(replyObject, 'results')) {
+        return replyObject['results'];
+    }
+    return ((0, reply_transformers_1.getMapValue)(replyObject, ['results']) ?? reply);
+}
+exports.extractProfileResultsReply = extractProfileResultsReply;
+function normalizeLegacyProfileReply(profile) {
+    return (0, reply_transformers_1.mapLikeEntries)(profile).map(([key, value]) => {
+        // Redis 7.4 often wraps iterator profiles as a single-element array containing an object.
+        // Tests expect the inner object normalized directly as a flat key/value list.
+        if (Array.isArray(value) && value.length === 1) {
+            const first = value[0];
+            if (Object.keys((0, reply_transformers_1.mapLikeToObject)(first)).length > 0) {
+                return [key, (0, reply_transformers_1.normalizeProfileReply)(first)];
+            }
+        }
+        return [key, (0, reply_transformers_1.normalizeProfileReply)(value)];
+    });
+}
+function transformProfileReply(reply) {
+    const replyObject = (0, reply_transformers_1.mapLikeToObject)(reply);
+    const profile = (Object.hasOwn(replyObject, 'Profile') ?
+        replyObject['Profile'] :
+        Object.hasOwn(replyObject, 'profile') ?
+            replyObject['profile'] :
+            (0, reply_transformers_1.getMapValue)(replyObject, ['Profile', 'profile']));
+    const profileObject = (0, reply_transformers_1.mapLikeToObject)(profile);
+    // Redis 7.2 - 7.4 profile payload is a plain map keyed by timing labels.
+    if (Object.hasOwn(profileObject, 'Total profile time')) {
+        return normalizeLegacyProfileReply(profile);
+    }
+    return (0, reply_transformers_1.normalizeProfileReply)(profile);
+}
+exports.transformProfileReply = transformProfileReply;
+function transformProfileSearchReplyResp3(reply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+preserve, typeMapping) {
+    return {
+        results: SEARCH_1.default.transformReply[3](extractProfileResultsReply(reply), preserve, typeMapping),
+        profile: transformProfileReply(reply)
+    };
+}
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    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, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        preserve, typeMapping) => {
+            return {
+                results: SEARCH_1.default.transformReply[2](reply[0], preserve, typeMapping),
+                profile: reply[1]
+            };
+        },
+        3: transformProfileSearchReplyResp3
+    },
+};
+//# sourceMappingURL=PROFILE_SEARCH.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH.d.ts

@@ -0,0 +1,67 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ReplyUnion, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { RediSearchLanguage } from './CREATE';
+export type FtSearchParams = Record<string, RedisArgument | number>;
+export declare function parseParamsArgument(parser: CommandParser, params?: FtSearchParams): void;
+export interface FtSearchOptions {
+    VERBATIM?: boolean;
+    NOSTOPWORDS?: boolean;
+    INKEYS?: RedisVariadicArgument;
+    INFIELDS?: RedisVariadicArgument;
+    RETURN?: RedisVariadicArgument;
+    SUMMARIZE?: boolean | {
+        FIELDS?: RedisArgument | Array<RedisArgument>;
+        FRAGS?: number;
+        LEN?: number;
+        SEPARATOR?: RedisArgument;
+    };
+    HIGHLIGHT?: boolean | {
+        FIELDS?: RedisArgument | Array<RedisArgument>;
+        TAGS?: {
+            open: RedisArgument;
+            close: RedisArgument;
+        };
+    };
+    SLOP?: number;
+    TIMEOUT?: number;
+    INORDER?: boolean;
+    LANGUAGE?: RediSearchLanguage;
+    EXPANDER?: RedisArgument;
+    SCORER?: RedisArgument;
+    SORTBY?: RedisArgument | {
+        BY: RedisArgument;
+        DIRECTION?: 'ASC' | 'DESC';
+    };
+    LIMIT?: {
+        from: number | RedisArgument;
+        size: number | RedisArgument;
+    };
+    PARAMS?: FtSearchParams;
+    DIALECT?: number;
+}
+export declare function parseSearchOptions(parser: CommandParser, options?: FtSearchOptions): void;
+declare function transformSearchReplyResp2(reply: SearchRawReply, _preserve?: any, _typeMapping?: TypeMapping): SearchReply;
+declare function transformSearchReplyResp3(rawReply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping): SearchReply;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtSearchOptions) => void;
+    readonly transformReply: {
+        readonly 2: typeof transformSearchReplyResp2;
+        readonly 3: typeof transformSearchReplyResp3;
+    };
+};
+export default _default;
+export type SearchRawReply = Array<unknown>;
+interface SearchDocumentValue {
+    [key: string]: string | number | null | Array<SearchDocumentValue> | SearchDocumentValue;
+}
+export interface SearchReply {
+    total: number;
+    documents: Array<{
+        id: string;
+        value: SearchDocumentValue;
+    }>;
+}
+//# sourceMappingURL=SEARCH.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SEARCH.d.ts","sourceRoot":"","sources":["../../../lib/commands/SEARCH.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,UAAU,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACpG,OAAO,EAAE,qBAAqB,EAAiC,MAAM,sDAAsD,CAAC;AAC5H,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAI9C,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC,CAAC;AAEpE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,cAAc,QAiBjF;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,GAAG;QACpB,MAAM,CAAC,EAAE,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;QAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,aAAa,CAAC;KAC3B,CAAC;IACF,SAAS,CAAC,EAAE,OAAO,GAAG;QACpB,MAAM,CAAC,EAAE,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;QAC9C,IAAI,CAAC,EAAE;YACL,IAAI,EAAE,aAAa,CAAC;YACpB,KAAK,EAAE,aAAa,CAAC;SACtB,CAAC;KACH,CAAC;IACF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,MAAM,CAAC,EAAE,aAAa,GAAG;QACvB,EAAE,EAAE,aAAa,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;KAC5B,CAAC;IACF,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;QAC7B,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;KAC9B,CAAC;IACF,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,QA8FlF;AAED,iBAAS,yBAAyB,CAChC,KAAK,EAAE,cAAc,EAErB,SAAS,CAAC,EAAE,GAAG,EACf,YAAY,CAAC,EAAE,WAAW,GACzB,WAAW,CAiBb;AAED,iBAAS,yBAAyB,CAChC,QAAQ,EAAE,UAAU,EAEpB,QAAQ,CAAC,EAAE,GAAG,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,WAAW,CAwBb;;;;gDAKsB,aAAa,SAAS,aAAa,SAAS,aAAa,YAAY,eAAe;;;;;;AAH3G,wBAY6B;AAE7B,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;AAE5C,UAAU,mBAAmB;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,mBAAmB,CAAC,GAAG,mBAAmB,CAAC;CAC1F;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,KAAK,CAAC;QACb,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,mBAAmB,CAAC;KAC9B,CAAC,CAAC;CACJ"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSearchOptions = exports.parseParamsArgument = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const default_1 = require("../dialect/default");
+const reply_transformers_1 = require("./reply-transformers");
+function parseParamsArgument(parser, params) {
+    if (params) {
+        parser.push('PARAMS');
+        const args = [];
+        for (const key in params) {
+            if (!Object.hasOwn(params, key))
+                continue;
+            const value = params[key];
+            args.push(key, typeof value === 'number' ? value.toString() : value);
+        }
+        parser.pushVariadicWithLength(args);
+    }
+}
+exports.parseParamsArgument = parseParamsArgument;
+function parseSearchOptions(parser, options) {
+    if (options?.VERBATIM) {
+        parser.push('VERBATIM');
+    }
+    if (options?.NOSTOPWORDS) {
+        parser.push('NOSTOPWORDS');
+    }
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'INKEYS', options?.INKEYS);
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'INFIELDS', options?.INFIELDS);
+    (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'RETURN', options?.RETURN);
+    if (options?.SUMMARIZE) {
+        parser.push('SUMMARIZE');
+        if (typeof options.SUMMARIZE === 'object') {
+            (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'FIELDS', options.SUMMARIZE.FIELDS);
+            if (options.SUMMARIZE.FRAGS !== undefined) {
+                parser.push('FRAGS', options.SUMMARIZE.FRAGS.toString());
+            }
+            if (options.SUMMARIZE.LEN !== undefined) {
+                parser.push('LEN', options.SUMMARIZE.LEN.toString());
+            }
+            if (options.SUMMARIZE.SEPARATOR !== undefined) {
+                parser.push('SEPARATOR', options.SUMMARIZE.SEPARATOR);
+            }
+        }
+    }
+    if (options?.HIGHLIGHT) {
+        parser.push('HIGHLIGHT');
+        if (typeof options.HIGHLIGHT === 'object') {
+            (0, generic_transformers_1.parseOptionalVariadicArgument)(parser, 'FIELDS', options.HIGHLIGHT.FIELDS);
+            if (options.HIGHLIGHT.TAGS) {
+                parser.push('TAGS', options.HIGHLIGHT.TAGS.open, options.HIGHLIGHT.TAGS.close);
+            }
+        }
+    }
+    if (options?.SLOP !== undefined) {
+        parser.push('SLOP', options.SLOP.toString());
+    }
+    if (options?.TIMEOUT !== undefined) {
+        parser.push('TIMEOUT', options.TIMEOUT.toString());
+    }
+    if (options?.INORDER) {
+        parser.push('INORDER');
+    }
+    if (options?.LANGUAGE) {
+        parser.push('LANGUAGE', options.LANGUAGE);
+    }
+    if (options?.EXPANDER) {
+        parser.push('EXPANDER', options.EXPANDER);
+    }
+    if (options?.SCORER) {
+        parser.push('SCORER', options.SCORER);
+    }
+    if (options?.SORTBY) {
+        parser.push('SORTBY');
+        if (typeof options.SORTBY === 'string' || options.SORTBY instanceof Buffer) {
+            parser.push(options.SORTBY);
+        }
+        else {
+            parser.push(options.SORTBY.BY);
+            if (options.SORTBY.DIRECTION) {
+                parser.push(options.SORTBY.DIRECTION);
+            }
+        }
+    }
+    if (options?.LIMIT) {
+        parser.push('LIMIT', options.LIMIT.from.toString(), options.LIMIT.size.toString());
+    }
+    parseParamsArgument(parser, options?.PARAMS);
+    if (options?.DIALECT) {
+        parser.push('DIALECT', options.DIALECT.toString());
+    }
+    else {
+        parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+    }
+}
+exports.parseSearchOptions = parseSearchOptions;
+function transformSearchReplyResp2(reply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+_preserve, _typeMapping) {
+    // if reply[2] is array, then we have content/documents. Otherwise, only ids
+    const withoutDocuments = reply.length > 2 && !Array.isArray(reply[2]);
+    const documents = [];
+    let i = 1;
+    while (i < reply.length) {
+        documents.push({
+            id: reply[i++],
+            value: (withoutDocuments ? {} : documentValue(reply[i++]))
+        });
+    }
+    return {
+        total: reply[0],
+        documents
+    };
+}
+function transformSearchReplyResp3(rawReply, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+preserve, typeMapping) {
+    if (Array.isArray(rawReply)) {
+        return transformSearchReplyResp2(rawReply, preserve, typeMapping);
+    }
+    const reply = (0, reply_transformers_1.mapLikeToObject)(rawReply);
+    const total = Number((0, reply_transformers_1.getMapValue)(reply, ['total_results', 'total']) ?? 0);
+    const results = (0, reply_transformers_1.mapLikeValues)((0, reply_transformers_1.getMapValue)(reply, ['results', 'documents']) ?? []);
+    const documents = results.map(result => {
+        const { id, value } = (0, reply_transformers_1.parseSearchResultRow)(result);
+        return {
+            id: String(id?.toString?.() ?? id ?? ''),
+            value: value
+        };
+    });
+    return {
+        total,
+        documents
+    };
+}
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.SEARCH', index, query);
+        parseSearchOptions(parser, options);
+    },
+    transformReply: {
+        2: transformSearchReplyResp2,
+        3: transformSearchReplyResp3
+    },
+};
+function documentValue(tuples) {
+    return (0, reply_transformers_1.parseDocumentValue)(tuples);
+}
+//# sourceMappingURL=SEARCH.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH_NOCONTENT.d.ts

@@ -0,0 +1,17 @@
+import { ReplyUnion, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { SearchRawReply } from './SEARCH';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client/dist/lib/RESP/types").RedisArgument, query: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./SEARCH").FtSearchOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (reply: SearchRawReply) => SearchNoContentReply;
+        readonly 3: (reply: ReplyUnion, preserve?: any, typeMapping?: TypeMapping) => SearchNoContentReply;
+    };
+};
+export default _default;
+export interface SearchNoContentReply {
+    total: number;
+    documents: Array<string>;
+}
+//# sourceMappingURL=SEARCH_NOCONTENT.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH_NOCONTENT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SEARCH_NOCONTENT.d.ts","sourceRoot":"","sources":["../../../lib/commands/SEARCH_NOCONTENT.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,UAAU,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrF,OAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;+CAUlB,oBAAoB;4BAOvC,UAAU,aAEN,GAAG,gBACA,WAAW,KACxB,oBAAoB;;;AAnB3B,wBAiC6B;AAE7B,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC1B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH_NOCONTENT.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SEARCH_1 = __importDefault(require("./SEARCH"));
+exports.default = {
+    NOT_KEYED_COMMAND: SEARCH_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: SEARCH_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        SEARCH_1.default.parseCommand(...args);
+        args[0].push('NOCONTENT');
+    },
+    transformReply: {
+        2: (reply) => {
+            return {
+                total: reply[0],
+                documents: reply.slice(1)
+            };
+        },
+        3: (reply, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract
+        preserve, typeMapping) => {
+            const transformed = SEARCH_1.default.transformReply[3](reply, preserve, typeMapping);
+            return {
+                total: transformed.total,
+                documents: transformed.documents.map(document => document.id)
+            };
+        }
+    },
+};
+;
+//# sourceMappingURL=SEARCH_NOCONTENT.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SEARCH_NOCONTENT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SEARCH_NOCONTENT.js","sourceRoot":"","sources":["../../../lib/commands/SEARCH_NOCONTENT.ts"],"names":[],"mappings":";;;;;AACA,sDAAkD;AAElD,kBAAe;IACb,iBAAiB,EAAE,gBAAM,CAAC,iBAAiB;IAC3C,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,CAAC,GAAG,IAA4C;QAC1D,gBAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5B,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CAAC,KAAqB,EAAwB,EAAE;YACjD,OAAO;gBACL,KAAK,EAAE,KAAK,CAAC,CAAC,CAAW;gBACzB,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAkB;aAC3C,CAAA;QACH,CAAC;QACD,CAAC,EAAE,CACD,KAAiB;QACjB,iGAAiG;QACjG,QAAc,EACd,WAAyB,EACH,EAAE;YACxB,MAAM,WAAW,GAAG,gBAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAKxE,CAAC;YAEF,OAAO;gBACL,KAAK,EAAE,WAAW,CAAC,KAAK;gBACxB,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC;aAC9D,CAAC;QACJ,CAAC;KACF;CACyB,CAAC;AAK5B,CAAC","sourcesContent":["import { Command, ReplyUnion, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport SEARCH, { SearchRawReply } from './SEARCH';\n\nexport default {\n  NOT_KEYED_COMMAND: SEARCH.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: SEARCH.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof SEARCH.parseCommand>) {\n    SEARCH.parseCommand(...args);\n    args[0].push('NOCONTENT');\n  },\n  transformReply: {\n    2: (reply: SearchRawReply): SearchNoContentReply => {\n      return {\n        total: reply[0] as number,\n        documents: reply.slice(1) as Array<string>\n      }\n    },\n    3: (\n      reply: ReplyUnion,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches TransformReply contract\n      preserve?: any,\n      typeMapping?: TypeMapping\n    ): SearchNoContentReply => {\n      const transformed = SEARCH.transformReply[3](reply, preserve, typeMapping) as {\n        total: number;\n        documents: Array<{\n          id: string;\n        }>;\n      };\n\n      return {\n        total: transformed.total,\n        documents: transformed.documents.map(document => document.id)\n      };\n    }\n  },\n} as const satisfies Command;\n\nexport interface SearchNoContentReply {\n  total: number;\n  documents: Array<string>;\n};\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SPELLCHECK.d.ts

@@ -0,0 +1,35 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ReplyUnion } from '@redis/client/dist/lib/RESP/types';
+export interface Terms {
+    mode: 'INCLUDE' | 'EXCLUDE';
+    dictionary: RedisArgument;
+}
+export interface FtSpellCheckOptions {
+    DISTANCE?: number;
+    TERMS?: Terms | Array<Terms>;
+    DIALECT?: number;
+}
+declare function transformSpellCheckReplyResp3(rawReply: ReplyUnion): SpellCheckReply;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, query: RedisArgument, options?: FtSpellCheckOptions) => void;
+    readonly transformReply: {
+        readonly 2: (rawReply: SpellCheckRawReply) => SpellCheckReply;
+        readonly 3: typeof transformSpellCheckReplyResp3;
+    };
+};
+export default _default;
+type SpellCheckRawReply = Array<[
+    _: string,
+    term: string,
+    suggestions: Array<[score: string, suggestion: string]>
+]>;
+type SpellCheckReply = Array<{
+    term: string;
+    suggestions: Array<{
+        score: number;
+        suggestion: string;
+    }>;
+}>;
+//# sourceMappingURL=SPELLCHECK.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SPELLCHECK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SPELLCHECK.d.ts","sourceRoot":"","sources":["../../../lib/commands/SPELLCHECK.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAIvF,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,UAAU,EAAE,aAAa,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,iBAAS,6BAA6B,CAAC,QAAQ,EAAE,UAAU,GAAG,eAAe,CAgD5E;;;;gDAKsB,aAAa,SAAS,aAAa,SAAS,aAAa,YAAY,mBAAmB;;;;;;AAH/G,wBAsC6B;AAM7B,KAAK,kBAAkB,GAAG,KAAK,CAAC;IAC9B,CAAC,EAAE,MAAM;IACT,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;CACxD,CAAC,CAAC;AAEH,KAAK,eAAe,GAAG,KAAK,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,KAAK,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAA;KACnB,CAAC,CAAA;CACH,CAAC,CAAC"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SPELLCHECK.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_1 = require("../dialect/default");
+const reply_transformers_1 = require("./reply-transformers");
+function transformSpellCheckReplyResp3(rawReply) {
+    const transformed = [];
+    const results = (0, reply_transformers_1.getMapValue)(rawReply, ['results', 'Results']) ?? rawReply;
+    for (const [term, rawSuggestions] of (0, reply_transformers_1.mapLikeEntries)(results)) {
+        const suggestions = [];
+        for (const rawSuggestion of (0, reply_transformers_1.mapLikeValues)(rawSuggestions)) {
+            if (Array.isArray(rawSuggestion) && rawSuggestion.length >= 2) {
+                const first = rawSuggestion[0];
+                const second = rawSuggestion[1];
+                const numericFirst = Number(first);
+                if (!Number.isNaN(numericFirst)) {
+                    suggestions.push({
+                        score: numericFirst,
+                        suggestion: second.toString()
+                    });
+                }
+                else {
+                    suggestions.push({
+                        score: Number(second),
+                        suggestion: first.toString()
+                    });
+                }
+                continue;
+            }
+            const entries = (0, reply_transformers_1.mapLikeEntries)(rawSuggestion);
+            if (entries.length === 0)
+                continue;
+            const [suggestion, score] = entries[0];
+            suggestions.push({
+                score: Number(score),
+                suggestion
+            });
+        }
+        transformed.push({
+            term,
+            suggestions
+        });
+    }
+    return transformed;
+}
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, query, options) {
+        parser.push('FT.SPELLCHECK', index, query);
+        if (options?.DISTANCE) {
+            parser.push('DISTANCE', options.DISTANCE.toString());
+        }
+        if (options?.TERMS) {
+            if (Array.isArray(options.TERMS)) {
+                for (const term of options.TERMS) {
+                    parseTerms(parser, term);
+                }
+            }
+            else {
+                parseTerms(parser, options.TERMS);
+            }
+        }
+        if (options?.DIALECT) {
+            parser.push('DIALECT', options.DIALECT.toString());
+        }
+        else {
+            parser.push('DIALECT', default_1.DEFAULT_DIALECT);
+        }
+    },
+    transformReply: {
+        2: (rawReply) => {
+            return rawReply.map(([, term, suggestions]) => ({
+                term,
+                suggestions: suggestions.map(([score, suggestion]) => ({
+                    score: Number(score),
+                    suggestion
+                }))
+            }));
+        },
+        3: transformSpellCheckReplyResp3,
+    },
+};
+function parseTerms(parser, { mode, dictionary }) {
+    parser.push('TERMS', mode, dictionary);
+}
+//# sourceMappingURL=SPELLCHECK.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGADD.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+export interface FtSugAddOptions {
+    INCR?: boolean;
+    PAYLOAD?: RedisArgument;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, string: RedisArgument, score: number, options?: FtSugAddOptions) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=SUGADD.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGADD.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGADD.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AAExF,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;;;gDAIsB,aAAa,OAAO,aAAa,UAAU,aAAa,SAAS,MAAM,YAAY,eAAe;mCAazE,WAAW;;AAf3D,wBAgB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGADD.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, key, string, score, options) {
+        parser.push('FT.SUGADD');
+        parser.pushKey(key);
+        parser.push(string, score.toString());
+        if (options?.INCR) {
+            parser.push('INCR');
+        }
+        if (options?.PAYLOAD) {
+            parser.push('PAYLOAD', options.PAYLOAD);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGADD.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGADD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGADD.js","sourceRoot":"","sources":["../../../lib/commands/SUGADD.ts"],"names":[],"mappings":";;AAQA,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,MAAqB,EAAE,KAAa,EAAE,OAAyB;QACrH,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEtC,IAAI,OAAO,EAAE,IAAI,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtB,CAAC;QAED,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport interface FtSugAddOptions {\n  INCR?: boolean;\n  PAYLOAD?: RedisArgument;\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, key: RedisArgument, string: RedisArgument, score: number, options?: FtSugAddOptions) {\n    parser.push('FT.SUGADD');\n    parser.pushKey(key);\n    parser.push(string, score.toString());\n\n    if (options?.INCR) {\n      parser.push('INCR');\n    }\n\n    if (options?.PAYLOAD) {\n      parser.push('PAYLOAD', options.PAYLOAD);\n    }\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGDEL.d.ts

@@ -0,0 +1,9 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, string: RedisArgument) => void;
+    readonly transformReply: () => NumberReply<0 | 1>;
+};
+export default _default;
+//# sourceMappingURL=SUGDEL.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGDEL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGDEL.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGDEL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;;;gDAIjE,aAAa,OAAO,aAAa,UAAU,aAAa;mCAK/B,YAAY,CAAC,GAAG,CAAC,CAAC;;AAPlE,wBAQ6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGDEL.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, key, string) {
+        parser.push('FT.SUGDEL');
+        parser.pushKey(key);
+        parser.push(string);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGDEL.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGDEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGDEL.js","sourceRoot":"","sources":["../../../lib/commands/SUGDEL.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,MAAqB;QAC3E,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtB,CAAC;IACD,cAAc,EAAE,SAAgD;CACtC,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, key: RedisArgument, string: RedisArgument) {\n    parser.push('FT.SUGDEL');\n    parser.pushKey(key);\n    parser.push(string);\n  },\n  transformReply: undefined as unknown as () => NumberReply<0 | 1>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { NullReply, ArrayReply, BlobStringReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+export interface FtSugGetOptions {
+    FUZZY?: boolean;
+    MAX?: number;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, prefix: RedisArgument, options?: FtSugGetOptions) => void;
+    readonly transformReply: () => NullReply | ArrayReply<BlobStringReply>;
+};
+export default _default;
+//# sourceMappingURL=SUGGET.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGGET.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAW,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEnH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;;;gDAIsB,aAAa,OAAO,aAAa,UAAU,aAAa,YAAY,eAAe;mCAa1D,SAAS,GAAG,WAAW,eAAe,CAAC;;AAfvF,wBAgB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, key, prefix, options) {
+        parser.push('FT.SUGGET');
+        parser.pushKey(key);
+        parser.push(prefix);
+        if (options?.FUZZY) {
+            parser.push('FUZZY');
+        }
+        if (options?.MAX !== undefined) {
+            parser.push('MAX', options.MAX.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGGET.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET.js","sourceRoot":"","sources":["../../../lib/commands/SUGGET.ts"],"names":[],"mappings":";;AAQA,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,MAAqB,EAAE,OAAyB;QACtG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEpB,IAAI,OAAO,EAAE,KAAK,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,OAAO,EAAE,GAAG,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAAqE;CAC3D,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { NullReply, ArrayReply, BlobStringReply, Command, RedisArgument } from '@redis/client/dist/lib/RESP/types';\n\nexport interface FtSugGetOptions {\n  FUZZY?: boolean;\n  MAX?: number;\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, key: RedisArgument, prefix: RedisArgument, options?: FtSugGetOptions) {\n    parser.push('FT.SUGGET');\n    parser.pushKey(key);\n    parser.push(prefix);\n\n    if (options?.FUZZY) {\n      parser.push('FUZZY');\n    }\n\n    if (options?.MAX !== undefined) {\n      parser.push('MAX', options.MAX.toString());\n    }\n  },\n  transformReply: undefined as unknown as () => NullReply | ArrayReply<BlobStringReply>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHPAYLOADS.d.ts

@@ -0,0 +1,11 @@
+import { NullReply, ArrayReply, BlobStringReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, prefix: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+    readonly transformReply: (this: void, reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>) => {
+        suggestion: BlobStringReply;
+        payload: BlobStringReply;
+    }[] | null;
+};
+export default _default;
+//# sourceMappingURL=SUGGET_WITHPAYLOADS.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHPAYLOADS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHPAYLOADS.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHPAYLOADS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;;;;iDAUzF,SAAS,GAAG,YAAY,WAAW,eAAe,CAAC,CAAC;oBAI1D,eAAe;iBAClB,eAAe;;;AAX9B,wBAwB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHPAYLOADS.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHPAYLOADS');
+    },
+    transformReply(reply) {
+        if ((0, generic_transformers_1.isNullReply)(reply))
+            return null;
+        const transformedReply = new Array(reply.length / 2);
+        let replyIndex = 0, arrIndex = 0;
+        while (replyIndex < reply.length) {
+            transformedReply[arrIndex++] = {
+                suggestion: reply[replyIndex++],
+                payload: reply[replyIndex++]
+            };
+        }
+        return transformedReply;
+    }
+};
+//# sourceMappingURL=SUGGET_WITHPAYLOADS.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHPAYLOADS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHPAYLOADS.js","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHPAYLOADS.ts"],"names":[],"mappings":";;;;;AACA,+FAAmF;AACnF,sDAA8B;AAE9B,kBAAe;IACb,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,CAAC,GAAG,IAA4C;QAC1D,gBAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC/B,CAAC;IACD,cAAc,CAAC,KAA2D;QACxE,IAAI,IAAA,kCAAW,EAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAEpC,MAAM,gBAAgB,GAGjB,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACjC,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,CAAC,CAAC;QACf,OAAO,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YACjC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG;gBAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;gBAC/B,OAAO,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;aAC7B,CAAC;QACJ,CAAC;QAED,OAAO,gBAAgB,CAAC;IAC1B,CAAC;CACyB,CAAC","sourcesContent":["import { NullReply, ArrayReply, BlobStringReply, UnwrapReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { isNullReply } from '@redis/client/dist/lib/commands/generic-transformers';\nimport SUGGET from './SUGGET';\n\nexport default {\n  IS_READ_ONLY: SUGGET.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof SUGGET.parseCommand>) {\n    SUGGET.parseCommand(...args);\n    args[0].push('WITHPAYLOADS');\n  },\n  transformReply(reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>) {\n    if (isNullReply(reply)) return null;\n\n    const transformedReply: Array<{\n      suggestion: BlobStringReply;\n      payload: BlobStringReply;\n    }> = new Array(reply.length / 2);\n    let replyIndex = 0,\n      arrIndex = 0;\n    while (replyIndex < reply.length) {\n      transformedReply[arrIndex++] = {\n        suggestion: reply[replyIndex++],\n        payload: reply[replyIndex++]\n      };\n    }\n\n    return transformedReply;\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES.d.ts

@@ -0,0 +1,15 @@
+import { NullReply, ArrayReply, BlobStringReply, DoubleReply, UnwrapReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+type SuggestScore = {
+    suggestion: BlobStringReply;
+    score: DoubleReply;
+};
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, prefix: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>, preserve?: unknown, typeMapping?: TypeMapping) => SuggestScore[] | null;
+        readonly 3: (reply: UnwrapReply<ArrayReply<BlobStringReply | DoubleReply>>) => SuggestScore[] | null;
+    };
+};
+export default _default;
+//# sourceMappingURL=SUGGET_WITHSCORES.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHSCORES.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHSCORES.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAW,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAI3I,KAAK,YAAY,GAAG;IAClB,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC;CACpB,CAAA;;;;;4BASc,SAAS,GAAG,YAAY,WAAW,eAAe,CAAC,CAAC,aAAa,OAAO,gBAAgB,WAAW;4BAenG,YAAY,WAAW,eAAe,GAAG,WAAW,CAAC,CAAC;;;AAtBrE,wBAsC6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHSCORES');
+    },
+    transformReply: {
+        2: (reply, preserve, typeMapping) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 2);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: generic_transformers_1.transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping)
+                };
+            }
+            return transformedReply;
+        },
+        3: (reply) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 2);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        }
+    }
+};
+//# sourceMappingURL=SUGGET_WITHSCORES.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHSCORES.js","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHSCORES.ts"],"names":[],"mappings":";;;;;AACA,+FAAyG;AACzG,sDAA8B;AAO9B,kBAAe;IACb,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,CAAC,GAAG,IAA4C;QAC1D,gBAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC7B,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CAAC,KAA2D,EAAE,QAAkB,EAAE,WAAyB,EAAE,EAAE;YAChH,IAAI,IAAA,kCAAW,EAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAEpC,MAAM,gBAAgB,GAAwB,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC1E,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,CAAC,CAAC;YACf,OAAO,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG;oBAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;oBAC/B,KAAK,EAAE,2CAAoB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC;iBAC3E,CAAC;YACJ,CAAC;YAED,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,CAAC,EAAE,CAAC,KAA6D,EAAE,EAAE;YACnE,IAAI,IAAA,kCAAW,EAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAEpC,MAAM,gBAAgB,GAAwB,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC1E,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,CAAC,CAAC;YACf,OAAO,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG;oBAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAoB;oBAClD,KAAK,EAAE,KAAK,CAAC,UAAU,EAAE,CAAgB;iBAC1C,CAAC;YACJ,CAAC;YAED,OAAO,gBAAgB,CAAC;QAC1B,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { NullReply, ArrayReply, BlobStringReply, DoubleReply, UnwrapReply, Command, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport { isNullReply, transformDoubleReply } from '@redis/client/dist/lib/commands/generic-transformers';\nimport SUGGET from './SUGGET';\n\ntype SuggestScore = {\n  suggestion: BlobStringReply;\n  score: DoubleReply;\n}\n\nexport default {\n  IS_READ_ONLY: SUGGET.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof SUGGET.parseCommand>) {\n    SUGGET.parseCommand(...args);\n    args[0].push('WITHSCORES');\n  },\n  transformReply: {\n    2: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>, preserve?: unknown, typeMapping?: TypeMapping) => {\n      if (isNullReply(reply)) return null;\n\n      const transformedReply: Array<SuggestScore> = new Array(reply.length / 2);\n      let replyIndex = 0,\n        arrIndex = 0;\n      while (replyIndex < reply.length) {\n        transformedReply[arrIndex++] = {\n          suggestion: reply[replyIndex++],\n          score: transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping)\n        };\n      }\n\n      return transformedReply;\n    },\n    3: (reply: UnwrapReply<ArrayReply<BlobStringReply | DoubleReply>>) => {\n      if (isNullReply(reply)) return null;\n      \n      const transformedReply: Array<SuggestScore> = new Array(reply.length / 2);\n      let replyIndex = 0,\n        arrIndex = 0;\n      while (replyIndex < reply.length) {\n        transformedReply[arrIndex++] = {\n          suggestion: reply[replyIndex++] as BlobStringReply,\n          score: reply[replyIndex++] as DoubleReply\n        };\n      }\n\n      return transformedReply;\n    }\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.d.ts

@@ -0,0 +1,16 @@
+import { NullReply, ArrayReply, BlobStringReply, DoubleReply, UnwrapReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+type SuggestScoreWithPayload = {
+    suggestion: BlobStringReply;
+    score: DoubleReply;
+    payload: BlobStringReply;
+};
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, prefix: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>, preserve?: unknown, typeMapping?: TypeMapping) => SuggestScoreWithPayload[] | null;
+        readonly 3: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply | DoubleReply>>) => SuggestScoreWithPayload[] | null;
+    };
+};
+export default _default;
+//# sourceMappingURL=SUGGET_WITHSCORES_WITHPAYLOADS.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHSCORES_WITHPAYLOADS.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,WAAW,EAAW,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAI3I,KAAK,uBAAuB,GAAG;IAC7B,UAAU,EAAE,eAAe,CAAC;IAC5B,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAA;;;;;4BAYc,SAAS,GAAG,YAAY,WAAW,eAAe,CAAC,CAAC,aAAa,OAAO,gBAAgB,WAAW;4BAgBnG,SAAS,GAAG,YAAY,WAAW,eAAe,GAAG,WAAW,CAAC,CAAC;;;AA1BjF,wBA2C6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+exports.default = {
+    IS_READ_ONLY: SUGGET_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        SUGGET_1.default.parseCommand(...args);
+        args[0].push('WITHSCORES', 'WITHPAYLOADS');
+    },
+    transformReply: {
+        2: (reply, preserve, typeMapping) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 3);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: generic_transformers_1.transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping),
+                    payload: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        },
+        3: (reply) => {
+            if ((0, generic_transformers_1.isNullReply)(reply))
+                return null;
+            const transformedReply = new Array(reply.length / 3);
+            let replyIndex = 0, arrIndex = 0;
+            while (replyIndex < reply.length) {
+                transformedReply[arrIndex++] = {
+                    suggestion: reply[replyIndex++],
+                    score: reply[replyIndex++],
+                    payload: reply[replyIndex++]
+                };
+            }
+            return transformedReply;
+        }
+    }
+};
+//# sourceMappingURL=SUGGET_WITHSCORES_WITHPAYLOADS.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGGET_WITHSCORES_WITHPAYLOADS.js","sourceRoot":"","sources":["../../../lib/commands/SUGGET_WITHSCORES_WITHPAYLOADS.ts"],"names":[],"mappings":";;;;;AACA,+FAAyG;AACzG,sDAA8B;AAQ9B,kBAAe;IACb,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,CAAC,GAAG,IAA4C;QAC1D,gBAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CACV,YAAY,EACZ,cAAc,CACf,CAAC;IACJ,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CAAC,KAA2D,EAAE,QAAkB,EAAE,WAAyB,EAAE,EAAE;YAChH,IAAI,IAAA,kCAAW,EAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAEpC,MAAM,gBAAgB,GAAmC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACrF,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,CAAC,CAAC;YACf,OAAO,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG;oBAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;oBAC/B,KAAK,EAAE,2CAAoB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC;oBAC1E,OAAO,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC;iBAC7B,CAAC;YACJ,CAAC;YAED,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,CAAC,EAAE,CAAC,KAAyE,EAAE,EAAE;YAC/E,IAAI,IAAA,kCAAW,EAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YAEpC,MAAM,gBAAgB,GAAmC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACrF,IAAI,UAAU,GAAG,CAAC,EAChB,QAAQ,GAAG,CAAC,CAAC;YACf,OAAO,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG;oBAC7B,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAoB;oBAClD,KAAK,EAAE,KAAK,CAAC,UAAU,EAAE,CAAgB;oBACzC,OAAO,EAAE,KAAK,CAAC,UAAU,EAAE,CAAoB;iBAChD,CAAC;YACJ,CAAC;YAED,OAAO,gBAAgB,CAAC;QAC1B,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { NullReply, ArrayReply, BlobStringReply, DoubleReply, UnwrapReply, Command, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport { isNullReply, transformDoubleReply } from '@redis/client/dist/lib/commands/generic-transformers';\nimport SUGGET from './SUGGET';\n\ntype SuggestScoreWithPayload = {\n  suggestion: BlobStringReply;\n  score: DoubleReply;\n  payload: BlobStringReply;\n}\n\nexport default {\n  IS_READ_ONLY: SUGGET.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof SUGGET.parseCommand>) {\n    SUGGET.parseCommand(...args);\n    args[0].push(\n      'WITHSCORES',\n      'WITHPAYLOADS'\n    );\n  },\n  transformReply: {\n    2: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply>>, preserve?: unknown, typeMapping?: TypeMapping) => {\n      if (isNullReply(reply)) return null;\n\n      const transformedReply: Array<SuggestScoreWithPayload> = new Array(reply.length / 3);\n      let replyIndex = 0,\n        arrIndex = 0;\n      while (replyIndex < reply.length) {\n        transformedReply[arrIndex++] = {\n          suggestion: reply[replyIndex++],\n          score: transformDoubleReply[2](reply[replyIndex++], preserve, typeMapping),\n          payload: reply[replyIndex++]\n        };\n      }\n\n      return transformedReply;\n    },\n    3: (reply: NullReply | UnwrapReply<ArrayReply<BlobStringReply | DoubleReply>>) => {\n      if (isNullReply(reply)) return null;\n\n      const transformedReply: Array<SuggestScoreWithPayload> = new Array(reply.length / 3);\n      let replyIndex = 0,\n        arrIndex = 0;\n      while (replyIndex < reply.length) {\n        transformedReply[arrIndex++] = {\n          suggestion: reply[replyIndex++] as BlobStringReply,\n          score: reply[replyIndex++] as DoubleReply,\n          payload: reply[replyIndex++] as BlobStringReply\n        };\n      }\n\n      return transformedReply;\n    }\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGLEN.d.ts

@@ -0,0 +1,9 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=SUGLEN.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGLEN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGLEN.d.ts","sourceRoot":"","sources":["../../../lib/commands/SUGLEN.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;;;gDAIjE,aAAa,OAAO,aAAa;mCAGR,WAAW;;AAL3D,wBAM6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGLEN.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, key) {
+        parser.push('FT.SUGLEN', key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SUGLEN.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SUGLEN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SUGLEN.js","sourceRoot":"","sources":["../../../lib/commands/SUGLEN.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,GAAkB;QACpD,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IAChC,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, key: RedisArgument) {\n    parser.push('FT.SUGLEN', key);\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNDUMP.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, MapReply, BlobStringReply, ArrayReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument) => void;
+    readonly transformReply: {
+        readonly 2: (reply: UnwrapReply<ArrayReply<BlobStringReply | ArrayReply<BlobStringReply>>>) => Record<string, ArrayReply<BlobStringReply<string>>>;
+        readonly 3: () => MapReply<BlobStringReply, ArrayReply<BlobStringReply>>;
+    };
+};
+export default _default;
+//# sourceMappingURL=SYNDUMP.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNDUMP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SYNDUMP.d.ts","sourceRoot":"","sources":["../../../lib/commands/SYNDUMP.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;;;;gDAKxG,aAAa,SAAS,aAAa;;4BAI3C,YAAY,WAAW,eAAe,GAAG,WAAW,eAAe,CAAC,CAAC,CAAC;0BAUhD,SAAS,eAAe,EAAE,WAAW,eAAe,CAAC,CAAC;;;AAjB3F,wBAmB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNDUMP.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index) {
+        parser.push('FT.SYNDUMP', index);
+    },
+    transformReply: {
+        2: (reply) => {
+            const result = {};
+            let i = 0;
+            while (i < reply.length) {
+                const key = reply[i++].toString(), value = reply[i++];
+                result[key] = value;
+            }
+            return result;
+        },
+        3: undefined
+    }
+};
+//# sourceMappingURL=SYNDUMP.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNDUMP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SYNDUMP.js","sourceRoot":"","sources":["../../../lib/commands/SYNDUMP.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB;QACtD,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,CAAC,KAA6E,EAAE,EAAE;YACnF,MAAM,MAAM,GAAgD,EAAE,CAAC;YAC/D,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;gBACxB,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,EAAE,CAA6C,CAAC,QAAQ,EAAE,EAC5E,KAAK,GAAG,KAAK,CAAC,CAAC,EAAE,CAA2C,CAAC;gBAC/D,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACtB,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,CAAC,EAAE,SAAoF;KACxF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, MapReply, BlobStringReply, ArrayReply, UnwrapReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument) {\n    parser.push('FT.SYNDUMP', index);\n  },\n  transformReply: {\n    2: (reply: UnwrapReply<ArrayReply<BlobStringReply | ArrayReply<BlobStringReply>>>) => {\n      const result: Record<string, ArrayReply<BlobStringReply>> = {};\n      let i = 0;\n      while (i < reply.length) {\n        const key = (reply[i++] as unknown as UnwrapReply<BlobStringReply>).toString(),\n          value = reply[i++] as unknown as ArrayReply<BlobStringReply>;\n        result[key] = value;\n      }\n      return result;\n    },\n    3: undefined as unknown as () => MapReply<BlobStringReply, ArrayReply<BlobStringReply>>\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNUPDATE.d.ts

@@ -0,0 +1,14 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { SimpleStringReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+export interface FtSynUpdateOptions {
+    SKIPINITIALSCAN?: boolean;
+}
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, groupId: RedisArgument, terms: RedisVariadicArgument, options?: FtSynUpdateOptions) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=SYNUPDATE.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNUPDATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SYNUPDATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/SYNUPDATE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAW,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAE7F,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;;;;gDAMW,aAAa,SACd,aAAa,WACX,aAAa,SACf,qBAAqB,YAClB,kBAAkB;mCAUgB,kBAAkB,IAAI,CAAC;;AAlBvE,wBAmB6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNUPDATE.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, groupId, terms, options) {
+        parser.push('FT.SYNUPDATE', index, groupId);
+        if (options?.SKIPINITIALSCAN) {
+            parser.push('SKIPINITIALSCAN');
+        }
+        parser.pushVariadic(terms);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=SYNUPDATE.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/SYNUPDATE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SYNUPDATE.js","sourceRoot":"","sources":["../../../lib/commands/SYNUPDATE.ts"],"names":[],"mappings":";;AAQA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CACV,MAAqB,EACrB,KAAoB,EACpB,OAAsB,EACtB,KAA4B,EAC5B,OAA4B;QAE5B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAE5C,IAAI,OAAO,EAAE,eAAe,EAAE,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACjC,CAAC;QAED,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { SimpleStringReply, Command, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\n\nexport interface FtSynUpdateOptions {\n  SKIPINITIALSCAN?: boolean;\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(\n    parser: CommandParser,\n    index: RedisArgument,\n    groupId: RedisArgument,\n    terms: RedisVariadicArgument,\n    options?: FtSynUpdateOptions\n  ) {\n    parser.push('FT.SYNUPDATE', index, groupId);\n\n    if (options?.SKIPINITIALSCAN) {\n      parser.push('SKIPINITIALSCAN');\n    }\n\n    parser.pushVariadic(terms);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/TAGVALS.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, ArrayReply, SetReply, BlobStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, index: RedisArgument, fieldName: RedisArgument) => void;
+    readonly transformReply: {
+        readonly 2: () => ArrayReply<BlobStringReply>;
+        readonly 3: () => SetReply<BlobStringReply>;
+    };
+};
+export default _default;
+//# sourceMappingURL=TAGVALS.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/TAGVALS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TAGVALS.d.ts","sourceRoot":"","sources":["../../../lib/commands/TAGVALS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAW,MAAM,mCAAmC,CAAC;;;;gDAK3F,aAAa,SAAS,aAAa,aAAa,aAAa;;0BAI/C,WAAW,eAAe,CAAC;0BAC3B,SAAS,eAAe,CAAC;;;AAR9D,wBAU6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/TAGVALS.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, index, fieldName) {
+        parser.push('FT.TAGVALS', index, fieldName);
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=TAGVALS.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/TAGVALS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TAGVALS.js","sourceRoot":"","sources":["../../../lib/commands/TAGVALS.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,KAAoB,EAAE,SAAwB;QAChF,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAC9C,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,SAAyD;QAC5D,CAAC,EAAE,SAAuD;KAC3D;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, ArrayReply, SetReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, index: RedisArgument, fieldName: RedisArgument) {\n    parser.push('FT.TAGVALS', index, fieldName);\n  },\n  transformReply: {\n    2: undefined as unknown as () => ArrayReply<BlobStringReply>,\n    3: undefined as unknown as () => SetReply<BlobStringReply>\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/_LIST.d.ts

@@ -0,0 +1,13 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, SetReply, BlobStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser) => void;
+    readonly transformReply: {
+        readonly 2: () => ArrayReply<BlobStringReply>;
+        readonly 3: () => SetReply<BlobStringReply>;
+    };
+};
+export default _default;
+//# sourceMappingURL=_LIST.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/_LIST.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_LIST.d.ts","sourceRoot":"","sources":["../../../lib/commands/_LIST.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAW,MAAM,mCAAmC,CAAC;;;;gDAK5E,aAAa;;0BAIC,WAAW,eAAe,CAAC;0BAC3B,SAAS,eAAe,CAAC;;;AAR9D,wBAU6B"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/_LIST.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser) {
+        parser.push('FT._LIST');
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=_LIST.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/_LIST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_LIST.js","sourceRoot":"","sources":["../../../lib/commands/_LIST.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB;QAChC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1B,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,SAAyD;QAC5D,CAAC,EAAE,SAAuD;KAC3D;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { ArrayReply, SetReply, BlobStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser) {\n    parser.push('FT._LIST');\n  },\n  transformReply: {\n    2: undefined as unknown as () => ArrayReply<BlobStringReply>,\n    3: undefined as unknown as () => SetReply<BlobStringReply>\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/index.d.ts

@@ -0,0 +1,1065 @@
+/// <reference types="node" />
+declare const _default: {
+    /**
+     * Lists all existing indexes in the database.
+     */
+    _LIST: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Lists all existing indexes in the database.
+     */
+    _list: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Alters an existing RediSearch index schema by adding new fields.
+     * @param index - The index to alter
+     * @param schema - The schema definition containing new fields to add
+     */
+    ALTER: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, schema: import("./CREATE").RediSearchSchema) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Alters an existing RediSearch index schema by adding new fields.
+     * @param index - The index to alter
+     * @param schema - The schema definition containing new fields to add
+     */
+    alter: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, schema: import("./CREATE").RediSearchSchema) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Performs an aggregation with a cursor for retrieving large result sets.
+     * @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
+     */
+    AGGREGATE_WITHCURSOR: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./AGGREGATE_WITHCURSOR").FtAggregateWithCursorOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [result: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], cursor: import("@redis/client/dist/lib/RESP/types").NumberReply<number>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+        };
+    };
+    /**
+     * Performs an aggregation with a cursor for retrieving large result sets.
+     * @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
+     */
+    aggregateWithCursor: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./AGGREGATE_WITHCURSOR").FtAggregateWithCursorOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [result: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], cursor: import("@redis/client/dist/lib/RESP/types").NumberReply<number>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+        };
+    };
+    /**
+     * Performs an aggregation query on a RediSearch index.
+     * @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
+     */
+    AGGREGATE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./AGGREGATE").FtAggregateOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (rawReply: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE").AggregateReply;
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE").AggregateReply;
+        };
+    };
+    /**
+     * Performs an aggregation query on a RediSearch index.
+     * @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
+     */
+    aggregate: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./AGGREGATE").FtAggregateOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (rawReply: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE").AggregateReply;
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE").AggregateReply;
+        };
+    };
+    /**
+     * Adds an alias to a RediSearch index.
+     * @param alias - The alias to add
+     * @param index - The index name to alias
+     */
+    ALIASADD: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Adds an alias to a RediSearch index.
+     * @param alias - The alias to add
+     * @param index - The index name to alias
+     */
+    aliasAdd: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Removes an existing alias from a RediSearch index.
+     * @param alias - The alias to remove
+     */
+    ALIASDEL: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Removes an existing alias from a RediSearch index.
+     * @param alias - The alias to remove
+     */
+    aliasDel: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Updates the index pointed to by an existing alias.
+     * @param alias - The existing alias to update
+     * @param index - The new index name that the alias should point to
+     */
+    ALIASUPDATE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Updates the index pointed to by an existing alias.
+     * @param alias - The existing alias to update
+     * @param index - The new index name that the alias should point to
+     */
+    aliasUpdate: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, alias: import("@redis/client").RedisArgument, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Gets a RediSearch configuration option value.
+     * @param option - The name of the configuration option to retrieve
+     */
+    CONFIG_GET: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, option: string) => void;
+        readonly transformReply: (this: void, reply: import("@redis/client/dist/lib/RESP/types").TuplesReply<[import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").NullReply]>[]) => Record<string, unknown>;
+    };
+    /**
+     * Gets a RediSearch configuration option value.
+     * @param option - The name of the configuration option to retrieve
+     */
+    configGet: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, option: string) => void;
+        readonly transformReply: (this: void, reply: import("@redis/client/dist/lib/RESP/types").TuplesReply<[import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").NullReply]>[]) => Record<string, unknown>;
+    };
+    /**
+     * Sets a RediSearch configuration option value.
+     * @param property - The name of the configuration option to set
+     * @param value - The value to set for the configuration option
+     */
+    CONFIG_SET: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, property: Buffer | (string & {}) | "a" | "b", value: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Sets a RediSearch configuration option value.
+     * @param property - The name of the configuration option to set
+     * @param value - The value to set for the configuration option
+     */
+    configSet: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, property: Buffer | (string & {}) | "a" | "b", value: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a new search index with the given schema and options.
+     * @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
+     */
+    CREATE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, schema: import("./CREATE").RediSearchSchema, options?: import("./CREATE").CreateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a new search index with the given schema and options.
+     * @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
+     */
+    create: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, schema: import("./CREATE").RediSearchSchema, options?: import("./CREATE").CreateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Deletes a cursor from an index.
+     * @param index - The index name that contains the cursor
+     * @param cursorId - The cursor ID to delete
+     */
+    CURSOR_DEL: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, cursorId: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Deletes a cursor from an index.
+     * @param index - The index name that contains the cursor
+     * @param cursorId - The cursor ID to delete
+     */
+    cursorDel: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, cursorId: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Reads from an existing cursor to get more results from an index.
+     * @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
+     */
+    CURSOR_READ: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, cursor: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, options?: import("./CURSOR_READ").FtCursorReadOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [result: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], cursor: import("@redis/client/dist/lib/RESP/types").NumberReply<number>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+        };
+    };
+    /**
+     * Reads from an existing cursor to get more results from an index.
+     * @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
+     */
+    cursorRead: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, cursor: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, options?: import("./CURSOR_READ").FtCursorReadOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [result: [total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], cursor: import("@redis/client/dist/lib/RESP/types").NumberReply<number>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./AGGREGATE_WITHCURSOR").AggregateWithCursorReply;
+        };
+    };
+    /**
+     * Adds terms to a dictionary.
+     * @param dictionary - Name of the dictionary to add terms to
+     * @param term - One or more terms to add to the dictionary
+     */
+    DICTADD: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument, term: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Adds terms to a dictionary.
+     * @param dictionary - Name of the dictionary to add terms to
+     * @param term - One or more terms to add to the dictionary
+     */
+    dictAdd: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument, term: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes terms from a dictionary.
+     * @param dictionary - Name of the dictionary to remove terms from
+     * @param term - One or more terms to delete from the dictionary
+     */
+    DICTDEL: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument, term: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes terms from a dictionary.
+     * @param dictionary - Name of the dictionary to remove terms from
+     * @param term - One or more terms to delete from the dictionary
+     */
+    dictDel: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument, term: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Returns all terms in a dictionary.
+     * @param dictionary - Name of the dictionary to dump
+     */
+    DICTDUMP: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Returns all terms in a dictionary.
+     * @param dictionary - Name of the dictionary to dump
+     */
+    dictDump: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, dictionary: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Deletes an index and all associated documents.
+     * @param index - Name of the index to delete
+     * @param options - Optional parameters:
+     *   - DD: Also delete the indexed documents themselves
+     */
+    DROPINDEX: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, options?: import("./DROPINDEX").FtDropIndexOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+        };
+    };
+    /**
+     * Deletes an index and all associated documents.
+     * @param index - Name of the index to delete
+     * @param options - Optional parameters:
+     *   - DD: Also delete the indexed documents themselves
+     */
+    dropIndex: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, options?: import("./DROPINDEX").FtDropIndexOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+        };
+    };
+    /**
+     * Returns the execution plan for a complex query.
+     * @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)
+     */
+    EXPLAIN: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./EXPLAIN").FtExplainOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<string>;
+    };
+    /**
+     * Returns the execution plan for a complex query.
+     * @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)
+     */
+    explain: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./EXPLAIN").FtExplainOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<string>;
+    };
+    /**
+     * Returns the execution plan for a complex query in a more verbose format than FT.EXPLAIN.
+     * @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)
+     */
+    EXPLAINCLI: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./EXPLAINCLI").FtExplainCLIOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+    };
+    /**
+     * Returns the execution plan for a complex query in a more verbose format than FT.EXPLAIN.
+     * @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)
+     */
+    explainCli: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./EXPLAINCLI").FtExplainCLIOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+    };
+    /**
+     * 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 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
+     */
+    HYBRID: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, options: import("./HYBRID").FtHybridOptions) => void;
+        readonly transformReply: {
+            readonly 2: (reply: unknown, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./HYBRID").HybridSearchResult;
+            readonly 3: (reply: unknown, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./HYBRID").HybridSearchResult;
+        };
+    };
+    /**
+     * 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 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
+     */
+    hybrid: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, options: import("./HYBRID").FtHybridOptions) => void;
+        readonly transformReply: {
+            readonly 2: (reply: unknown, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./HYBRID").HybridSearchResult;
+            readonly 3: (reply: unknown, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./HYBRID").HybridSearchResult;
+        };
+    };
+    /**
+     * Returns information and statistics about an index.
+     * @param index - Name of the index to get information about
+     */
+    INFO: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: (reply: unknown[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./INFO").InfoReply;
+            readonly 3: () => import("./INFO").InfoReply;
+        };
+    };
+    /**
+     * Returns information and statistics about an index.
+     * @param index - Name of the index to get information about
+     */
+    info: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: (reply: unknown[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./INFO").InfoReply;
+            readonly 3: () => import("./INFO").InfoReply;
+        };
+    };
+    /**
+     * Profiles the execution of a search query for performance analysis.
+     * @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
+     */
+    PROFILESEARCH: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: (import("./PROFILE_SEARCH").ProfileOptions & import("./SEARCH").FtSearchOptions) | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [import("./SEARCH").SearchRawReply, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").ReplyUnion>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+        };
+    };
+    /**
+     * Profiles the execution of a search query for performance analysis.
+     * @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
+     */
+    profileSearch: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: (import("./PROFILE_SEARCH").ProfileOptions & import("./SEARCH").FtSearchOptions) | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [import("./SEARCH").SearchRawReply, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").ReplyUnion>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+        };
+    };
+    /**
+     * Profiles the execution of an aggregation query for performance analysis.
+     * @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
+     */
+    PROFILEAGGREGATE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: string, query: string, options?: (import("./PROFILE_SEARCH").ProfileOptions & import("./AGGREGATE").FtAggregateOptions) | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [[total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").ReplyUnion>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+        };
+    };
+    /**
+     * Profiles the execution of an aggregation query for performance analysis.
+     * @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
+     */
+    profileAggregate: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: string, query: string, options?: (import("./PROFILE_SEARCH").ProfileOptions & import("./AGGREGATE").FtAggregateOptions) | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: [[total: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").NumberReply<number>>, ...results: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>[]], import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").ReplyUnion>], preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./PROFILE_SEARCH").ProfileReplyResp2;
+        };
+    };
+    /**
+     * Performs a search query but returns only document ids without their contents.
+     * @param args - Same parameters as FT.SEARCH:
+     *   - parser: The command parser
+     *   - index: Name of the index to search
+     *   - query: The text query to search
+     *   - options: Optional search parameters
+     */
+    SEARCH_NOCONTENT: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SEARCH").FtSearchOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./SEARCH").SearchRawReply) => import("./SEARCH_NOCONTENT").SearchNoContentReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH_NOCONTENT").SearchNoContentReply;
+        };
+    };
+    /**
+     * Performs a search query but returns only document ids without their contents.
+     * @param args - Same parameters as FT.SEARCH:
+     *   - parser: The command parser
+     *   - index: Name of the index to search
+     *   - query: The text query to search
+     *   - options: Optional search parameters
+     */
+    searchNoContent: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SEARCH").FtSearchOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./SEARCH").SearchRawReply) => import("./SEARCH_NOCONTENT").SearchNoContentReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH_NOCONTENT").SearchNoContentReply;
+        };
+    };
+    /**
+     * Searches a RediSearch index with the given query.
+     * @param index - The index name to search
+     * @param query - The text query to search. For syntax, see https://redis.io/docs/stack/search/reference/query_syntax
+     * @param options - Optional search parameters including:
+     *   - VERBATIM: do not try to use stemming for query expansion
+     *   - NOSTOPWORDS: do not filter stopwords from the query
+     *   - INKEYS/INFIELDS: restrict the search to specific keys/fields
+     *   - RETURN: limit which fields are returned
+     *   - SUMMARIZE/HIGHLIGHT: create search result highlights
+     *   - LIMIT: pagination control
+     *   - SORTBY: sort results by a specific field
+     *   - PARAMS: bind parameters to the query
+     */
+    SEARCH: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SEARCH").FtSearchOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./SEARCH").SearchRawReply, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH").SearchReply;
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH").SearchReply;
+        };
+    };
+    /**
+     * Searches a RediSearch index with the given query.
+     * @param index - The index name to search
+     * @param query - The text query to search. For syntax, see https://redis.io/docs/stack/search/reference/query_syntax
+     * @param options - Optional search parameters including:
+     *   - VERBATIM: do not try to use stemming for query expansion
+     *   - NOSTOPWORDS: do not filter stopwords from the query
+     *   - INKEYS/INFIELDS: restrict the search to specific keys/fields
+     *   - RETURN: limit which fields are returned
+     *   - SUMMARIZE/HIGHLIGHT: create search result highlights
+     *   - LIMIT: pagination control
+     *   - SORTBY: sort results by a specific field
+     *   - PARAMS: bind parameters to the query
+     */
+    search: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SEARCH").FtSearchOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./SEARCH").SearchRawReply, _preserve?: any, _typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH").SearchReply;
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: any, typeMapping?: import("@redis/client").TypeMapping | undefined) => import("./SEARCH").SearchReply;
+        };
+    };
+    /**
+     * Performs spelling correction on a search query.
+     * @param index - Name of the index to use for spelling corrections
+     * @param query - The search query to check for spelling
+     * @param options - Optional parameters:
+     *   - DISTANCE: Maximum Levenshtein distance for spelling suggestions
+     *   - TERMS: Custom dictionary terms to include/exclude
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    SPELLCHECK: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SPELLCHECK").FtSpellCheckOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (rawReply: [_: string, term: string, suggestions: [score: string, suggestion: string][]][]) => {
+                term: string;
+                suggestions: {
+                    score: number;
+                    suggestion: string;
+                }[];
+            }[];
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion) => {
+                term: string;
+                suggestions: {
+                    score: number;
+                    suggestion: string;
+                }[];
+            }[];
+        };
+    };
+    /**
+     * Performs spelling correction on a search query.
+     * @param index - Name of the index to use for spelling corrections
+     * @param query - The search query to check for spelling
+     * @param options - Optional parameters:
+     *   - DISTANCE: Maximum Levenshtein distance for spelling suggestions
+     *   - TERMS: Custom dictionary terms to include/exclude
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    spellCheck: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, query: import("@redis/client").RedisArgument, options?: import("./SPELLCHECK").FtSpellCheckOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (rawReply: [_: string, term: string, suggestions: [score: string, suggestion: string][]][]) => {
+                term: string;
+                suggestions: {
+                    score: number;
+                    suggestion: string;
+                }[];
+            }[];
+            readonly 3: (rawReply: import("@redis/client/dist/lib/RESP/types").ReplyUnion) => {
+                term: string;
+                suggestions: {
+                    score: number;
+                    suggestion: string;
+                }[];
+            }[];
+        };
+    };
+    /**
+     * Adds a suggestion string to an auto-complete suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to add
+     * @param score - The suggestion score used for sorting
+     * @param options - Optional parameters:
+     *   - INCR: If true, increment the existing entry's score
+     *   - PAYLOAD: Optional payload to associate with the suggestion
+     */
+    SUGADD: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, string: import("@redis/client").RedisArgument, score: number, options?: import("./SUGADD").FtSugAddOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Adds a suggestion string to an auto-complete suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to add
+     * @param score - The suggestion score used for sorting
+     * @param options - Optional parameters:
+     *   - INCR: If true, increment the existing entry's score
+     *   - PAYLOAD: Optional payload to associate with the suggestion
+     */
+    sugAdd: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, string: import("@redis/client").RedisArgument, score: number, options?: import("./SUGADD").FtSugAddOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes a string from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to delete
+     */
+    SUGDEL: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, string: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<0 | 1>;
+    };
+    /**
+     * Deletes a string from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to delete
+     */
+    sugDel: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, string: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<0 | 1>;
+    };
+    /**
+     * Gets completion suggestions with their payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHPAYLOADS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: (this: void, reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]) => {
+            suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+        }[] | null;
+    };
+    /**
+     * Gets completion suggestions with their payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithPayloads: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: (this: void, reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]) => {
+            suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+        }[] | null;
+    };
+    /**
+     * Gets completion suggestions with their scores and payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHSCORES_WITHPAYLOADS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            }[] | null;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").DoubleReply<number>)[]) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            }[] | null;
+        };
+    };
+    /**
+     * Gets completion suggestions with their scores and payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithScoresWithPayloads: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            }[] | null;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").DoubleReply<number>)[]) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                payload: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+            }[] | null;
+        };
+    };
+    /**
+     * Gets completion suggestions with their scores from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHSCORES: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[] | null;
+            readonly 3: (reply: (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").DoubleReply<number>)[]) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[] | null;
+        };
+    };
+    /**
+     * Gets completion suggestions with their scores from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithScores: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[], preserve?: unknown, typeMapping?: import("@redis/client").TypeMapping | undefined) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[] | null;
+            readonly 3: (reply: (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").DoubleReply<number>)[]) => {
+                suggestion: import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>;
+                score: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[] | null;
+        };
+    };
+    /**
+     * Gets completion suggestions for a prefix from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param prefix - The prefix to get completion suggestions for
+     * @param options - Optional parameters:
+     *   - FUZZY: Enable fuzzy prefix matching
+     *   - MAX: Maximum number of results to return
+     */
+    SUGGET: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>> | import("@redis/client/dist/lib/RESP/types").NullReply;
+    };
+    /**
+     * Gets completion suggestions for a prefix from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param prefix - The prefix to get completion suggestions for
+     * @param options - Optional parameters:
+     *   - FUZZY: Enable fuzzy prefix matching
+     *   - MAX: Maximum number of results to return
+     */
+    sugGet: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument, prefix: import("@redis/client").RedisArgument, options?: import("./SUGGET").FtSugGetOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>> | import("@redis/client/dist/lib/RESP/types").NullReply;
+    };
+    /**
+     * Gets the size of a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     */
+    SUGLEN: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Gets the size of a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     */
+    sugLen: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Dumps the contents of a synonym group.
+     * @param index - Name of the index that contains the synonym group
+     */
+    SYNDUMP: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: (reply: (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>)[]) => Record<string, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>>;
+        };
+    };
+    /**
+     * Dumps the contents of a synonym group.
+     * @param index - Name of the index that contains the synonym group
+     */
+    synDump: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: (reply: (import("@redis/client/dist/lib/RESP/types").BlobStringReply<string> | import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>)[]) => Record<string, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>>;
+        };
+    };
+    /**
+     * Updates a synonym group with new terms.
+     * @param index - Name of the index that contains the synonym group
+     * @param groupId - ID of the synonym group to update
+     * @param terms - One or more synonym terms to add to the group
+     * @param options - Optional parameters:
+     *   - SKIPINITIALSCAN: Skip the initial scan for existing documents
+     */
+    SYNUPDATE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, groupId: import("@redis/client").RedisArgument, terms: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./SYNUPDATE").FtSynUpdateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Updates a synonym group with new terms.
+     * @param index - Name of the index that contains the synonym group
+     * @param groupId - ID of the synonym group to update
+     * @param terms - One or more synonym terms to add to the group
+     * @param options - Optional parameters:
+     *   - SKIPINITIALSCAN: Skip the initial scan for existing documents
+     */
+    synUpdate: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, groupId: import("@redis/client").RedisArgument, terms: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./SYNUPDATE").FtSynUpdateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Returns the distinct values in a TAG field.
+     * @param index - Name of the index
+     * @param fieldName - Name of the TAG field to get values from
+     */
+    TAGVALS: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, fieldName: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Returns the distinct values in a TAG field.
+     * @param index - Name of the index
+     * @param fieldName - Name of the TAG field to get values from
+     */
+    tagVals: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, index: import("@redis/client").RedisArgument, fieldName: import("@redis/client").RedisArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/commands/index.ts"],"names":[],"mappings":";;IAqCE;;OAEG;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;IAEH;;;;;;;;;;OAUG;;;;;;;;;;IAEH;;;;;;;;;;OAUG;;;;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;OAGG;;;;;;;IAEH;;;OAGG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;OAGG;;;;;;;IAEH;;;OAGG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;;;;;;;;;;;;OAeG;;;;;;;IAEH;;;;;;;;;;;;;;;OAeG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;;OAIG;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;IAEH;;;;;;;OAOG;;;;;;;IAEH;;;;;;OAMG;;;;;;;IAEH;;;;;;OAMG;;;;;;;IAEH;;;;;;;;;;;;;;;OAeG;;;;;;;;;;IAEH;;;;;;;;;;;;;;;OAeG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;IAEH;;;;;;;;;;;;;OAaG;;;;;;;;;;IAEH;;;;;;;;;;;;;OAaG;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;IAEH;;;;;;;;OAQG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;IAEH;;;;;;;OAOG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;IAEH;;;;;;;OAOG;;;;;;;IAEH;;;;OAIG;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;AArjBL,wBAujBE"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/index.js

@@ -0,0 +1,609 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _LIST_1 = __importDefault(require("./_LIST"));
+const ALTER_1 = __importDefault(require("./ALTER"));
+const AGGREGATE_WITHCURSOR_1 = __importDefault(require("./AGGREGATE_WITHCURSOR"));
+const AGGREGATE_1 = __importDefault(require("./AGGREGATE"));
+const ALIASADD_1 = __importDefault(require("./ALIASADD"));
+const ALIASDEL_1 = __importDefault(require("./ALIASDEL"));
+const ALIASUPDATE_1 = __importDefault(require("./ALIASUPDATE"));
+const CONFIG_GET_1 = __importDefault(require("./CONFIG_GET"));
+const CONFIG_SET_1 = __importDefault(require("./CONFIG_SET"));
+const CREATE_1 = __importDefault(require("./CREATE"));
+const CURSOR_DEL_1 = __importDefault(require("./CURSOR_DEL"));
+const CURSOR_READ_1 = __importDefault(require("./CURSOR_READ"));
+const DICTADD_1 = __importDefault(require("./DICTADD"));
+const DICTDEL_1 = __importDefault(require("./DICTDEL"));
+const DICTDUMP_1 = __importDefault(require("./DICTDUMP"));
+const DROPINDEX_1 = __importDefault(require("./DROPINDEX"));
+const EXPLAIN_1 = __importDefault(require("./EXPLAIN"));
+const EXPLAINCLI_1 = __importDefault(require("./EXPLAINCLI"));
+const HYBRID_1 = __importDefault(require("./HYBRID"));
+const INFO_1 = __importDefault(require("./INFO"));
+const PROFILE_SEARCH_1 = __importDefault(require("./PROFILE_SEARCH"));
+const PROFILE_AGGREGATE_1 = __importDefault(require("./PROFILE_AGGREGATE"));
+const SEARCH_NOCONTENT_1 = __importDefault(require("./SEARCH_NOCONTENT"));
+const SEARCH_1 = __importDefault(require("./SEARCH"));
+const SPELLCHECK_1 = __importDefault(require("./SPELLCHECK"));
+const SUGADD_1 = __importDefault(require("./SUGADD"));
+const SUGDEL_1 = __importDefault(require("./SUGDEL"));
+const SUGGET_WITHPAYLOADS_1 = __importDefault(require("./SUGGET_WITHPAYLOADS"));
+const SUGGET_WITHSCORES_WITHPAYLOADS_1 = __importDefault(require("./SUGGET_WITHSCORES_WITHPAYLOADS"));
+const SUGGET_WITHSCORES_1 = __importDefault(require("./SUGGET_WITHSCORES"));
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+const SUGLEN_1 = __importDefault(require("./SUGLEN"));
+const SYNDUMP_1 = __importDefault(require("./SYNDUMP"));
+const SYNUPDATE_1 = __importDefault(require("./SYNUPDATE"));
+const TAGVALS_1 = __importDefault(require("./TAGVALS"));
+exports.default = {
+    /**
+     * Lists all existing indexes in the database.
+     */
+    _LIST: _LIST_1.default,
+    /**
+     * Lists all existing indexes in the database.
+     */
+    _list: _LIST_1.default,
+    /**
+     * Alters an existing RediSearch index schema by adding new fields.
+     * @param index - The index to alter
+     * @param schema - The schema definition containing new fields to add
+     */
+    ALTER: ALTER_1.default,
+    /**
+     * Alters an existing RediSearch index schema by adding new fields.
+     * @param index - The index to alter
+     * @param schema - The schema definition containing new fields to add
+     */
+    alter: ALTER_1.default,
+    /**
+     * Performs an aggregation with a cursor for retrieving large result sets.
+     * @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
+     */
+    AGGREGATE_WITHCURSOR: AGGREGATE_WITHCURSOR_1.default,
+    /**
+     * Performs an aggregation with a cursor for retrieving large result sets.
+     * @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
+     */
+    aggregateWithCursor: AGGREGATE_WITHCURSOR_1.default,
+    /**
+     * Performs an aggregation query on a RediSearch index.
+     * @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
+     */
+    AGGREGATE: AGGREGATE_1.default,
+    /**
+     * Performs an aggregation query on a RediSearch index.
+     * @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
+     */
+    aggregate: AGGREGATE_1.default,
+    /**
+     * Adds an alias to a RediSearch index.
+     * @param alias - The alias to add
+     * @param index - The index name to alias
+     */
+    ALIASADD: ALIASADD_1.default,
+    /**
+     * Adds an alias to a RediSearch index.
+     * @param alias - The alias to add
+     * @param index - The index name to alias
+     */
+    aliasAdd: ALIASADD_1.default,
+    /**
+     * Removes an existing alias from a RediSearch index.
+     * @param alias - The alias to remove
+     */
+    ALIASDEL: ALIASDEL_1.default,
+    /**
+     * Removes an existing alias from a RediSearch index.
+     * @param alias - The alias to remove
+     */
+    aliasDel: ALIASDEL_1.default,
+    /**
+     * Updates the index pointed to by an existing alias.
+     * @param alias - The existing alias to update
+     * @param index - The new index name that the alias should point to
+     */
+    ALIASUPDATE: ALIASUPDATE_1.default,
+    /**
+     * Updates the index pointed to by an existing alias.
+     * @param alias - The existing alias to update
+     * @param index - The new index name that the alias should point to
+     */
+    aliasUpdate: ALIASUPDATE_1.default,
+    /**
+     * Gets a RediSearch configuration option value.
+     * @param option - The name of the configuration option to retrieve
+     */
+    CONFIG_GET: CONFIG_GET_1.default,
+    /**
+     * Gets a RediSearch configuration option value.
+     * @param option - The name of the configuration option to retrieve
+     */
+    configGet: CONFIG_GET_1.default,
+    /**
+     * Sets a RediSearch configuration option value.
+     * @param property - The name of the configuration option to set
+     * @param value - The value to set for the configuration option
+     */
+    CONFIG_SET: CONFIG_SET_1.default,
+    /**
+     * Sets a RediSearch configuration option value.
+     * @param property - The name of the configuration option to set
+     * @param value - The value to set for the configuration option
+     */
+    configSet: CONFIG_SET_1.default,
+    /**
+     * Creates a new search index with the given schema and options.
+     * @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
+     */
+    CREATE: CREATE_1.default,
+    /**
+     * Creates a new search index with the given schema and options.
+     * @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
+     */
+    create: CREATE_1.default,
+    /**
+     * Deletes a cursor from an index.
+     * @param index - The index name that contains the cursor
+     * @param cursorId - The cursor ID to delete
+     */
+    CURSOR_DEL: CURSOR_DEL_1.default,
+    /**
+     * Deletes a cursor from an index.
+     * @param index - The index name that contains the cursor
+     * @param cursorId - The cursor ID to delete
+     */
+    cursorDel: CURSOR_DEL_1.default,
+    /**
+     * Reads from an existing cursor to get more results from an index.
+     * @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
+     */
+    CURSOR_READ: CURSOR_READ_1.default,
+    /**
+     * Reads from an existing cursor to get more results from an index.
+     * @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
+     */
+    cursorRead: CURSOR_READ_1.default,
+    /**
+     * Adds terms to a dictionary.
+     * @param dictionary - Name of the dictionary to add terms to
+     * @param term - One or more terms to add to the dictionary
+     */
+    DICTADD: DICTADD_1.default,
+    /**
+     * Adds terms to a dictionary.
+     * @param dictionary - Name of the dictionary to add terms to
+     * @param term - One or more terms to add to the dictionary
+     */
+    dictAdd: DICTADD_1.default,
+    /**
+     * Deletes terms from a dictionary.
+     * @param dictionary - Name of the dictionary to remove terms from
+     * @param term - One or more terms to delete from the dictionary
+     */
+    DICTDEL: DICTDEL_1.default,
+    /**
+     * Deletes terms from a dictionary.
+     * @param dictionary - Name of the dictionary to remove terms from
+     * @param term - One or more terms to delete from the dictionary
+     */
+    dictDel: DICTDEL_1.default,
+    /**
+     * Returns all terms in a dictionary.
+     * @param dictionary - Name of the dictionary to dump
+     */
+    DICTDUMP: DICTDUMP_1.default,
+    /**
+     * Returns all terms in a dictionary.
+     * @param dictionary - Name of the dictionary to dump
+     */
+    dictDump: DICTDUMP_1.default,
+    /**
+     * Deletes an index and all associated documents.
+     * @param index - Name of the index to delete
+     * @param options - Optional parameters:
+     *   - DD: Also delete the indexed documents themselves
+     */
+    DROPINDEX: DROPINDEX_1.default,
+    /**
+     * Deletes an index and all associated documents.
+     * @param index - Name of the index to delete
+     * @param options - Optional parameters:
+     *   - DD: Also delete the indexed documents themselves
+     */
+    dropIndex: DROPINDEX_1.default,
+    /**
+     * Returns the execution plan for a complex query.
+     * @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)
+     */
+    EXPLAIN: EXPLAIN_1.default,
+    /**
+     * Returns the execution plan for a complex query.
+     * @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)
+     */
+    explain: EXPLAIN_1.default,
+    /**
+     * Returns the execution plan for a complex query in a more verbose format than FT.EXPLAIN.
+     * @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)
+     */
+    EXPLAINCLI: EXPLAINCLI_1.default,
+    /**
+     * Returns the execution plan for a complex query in a more verbose format than FT.EXPLAIN.
+     * @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)
+     */
+    explainCli: EXPLAINCLI_1.default,
+    /**
+     * 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 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
+     */
+    HYBRID: HYBRID_1.default,
+    /**
+     * 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 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
+     */
+    hybrid: HYBRID_1.default,
+    /**
+     * Returns information and statistics about an index.
+     * @param index - Name of the index to get information about
+     */
+    INFO: INFO_1.default,
+    /**
+     * Returns information and statistics about an index.
+     * @param index - Name of the index to get information about
+     */
+    info: INFO_1.default,
+    /**
+     * Profiles the execution of a search query for performance analysis.
+     * @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
+     */
+    PROFILESEARCH: PROFILE_SEARCH_1.default,
+    /**
+     * Profiles the execution of a search query for performance analysis.
+     * @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
+     */
+    profileSearch: PROFILE_SEARCH_1.default,
+    /**
+     * Profiles the execution of an aggregation query for performance analysis.
+     * @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
+     */
+    PROFILEAGGREGATE: PROFILE_AGGREGATE_1.default,
+    /**
+     * Profiles the execution of an aggregation query for performance analysis.
+     * @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
+     */
+    profileAggregate: PROFILE_AGGREGATE_1.default,
+    /**
+     * Performs a search query but returns only document ids without their contents.
+     * @param args - Same parameters as FT.SEARCH:
+     *   - parser: The command parser
+     *   - index: Name of the index to search
+     *   - query: The text query to search
+     *   - options: Optional search parameters
+     */
+    SEARCH_NOCONTENT: SEARCH_NOCONTENT_1.default,
+    /**
+     * Performs a search query but returns only document ids without their contents.
+     * @param args - Same parameters as FT.SEARCH:
+     *   - parser: The command parser
+     *   - index: Name of the index to search
+     *   - query: The text query to search
+     *   - options: Optional search parameters
+     */
+    searchNoContent: SEARCH_NOCONTENT_1.default,
+    /**
+     * Searches a RediSearch index with the given query.
+     * @param index - The index name to search
+     * @param query - The text query to search. For syntax, see https://redis.io/docs/stack/search/reference/query_syntax
+     * @param options - Optional search parameters including:
+     *   - VERBATIM: do not try to use stemming for query expansion
+     *   - NOSTOPWORDS: do not filter stopwords from the query
+     *   - INKEYS/INFIELDS: restrict the search to specific keys/fields
+     *   - RETURN: limit which fields are returned
+     *   - SUMMARIZE/HIGHLIGHT: create search result highlights
+     *   - LIMIT: pagination control
+     *   - SORTBY: sort results by a specific field
+     *   - PARAMS: bind parameters to the query
+     */
+    SEARCH: SEARCH_1.default,
+    /**
+     * Searches a RediSearch index with the given query.
+     * @param index - The index name to search
+     * @param query - The text query to search. For syntax, see https://redis.io/docs/stack/search/reference/query_syntax
+     * @param options - Optional search parameters including:
+     *   - VERBATIM: do not try to use stemming for query expansion
+     *   - NOSTOPWORDS: do not filter stopwords from the query
+     *   - INKEYS/INFIELDS: restrict the search to specific keys/fields
+     *   - RETURN: limit which fields are returned
+     *   - SUMMARIZE/HIGHLIGHT: create search result highlights
+     *   - LIMIT: pagination control
+     *   - SORTBY: sort results by a specific field
+     *   - PARAMS: bind parameters to the query
+     */
+    search: SEARCH_1.default,
+    /**
+     * Performs spelling correction on a search query.
+     * @param index - Name of the index to use for spelling corrections
+     * @param query - The search query to check for spelling
+     * @param options - Optional parameters:
+     *   - DISTANCE: Maximum Levenshtein distance for spelling suggestions
+     *   - TERMS: Custom dictionary terms to include/exclude
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    SPELLCHECK: SPELLCHECK_1.default,
+    /**
+     * Performs spelling correction on a search query.
+     * @param index - Name of the index to use for spelling corrections
+     * @param query - The search query to check for spelling
+     * @param options - Optional parameters:
+     *   - DISTANCE: Maximum Levenshtein distance for spelling suggestions
+     *   - TERMS: Custom dictionary terms to include/exclude
+     *   - DIALECT: Version of query dialect to use (defaults to 1)
+     */
+    spellCheck: SPELLCHECK_1.default,
+    /**
+     * Adds a suggestion string to an auto-complete suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to add
+     * @param score - The suggestion score used for sorting
+     * @param options - Optional parameters:
+     *   - INCR: If true, increment the existing entry's score
+     *   - PAYLOAD: Optional payload to associate with the suggestion
+     */
+    SUGADD: SUGADD_1.default,
+    /**
+     * Adds a suggestion string to an auto-complete suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to add
+     * @param score - The suggestion score used for sorting
+     * @param options - Optional parameters:
+     *   - INCR: If true, increment the existing entry's score
+     *   - PAYLOAD: Optional payload to associate with the suggestion
+     */
+    sugAdd: SUGADD_1.default,
+    /**
+     * Deletes a string from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to delete
+     */
+    SUGDEL: SUGDEL_1.default,
+    /**
+     * Deletes a string from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param string - The suggestion string to delete
+     */
+    sugDel: SUGDEL_1.default,
+    /**
+     * Gets completion suggestions with their payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHPAYLOADS: SUGGET_WITHPAYLOADS_1.default,
+    /**
+     * Gets completion suggestions with their payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithPayloads: SUGGET_WITHPAYLOADS_1.default,
+    /**
+     * Gets completion suggestions with their scores and payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHSCORES_WITHPAYLOADS: SUGGET_WITHSCORES_WITHPAYLOADS_1.default,
+    /**
+     * Gets completion suggestions with their scores and payloads from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithScoresWithPayloads: SUGGET_WITHSCORES_WITHPAYLOADS_1.default,
+    /**
+     * Gets completion suggestions with their scores from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    SUGGET_WITHSCORES: SUGGET_WITHSCORES_1.default,
+    /**
+     * Gets completion suggestions with their scores from a suggestion dictionary.
+     * @param args - Same parameters as FT.SUGGET:
+     *   - parser: The command parser
+     *   - key: The suggestion dictionary key
+     *   - prefix: The prefix to get completion suggestions for
+     *   - options: Optional parameters for fuzzy matching and max results
+     */
+    sugGetWithScores: SUGGET_WITHSCORES_1.default,
+    /**
+     * Gets completion suggestions for a prefix from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param prefix - The prefix to get completion suggestions for
+     * @param options - Optional parameters:
+     *   - FUZZY: Enable fuzzy prefix matching
+     *   - MAX: Maximum number of results to return
+     */
+    SUGGET: SUGGET_1.default,
+    /**
+     * Gets completion suggestions for a prefix from a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     * @param prefix - The prefix to get completion suggestions for
+     * @param options - Optional parameters:
+     *   - FUZZY: Enable fuzzy prefix matching
+     *   - MAX: Maximum number of results to return
+     */
+    sugGet: SUGGET_1.default,
+    /**
+     * Gets the size of a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     */
+    SUGLEN: SUGLEN_1.default,
+    /**
+     * Gets the size of a suggestion dictionary.
+     * @param key - The suggestion dictionary key
+     */
+    sugLen: SUGLEN_1.default,
+    /**
+     * Dumps the contents of a synonym group.
+     * @param index - Name of the index that contains the synonym group
+     */
+    SYNDUMP: SYNDUMP_1.default,
+    /**
+     * Dumps the contents of a synonym group.
+     * @param index - Name of the index that contains the synonym group
+     */
+    synDump: SYNDUMP_1.default,
+    /**
+     * Updates a synonym group with new terms.
+     * @param index - Name of the index that contains the synonym group
+     * @param groupId - ID of the synonym group to update
+     * @param terms - One or more synonym terms to add to the group
+     * @param options - Optional parameters:
+     *   - SKIPINITIALSCAN: Skip the initial scan for existing documents
+     */
+    SYNUPDATE: SYNUPDATE_1.default,
+    /**
+     * Updates a synonym group with new terms.
+     * @param index - Name of the index that contains the synonym group
+     * @param groupId - ID of the synonym group to update
+     * @param terms - One or more synonym terms to add to the group
+     * @param options - Optional parameters:
+     *   - SKIPINITIALSCAN: Skip the initial scan for existing documents
+     */
+    synUpdate: SYNUPDATE_1.default,
+    /**
+     * Returns the distinct values in a TAG field.
+     * @param index - Name of the index
+     * @param fieldName - Name of the TAG field to get values from
+     */
+    TAGVALS: TAGVALS_1.default,
+    /**
+     * Returns the distinct values in a TAG field.
+     * @param index - Name of the index
+     * @param fieldName - Name of the TAG field to get values from
+     */
+    tagVals: TAGVALS_1.default
+};
+//# sourceMappingURL=index.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/reply-transformers.d.ts

@@ -0,0 +1,11 @@
+import { isPlainObject, mapLikeEntries, mapLikeValues, mapLikeToObject, mapLikeToFlatArray, getMapValue } from '@redis/client/dist/lib/commands/reply-utils';
+export { isPlainObject, mapLikeEntries, mapLikeValues, mapLikeToObject, mapLikeToFlatArray, getMapValue };
+export declare function toCompatObject(value: Record<string, unknown>): Record<string, unknown>;
+export declare function parseDocumentValue(value: unknown): Record<string, unknown>;
+export declare function normalizeProfileReply(profile: unknown): unknown;
+export declare function parseSearchResultRow(rawRow: unknown): {
+    id: unknown;
+    value: Record<string, unknown>;
+};
+export declare function parseAggregateResultRow(rawRow: unknown): Record<string, unknown>;
+//# sourceMappingURL=reply-transformers.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/commands/reply-transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-transformers.d.ts","sourceRoot":"","sources":["../../../lib/commands/reply-transformers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,cAAc,EACd,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,WAAW,EACZ,MAAM,6CAA6C,CAAC;AAErD,OAAO,EACL,aAAa,EACb,cAAc,EACd,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,WAAW,EACZ,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAatF;AAkBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQ1E;AAkBD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAE/D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG;IACrD,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAWA;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBhF"}

landvex-report-system/node_modules/@redis/search/dist/lib/commands/reply-transformers.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAggregateResultRow = exports.parseSearchResultRow = exports.normalizeProfileReply = exports.parseDocumentValue = exports.toCompatObject = exports.getMapValue = exports.mapLikeToFlatArray = exports.mapLikeToObject = exports.mapLikeValues = exports.mapLikeEntries = exports.isPlainObject = void 0;
+const reply_utils_1 = require("@redis/client/dist/lib/commands/reply-utils");
+Object.defineProperty(exports, "isPlainObject", { enumerable: true, get: function () { return reply_utils_1.isPlainObject; } });
+Object.defineProperty(exports, "mapLikeEntries", { enumerable: true, get: function () { return reply_utils_1.mapLikeEntries; } });
+Object.defineProperty(exports, "mapLikeValues", { enumerable: true, get: function () { return reply_utils_1.mapLikeValues; } });
+Object.defineProperty(exports, "mapLikeToObject", { enumerable: true, get: function () { return reply_utils_1.mapLikeToObject; } });
+Object.defineProperty(exports, "mapLikeToFlatArray", { enumerable: true, get: function () { return reply_utils_1.mapLikeToFlatArray; } });
+Object.defineProperty(exports, "getMapValue", { enumerable: true, get: function () { return reply_utils_1.getMapValue; } });
+function toCompatObject(value) {
+    const descriptors = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        descriptors[key] = {
+            value: entryValue,
+            configurable: true,
+            enumerable: true,
+            writable: true
+        };
+    }
+    return Object.defineProperties({}, descriptors);
+}
+exports.toCompatObject = toCompatObject;
+function assignDocumentField(target, key, value) {
+    if (key === '$') {
+        const json = value?.toString?.() ?? value;
+        if (typeof json === 'string') {
+            try {
+                Object.assign(target, JSON.parse(json));
+                return;
+            }
+            catch {
+                // Fallback to setting the raw value below.
+            }
+        }
+    }
+    target[key] = value;
+}
+function parseDocumentValue(value) {
+    const document = {};
+    for (const [key, entryValue] of (0, reply_utils_1.mapLikeEntries)(value)) {
+        assignDocumentField(document, key, entryValue);
+    }
+    return document;
+}
+exports.parseDocumentValue = parseDocumentValue;
+function normalizeProfileValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeProfileValue);
+    }
+    if (value instanceof Map || (0, reply_utils_1.isPlainObject)(value)) {
+        const normalized = [];
+        for (const [key, entryValue] of (0, reply_utils_1.mapLikeEntries)(value)) {
+            normalized.push(key, normalizeProfileValue(entryValue));
+        }
+        return normalized;
+    }
+    return value;
+}
+function normalizeProfileReply(profile) {
+    return normalizeProfileValue(profile);
+}
+exports.normalizeProfileReply = normalizeProfileReply;
+function parseSearchResultRow(rawRow) {
+    const row = (0, reply_utils_1.mapLikeToObject)(rawRow);
+    const value = {};
+    Object.assign(value, parseDocumentValue((0, reply_utils_1.getMapValue)(row, ['values'])));
+    Object.assign(value, parseDocumentValue((0, reply_utils_1.getMapValue)(row, ['extra_attributes', 'extraAttributes'])));
+    return {
+        id: (0, reply_utils_1.getMapValue)(row, ['id', 'doc_id']),
+        value: toCompatObject(value)
+    };
+}
+exports.parseSearchResultRow = parseSearchResultRow;
+function parseAggregateResultRow(rawRow) {
+    const row = (0, reply_utils_1.mapLikeToObject)(rawRow);
+    const result = {};
+    Object.assign(result, parseDocumentValue((0, reply_utils_1.getMapValue)(row, ['values'])));
+    Object.assign(result, parseDocumentValue((0, reply_utils_1.getMapValue)(row, ['extra_attributes', 'extraAttributes'])));
+    for (const [key, value] of Object.entries(row)) {
+        if (key === 'id' ||
+            key === 'values' ||
+            key.toLowerCase() === 'extra_attributes' ||
+            key === 'extraAttributes') {
+            continue;
+        }
+        if (!Object.hasOwn(result, key)) {
+            result[key] = value;
+        }
+    }
+    return toCompatObject(result);
+}
+exports.parseAggregateResultRow = parseAggregateResultRow;
+//# sourceMappingURL=reply-transformers.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/dialect/default.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_DIALECT = "2";
+//# sourceMappingURL=default.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/dialect/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../lib/dialect/default.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,MAAM,CAAC"}

landvex-report-system/node_modules/@redis/search/dist/lib/dialect/default.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DIALECT = void 0;
+exports.DEFAULT_DIALECT = '2';
+//# sourceMappingURL=default.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/dialect/default.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.js","sourceRoot":"","sources":["../../../lib/dialect/default.ts"],"names":[],"mappings":";;;AAAa,QAAA,eAAe,GAAG,GAAG,CAAC","sourcesContent":["export const DEFAULT_DIALECT = '2';\n"]}

landvex-report-system/node_modules/@redis/search/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { default } from './commands';
+export { SearchReply } from './commands/SEARCH';
+export { RediSearchSchema } from './commands/CREATE';
+export { REDISEARCH_LANGUAGE, RediSearchLanguage, SCHEMA_FIELD_TYPE, SchemaFieldType, SCHEMA_TEXT_FIELD_PHONETIC, SchemaTextFieldPhonetic, SCHEMA_VECTOR_FIELD_ALGORITHM, SchemaVectorFieldAlgorithm } from './commands/CREATE';
+export { FT_AGGREGATE_GROUP_BY_REDUCERS, FtAggregateGroupByReducer, FT_AGGREGATE_STEPS, FtAggregateStep } from './commands/AGGREGATE';
+export { FtSearchOptions } from './commands/SEARCH';
+//# sourceMappingURL=index.d.ts.map

landvex-report-system/node_modules/@redis/search/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,0BAA0B,EAC1B,uBAAuB,EACvB,6BAA6B,EAC7B,0BAA0B,EAC7B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACH,8BAA8B,EAC9B,yBAAyB,EACzB,kBAAkB,EAClB,eAAe,EAClB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}

landvex-report-system/node_modules/@redis/search/dist/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FT_AGGREGATE_STEPS = exports.FT_AGGREGATE_GROUP_BY_REDUCERS = exports.SCHEMA_VECTOR_FIELD_ALGORITHM = exports.SCHEMA_TEXT_FIELD_PHONETIC = exports.SCHEMA_FIELD_TYPE = exports.REDISEARCH_LANGUAGE = exports.default = void 0;
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(commands_1).default; } });
+var CREATE_1 = require("./commands/CREATE");
+Object.defineProperty(exports, "REDISEARCH_LANGUAGE", { enumerable: true, get: function () { return CREATE_1.REDISEARCH_LANGUAGE; } });
+Object.defineProperty(exports, "SCHEMA_FIELD_TYPE", { enumerable: true, get: function () { return CREATE_1.SCHEMA_FIELD_TYPE; } });
+Object.defineProperty(exports, "SCHEMA_TEXT_FIELD_PHONETIC", { enumerable: true, get: function () { return CREATE_1.SCHEMA_TEXT_FIELD_PHONETIC; } });
+Object.defineProperty(exports, "SCHEMA_VECTOR_FIELD_ALGORITHM", { enumerable: true, get: function () { return CREATE_1.SCHEMA_VECTOR_FIELD_ALGORITHM; } });
+var AGGREGATE_1 = require("./commands/AGGREGATE");
+Object.defineProperty(exports, "FT_AGGREGATE_GROUP_BY_REDUCERS", { enumerable: true, get: function () { return AGGREGATE_1.FT_AGGREGATE_GROUP_BY_REDUCERS; } });
+Object.defineProperty(exports, "FT_AGGREGATE_STEPS", { enumerable: true, get: function () { return AGGREGATE_1.FT_AGGREGATE_STEPS; } });
+//# sourceMappingURL=index.js.map

landvex-report-system/node_modules/@redis/search/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;AAAA,uCAAoC;AAA3B,oHAAA,OAAO,OAAA;AAIhB,4CAS0B;AARtB,6GAAA,mBAAmB,OAAA;AAEnB,2GAAA,iBAAiB,OAAA;AAEjB,oHAAA,0BAA0B,OAAA;AAE1B,uHAAA,6BAA6B,OAAA;AAGjC,kDAK6B;AAJzB,2HAAA,8BAA8B,OAAA;AAE9B,+GAAA,kBAAkB,OAAA","sourcesContent":["export { default } from './commands'\n\nexport { SearchReply } from './commands/SEARCH'\nexport { RediSearchSchema } from './commands/CREATE'\nexport {\n    REDISEARCH_LANGUAGE,\n    RediSearchLanguage,\n    SCHEMA_FIELD_TYPE,\n    SchemaFieldType,\n    SCHEMA_TEXT_FIELD_PHONETIC,\n    SchemaTextFieldPhonetic,\n    SCHEMA_VECTOR_FIELD_ALGORITHM,\n    SchemaVectorFieldAlgorithm\n} from './commands/CREATE'\nexport {\n    FT_AGGREGATE_GROUP_BY_REDUCERS,\n    FtAggregateGroupByReducer,\n    FT_AGGREGATE_STEPS,\n    FtAggregateStep\n} from './commands/AGGREGATE'\nexport { FtSearchOptions } from './commands/SEARCH'\n"]}

landvex-report-system/node_modules/@redis/search/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@redis/search",
+  "version": "6.1.0",
+  "license": "MIT",
+  "main": "./dist/lib/index.js",
+  "types": "./dist/lib/index.d.ts",
+  "files": [
+    "dist/",
+    "!dist/tsconfig.tsbuildinfo"
+  ],
+  "scripts": {
+    "test": "nyc -r text-summary -r lcov mocha -r tsx --reporter mocha-multi-reporters --reporter-options configFile=mocha-multi-reporter-config.json --exit  './lib/**/*.spec.ts'",
+    "test-sourcemap": "mocha -r ts-node/register/transpile-only './lib/**/*.spec.ts'",
+    "release": "release-it"
+  },
+  "peerDependencies": {
+    "@redis/client": "^6.1.0"
+  },
+  "devDependencies": {
+    "@redis/test-utils": "*"
+  },
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/redis/node-redis.git"
+  },
+  "bugs": {
+    "url": "https://github.com/redis/node-redis/issues"
+  },
+  "homepage": "https://github.com/redis/node-redis/tree/master/packages/search",
+  "keywords": [
+    "redis",
+    "RediSearch"
+  ]
+}