@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc0

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

@@ -1,6 +1,6 @@
 import { Options } from "./core";
 import { Iterator, Source } from "./lazy";
-import { RawObject } from "./types";
+import { AnyObject } from "./types";
 /**
  * Provides functionality for the mongoDB aggregation pipeline
  *
@@ -9,21 +9,19 @@ import { RawObject } from "./types";
  * @constructor
  */
 export declare class Aggregator {
-    private readonly pipeline;
-    private readonly options;
-    constructor(pipeline: Array<RawObject>, options?: Partial<Options>);
+    #private;
+    constructor(pipeline: AnyObject[], options?: Partial<Options>);
     /**
-     * Returns an `Lazy` iterator for processing results of pipeline
+     * Returns an {@link Iterator} for lazy evaluation of the pipeline.
      *
      * @param {*} collection An array or iterator object
      * @returns {Iterator} an iterator object
      */
-    stream(collection: Source): Iterator;
+    stream(collection: Source, options?: Options): Iterator;
     /**
      * Return the results of the aggregation as an array.
      *
-     * @param {*} collection
-     * @param {*} query
+     * @param collection
      */
-    run<T extends RawObject>(collection: Source): T[];
+    run<T extends AnyObject>(collection: Source, options?: Options): T[];
 }

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

@@ -1,11 +1,11 @@
 import { Iterator } from "./lazy";
-import { AnyVal, Callback, HashFunction, Predicate, RawArray, RawObject, WindowOperatorInput } from "./types";
+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) => Array<RawObject>;
+export type CollectionResolver = (name: string) => AnyObject[];
 /** Specification for collation options */
 export interface CollationSpec {
     readonly locale: string;
@@ -20,7 +20,7 @@ export interface CollationSpec {
 /**
  * JSON schema validator
  */
-export type JsonSchemaValidator = (schema: RawObject) => Predicate<RawObject>;
+export type JsonSchemaValidator = (schema: AnyObject) => Predicate<AnyObject>;
 /**
  * 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.
@@ -78,24 +78,19 @@ export interface Options {
     /** 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>;
+    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?: AnyVal;
+    readonly groupId?: Any;
     /** Local user-defind variables. */
-    readonly variables?: RawObject;
+    readonly variables?: AnyObject;
 }
 /** 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;
     private constructor();
     /**
      * Initialize new ComputeOptions.
@@ -105,9 +100,15 @@ export declare class ComputeOptions implements Options {
      * @param local
      * @returns {ComputeOptions}
      */
-    static init(options: Options, root?: AnyVal, local?: LocalData): ComputeOptions;
-    /** Updates the internal mutable state. */
-    update(root?: AnyVal, local?: LocalData): 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;
@@ -120,14 +121,14 @@ export declare class ComputeOptions implements Options {
     get hashFunction(): HashFunction;
     get collectionResolver(): CollectionResolver;
     get jsonSchemaValidator(): JsonSchemaValidator;
-    get variables(): Readonly<RawObject>;
+    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;
+export declare function initOptions(options?: Partial<Options>): Options;
 /**
  * Supported cloning modes.
  * - "deep": Performs a recursive deep clone of the object.
@@ -152,63 +153,51 @@ export declare enum OperatorType {
     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;
+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: 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>;
-}>;
+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 readonly operators;
+    #private;
     private constructor();
-    static init(ops?: ContextMap): Context;
-    static from(ctx: Context): Context;
+    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;
-    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.
+ * Register global operators that are available when {@link Options.useGlobalContext} is enabled.
  *
- * @param context The new context to override the global one with.
+ * @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 operator Name of the operator
+ * @param name Name of the operator
+ * @param options
  */
-export declare function getOperator(type: OperatorType, operator: string, options: Pick<Options, "useGlobalContext" | "context">): Operator;
+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
  *
@@ -218,7 +207,7 @@ export declare function getOperator(type: OperatorType, operator: string, option
  * @param options {Object} extra options
  * @returns {*}
  */
-export declare function computeValue(obj: AnyVal, expr: AnyVal, operator: string | null, options?: Options): AnyVal;
+export declare function computeValue(obj: Any, expr: Any, operator: string | null, options?: Options): Any;
 /**
  * Redact an object
  * @param  {Object} obj The object to redact
@@ -226,5 +215,5 @@ export declare function computeValue(obj: AnyVal, expr: AnyVal, operator: string
  * @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 declare function redact(obj: AnyObject, expr: Any, options: ComputeOptions): Any;
 export {};

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

@@ -1,6 +1,6 @@
 import { CollationSpec, Options } from "./core";
 import { Iterator, Source } from "./lazy";
-import { AnyVal, Callback, Predicate, RawObject } from "./types";
+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`.
@@ -12,14 +12,8 @@ import { AnyVal, Callback, Predicate, RawObject } from "./types";
  * @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);
+    #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 */
@@ -48,10 +42,10 @@ export declare class Cursor<T> {
     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
+     * @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: RawObject): Cursor<T>;
+    sort(modifier: AnyObject): Cursor<T>;
     /**
      * Specifies the collation for the cursor returned by the `mingo.Query.find`
      * @param {*} spec
@@ -59,7 +53,7 @@ export declare class Cursor<T> {
     collation(spec: CollationSpec): Cursor<T>;
     /**
      * Returns the next document in a cursor.
-     * @returns {Object | Boolean}
+     * @returns {AnyObject | Boolean}
      */
     next(): T;
     /**

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

@@ -4,9 +4,11 @@ import { Options } from "./core";
 import { Cursor } from "./cursor";
 import { Source } from "./lazy";
 import { Query } from "./query";
-import { RawObject } from "./types";
+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)`
@@ -17,7 +19,7 @@ export { Query } from "./query";
  * @param options
  * @returns {Cursor} A cursor of results
  */
-export declare function find<T>(collection: Source, criteria: RawObject, projection?: RawObject, options?: Partial<Options>): Cursor<T>;
+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
  *
@@ -26,7 +28,7 @@ export declare function find<T>(collection: Source, criteria: RawObject, project
  * @param options
  * @returns {Array} New filtered array
  */
-export declare function remove(collection: RawObject[], criteria: RawObject, options?: Options): RawObject[];
+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)`
@@ -36,12 +38,14 @@ export declare function remove(collection: RawObject[], criteria: RawObject, opt
  * @param options
  * @returns {Array} New array of results
  */
-export declare function aggregate(collection: Source, pipeline: RawObject[], options?: Partial<Options>): RawObject[];
+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,6 +1 @@
-/**
- * Loads all Query and Projection operators
- */
-import { Context } from "../core";
-/** The basic context for queries. */
-export declare const BASIC_CONTEXT: Context;
+export {};

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

@@ -1,9 +1,9 @@
-import { AnyVal, Callback, Predicate, RawArray } from "./types";
+import { Any, Callback, Predicate } from "./types";
 /**
  * A value produced by a generator
  */
-interface IteratorResult {
-    readonly value?: AnyVal;
+export interface IteratorResult<T = Any> {
+    readonly value?: T;
     readonly done: boolean;
 }
 /**
@@ -12,20 +12,24 @@ interface IteratorResult {
 interface Generator<T> {
     next: () => T;
 }
-export type Source = Generator<IteratorResult> | Callback<IteratorResult> | RawArray;
+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;
-export declare function compose(...iterators: Iterator[]): 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 readonly iteratees;
-    private readonly yieldedValues;
-    private getNext;
+    #private;
     private isDone;
     /**
      * @param {*} source An iterable object or function.
@@ -39,17 +43,17 @@ export declare class Iterator {
      * Add an iteratee to this lazy sequence
      */
     private push;
-    next(): IteratorResult;
+    next<T = Any>(): IteratorResult<T>;
     /**
      * Transform each item in the sequence to a new value
      * @param {Function} f
      */
-    map<T = AnyVal>(f: Callback<T>): Iterator;
+    map<T = Any>(f: Callback<T>): Iterator;
     /**
      * Select only items matching the given predicate
      * @param {Function} pred
      */
-    filter<T = AnyVal>(predicate: Predicate<T>): Iterator;
+    filter<T = Any>(predicate: Predicate<T>): Iterator;
     /**
      * Take given numbe for values from sequence
      * @param {Number} n A number greater than 0
@@ -64,9 +68,9 @@ export declare class 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)
+     * @param {Callback<Source, Any[]>} fn Tranform function of type (Array) => (Any)
      */
-    transform(fn: Callback<Source, RawArray>): Iterator;
+    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.
@@ -78,14 +82,14 @@ export declare class Iterator {
      * @param {Function} f
      * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true
      */
-    each<T = AnyVal>(f: Callback<T>): boolean;
+    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 = AnyVal>(f: Callback<T>, initialValue?: AnyVal): T;
+    reduce<T = Any>(f: Callback<T>, initialValue?: Any): T;
     /**
      * Returns the number of matched items in the sequence
      */

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

@@ -2,7 +2,7 @@
  * Predicates used for Query and Expression operators.
  */
 import { ExpressionOperator, Options, QueryOperator } from "../core";
-import { AnyVal, BsonType, JsType, Predicate, RawArray, RawObject } from "../types";
+import { Any, AnyObject, BsonType, JsType, Predicate } from "../types";
 type PredicateOptions = Options & {
     depth: number;
 };
@@ -12,13 +12,13 @@ type ConversionType = number | JsType | BsonType;
  *
  * @param predicate Predicate function
  */
-export declare function createQueryOperator(predicate: Predicate<AnyVal>): QueryOperator;
+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<AnyVal>): ExpressionOperator;
+export declare function createExpressionOperator(predicate: Predicate<Any>): ExpressionOperator;
 /**
  * Checks that two values are equal.
  *
@@ -26,7 +26,7 @@ export declare function createExpressionOperator(predicate: Predicate<AnyVal>):
  * @param b         The rhs operand provided by the user
  * @returns {*}
  */
-export declare function $eq(a: AnyVal, b: AnyVal, options?: PredicateOptions): boolean;
+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.
  *
@@ -34,7 +34,7 @@ export declare function $eq(a: AnyVal, b: AnyVal, options?: PredicateOptions): b
  * @param b
  * @returns {boolean}
  */
-export declare function $ne(a: AnyVal, b: AnyVal, options?: PredicateOptions): 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.
  *
@@ -42,7 +42,7 @@ export declare function $ne(a: AnyVal, b: AnyVal, options?: PredicateOptions): b
  * @param b
  * @returns {*}
  */
-export declare function $in(a: RawArray, b: RawArray, options?: PredicateOptions): boolean;
+export declare function $in(a: Any[], b: Any[], options?: PredicateOptions): boolean;
 /**
  * Matches values that do not exist in an array specified to the query.
  *
@@ -50,7 +50,7 @@ export declare function $in(a: RawArray, b: RawArray, options?: PredicateOptions
  * @param b
  * @returns {*|boolean}
  */
-export declare function $nin(a: RawArray, b: RawArray, options?: PredicateOptions): boolean;
+export declare function $nin(a: Any[], b: Any[], options?: PredicateOptions): boolean;
 /**
  * Matches values that are less than the value specified in the query.
  *
@@ -58,7 +58,7 @@ export declare function $nin(a: RawArray, b: RawArray, options?: PredicateOption
  * @param b
  * @returns {boolean}
  */
-export declare function $lt(a: AnyVal, b: AnyVal, _options?: PredicateOptions): 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.
  *
@@ -66,7 +66,7 @@ export declare function $lt(a: AnyVal, b: AnyVal, _options?: PredicateOptions):
  * @param b
  * @returns {boolean}
  */
-export declare function $lte(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+export declare function $lte(a: Any, b: Any, _options?: PredicateOptions): boolean;
 /**
  * Matches values that are greater than the value specified in the query.
  *
@@ -74,7 +74,7 @@ export declare function $lte(a: AnyVal, b: AnyVal, _options?: PredicateOptions):
  * @param b
  * @returns {boolean}
  */
-export declare function $gt(a: AnyVal, b: AnyVal, _options?: PredicateOptions): 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.
  *
@@ -82,7 +82,7 @@ export declare function $gt(a: AnyVal, b: AnyVal, _options?: PredicateOptions):
  * @param b
  * @returns {boolean}
  */
-export declare function $gte(a: AnyVal, b: AnyVal, _options?: PredicateOptions): 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.
  *
@@ -90,7 +90,7 @@ export declare function $gte(a: AnyVal, b: AnyVal, _options?: PredicateOptions):
  * @param b
  * @returns {boolean}
  */
-export declare function $mod(a: AnyVal, b: number[], _options?: PredicateOptions): boolean;
+export declare function $mod(a: Any, b: number[], _options?: PredicateOptions): boolean;
 /**
  * Selects documents where values match a specified regular expression.
  *
@@ -98,7 +98,7 @@ export declare function $mod(a: AnyVal, b: number[], _options?: PredicateOptions
  * @param b
  * @returns {boolean}
  */
-export declare function $regex(a: AnyVal, b: RegExp, options?: PredicateOptions): boolean;
+export declare function $regex(a: Any, b: RegExp, options?: PredicateOptions): boolean;
 /**
  * Matches documents that have the specified field.
  *
@@ -106,7 +106,7 @@ export declare function $regex(a: AnyVal, b: RegExp, options?: PredicateOptions)
  * @param b
  * @returns {boolean}
  */
-export declare function $exists(a: AnyVal, b: AnyVal, _options?: PredicateOptions): boolean;
+export declare function $exists(a: Any, b: Any, _options?: PredicateOptions): boolean;
 /**
  * Matches arrays that contain all elements specified in the query.
  *
@@ -114,7 +114,7 @@ export declare function $exists(a: AnyVal, b: AnyVal, _options?: PredicateOption
  * @param queries
  * @returns boolean
  */
-export declare function $all(values: RawArray, queries: Array<RawObject>, options?: PredicateOptions): boolean;
+export declare function $all(values: Any[], queries: AnyObject[], options?: PredicateOptions): boolean;
 /**
  * Selects documents if the array field is a specified size.
  *
@@ -122,14 +122,14 @@ export declare function $all(values: RawArray, queries: Array<RawObject>, option
  * @param b
  * @returns {*|boolean}
  */
-export declare function $size(a: RawArray, b: number, _options?: PredicateOptions): 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 {Array} element to match against
- * @param b {Object} subquery
+ * @param a {Any[]} element to match against
+ * @param b {AnyObject} subquery
  */
-export declare function $elemMatch(a: RawArray, b: RawObject, options?: PredicateOptions): boolean;
+export declare function $elemMatch(a: Any[], b: AnyObject, options?: PredicateOptions): boolean;
 /**
  * Selects documents if a field is of the specified type.
  *
@@ -137,5 +137,5 @@ export declare function $elemMatch(a: RawArray, b: RawObject, options?: Predicat
  * @param b
  * @returns {boolean}
  */
-export declare function $type(a: AnyVal, b: ConversionType | Array<ConversionType>, options?: PredicateOptions): boolean;
+export declare function $type(a: Any, b: ConversionType | ConversionType[], options?: PredicateOptions): boolean;
 export {};

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

@@ -2,7 +2,7 @@ import { AccumulatorOperator } from "../../core";
 /**
  * Defines a custom accumulator function.
  *
- * @param {Array} collection The input array
+ * @param {Any[]} collection The input array
  * @param {*} expr The expression for the operator
  * @param {Options} options Options
  */

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

@@ -3,7 +3,7 @@ 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 {AnyObject} expr The right-hand side expression value of the operator
  * @param {Options} options The options to use for this operation
  * @returns {*}
  */

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

@@ -3,7 +3,7 @@ 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 {AnyObject} expr The right-hand side expression value of the operator
  * @param {Options} options The options to use for this operation
  * @returns {Number}
  */

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

@@ -2,8 +2,8 @@ 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 {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 {*}
  */

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

@@ -1,12 +1,12 @@
 import { AccumulatorOperator } from "../../core";
-import { RawArray } from "../../types";
+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 {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
+ * @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<RawArray>;
+export declare const $bottomN: AccumulatorOperator<Any[]>;

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

@@ -3,7 +3,7 @@ import { AccumulatorOperator } from "../../core";
  * Returns the number of documents in the group or window.
  *
  * @param {Array} collection The input array
- * @param {Object} expr The right-hand side expression value of the operator
+ * @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

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