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

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

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

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

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

@@ -1,6 +0,0 @@
-/**
- * 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

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

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

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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-/**
- * 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

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

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

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

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

@@ -1,12 +0,0 @@
-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>;