@valkey/valkey-glide 1.2.0-rc9 → 1.2.0

package/build-ts/src/server-modules/GlideFt.d.ts

@@ -0,0 +1,412 @@
+/**
+ * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+ */
+import { DecoderOption, GlideRecord, GlideReturnType, GlideString } from "../BaseClient";
+import { GlideClient } from "../GlideClient";
+import { GlideClusterClient } from "../GlideClusterClient";
+import { Field, FtAggregateOptions, FtCreateOptions, FtSearchOptions } from "./GlideFtOptions";
+/** Response type of {@link GlideFt.info | ft.info} command. */
+export type FtInfoReturnType = Record<string, GlideString | number | GlideString[] | Record<string, GlideString | Record<string, GlideString | number>[]>>;
+/**
+ * Response type for the {@link GlideFt.search | ft.search} command.
+ */
+export type FtSearchReturnType = [
+    number,
+    GlideRecord<GlideRecord<GlideString>>
+];
+/**
+ * Response type for the {@link GlideFt.aggregate | ft.aggregate} command.
+ */
+export type FtAggregateReturnType = GlideRecord<GlideReturnType>[];
+/** Module for Vector Search commands. */
+export declare class GlideFt {
+    /**
+     * Creates an index and initiates a backfill of that index.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name for the index to be created.
+     * @param schema - The fields of the index schema, specifying the fields and their types.
+     * @param options - (Optional) Options for the `FT.CREATE` command. See {@link FtCreateOptions}.
+     * @returns If the index is successfully created, returns "OK".
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT.CREATE to create a 6-dimensional JSON index using the HNSW algorithm
+     * await GlideFt.create(client, "json_idx1", [{
+     *      type: "VECTOR",
+     *      name: "$.vec",
+     *      alias: "VEC",
+     *      attributes: {
+     *          algorithm: "HNSW",
+     *          type: "FLOAT32",
+     *          dimension: 6,
+     *          distanceMetric: "L2",
+     *          numberOfEdges: 32,
+     *      },
+     *  }], {
+     *      dataType: "JSON",
+     *      prefixes: ["json:"]
+     *  });
+     * ```
+     */
+    static create(client: GlideClient | GlideClusterClient, indexName: GlideString, schema: Field[], options?: FtCreateOptions): Promise<"OK">;
+    /**
+     * Deletes an index and associated content. Indexed document keys are unaffected.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @returns "OK"
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT.DROPINDEX to drop an index
+     * await GlideFt.dropindex(client, "json_idx1"); // "OK"
+     * ```
+     */
+    static dropindex(client: GlideClient | GlideClusterClient, indexName: GlideString): Promise<"OK">;
+    /**
+     * Lists all indexes.
+     *
+     * @param client - The client to execute the command.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns An array of index names.
+     *
+     * @example
+     * ```typescript
+     * console.log(await GlideFt.list(client)); // Output: ["index1", "index2"]
+     * ```
+     */
+    static list(client: GlideClient | GlideClusterClient, options?: DecoderOption): Promise<GlideString[]>;
+    /**
+     * Runs a search query on an index, and perform aggregate transformations on the results.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param query - The text query to search.
+     * @param options - Additional parameters for the command - see {@link FtAggregateOptions} and {@link DecoderOption}.
+     * @returns Results of the last stage of the pipeline.
+     *
+     * @example
+     * ```typescript
+     * const options: FtAggregateOptions = {
+     *      loadFields: ["__key"],
+     *      clauses: [
+     *          {
+     *              type: "GROUPBY",
+     *              properties: ["@condition"],
+     *              reducers: [
+     *                  {
+     *                      function: "TOLIST",
+     *                      args: ["__key"],
+     *                      name: "bicycles",
+     *                  },
+     *              ],
+     *          },
+     *      ],
+     *  };
+     * const result = await GlideFt.aggregate(client, "myIndex", "*", options);
+     * console.log(result); // Output:
+     * // [
+     * //     [
+     * //         {
+     * //             key: "condition",
+     * //             value: "refurbished"
+     * //         },
+     * //         {
+     * //             key: "bicycles",
+     * //             value: [ "bicycle:9" ]
+     * //         }
+     * //     ],
+     * //     [
+     * //         {
+     * //             key: "condition",
+     * //             value: "used"
+     * //         },
+     * //         {
+     * //             key: "bicycles",
+     * //             value: [ "bicycle:1", "bicycle:2", "bicycle:3" ]
+     * //         }
+     * //     ],
+     * //     [
+     * //         {
+     * //             key: "condition",
+     * //             value: "new"
+     * //         },
+     * //         {
+     * //             key: "bicycles",
+     * //             value: [ "bicycle:0", "bicycle:5" ]
+     * //         }
+     * //     ]
+     * // ]
+     * ```
+     */
+    static aggregate(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption & FtAggregateOptions): Promise<FtAggregateReturnType>;
+    /**
+     * Returns information about a given index.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns Nested maps with info about the index. See example for more details.
+     *
+     * @example
+     * ```typescript
+     * const info = await GlideFt.info(client, "myIndex");
+     * console.log(info); // Output:
+     * // {
+     * //     index_name: 'myIndex',
+     * //     index_status: 'AVAILABLE',
+     * //     key_type: 'JSON',
+     * //     creation_timestamp: 1728348101728771,
+     * //     key_prefixes: [ 'json:' ],
+     * //     num_indexed_vectors: 0,
+     * //     space_usage: 653471,
+     * //     num_docs: 0,
+     * //     vector_space_usage: 653471,
+     * //     index_degradation_percentage: 0,
+     * //     fulltext_space_usage: 0,
+     * //     current_lag: 0,
+     * //     fields: [
+     * //         {
+     * //             identifier: '$.vec',
+     * //             type: 'VECTOR',
+     * //             field_name: 'VEC',
+     * //             option: '',
+     * //             vector_params: {
+     * //                 data_type: 'FLOAT32',
+     * //                 initial_capacity: 1000,
+     * //                 current_capacity: 1000,
+     * //                 distance_metric: 'L2',
+     * //                 dimension: 6,
+     * //                 block_size: 1024,
+     * //                 algorithm: 'FLAT'
+     * //             }
+     * //         },
+     * //         {
+     * //             identifier: 'name',
+     * //             type: 'TEXT',
+     * //             field_name: 'name',
+     * //             option: ''
+     * //         },
+     * //     ]
+     * // }
+     * ```
+     */
+    static info(client: GlideClient | GlideClusterClient, indexName: GlideString, options?: DecoderOption): Promise<FtInfoReturnType>;
+    /**
+     * Parse a query and return information about how that query was parsed.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param query - The text query to search. It is the same as the query passed as
+     * an argument to {@link search | FT.SEARCH} or {@link aggregate | FT.AGGREGATE}.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A query execution plan.
+     *
+     * @example
+     * ```typescript
+     * const result = GlideFt.explain(client, "myIndex", "@price:[0 10]");
+     * console.log(result); // Output: "Field {\n\tprice\n\t0\n\t10\n}"
+     * ```
+     */
+    static explain(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption): Promise<GlideString>;
+    /**
+     * Parse a query and return information about how that query was parsed.
+     * Same as {@link explain | FT.EXPLAIN}, except that the results are
+     * displayed in a different format.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param query - The text query to search. It is the same as the query passed as
+     * an argument to {@link search | FT.SEARCH} or {@link aggregate | FT.AGGREGATE}.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A query execution plan.
+     *
+     * @example
+     * ```typescript
+     * const result = GlideFt.explaincli(client, "myIndex", "@price:[0 10]");
+     * console.log(result); // Output: ["Field {", "price", "0", "10", "}"]
+     * ```
+     */
+    static explaincli(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption): Promise<GlideString[]>;
+    /**
+     * Uses the provided query expression to locate keys within an index. Once located, the count
+     * and/or content of indexed fields within those keys can be returned.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name to search into.
+     * @param query - The text query to search.
+     * @param options - (Optional) See {@link FtSearchOptions} and {@link DecoderOption}.
+     * @returns A two-element array, where the first element is the number of documents in the result set, and the
+     * second element has the format: `GlideRecord<GlideRecord<GlideString>>`:
+     * a mapping between document names and a map of their attributes.
+     *
+     * If `count` or `limit` with values `{offset: 0, count: 0}` is
+     * set, the command returns array with only one element: the number of documents.
+     *
+     * @example
+     * ```typescript
+     * //
+     * const vector = Buffer.alloc(24);
+     * const result = await GlideFt.search(client, "json_idx1", "*=>[KNN 2 @VEC $query_vec]", {params: [{key: "query_vec", value: vector}]});
+     * console.log(result); // Output:
+     * // [
+     * //   2,
+     * //   [
+     * //     {
+     * //       key: "json:2",
+     * //       value: [
+     * //         {
+     * //           key: "$",
+     * //           value: '{"vec":[1.1,1.2,1.3,1.4,1.5,1.6]}',
+     * //         },
+     * //         {
+     * //           key: "__VEC_score",
+     * //           value: "11.1100006104",
+     * //         },
+     * //       ],
+     * //     },
+     * //     {
+     * //       key: "json:0",
+     * //       value: [
+     * //         {
+     * //           key: "$",
+     * //           value: '{"vec":[1,2,3,4,5,6]}',
+     * //         },
+     * //         {
+     * //           key: "__VEC_score",
+     * //           value: "91",
+     * //         },
+     * //       ],
+     * //     },
+     * //   ],
+     * // ]
+     * ```
+     */
+    static search(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: FtSearchOptions & DecoderOption): Promise<FtSearchReturnType>;
+    /**
+     * Runs a search query and collects performance profiling information.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param query - The text query to search.
+     * @param options - (Optional) See {@link FtSearchOptions} and {@link DecoderOption}. Additionally:
+     * - `limited` (Optional) - Either provide a full verbose output or some brief version.
+     *
+     * @returns A two-element array. The first element contains results of the search query being profiled, the
+     *     second element stores profiling information.
+     *
+     * @example
+     * ```typescript
+     * // Example of running profile on a search query
+     * const vector = Buffer.alloc(24);
+     * const result = await GlideFt.profileSearch(client, "json_idx1", "*=>[KNN 2 @VEC $query_vec]", {params: [{key: "query_vec", value: vector}]});
+     * console.log(result); // Output:
+     * // result[0] contains `FT.SEARCH` response with the given query
+     * // result[1] contains profiling data as a `Record<string, number>`
+     * ```
+     */
+    static profileSearch(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption & FtSearchOptions & {
+        limited?: boolean;
+    }): Promise<[FtSearchReturnType, Record<string, number>]>;
+    /**
+     * Runs an aggregate query and collects performance profiling information.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The index name.
+     * @param query - The text query to search.
+     * @param options - (Optional) See {@link FtAggregateOptions} and {@link DecoderOption}. Additionally:
+     * - `limited` (Optional) - Either provide a full verbose output or some brief version.
+     *
+     * @returns A two-element array. The first element contains results of the aggregate query being profiled, the
+     *     second element stores profiling information.
+     *
+     * @example
+     * ```typescript
+     * // Example of running profile on an aggregate query
+     * const options: FtAggregateOptions = {
+     *      loadFields: ["__key"],
+     *      clauses: [
+     *          {
+     *              type: "GROUPBY",
+     *              properties: ["@condition"],
+     *              reducers: [
+     *                  {
+     *                      function: "TOLIST",
+     *                      args: ["__key"],
+     *                      name: "bicycles",
+     *                  },
+     *              ],
+     *          },
+     *      ],
+     *  };
+     * const result = await GlideFt.profileAggregate(client, "myIndex", "*", options);
+     * console.log(result); // Output:
+     * // result[0] contains `FT.AGGREGATE` response with the given query
+     * // result[1] contains profiling data as a `Record<string, number>`
+     * ```
+     */
+    static profileAggregate(client: GlideClient | GlideClusterClient, indexName: GlideString, query: GlideString, options?: DecoderOption & FtAggregateOptions & {
+        limited?: boolean;
+    }): Promise<[FtAggregateReturnType, Record<string, number>]>;
+    /**
+     * Adds an alias for an index. The new alias name can be used anywhere that an index name is required.
+     *
+     * @param client - The client to execute the command.
+     * @param indexName - The alias to be added to the index.
+     * @param alias - The index name for which the alias has to be added.
+     * @returns `"OK"`
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT.ALIASADD to add an alias for an index.
+     * await GlideFt.aliasadd(client, "index", "alias"); // "OK"
+     * ```
+     */
+    static aliasadd(client: GlideClient | GlideClusterClient, indexName: GlideString, alias: GlideString): Promise<"OK">;
+    /**
+     * Deletes an existing alias for an index.
+     *
+     * @param client - The client to execute the command.
+     * @param alias -  The existing alias to be deleted for an index.
+     * @returns `"OK"`
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT.ALIASDEL to delete an existing alias.
+     * await GlideFt.aliasdel(client, "alias"); // "OK"
+     * ```
+     */
+    static aliasdel(client: GlideClient | GlideClusterClient, alias: GlideString): Promise<"OK">;
+    /**
+     * Updates an existing alias to point to a different physical index. This command only affects future references to the alias.
+     *
+     * @param client - The client to execute the command.
+     * @param alias - The alias name. This alias will now be pointed to a different index.
+     * @param indexName - The index name for which an existing alias has to updated.
+     * @returns `"OK"`
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT.ALIASUPDATE to update an alias to point to a different index.
+     * await GlideFt.aliasupdate(client, "newAlias", "index"); // "OK"
+     * ```
+     */
+    static aliasupdate(client: GlideClient | GlideClusterClient, alias: GlideString, indexName: GlideString): Promise<"OK">;
+    /**
+     * List the index aliases.
+     *
+     * @param client - The client to execute the command.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A map of index aliases for indices being aliased.
+     *
+     * @example
+     * ```typescript
+     * // Example usage of FT._ALIASLIST to query index aliases
+     * const result = await GlideFt.aliaslist(client);
+     * console.log(result); // Output:
+     * //[{"key": "alias1", "value": "index1"}, {"key": "alias2", "value": "index2"}]
+     * ```
+     */
+    static aliaslist(client: GlideClient | GlideClusterClient, options?: DecoderOption): Promise<GlideRecord<GlideString>>;
+}

package/build-ts/src/server-modules/GlideFtOptions.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+ */
+import { SortOrder } from "src/Commands";
+import { GlideRecord, GlideString } from "../BaseClient";
+interface BaseField {
+    /** The name of the field. */
+    name: GlideString;
+    /** An alias for field. */
+    alias?: GlideString;
+}
+/**
+ * Field contains any blob of data.
+ */
+export type TextField = BaseField & {
+    /** Field identifier */
+    type: "TEXT";
+};
+/**
+ * Tag fields are similar to full-text fields, but they interpret the text as a simple list of
+ * tags delimited by a separator character.
+ *
+ * For HASH fields, separator default is a comma (`,`). For JSON fields, there is no default
+ * separator; you must declare one explicitly if needed.
+ */
+export type TagField = BaseField & {
+    /** Field identifier */
+    type: "TAG";
+    /** Specify how text in the attribute is split into individual tags. Must be a single character. */
+    separator?: GlideString;
+    /** Preserve the original letter cases of tags. If set to `false`, characters are converted to lowercase by default. */
+    caseSensitive?: boolean;
+};
+/**
+ * Field contains a number.
+ */
+export type NumericField = BaseField & {
+    /** Field identifier */
+    type: "NUMERIC";
+};
+/**
+ * Superclass for vector field implementations, contains common logic.
+ */
+export type VectorField = BaseField & {
+    /** Field identifier */
+    type: "VECTOR";
+    /** Additional attributes to be passed with the vector field after the algorithm name. */
+    attributes: VectorFieldAttributesFlat | VectorFieldAttributesHnsw;
+};
+/**
+ * Base class for defining vector field attributes to be used after the vector algorithm name.
+ */
+export interface VectorFieldAttributes {
+    /** Number of dimensions in the vector. Equivalent to `DIM` in the module API. */
+    dimensions: number;
+    /**
+     * The distance metric used in vector type field. Can be one of `[L2 | IP | COSINE]`. Equivalent to `DISTANCE_METRIC` in the module API.
+     */
+    distanceMetric: "L2" | "IP" | "COSINE";
+    /** Vector type. The only supported type is FLOAT32. */
+    type?: "FLOAT32";
+    /**
+     * Initial vector capacity in the index affecting memory allocation size of the index. Defaults to `1024`. Equivalent to `INITIAL_CAP` in the module API.
+     */
+    initialCap?: number;
+}
+/**
+ * Vector field that supports vector search by FLAT (brute force) algorithm.
+ *
+ * The algorithm is a brute force linear processing of each vector in the index, yielding exact
+ * answers within the bounds of the precision of the distance computations.
+ */
+export type VectorFieldAttributesFlat = VectorFieldAttributes & {
+    algorithm: "FLAT";
+};
+/**
+ * Vector field that supports vector search by HNSM (Hierarchical Navigable Small World) algorithm.
+ *
+ * The algorithm provides an approximation of the correct answer in exchange for substantially
+ * lower execution times.
+ */
+export type VectorFieldAttributesHnsw = VectorFieldAttributes & {
+    algorithm: "HNSW";
+    /**
+     * Number of maximum allowed outgoing edges for each node in the graph in each layer. Default is `16`, maximum is `512`.
+     * Equivalent to `M` in the module API.
+     */
+    numberOfEdges?: number;
+    /**
+     * Controls the number of vectors examined during index construction. Default value is `200`, Maximum value is `4096`.
+     * Equivalent to `EF_CONSTRUCTION` in the module API.
+     */
+    vectorsExaminedOnConstruction?: number;
+    /**
+     * Controls the number of vectors examined during query operations. Default value is `10`, Maximum value is `4096`.
+     * Equivalent to `EF_RUNTIME` in the module API.
+     */
+    vectorsExaminedOnRuntime?: number;
+};
+export type Field = TextField | TagField | NumericField | VectorField;
+/**
+ * Represents the input options to be used in the {@link GlideFt.create | FT.CREATE} command.
+ * All fields in this class are optional inputs for FT.CREATE.
+ */
+export interface FtCreateOptions {
+    /** The type of data to be indexed using FT.CREATE. */
+    dataType: "JSON" | "HASH";
+    /** The prefix of the key to be indexed. */
+    prefixes?: GlideString[];
+}
+/** Additional parameters for {@link GlideFt.aggregate | FT.AGGREGATE} command. */
+export type FtAggregateOptions = {
+    /** Query timeout in milliseconds. */
+    timeout?: number;
+    /**
+     * {@link FtAggregateFilter | FILTER}, {@link FtAggregateLimit | LIMIT}, {@link FtAggregateGroupBy | GROUPBY},
+     * {@link FtAggregateSortBy | SORTBY} and {@link FtAggregateApply | APPLY} clauses, that can be repeated
+     * multiple times in any order and be freely intermixed. They are applied in the order specified,
+     * with the output of one clause feeding the input of the next clause.
+     */
+    clauses?: (FtAggregateLimit | FtAggregateFilter | FtAggregateGroupBy | FtAggregateSortBy | FtAggregateApply)[];
+    /**
+     * Query parameters, which could be referenced in the query by `$` sign, followed by
+     * the parameter name.
+     */
+    params?: GlideRecord<GlideString>;
+} & ({
+    /** List of fields to load from the index. */
+    loadFields?: GlideString[];
+    /** `loadAll` and `loadFields` are mutually exclusive. */
+    loadAll?: never;
+} | {
+    /** Option to load all fields declared in the index */
+    loadAll?: boolean;
+    /** `loadAll` and `loadFields` are mutually exclusive. */
+    loadFields?: never;
+});
+/** A clause for limiting the number of retained records. */
+export interface FtAggregateLimit {
+    type: "LIMIT";
+    /** Starting point from which the records have to be retained. */
+    offset: number;
+    /** The total number of records to be retained. */
+    count: number;
+}
+/**
+ * A clause for filtering the results using predicate expression relating to values in each result.
+ * It is applied post query and relate to the current state of the pipeline.
+ */
+export interface FtAggregateFilter {
+    type: "FILTER";
+    /** The expression to filter the results. */
+    expression: GlideString;
+}
+/** A clause for grouping the results in the pipeline based on one or more properties. */
+export interface FtAggregateGroupBy {
+    type: "GROUPBY";
+    /** The list of properties to be used for grouping the results in the pipeline. */
+    properties: GlideString[];
+    /** The list of functions that handles the group entries by performing multiple aggregate operations. */
+    reducers: FtAggregateReducer[];
+}
+/**
+ * A clause for reducing the matching results in each group using a reduction function.
+ * The matching results are reduced into a single record.
+ */
+export interface FtAggregateReducer {
+    /** The reduction function name for the respective group. */
+    function: string;
+    /** The list of arguments for the reducer. */
+    args: GlideString[];
+    /** User defined property name for the reducer. */
+    name?: GlideString;
+}
+/** A clause for sorting the pipeline up until the point of SORTBY, using a list of properties. */
+export interface FtAggregateSortBy {
+    type: "SORTBY";
+    /** A list of sorting parameters for the sort operation. */
+    properties: FtAggregateSortProperty[];
+    /** The MAX value for optimizing the sorting, by sorting only for the n-largest elements. */
+    max?: number;
+}
+/** A single property for the {@link FtAggregateSortBy | SORTBY} clause. */
+export interface FtAggregateSortProperty {
+    /** The sorting parameter. */
+    property: GlideString;
+    /** The order for the sorting. */
+    order: SortOrder;
+}
+/**
+ * A clause for applying a 1-to-1 transformation on one or more properties and stores the result
+ * as a new property down the pipeline or replaces any property using this transformation.
+ */
+export interface FtAggregateApply {
+    type: "APPLY";
+    /** The transformation expression. */
+    expression: GlideString;
+    /** The new property name to store the result of apply. This name can be referenced by further operations down the pipeline. */
+    name: GlideString;
+}
+/**
+ * Represents the input options to be used in the FT.SEARCH command.
+ * All fields in this class are optional inputs for FT.SEARCH.
+ */
+export type FtSearchOptions = {
+    /** Query timeout in milliseconds. */
+    timeout?: number;
+    /**
+     * Add a field to be returned.
+     * @param fieldIdentifier field name to return.
+     * @param alias optional alias for the field name to return.
+     */
+    returnFields?: {
+        fieldIdentifier: GlideString;
+        alias?: GlideString;
+    }[];
+    /**
+     * Query parameters, which could be referenced in the query by `$` sign, followed by
+     * the parameter name.
+     */
+    params?: GlideRecord<GlideString>;
+} & ({
+    /**
+     * Configure query pagination. By default only first 10 documents are returned.
+     *
+     * @param offset Zero-based offset.
+     * @param count Number of elements to return.
+     */
+    limit?: {
+        offset: number;
+        count: number;
+    };
+    /** `limit` and `count` are mutually exclusive. */
+    count?: never;
+} | {
+    /**
+     * Once set, the query will return only the number of documents in the result set without actually
+     * returning them.
+     */
+    count?: boolean;
+    /** `limit` and `count` are mutually exclusive. */
+    limit?: never;
+});
+export {};