@valkey/valkey-glide-darwin-arm64 1.3.1 → 1.3.3-rc0

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

@@ -1,194 +0,0 @@
-import { Iterator } from "./lazy";
-import { Any, AnyObject, Callback, HashFunction, Predicate, 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) => AnyObject[];
-/** 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: AnyObject) => Predicate<AnyObject>;
-/**
- * Specified how input and output documents are processed.
- */
-export declare enum ProcessingMode {
-    /** Do not clone inputs or outputs. Resulting documents may share references. @default */
-    CLONE_OFF = 0,
-    /** Clone input documents to maintain immutability of original input. */
-    CLONE_INPUT = 1,
-    /** Clone output documents to ensure distinct objects without shared references. */
-    CLONE_OUTPUT = 2,
-    /** Clone input and output documents. */
-    CLONE_ALL = 3
-}
-/**
- * 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 using `$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<AnyObject>;
-    /** Extra references to operators to be used for processing. */
-    readonly context: Context;
-}
-interface LocalData {
-    /** The groupId computed for a group of documents. */
-    readonly groupId?: Any;
-    /** Local user-defind variables. */
-    readonly variables?: AnyObject;
-}
-/** Custom type to facilitate type checking for global options */
-export declare class ComputeOptions implements Options {
-    #private;
-    private constructor();
-    /**
-     * Initialize new ComputeOptions.
-     * @returns {ComputeOptions}
-     */
-    static init(options: Options, root?: Any, local?: LocalData): ComputeOptions;
-    /**
-     * Updates the internal state.
-     *
-     * @param root The new root context for this object.
-     * @param local The new local state to merge into current if it exists.
-     * @returns
-     */
-    update(root?: Any, 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<AnyObject>;
-    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 = Any> = (collection: Any[], expr: Any, options: Options) => R;
-export type ExpressionOperator<R = Any> = (obj: AnyObject, expr: Any, options: Options) => R;
-export type PipelineOperator = (collection: Iterator, expr: Any, options: Options) => Iterator;
-export type ProjectionOperator = (obj: AnyObject, expr: Any, selector: string, options: Options) => Any;
-export type QueryOperator = (selector: string, value: Any, options: Options) => (obj: AnyObject) => boolean;
-export type WindowOperator = (obj: AnyObject, array: AnyObject[], expr: WindowOperatorInput, options: Options) => Any;
-/** Interface for update operators */
-export type UpdateOperator = (obj: AnyObject, expr: AnyObject, arrayFilters: AnyObject[], options: UpdateOptions) => string[];
-type Operator = AccumulatorOperator | ExpressionOperator | PipelineOperator | ProjectionOperator | QueryOperator | 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>;
-/** Kinds of operators that can be registered. */
-export type OpType = "accumulator" | "expression" | "pipeline" | "projection" | "query" | "window";
-export declare class Context {
-    #private;
-    private constructor();
-    static init(): Context;
-    static from(ctx?: Context): Context;
-    private addOperators;
-    getOperator(type: OpType, name: string): Callback | null;
-    addAccumulatorOps(ops: AccumulatorOps): Context;
-    addExpressionOps(ops: ExpressionOps): Context;
-    addQueryOps(ops: QueryOps): Context;
-    addPipelineOps(ops: PipelineOps): Context;
-    addProjectionOps(ops: ProjectionOps): Context;
-    addWindowOps(ops: WindowOps): Context;
-}
-/**
- * Register global operators that are available when {@link Options.useGlobalContext} is enabled.
- *
- * @param type Operator type
- * @param operators Map of operator name to functions
- */
-export declare function useOperators(type: OpType, operators: Record<string, Operator>): void;
-/**
- * Returns the operator function or undefined if it is not found
- * @param type Type of operator
- * @param name Name of the operator
- * @param options
- */
-export declare function getOperator(type: OpType, name: 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: Any, expr: Any, operator: string | null, options?: Options): Any;
-/**
- * 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: AnyObject, expr: Any, options: ComputeOptions): Any;
-export {};

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

@@ -1,76 +0,0 @@
-import { CollationSpec, Options } from "./core";
-import { Iterator, Source } from "./lazy";
-import { Any, AnyObject, Callback, Predicate } 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> {
-    #private;
-    constructor(source: Source, predicate: Predicate<Any>, projection: AnyObject, 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 {AnyObject} 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: AnyObject): 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 {AnyObject | 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,51 +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 { AnyObject } from "./types";
-import { createUpdater } from "./updater";
-export { Aggregator } from "./aggregator";
-export { Query } from "./query";
-export { createUpdater, update } from "./updater";
-/**
- * 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: AnyObject, projection?: AnyObject, 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: AnyObject[], criteria: AnyObject, options?: Options): AnyObject[];
-/**
- * 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: AnyObject[], options?: Partial<Options>): AnyObject[];
-declare const _default: {
-    Aggregator: typeof Aggregator;
-    Query: typeof Query;
-    aggregate: typeof aggregate;
-    createUpdater: typeof createUpdater;
-    find: typeof find;
-    remove: typeof remove;
-    update: import("./updater").Updater;
-};
-export default _default;

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

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

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,99 +0,0 @@
-import { Any, Callback, Predicate } from "./types";
-/**
- * A value produced by a generator
- */
-export interface IteratorResult<T = Any> {
-    readonly value?: T;
-    readonly done: boolean;
-}
-/**
- * Simplified generator interface
- */
-interface Generator<T> {
-    next: () => T;
-}
-export type Source = Generator<IteratorResult> | Callback<IteratorResult> | Any[];
-/**
- * Returns an iterator
- * @param {*} source An iterable source (Array, Function, Generator, or Iterator)
- */
-export declare function Lazy(source: Source): Iterator;
-/**
- * Concatenate multiple iterators and return a new iterator.
- *
- * @param iterators The iterators to concatenate
- * @returns {Iterator} A new iterator
- */
-export declare function concat(...iterators: Iterator[]): Iterator;
-/**
- * A lazy collection iterator yields a single value at a time upon request.
- */
-export declare class Iterator {
-    #private;
-    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<T = Any>(): IteratorResult<T>;
-    /**
-     * Transform each item in the sequence to a new value
-     * @param {Function} f
-     */
-    map<T = Any>(f: Callback<T>): Iterator;
-    /**
-     * Select only items matching the given predicate
-     * @param {Function} pred
-     */
-    filter<T = Any>(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, Any[]>} fn Tranform function of type (Array) => (Any)
-     */
-    transform(fn: Callback<Source, Any[]>): 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 = Any>(f: Callback<T>): boolean;
-    /**
-     * Returns the reduction of sequence according the reducing function
-     *
-     * @param {*} f a reducing function
-     * @param {*} initialValue
-     */
-    reduce<T = Any>(f: Callback<T>, initialValue?: Any): 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 { Any, AnyObject, BsonType, JsType, Predicate } 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<Any>): QueryOperator;
-/**
- * Returns an expression operator created from the predicate
- *
- * @param predicate Predicate function
- */
-export declare function createExpressionOperator(predicate: Predicate<Any>): 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: Any, b: Any, 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: Any, b: Any, 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: Any[], b: Any[], 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: Any[], b: Any[], 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: Any, b: Any, _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: Any, b: Any, _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: Any, b: Any, _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: Any, b: Any, _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: Any, 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: Any, b: RegExp, options?: PredicateOptions): boolean;
-/**
- * Matches documents that have the specified field.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-export declare function $exists(a: Any, b: Any, _options?: PredicateOptions): boolean;
-/**
- * Matches arrays that contain all elements specified in the query.
- *
- * @param values
- * @param queries
- * @returns boolean
- */
-export declare function $all(values: Any[], queries: AnyObject[], options?: PredicateOptions): boolean;
-/**
- * Selects documents if the array field is a specified size.
- *
- * @param a
- * @param b
- * @returns {*|boolean}
- */
-export declare function $size(a: Any[], b: number, _options?: PredicateOptions): boolean;
-/**
- * Selects documents if element in the array field matches all the specified $elemMatch condition.
- *
- * @param a {Any[]} element to match against
- * @param b {AnyObject} subquery
- */
-export declare function $elemMatch(a: Any[], b: AnyObject, options?: PredicateOptions): boolean;
-/**
- * Selects documents if a field is of the specified type.
- *
- * @param a
- * @param b
- * @returns {boolean}
- */
-export declare function $type(a: Any, b: ConversionType | 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 {Any[]} 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 {AnyObject} 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 {AnyObject} 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 {Any[]} collection The input array
- * @param {AnyObject} 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 { Any } 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 {Any[]} collection The input array
- * @param {AnyObject} 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<Any[]>;

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

@@ -1,9 +0,0 @@
-import { AccumulatorOperator } from "../../core";
-/**
- * Returns the number of documents in the group or window.
- *
- * @param {Array} collection The input array
- * @param {AnyObject} expr The right-hand side expression value of the operator
- * @returns {*}
- */
-export declare const $count: AccumulatorOperator;

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

@@ -1,8 +0,0 @@
-import { AccumulatorOperator } from "../../core";
-/**
- * Returns the population covariance of two numeric expressions.
- * @param  {Array} collection
- * @param  {AnyObject} expr
- * @return {Number|null}
- */
-export declare const $covariancePop: AccumulatorOperator;

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

@@ -1,8 +0,0 @@
-import { AccumulatorOperator } from "../../core";
-/**
- * Returns the sample covariance of two numeric expressions.
- * @param  {Array} collection
- * @param  {AnyObject} expr
- * @return {Number|null}
- */
-export declare const $covarianceSamp: AccumulatorOperator;

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

@@ -1,9 +0,0 @@
-import { AccumulatorOperator } from "../../core";
-/**
- * Returns the first value in a group.
- *
- * @param collection The input array
- * @param expr The right-hand side expression value of the operator
- * @returns {*}
- */
-export declare const $first: AccumulatorOperator;