@valkey/valkey-glide-darwin-arm64 1.2.0-rc10 → 1.2.0-rc11

package/rust-client/node_modules/mingo/dist/types/core.d.ts

@@ -0,0 +1,230 @@
+import { Iterator } from "./lazy";
+import { AnyVal, Callback, HashFunction, Predicate, RawArray, RawObject, WindowOperatorInput } from "./types";
+/**
+ * Resolves the given string to a Collection.
+ * This is useful for operators that require a second collection to use such as $lookup and $out.
+ * The collection is not cached and will be resolved each time it is used.
+ */
+export type CollectionResolver = (name: string) => Array<RawObject>;
+/** Specification for collation options */
+export interface CollationSpec {
+    readonly locale: string;
+    readonly caseLevel?: boolean;
+    readonly caseFirst?: "upper" | "lower" | "off";
+    readonly strength?: 1 | 2 | 3;
+    readonly numericOrdering?: boolean;
+    readonly alternate?: string;
+    readonly maxVariable?: never;
+    readonly backwards?: never;
+}
+/**
+ * JSON schema validator
+ */
+export type JsonSchemaValidator = (schema: RawObject) => Predicate<RawObject>;
+/**
+ * This controls how input and output documents are processed to meet different application needs.
+ * Each mode has different trade offs for; immutability, reference sharing, and performance.
+ */
+export declare enum ProcessingMode {
+    /**
+     * Clone inputs prior to processing, and the outputs if some objects graphs may be shared.
+     * Use this option to keep input collection immutable and to get distinct output objects.
+     *
+     * Note: This option is expensive and reduces performance.
+     */
+    CLONE_ALL = "CLONE_ALL",
+    /**
+     * Clones inputs prior to processing.
+     * This option will return output objects with shared graphs in their path if specific operators are used.
+     * Use this option to keep the input collection immutable.
+     *
+     */
+    CLONE_INPUT = "CLONE_INPUT",
+    /**
+     * Clones the output to return distinct objects with no shared paths.
+     * This option modifies the input collection and during processing.
+     */
+    CLONE_OUTPUT = "CLONE_OUTPUT",
+    /**
+     * Turn off cloning and modifies the input collection as needed.
+     * This option will also return output objects with shared paths in their graph when specific operators are used.
+     * This option provides the greatest speedup for the biggest tradeoff.
+     * When using the aggregation pipeline, you can use the "$out" operator to collect immutable intermediate results.
+     *
+     * @default
+     */
+    CLONE_OFF = "CLONE_OFF"
+}
+/**
+ * Generic options interface passed down to all operators
+ */
+export interface Options {
+    /** The key that is used to lookup the ID value of a document. @default "_id". */
+    readonly idKey: string;
+    /** The collation specification for string sorting operations. */
+    readonly collation?: CollationSpec;
+    /** Determines how to treat inputs and outputs. @default ProcessingMode.CLONE_OFF. */
+    readonly processingMode: ProcessingMode;
+    /** Enforces strict MongoDB compatibilty. See README. @default true. */
+    readonly useStrictMode: boolean;
+    /** Enable or disable custom script execution via $where, $accumulator, and $function operators. @default true. */
+    readonly scriptEnabled: boolean;
+    /** Enable or disable falling back to the global context for operators. @default true. */
+    readonly useGlobalContext: boolean;
+    /** Hash function to replace the Effective Java default implementation. */
+    readonly hashFunction?: HashFunction;
+    /** Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`. */
+    readonly collectionResolver?: CollectionResolver;
+    /** JSON schema validator to use with the '$jsonSchema' operator. Required in order to use the operator. */
+    readonly jsonSchemaValidator?: JsonSchemaValidator;
+    /** Global variables. */
+    readonly variables?: Readonly<RawObject>;
+    /** Extra references to operators to be used for processing. */
+    readonly context: Context;
+}
+interface LocalData {
+    /** The groupId computed for a group of documents. */
+    readonly groupId?: AnyVal;
+    /** Local user-defind variables. */
+    readonly variables?: RawObject;
+}
+/** Custom type to facilitate type checking for global options */
+export declare class ComputeOptions implements Options {
+    private _opts;
+    /** Reference to the root object when processing subgraphs of the object. */
+    private _root;
+    private _local?;
+    /** The current time in milliseconds. Remains the same throughout all stages of the aggregation pipeline. */
+    readonly timestamp: number;
+    private constructor();
+    /**
+     * Initialize new ComputeOptions.
+     *
+     * @param options
+     * @param root
+     * @param local
+     * @returns {ComputeOptions}
+     */
+    static init(options: Options, root?: AnyVal, local?: LocalData): ComputeOptions;
+    /** Updates the internal mutable state. */
+    update(root?: AnyVal, local?: LocalData): ComputeOptions;
+    getOptions(): Options;
+    get root(): unknown;
+    get local(): LocalData;
+    get idKey(): string;
+    get collation(): CollationSpec;
+    get processingMode(): ProcessingMode;
+    get useStrictMode(): boolean;
+    get scriptEnabled(): boolean;
+    get useGlobalContext(): boolean;
+    get hashFunction(): HashFunction;
+    get collectionResolver(): CollectionResolver;
+    get jsonSchemaValidator(): JsonSchemaValidator;
+    get variables(): Readonly<RawObject>;
+    get context(): Context;
+}
+/**
+ * Creates an Option from another where required keys are initialized.
+ * @param options Options
+ */
+export declare function initOptions(options: Partial<Options>): Options;
+/**
+ * Supported cloning modes.
+ * - "deep": Performs a recursive deep clone of the object.
+ * - "copy": Performs a shallow copy of the object.
+ * - "none": No cloning. Uses the value as given.
+ */
+export type CloneMode = "deep" | "copy" | "none";
+export interface UpdateOptions {
+    /** Specifies whether to deep clone values to persist in the internal store. @default "copy". */
+    readonly cloneMode?: CloneMode;
+    /** Options to use for processing queries. Unless overriden 'useStrictMode' is false.  */
+    readonly queryOptions?: Partial<Options>;
+}
+/**
+ * The different groups of operators
+ */
+export declare enum OperatorType {
+    ACCUMULATOR = "accumulator",
+    EXPRESSION = "expression",
+    PIPELINE = "pipeline",
+    PROJECTION = "projection",
+    QUERY = "query",
+    WINDOW = "window"
+}
+export type AccumulatorOperator<R = AnyVal> = (collection: RawArray, expr: AnyVal, options: Options) => R;
+export type ExpressionOperator<R = AnyVal> = (obj: RawObject, expr: AnyVal, options: Options) => R;
+export type PipelineOperator = (collection: Iterator, expr: AnyVal, options: Options) => Iterator;
+export type ProjectionOperator = (obj: RawObject, expr: AnyVal, selector: string, options: Options) => AnyVal;
+export type QueryOperator = (selector: string, value: AnyVal, options: Options) => (obj: RawObject) => boolean;
+export type WindowOperator = (obj: RawObject, array: RawObject[], expr: WindowOperatorInput, options: Options) => AnyVal;
+/** Interface for update operators */
+export type UpdateOperator = (obj: RawObject, expr: RawObject, arrayFilters: RawObject[], options: UpdateOptions) => string[];
+export type Operator = AccumulatorOperator | ExpressionOperator | PipelineOperator | ProjectionOperator | QueryOperator | WindowOperator;
+/** Map of operator functions */
+export type OperatorMap = Record<string, Operator>;
+type ContextMap = Partial<{
+    [OperatorType.ACCUMULATOR]: Record<string, AccumulatorOperator>;
+    [OperatorType.EXPRESSION]: Record<string, ExpressionOperator>;
+    [OperatorType.PIPELINE]: Record<string, PipelineOperator>;
+    [OperatorType.PROJECTION]: Record<string, ProjectionOperator>;
+    [OperatorType.QUERY]: Record<string, QueryOperator>;
+    [OperatorType.WINDOW]: Record<string, WindowOperator>;
+}>;
+type AccumulatorOps = Record<string, AccumulatorOperator>;
+type ExpressionOps = Record<string, ExpressionOperator>;
+type ProjectionOps = Record<string, ProjectionOperator>;
+type QueryOps = Record<string, QueryOperator>;
+type PipelineOps = Record<string, PipelineOperator>;
+type WindowOps = Record<string, WindowOperator>;
+export declare class Context {
+    private readonly operators;
+    private constructor();
+    static init(ops?: ContextMap): Context;
+    static from(ctx: Context): Context;
+    private addOperators;
+    addAccumulatorOps(ops: AccumulatorOps): Context;
+    addExpressionOps(ops: ExpressionOps): Context;
+    addQueryOps(ops: QueryOps): Context;
+    addPipelineOps(ops: PipelineOps): Context;
+    addProjectionOps(ops: ProjectionOps): Context;
+    addWindowOps(ops: WindowOps): Context;
+    getOperator(type: OperatorType, name: string): Callback | null;
+}
+/**
+ * Register fully specified operators for the given operator class.
+ *
+ * @param type The operator type
+ * @param operators Map of the operators
+ */
+export declare function useOperators(type: OperatorType, operators: OperatorMap): void;
+/**
+ * Overrides the current global context with this new one.
+ *
+ * @param context The new context to override the global one with.
+ */
+/**
+ * Returns the operator function or undefined if it is not found
+ * @param type Type of operator
+ * @param operator Name of the operator
+ */
+export declare function getOperator(type: OperatorType, operator: string, options: Pick<Options, "useGlobalContext" | "context">): Operator;
+/**
+ * Computes the value of the expression on the object for the given operator
+ *
+ * @param obj the current object from the collection
+ * @param expr the expression for the given field
+ * @param operator the operator to resolve the field with
+ * @param options {Object} extra options
+ * @returns {*}
+ */
+export declare function computeValue(obj: AnyVal, expr: AnyVal, operator: string | null, options?: Options): AnyVal;
+/**
+ * Redact an object
+ * @param  {Object} obj The object to redact
+ * @param  {*} expr The redact expression
+ * @param  {*} options  Options for value
+ * @return {*} returns the result of the redacted object
+ */
+export declare function redact(obj: RawObject, expr: AnyVal, options: ComputeOptions): AnyVal;
+export {};

package/rust-client/node_modules/mingo/dist/types/cursor.d.ts

@@ -0,0 +1,82 @@
+import { CollationSpec, Options } from "./core";
+import { Iterator, Source } from "./lazy";
+import { AnyVal, Callback, Predicate, RawObject } from "./types";
+/**
+ * Cursor to iterate and perform filtering on matched objects.
+ * This object must not be used directly. A cursor may be obtaine from calling `find()` on an instance of `Query`.
+ *
+ * @param collection The input source of the collection
+ * @param predicate A predicate function to test documents
+ * @param projection A projection criteria
+ * @param options Options
+ * @constructor
+ */
+export declare class Cursor<T> {
+    readonly source: Source;
+    readonly predicate: Predicate<AnyVal>;
+    readonly projection: RawObject;
+    private options?;
+    private readonly operators;
+    private result;
+    private buffer;
+    constructor(source: Source, predicate: Predicate<AnyVal>, projection: RawObject, options?: Options);
+    /** Returns the iterator from running the query */
+    private fetch;
+    /** Returns an iterator with the buffered data included */
+    private fetchAll;
+    /**
+     * Return remaining objects in the cursor as an array. This method exhausts the cursor
+     * @returns {Array}
+     */
+    all(): T[];
+    /**
+     * Returns the number of objects return in the cursor. This method exhausts the cursor
+     * @returns {Number}
+     */
+    count(): number;
+    /**
+     * Returns a cursor that begins returning results only after passing or skipping a number of documents.
+     * @param {Number} n the number of results to skip.
+     * @return {Cursor} Returns the cursor, so you can chain this call.
+     */
+    skip(n: number): Cursor<T>;
+    /**
+     * Constrains the size of a cursor's result set.
+     * @param {Number} n the number of results to limit to.
+     * @return {Cursor} Returns the cursor, so you can chain this call.
+     */
+    limit(n: number): Cursor<T>;
+    /**
+     * Returns results ordered according to a sort specification.
+     * @param {Object} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
+     * @return {Cursor} Returns the cursor, so you can chain this call.
+     */
+    sort(modifier: RawObject): Cursor<T>;
+    /**
+     * Specifies the collation for the cursor returned by the `mingo.Query.find`
+     * @param {*} spec
+     */
+    collation(spec: CollationSpec): Cursor<T>;
+    /**
+     * Returns the next document in a cursor.
+     * @returns {Object | Boolean}
+     */
+    next(): T;
+    /**
+     * Returns true if the cursor has documents and can be iterated.
+     * @returns {boolean}
+     */
+    hasNext(): boolean;
+    /**
+     * Applies a function to each document in a cursor and collects the return values in an array.
+     * @param fn
+     * @returns {Array}
+     */
+    map<R>(fn: Callback<R, T>): R[];
+    /**
+     * Applies a JavaScript function for every document in a cursor.
+     * @param fn
+     */
+    forEach(fn: Callback<void, T>): void;
+    [Symbol.iterator](): Iterator;
+}

package/rust-client/node_modules/mingo/dist/types/index.d.ts

@@ -0,0 +1,47 @@
+import "./init/basic";
+import { Aggregator } from "./aggregator";
+import { Options } from "./core";
+import { Cursor } from "./cursor";
+import { Source } from "./lazy";
+import { Query } from "./query";
+import { RawObject } from "./types";
+export { Aggregator } from "./aggregator";
+export { Query } from "./query";
+/**
+ * Performs a query on a collection and returns a cursor object.
+ * Shorthand for `Query(criteria).find(collection, projection)`
+ *
+ * @param collection Array of objects
+ * @param criteria Query criteria
+ * @param projection Projection criteria
+ * @param options
+ * @returns {Cursor} A cursor of results
+ */
+export declare function find<T>(collection: Source, criteria: RawObject, projection?: RawObject, options?: Partial<Options>): Cursor<T>;
+/**
+ * Returns a new array without objects which match the criteria
+ *
+ * @param collection Array of objects
+ * @param criteria Query criteria of objects to remove
+ * @param options
+ * @returns {Array} New filtered array
+ */
+export declare function remove(collection: RawObject[], criteria: RawObject, options?: Options): RawObject[];
+/**
+ * Return the result collection after running the aggregation pipeline for the given collection.
+ * Shorthand for `(new Aggregator(pipeline, options)).run(collection)`
+ *
+ * @param collection array or stream of objects
+ * @param pipeline The pipeline operators to use
+ * @param options
+ * @returns {Array} New array of results
+ */
+export declare function aggregate(collection: Source, pipeline: RawObject[], options?: Partial<Options>): RawObject[];
+declare const _default: {
+    Aggregator: typeof Aggregator;
+    Query: typeof Query;
+    aggregate: typeof aggregate;
+    find: typeof find;
+    remove: typeof remove;
+};
+export default _default;

package/rust-client/node_modules/mingo/dist/types/init/basic.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads all Query and Projection operators
+ */
+import { Context } from "../core";
+/** The basic context for queries. */
+export declare const BASIC_CONTEXT: Context;

package/rust-client/node_modules/mingo/dist/types/init/system.d.ts

@@ -0,0 +1 @@
+export {};

package/rust-client/node_modules/mingo/dist/types/lazy.d.ts

@@ -0,0 +1,95 @@
+import { AnyVal, Callback, Predicate, RawArray } from "./types";
+/**
+ * A value produced by a generator
+ */
+interface IteratorResult {
+    readonly value?: AnyVal;
+    readonly done: boolean;
+}
+/**
+ * Simplified generator interface
+ */
+interface Generator<T> {
+    next: () => T;
+}
+export type Source = Generator<IteratorResult> | Callback<IteratorResult> | RawArray;
+/**
+ * Returns an iterator
+ * @param {*} source An iterable source (Array, Function, Generator, or Iterator)
+ */
+export declare function Lazy(source: Source): Iterator;
+export declare function compose(...iterators: Iterator[]): Iterator;
+/**
+ * A lazy collection iterator yields a single value at a time upon request.
+ */
+export declare class Iterator {
+    private readonly iteratees;
+    private readonly yieldedValues;
+    private getNext;
+    private isDone;
+    /**
+     * @param {*} source An iterable object or function.
+     *    Array - return one element per cycle
+     *    Object{next:Function} - call next() for the next value (this also handles generator functions)
+     *    Function - call to return the next value
+     * @param {Function} fn An optional transformation function
+     */
+    constructor(source: Source);
+    /**
+     * Add an iteratee to this lazy sequence
+     */
+    private push;
+    next(): IteratorResult;
+    /**
+     * Transform each item in the sequence to a new value
+     * @param {Function} f
+     */
+    map<T = AnyVal>(f: Callback<T>): Iterator;
+    /**
+     * Select only items matching the given predicate
+     * @param {Function} pred
+     */
+    filter<T = AnyVal>(predicate: Predicate<T>): Iterator;
+    /**
+     * Take given numbe for values from sequence
+     * @param {Number} n A number greater than 0
+     */
+    take(n: number): Iterator;
+    /**
+     * Drop a number of values from the sequence
+     * @param {Number} n Number of items to drop greater than 0
+     */
+    drop(n: number): Iterator;
+    /**
+     * Returns a new lazy object with results of the transformation
+     * The entire sequence is realized.
+     *
+     * @param {Callback<Source, RawArray>} fn Tranform function of type (Array) => (Any)
+     */
+    transform(fn: Callback<Source, RawArray>): Iterator;
+    /**
+     * Returns the fully realized values of the iterators.
+     * The return value will be an array unless `lazy.first()` was used.
+     * The realized values are cached for subsequent calls.
+     */
+    value<T>(): T[];
+    /**
+     * Execute the funcion for each value. Will stop when an execution returns false.
+     * @param {Function} f
+     * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true
+     */
+    each<T = AnyVal>(f: Callback<T>): boolean;
+    /**
+     * Returns the reduction of sequence according the reducing function
+     *
+     * @param {*} f a reducing function
+     * @param {*} initialValue
+     */
+    reduce<T = AnyVal>(f: Callback<T>, initialValue?: AnyVal): T;
+    /**
+     * Returns the number of matched items in the sequence
+     */
+    size(): number;
+    [Symbol.iterator](): Iterator;
+}
+export {};

package/rust-client/node_modules/mingo/dist/types/operators/_predicates.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Predicates used for Query and Expression operators.
+ */
+import { ExpressionOperator, Options, QueryOperator } from "../core";
+import { AnyVal, BsonType, JsType, Predicate, RawArray, RawObject } from "../types";
+type PredicateOptions = Options & {
+    depth: number;
+};
+type ConversionType = number | JsType | BsonType;
+/**
+ * Returns a query operator created from the predicate
+ *
+ * @param predicate Predicate function
+ */
+export declare function createQueryOperator(predicate: Predicate<AnyVal>): QueryOperator;
+/**
+ * Returns an expression operator created from the predicate
+ *
+ * @param predicate Predicate function
+ */
+export declare function createExpressionOperator(predicate: Predicate<AnyVal>): ExpressionOperator;
+/**
+ * Checks that two values are equal.
+ *
+ * @param a         The lhs operand as resolved from the object by the given selector
+ * @param b         The rhs operand provided by the user
+ * @returns {*}
+ */
+export declare function $eq(a: AnyVal, b: AnyVal, options?: PredicateOptions): boolean;
+/**
+ * Matches all values that are not equal to the value specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $ne(a: AnyVal, b: AnyVal, options?: PredicateOptions): boolean;
+/**
+ * Matches any of the values that exist in an array specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {*}
+ */
+export declare function $in(a: RawArray, b: RawArray, options?: PredicateOptions): boolean;
+/**
+ * Matches values that do not exist in an array specified to the query.
+ *
+ * @param a
+ * @param b
+ * @returns {*|boolean}
+ */
+export declare function $nin(a: RawArray, b: RawArray, options?: PredicateOptions): boolean;
+/**
+ * Matches values that are less than the value specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $lt(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+/**
+ * Matches values that are less than or equal to the value specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $lte(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+/**
+ * Matches values that are greater than the value specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $gt(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+/**
+ * Matches values that are greater than or equal to the value specified in the query.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $gte(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+/**
+ * Performs a modulo operation on the value of a field and selects documents with a specified result.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $mod(a: AnyVal, b: number[], _options?: PredicateOptions): boolean;
+/**
+ * Selects documents where values match a specified regular expression.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $regex(a: AnyVal, b: RegExp, options?: PredicateOptions): boolean;
+/**
+ * Matches documents that have the specified field.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $exists(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+/**
+ * Matches arrays that contain all elements specified in the query.
+ *
+ * @param values
+ * @param queries
+ * @returns boolean
+ */
+export declare function $all(values: RawArray, queries: Array<RawObject>, options?: PredicateOptions): boolean;
+/**
+ * Selects documents if the array field is a specified size.
+ *
+ * @param a
+ * @param b
+ * @returns {*|boolean}
+ */
+export declare function $size(a: RawArray, b: number, _options?: PredicateOptions): boolean;
+/**
+ * Selects documents if element in the array field matches all the specified $elemMatch condition.
+ *
+ * @param a {Array} element to match against
+ * @param b {Object} subquery
+ */
+export declare function $elemMatch(a: RawArray, b: RawObject, options?: PredicateOptions): boolean;
+/**
+ * Selects documents if a field is of the specified type.
+ *
+ * @param a
+ * @param b
+ * @returns {boolean}
+ */
+export declare function $type(a: AnyVal, b: ConversionType | Array<ConversionType>, options?: PredicateOptions): boolean;
+export {};

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/_internal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compute the standard deviation of the data set
+ * @param {Array} array of numbers
+ * @param {Boolean} if true calculates a sample standard deviation, otherwise calculates a population stddev
+ * @return {Number}
+ */
+export declare function stddev(data: number[], sampled?: boolean): number;
+export declare function covariance(dataset: number[][], sampled?: boolean): number;

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/accumulator.d.ts

@@ -0,0 +1,9 @@
+import { AccumulatorOperator } from "../../core";
+/**
+ * Defines a custom accumulator function.
+ *
+ * @param {Array} collection The input array
+ * @param {*} expr The expression for the operator
+ * @param {Options} options Options
+ */
+export declare const $accumulator: AccumulatorOperator;

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/addToSet.d.ts

@@ -0,0 +1,10 @@
+import { AccumulatorOperator } from "../../core";
+/**
+ * Returns an array of all the unique values for the selected field among for each document in that group.
+ *
+ * @param {Array} collection The input array
+ * @param {Object} expr The right-hand side expression value of the operator
+ * @param {Options} options The options to use for this operation
+ * @returns {*}
+ */
+export declare const $addToSet: AccumulatorOperator;

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/avg.d.ts

@@ -0,0 +1,10 @@
+import { AccumulatorOperator } from "../../core";
+/**
+ * Returns an average of all the values in a group.
+ *
+ * @param {Array} collection The input array
+ * @param {Object} expr The right-hand side expression value of the operator
+ * @param {Options} options The options to use for this operation
+ * @returns {Number}
+ */
+export declare const $avg: AccumulatorOperator;

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/bottom.d.ts

@@ -0,0 +1,10 @@
+import { AccumulatorOperator } from "../../core";
+/**
+ * Returns the bottom element within a group according to the specified sort order.
+ *
+ * @param {Array} collection The input array
+ * @param {Object} expr The right-hand side expression value of the operator
+ * @param {Options} options The options to use for this operation
+ * @returns {*}
+ */
+export declare const $bottom: AccumulatorOperator;

package/rust-client/node_modules/mingo/dist/types/operators/accumulator/bottomN.d.ts

@@ -0,0 +1,12 @@
+import { AccumulatorOperator } from "../../core";
+import { RawArray } from "../../types";
+/**
+ * Returns an aggregation of the bottom n elements within a group, according to the specified sort order.
+ * If the group contains fewer than n elements, $bottomN returns all elements in the group.
+ *
+ * @param {Array} collection The input array
+ * @param {Object} expr The right-hand side expression value of the operator
+ * @param {Options} options The options to use for this operation
+ * @returns {*}
+ */
+export declare const $bottomN: AccumulatorOperator<RawArray>;