@redis/search 1.1.5 → 2.0.0-next.2

package/dist/lib/commands/AGGREGATE.d.ts

@@ -0,0 +1,102 @@
+import { RedisArgument } 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;
+}
+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;
+    LOAD?: LoadField | Array<LoadField>;
+    TIMEOUT?: number;
+    STEPS?: Array<GroupByStep | SortStep | ApplyStep | LimitStep | FilterStep>;
+    PARAMS?: FtSearchParams;
+    DIALECT?: number;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, index: RedisArgument, query: RedisArgument, options?: FtAggregateOptions) => RedisArgument[];
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/AGGREGATE.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.FT_AGGREGATE_STEPS = {
+    GROUPBY: 'GROUPBY',
+    SORTBY: 'SORTBY',
+    APPLY: 'APPLY',
+    LIMIT: 'LIMIT',
+    FILTER: 'FILTER'
+};
+exports.FT_AGGREGATE_GROUP_BY_REDUCERS = {
+    COUNT: 'COUNT',
+    COUNT_DISTINCT: 'COUNT_DISTINCT',
+    COUNT_DISTINCTISH: 'COUNT_DISTINCTISH',
+    SUM: 'SUM',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    AVG: 'AVG',
+    STDDEV: 'STDDEV',
+    QUANTILE: 'QUANTILE',
+    TOLIST: 'TOLIST',
+    FIRST_VALUE: 'FIRST_VALUE',
+    RANDOM_SAMPLE: 'RANDOM_SAMPLE'
+};
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(index, query, options) {
+        const args = ['FT.AGGREGATE', index, query];
+        if (options?.VERBATIM) {
+            args.push('VERBATIM');
+        }
+        if (options?.LOAD) {
+            const length = args.push('LOAD', '');
+            if (Array.isArray(options.LOAD)) {
+                for (const load of options.LOAD) {
+                    pushLoadField(args, load);
+                }
+            }
+            else {
+                pushLoadField(args, options.LOAD);
+            }
+            args[length - 1] = (args.length - length).toString();
+        }
+        if (options?.TIMEOUT !== undefined) {
+            args.push('TIMEOUT', options.TIMEOUT.toString());
+        }
+        if (options?.STEPS) {
+            for (const step of options.STEPS) {
+                args.push(step.type);
+                switch (step.type) {
+                    case exports.FT_AGGREGATE_STEPS.GROUPBY:
+                        if (!step.properties) {
+                            args.push('0');
+                        }
+                        else {
+                            (0, generic_transformers_1.pushVariadicArgument)(args, step.properties);
+                        }
+                        if (Array.isArray(step.REDUCE)) {
+                            for (const reducer of step.REDUCE) {
+                                pushGroupByReducer(args, reducer);
+                            }
+                        }
+                        else {
+                            pushGroupByReducer(args, step.REDUCE);
+                        }
+                        break;
+                    case exports.FT_AGGREGATE_STEPS.SORTBY:
+                        const length = args.push('');
+                        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());
+                        }
+                        args[length - 1] = (args.length - length).toString();
+                        break;
+                    case exports.FT_AGGREGATE_STEPS.APPLY:
+                        args.push(step.expression, 'AS', step.AS);
+                        break;
+                    case exports.FT_AGGREGATE_STEPS.LIMIT:
+                        args.push(step.from.toString(), step.size.toString());
+                        break;
+                    case exports.FT_AGGREGATE_STEPS.FILTER:
+                        args.push(step.expression);
+                        break;
+                }
+            }
+        }
+        (0, SEARCH_1.pushParamsArgument)(args, options?.PARAMS);
+        if (options?.DIALECT !== undefined) {
+            args.push('DIALECT', options.DIALECT.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};
+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 pushGroupByReducer(args, reducer) {
+    args.push('REDUCE', reducer.type);
+    switch (reducer.type) {
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.COUNT:
+            args.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:
+            args.push('1', reducer.property);
+            break;
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.QUANTILE:
+            args.push('2', reducer.property, reducer.quantile.toString());
+            break;
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.FIRST_VALUE: {
+            const length = args.push('', reducer.property) - 1;
+            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);
+                    }
+                }
+            }
+            args[length - 1] = (args.length - length).toString();
+            break;
+        }
+        case exports.FT_AGGREGATE_GROUP_BY_REDUCERS.RANDOM_SAMPLE:
+            args.push('2', reducer.property, reducer.sampleSize.toString());
+            break;
+    }
+    if (reducer.AS) {
+        args.push('AS', reducer.AS);
+    }
+}
+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);
+        }
+    }
+}

package/dist/lib/commands/AGGREGATE_WITHCURSOR.d.ts

@@ -0,0 +1,13 @@
+import { RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { FtAggregateOptions } from './AGGREGATE';
+export interface FtAggregateWithCursorOptions extends FtAggregateOptions {
+    COUNT?: number;
+    MAXIDLE?: number;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, index: RedisArgument, query: RedisArgument, options?: FtAggregateWithCursorOptions) => RedisArgument[];
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/AGGREGATE_WITHCURSOR.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AGGREGATE_1 = __importDefault(require("./AGGREGATE"));
+exports.default = {
+    FIRST_KEY_INDEX: AGGREGATE_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: AGGREGATE_1.default.IS_READ_ONLY,
+    transformArguments(index, query, options) {
+        const args = AGGREGATE_1.default.transformArguments(index, query, options);
+        args.push('WITHCURSOR');
+        if (options?.COUNT !== undefined) {
+            args.push('COUNT', options.COUNT.toString());
+        }
+        if (options?.MAXIDLE !== undefined) {
+            args.push('MAXIDLE', options.MAXIDLE.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/ALIASADD.d.ts

@@ -0,0 +1,8 @@
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, alias: RedisArgument, index: RedisArgument) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/ALIASADD.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(alias, index) {
+        return ['FT.ALIASADD', alias, index];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/ALIASDEL.d.ts

@@ -0,0 +1,8 @@
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, alias: RedisArgument) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/ALIASDEL.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(alias) {
+        return ['FT.ALIASDEL', alias];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/ALIASUPDATE.d.ts

@@ -0,0 +1,8 @@
+import { SimpleStringReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, alias: RedisArgument, index: RedisArgument) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/ALIASUPDATE.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(alias, index) {
+        return ['FT.ALIASUPDATE', alias, index];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/ALTER.d.ts

@@ -0,0 +1,9 @@
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { RediSearchSchema } from './CREATE';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, index: RedisArgument, schema: RediSearchSchema) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/ALTER.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CREATE_1 = require("./CREATE");
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(index, schema) {
+        const args = ['FT.ALTER', index, 'SCHEMA', 'ADD'];
+        (0, CREATE_1.pushSchema)(args, schema);
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/CONFIG_GET.d.ts

@@ -0,0 +1,8 @@
+import { ArrayReply, TuplesReply, BlobStringReply, NullReply, UnwrapReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, option: string) => string[];
+    readonly transformReply: (this: void, reply: UnwrapReply<ArrayReply<TuplesReply<[BlobStringReply, BlobStringReply | NullReply]>>>) => Record<string, BlobStringReply<string> | NullReply>;
+};
+export default _default;

package/dist/lib/commands/CONFIG_GET.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(option) {
+        return ['FT.CONFIG', 'GET', option];
+    },
+    transformReply(reply) {
+        const transformedReply = Object.create(null);
+        for (const item of reply) {
+            const [key, value] = item;
+            transformedReply[key.toString()] = value;
+        }
+        return transformedReply;
+    }
+};

package/dist/lib/commands/CONFIG_SET.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+type FtConfigProperties = 'a' | 'b' | (string & {}) | Buffer;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, property: FtConfigProperties, value: RedisArgument) => (string | Buffer)[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/CONFIG_SET.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(property, value) {
+        return ['FT.CONFIG', 'SET', property, value];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/CREATE.d.ts

@@ -0,0 +1,124 @@
+import { RedisArgument, SimpleStringReply, CommandArguments } 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];
+type SchemaField<T extends SchemaFieldType, E = Record<PropertyKey, unknown>> = T | ({
+    type: T;
+    AS?: RedisArgument;
+} & E);
+type SchemaCommonField<T extends SchemaFieldType, E = Record<PropertyKey, unknown>> = SchemaField<T, ({
+    SORTABLE?: boolean | 'UNF';
+    NOINDEX?: boolean;
+} & E)>;
+export declare const SCHEMA_TEXT_FIELD_PHONETIC: {
+    readonly DM_EN: "dm:en";
+    readonly DM_FR: "dm:fr";
+    readonly FM_PT: "dm:pt";
+    readonly DM_ES: "dm:es";
+};
+export type SchemaTextFieldPhonetic = typeof SCHEMA_TEXT_FIELD_PHONETIC[keyof typeof SCHEMA_TEXT_FIELD_PHONETIC];
+type SchemaTextField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TEXT'], {
+    NOSTEM?: boolean;
+    WEIGHT?: number;
+    PHONETIC?: SchemaTextFieldPhonetic;
+    WITHSUFFIXTRIE?: boolean;
+}>;
+type SchemaNumericField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['NUMERIC']>;
+type SchemaGeoField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['GEO']>;
+type SchemaTagField = SchemaCommonField<typeof SCHEMA_FIELD_TYPE['TAG'], {
+    SEPARATOR?: RedisArgument;
+    CASESENSITIVE?: boolean;
+    WITHSUFFIXTRIE?: boolean;
+}>;
+export declare const SCHEMA_VECTOR_FIELD_ALGORITHM: {
+    readonly FLAT: "FLAT";
+    readonly HNSW: "HNSW";
+};
+export type SchemaVectorFieldAlgorithm = typeof SCHEMA_VECTOR_FIELD_ALGORITHM[keyof typeof SCHEMA_VECTOR_FIELD_ALGORITHM];
+type SchemaVectorField<T extends SchemaVectorFieldAlgorithm, A extends Record<string, unknown>> = SchemaField<typeof SCHEMA_FIELD_TYPE['VECTOR'], {
+    ALGORITHM: T;
+    TYPE: string;
+    DIM: number;
+    DISTANCE_METRIC: 'L2' | 'IP' | 'COSINE';
+    INITIAL_CAP?: number;
+} & A>;
+type SchemaFlatVectorField = SchemaVectorField<typeof SCHEMA_VECTOR_FIELD_ALGORITHM['FLAT'], {
+    BLOCK_SIZE?: number;
+}>;
+type SchemaHNSWVectorField = SchemaVectorField<typeof SCHEMA_VECTOR_FIELD_ALGORITHM['HNSW'], {
+    M?: number;
+    EF_CONSTRUCTION?: number;
+    EF_RUNTIME?: 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];
+type SchemaGeoShapeField = SchemaField<typeof SCHEMA_FIELD_TYPE['GEOSHAPE'], {
+    COORD_SYSTEM?: SchemaGeoShapeFieldCoordSystem;
+}>;
+export interface RediSearchSchema {
+    [field: string]: (SchemaTextField | SchemaNumericField | SchemaGeoField | SchemaTagField | SchemaFlatVectorField | SchemaHNSWVectorField | SchemaGeoShapeField);
+}
+export declare function pushSchema(args: CommandArguments, 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 FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, index: RedisArgument, schema: RediSearchSchema, options?: CreateOptions) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;